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