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