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