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