expression = consume(a + b)
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break,
    break
  ]
  returnValueType = null
  valuedReturnExpressions = []

        break;
      case (QuantizationComponentSpec::COMPONENT_WEIGHT):
        EXPECT_THAT(component, EqualsProto(expected_weight_component));
        break;
      case (QuantizationComponentSpec::COMPONENT_BIAS):
        EXPECT_THAT(component, EqualsProto(expected_bias_component));
        break;
      default:
        break;
    }
  }
}

                break;
            case ROOT_PROJECT: {
                ProjectComponentIdentifier projectComponentIdentifier = (ProjectComponentIdentifier) value;
                writeBuildIdentifierOf(projectComponentIdentifier, encoder);
                encoder.writeString(projectComponentIdentifier.getProjectName());
                break;
            }
            case ROOT_BUILD_PROJECT: {

          break;
        case 16:
          return DenseElementsAttr::get<int16_t>(shaped_type,
                                                 static_cast<int16_t>(value));
          break;
        case 32:
          return DenseElementsAttr::get<int32_t>(shaped_type,
                                                 static_cast<int32_t>(value));
          break;
        case 64:

  va_end(args);
  switch (level) {
    case TF_INFO:
      LOG(INFO) << message;
      break;
    case TF_WARNING:
      LOG(WARNING) << message;
      break;
    case TF_ERROR:
      LOG(ERROR) << message;
      break;
    case TF_FATAL:
      LOG(FATAL) << message;
      break;
  }
}

void TF_VLog(int level, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

        break;
      case EXPM1:
        y = Expm1(scope_, x);
        break;
      case LOG:
        y = Log(scope_, x);
        break;
      case LOG1P:
        y = Log1p(scope_, x);
        break;
      case SINH:
        y = Sinh(scope_, x);
        break;
      case COSH:
        y = Cosh(scope_, x);
        break;
      case TANH:
        y = Tanh(scope_, x);
        break;

}

func breaks() {
	var x, y int

	break /* ERROR "break" */
	{
		break /* ERROR "break" */
	}
	if x < y {
		break /* ERROR "break" */
	}

	switch x {
	case 0:
		break
	case 1:
		if x == y {
			break
		}
	default:
		break
		break
	}

	var z interface{}
	switch z.(type) {
	case int:
		break
	}

	for {
		break
	}

                }
                break;
            case 1:
                ASN1Integer msgType = ASN1Util.as(ASN1Integer.class, tagged);
                if ( !msgType.getValue().equals(new BigInteger(KerberosConstants.KERBEROS_AP_REQ)) )
                    throw new PACDecodingException("Invalid kerberos request");
                break;
            case 2:

	if ev.filter == _EVFILT_USER {
		if ev.ident == kqIdent {
			return true
		}
		println("runtime: netpoll: break fd ready for", ev.ident)
		throw("runtime: netpoll: break fd ready for something unexpected")
	}
	return false
}

func drainWakeupEvent(kq int32) {
	ev := keventt{
		ident:  kqIdent,
		filter: _EVFILT_USER,
		flags:  _EV_DISABLE,
	}
	kevent(kq, &ev, 1, nil, 0, nil)
}

                    executedTasksCount++;
                    break;
                case FROM_CACHE:
                    fromCacheTaskCount++;
                    break;
                case UP_TO_DATE:
                    upToDateTaskCount++;
                    break;
                default:
                    // Ignore any other outcome
                    break;
            }
        }
    }