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