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