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