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