// that takes care of accounting and error handling.
func (p *printer) write(data []byte) {
	n, err := p.output.Write(data)
	p.written += n
	if err != nil {
		panic(writeError{err})
	}
}

var (
	tabBytes    = []byte("\t\t\t\t\t\t\t\t")
	newlineByte = []byte("\n")
	blankByte   = []byte(" ")
)

func (p *printer) writeBytes(data []byte) {
	if len(data) == 0 {

	commentNewline bool              // true if the comment group contains newlines
}

type printer struct {
	// Configuration (does not change after initialization)
	Config
	fset *token.FileSet

	// Current state
	output       []byte       // raw printer result
	indent       int          // current indentation

            is KaAnnotation -> renderAnnotationApplication(value, printer)
            is KaAnnotationList -> renderAnnotationsList(value, printer)
            is KtModule -> renderKtModule(value, printer)
            // Other custom values
            is Name -> printer.append(value.asString())
            is FqName -> printer.append(value.asString())
            is ClassId -> printer.append(value.asString())

            is DefinitelyNotNullType -> renderDefinitelyNotNullType(unwrappedType, printer)
            is ErrorType -> renderErrorType(printer)
            is CapturedType -> renderCapturedType(unwrappedType, printer)
            is NewCapturedType -> renderCapturedType(unwrappedType, printer)
            is AbbreviatedType -> renderType(unwrappedType.abbreviation, printer)
            is SimpleType -> {

            is KaAnonymousFunctionSymbol -> anonymousFunctionRenderer.renderSymbol(analysisSession, symbol, this, printer)
            is KaConstructorSymbol -> constructorRenderer.renderSymbol(analysisSession, symbol, this, printer)
            is KaFunctionSymbol -> functionSymbolRenderer.renderSymbol(analysisSession, symbol, this, printer)
            is KaPropertyGetterSymbol -> getterRenderer.renderSymbol(analysisSession, symbol, this, printer)

		LookupPackage: p.lookupPackage,
		LookupSym:     p.lookupSym,
	}
}

// Printer returns a doc comment printer configured
// for printing doc comments from package p.
// Each call returns a new printer, so that the caller may
// customize it before use.
func (p *Package) Printer() *comment.Printer {
	// No customization today, but having p.Printer()
	// gives us flexibility in the future, and it is convenient for callers.

			continue
		}
		_, _ = printer.Fprintf(tabw, "%s\t%s\t%s\t%s\n", component.Name, component.NodeName, component.CurrentVersion, component.NewVersion)
	}
	_ = tabw.Flush()

	_, _ = printer.Fprintln(writer, "")
	_, _ = printer.Fprintf(writer, "Upgrade to the latest %s:\n", au.Description)
	_, _ = printer.Fprintln(writer, "")

		table := &metav1.Table{
			ColumnDefinitions: test.columns,
			Rows:              test.rows,
		}
		// Print the table
		out := bytes.NewBuffer([]byte{})
		printer := NewTablePrinter(test.options)
		printer.PrintObj(table, out)

		// Validate the printed table is empty.
		if len(out.String()) > 0 {
			t.Errorf("Error Printing Table. Should be empty; got (%s)", out.String())
		}
	}
}

		for scanner.Scan() {
			printer.Fprintf(w, "\t%s\n", scanner.Text())
		}
	}
}

// runPreflightChecks runs the root preflight check
func runPreflightChecks(client clientset.Interface, ignorePreflightErrors sets.Set[string], printer output.Printer) error {
	printer.Printf("[preflight] Running pre-flight checks.\n")
	err := preflight.RunRootCheckOnly(ignorePreflightErrors)
	if err != nil {
		return err
	}

// kinds of upgrades can be performed
func GetAvailableUpgrades(versionGetterImpl VersionGetter, experimentalUpgradesAllowed, rcUpgradesAllowed bool, client clientset.Interface, printer output.Printer) ([]Upgrade, error) {
	printer.Printf("[upgrade] Fetching available versions to upgrade to\n")

	// Collect the upgrades kubeadm can do in this list
	var upgrades []Upgrade

	// Get the kube-apiserver versions in the cluster