if ok {
					// if we're the last chunk, make sure we exhausted the name
					if len(pattern) == 0 && len(t) > 0 {
						continue
					}
					name = t
					continue Pattern
				}
				if err != nil {
					return false, err
				}
			}
		}
		return false, nil
	}
	return len(name) == 0, nil
}

// scanChunk gets the next segment of pattern, which is a non-star string

	if x == 0 {
		for {
			continue L1 /* ERROR "invalid continue label L1" */
		}
	}
}

func f3() {
L1:
L2:
L3:
	for {
		break L1 /* ERROR "invalid break label L1" */
		break L2 /* ERROR "invalid break label L2" */
		break L3
		continue L1 /* ERROR "invalid continue label L1" */
		continue L2 /* ERROR "invalid continue label L2" */
		continue L3
		goto L1
		goto L2
		goto L3

			if n.Values != nil {
				m = n.Values
				continue
			}
			if n.Type != nil {
				m = n.Type
				continue
			}
			if l := len(n.NameList); l > 0 {
				m = n.NameList[l-1]
				continue
			}
			return n.Pos()
		case *TypeDecl:
			m = n.Type
		case *VarDecl:
			if n.Values != nil {
				m = n.Values
				continue
			}
			if n.Type != nil {
				m = n.Type
				continue

func fuzzNodeRegistration(obj *kubeadm.NodeRegistrationOptions, c fuzz.Continue) {
	c.FuzzNoCustom(obj)

	// Pinning values for fields that get defaults if fuzz value is empty string or nil (thus making the round trip test fail)
	obj.IgnorePreflightErrors = nil
	obj.ImagePullSerial = ptr.To(true)
}

func fuzzClusterConfiguration(obj *kubeadm.ClusterConfiguration, c fuzz.Continue) {
	c.FuzzNoCustom(obj)

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = if (a - b > 0) continue@loop1
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = true
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break@loop2,
    continue@loop1
  ]
  returnValueType = null
  valuedReturnExpressions = []

                    val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration] as? CallableDescriptor ?: continue
                    val ktSymbol = descriptor.takeIf { nameFilter(it.name) }?.toKtCallableSymbol(analysisContext) ?: continue
                    yield(ktSymbol)
                }
            }
        }
    }

		if _, ok := hpke.SupportedKEMs[ec.KemID]; !ok {
			continue
		}
		var validSCS bool
		for _, cs := range ec.SymmetricCipherSuite {
			if _, ok := hpke.SupportedAEADs[cs.AEADID]; !ok {
				continue
			}
			if _, ok := hpke.SupportedKDFs[cs.KDFID]; !ok {
				continue
			}
			validSCS = true
			break
		}
		if !validSCS {
			continue
		}
		if !validDNSName(string(ec.PublicName)) {

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = if (a - b > 0) continue@loop1
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = true
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break@loop2,
    continue@loop1
  ]
  returnValueType = null
  valuedReturnExpressions = []

			endTrailerIndex = endIndex + len(pemEnd)
		}

		if endIndex < 0 {
			continue
		}

		// After the "-----" of the ending line, there should be the same type
		// and then a final five dashes.
		endTrailer := rest[endTrailerIndex:]
		endTrailerLen := len(typeLine) + len(pemEndOfLine)
		if len(endTrailer) < endTrailerLen {
			continue
		}

		restOfEndLine := endTrailer[endTrailerLen:]

		b := loop.header
		var p *Block // b's in-loop predecessor
		for _, e := range b.Preds {
			if e.b.Kind != BlockPlain {
				continue
			}
			if loopnest.b2l[e.b.ID] != loop {
				continue
			}
			p = e.b
		}
		if p == nil {
			continue
		}
		p.Hotness |= HotInitial
		if f.IsPgoHot {
			p.Hotness |= HotPgo
		}
		// blocks will be arranged so that p is ordered first, if it isn't already.