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