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