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