// might have been taken away to start a table.
	pos := p.pos()
	pos.EndLine = pos.StartLine + len(b.text) - 1
	return &Paragraph{
		pos,
		p.newText(pos, s),
	}
}

func newPara(p *parseState, s line) (line, bool) {
	// Process paragraph continuation text or start new paragraph.
	b := p.para()
	indented := p.lineDepth == len(p.stack)-2 // fully indented, not playing "pargraph continuation text" games

	for _, fn := range news {
		if l, ok := fn(p, s); ok {
			s = l
			if s.isBlank() {
				return
			}
			p.lineDepth++
			goto Prefixes
		}
	}

	newPara(p, s)
}

func (c *rootBuilder) extend(p *parseState, s line) (line, bool) {
	panic("root extend")
}

var news = []func(*parseState, line) (line, bool){
	newQuote,
	newATXHeading,

	x int
	y string
}

func (b *Bar) Plark() Itf {
	return b
}

type Itf interface {
	Plark() Itf
}

func newBar(x int) Itf {
	s := 0
	for i := 0; i < x; i++ {
		s += i
	}
	return &Bar{
		x: s,
	}
}

func newBar2(x int) (int, Itf, bool) {
	s := 0
	for i := 0; i < x; i++ {
		s += i
	}
	return 0, &Bar{x: s}, false
}

			}
			continue
		}

		// declare new variable
		obj := NewVar(ident.Pos(), check.pkg, name, nil)
		lhsVars[i] = obj
		if name != "_" {
			newVars = append(newVars, obj)
		}
		check.recordDef(ident, obj)
	}

	// create dummy variables where the lhs is invalid
	for i, obj := range lhsVars {
		if obj == nil {
			lhsVars[i] = NewVar(lhs[i].Pos(), check.pkg, "_", nil)
		}
	}

			}
			continue
		}

		// declare new variable
		obj := NewVar(ident.Pos(), check.pkg, name, nil)
		lhsVars[i] = obj
		if name != "_" {
			newVars = append(newVars, obj)
		}
		check.recordDef(ident, obj)
	}

	// create dummy variables where the lhs is invalid
	for i, obj := range lhsVars {
		if obj == nil {
			lhsVars[i] = NewVar(lhs[i].Pos(), check.pkg, "_", nil)
		}
	}

        arg_type = quantize_output.getType();
        new_arg = block.addArgument(arg_type, loc);
        quantize_output.replaceAllUsesWith(new_arg);
      } else if (input_type.isUnsignedInteger(
                     current_type.getIntOrFloatBitWidth())) {  // int8 != uint8
        arg_type = quant::ConvertSignedQuantizedToUnsigned(
            quantize_output.getType(), loc);
        new_arg = block.addArgument(arg_type, loc);

	}

	writeIfNotEqual := func(fileName string, newData []byte) error {
		if newData == nil {
			return nil
		}
		oldData, _ := os.ReadFile(path.Join(dir, fileName))
		if !bytes.Equal(oldData, newData) {
			if err := file.AtomicWrite(path.Join(dir, fileName), newData, certFileMode); err != nil {
				return fmt.Errorf("failed to write data to file %v: %v", fileName, err)
			}
		}

			t.Errorf("1st unmarshal error: %v", err)
		}
		newData, err := json.Marshal(new1)
		if err != nil {
			t.Errorf("2st marshal error: %v", err)
		}
		if err = json.Unmarshal(newData, &new2); err != nil {
			t.Errorf("2nd unmarshal error: %v", err)
		}
		if !bytes.Equal(data, newData) {
			t.Errorf("%s: re-marshaled data differs from original: %v %v", k, data, newData)
		}
		if !reflect.DeepEqual(tc.orig, new1) {

        generatedResourcesByOrigin.putAll(newData.getGeneratedResourcesByOrigin());

        return new AnnotationProcessingData(
            generatedTypesByOrigin,
            newData.getAggregatedTypes(),
            newData.getGeneratedTypesDependingOnAllOthers(),
            generatedResourcesByOrigin,
            newData.getGeneratedResourcesDependingOnAllOthers(),
            newData.getFullRebuildCause()
        );
    }

	}

	newData, err := json.Marshal(v1.Pod{
		ObjectMeta: metav1.ObjectMeta{UID: uid}, // only put the uid in the new object to ensure it appears in the patch as a precondition
		Status:     newPodStatus,
	})
	if err != nil {
		return nil, false, fmt.Errorf("failed to Marshal newData for pod %q/%q: %v", namespace, name, err)
	}