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