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