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