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