case SMB_COM_TREE_DISCONNECT:
            c = "SMB_COM_TREE_DISCONNECT";
            break;
        case SMB_COM_LOGOFF_ANDX:
            c = "SMB_COM_LOGOFF_ANDX";
            break;
        case SMB_COM_ECHO:
            c = "SMB_COM_ECHO";
            break;
        case SMB_COM_MOVE:
            c = "SMB_COM_MOVE";
            break;
        case SMB_COM_RENAME:

				if !lower(&c) {
					break
				}
				isInterWord = false
			} else if !c.copy() {
				break
			}
		} else {
			if c.info.isNotCasedAndNotCaseIgnorable() {
				if !c.copy() {
					break
				}
				isInterWord = true
			} else if !c.hasPrefix("Σ") {
				if !lower(&c) {
					break
				}
			} else if !finalSigmaBody(&c) {
				break
			}
		}
		c.checkpoint()
	}

        String value;
        switch (level) {
            case DEBUG:
                value = "debug";
                break;

            case INFO:
                value = "info";
                break;

            default:
                value = "error";
                break;
        }
        System.setProperty("maven.logging.root.level", value);
    }

    @Override
    public void activate() {

			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:

                    break;
                case ARMED:
                    LOGGER.debug("Watch probe for hierarchy is already armed: {}", watchableHierarchy);
                    break;
                case TRIGGERED:
                    LOGGER.debug("Watch probe for hierarchy has already been triggered: {}", watchableHierarchy);
                    break;
                default:

      dtype.code = DLDataTypeCode::kDLBool;
      break;
    case TF_DataType::TF_HALF:
    case TF_DataType::TF_FLOAT:
    case TF_DataType::TF_DOUBLE:
      dtype.code = DLDataTypeCode::kDLFloat;
      break;
    case TF_DataType::TF_INT8:
    case TF_DataType::TF_INT16:
    case TF_DataType::TF_INT32:
    case TF_DataType::TF_INT64:
      dtype.code = DLDataTypeCode::kDLInt;
      break;
    case TF_DataType::TF_UINT8:

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

                            artifact.expectGet()
                            break
                        case InteractionExpectation.HEAD:
                            artifact.expectHead()
                            break
                        case InteractionExpectation.HEAD_MISSING:
                            artifact.expectHeadMissing()
                            break
                        case InteractionExpectation.MAYBE:

  defaultExpressionInfo = DefaultExpressionInfo:
    expression = if (foo() == 5) {
                break
            } else if (foo() == 6) {
                continue
            }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = true
  hasMultipleJumpTargets = true
  jumpExpressions = [
    break,
    continue
  ]
  returnValueType = null
  valuedReturnExpressions = []

fun foo(a: Int): Int {
    val b: Int = 1
    for (n in 1..a) {
        <expr>if (a + b > 0) break
        consume(a - b)
        break</expr>
    }
    return 1
}