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