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