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