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