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