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