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