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