i--
	buf[i] = 'x'
	i--
	buf[i] = '0'
	gwrite(buf[i:])
}

func printpointer(p unsafe.Pointer) {
	printhex(uint64(uintptr(p)))
}
func printuintptr(p uintptr) {
	printhex(uint64(p))
}

func printstring(s string) {
	gwrite(bytes(s))
}

func printslice(s []byte) {
	sp := (*slice)(unsafe.Pointer(&s))
	print("[", len(s), "/", cap(s), "]")
	printpointer(sp.array)
}

	{"runtime.goPanicSlice3C", 1},
	{"runtime.goPanicSlice3CU", 1},
	{"runtime.goPanicSliceConvert", 1},
	{"runtime.printbool", 1},
	{"runtime.printfloat", 1},
	{"runtime.printint", 1},
	{"runtime.printhex", 1},
	{"runtime.printuint", 1},
	{"runtime.printcomplex", 1},
	{"runtime.printstring", 1},
	{"runtime.printpointer", 1},
	{"runtime.printuintptr", 1},
	{"runtime.printiface", 1},
	{"runtime.printeface", 1},

// to that file set. Otherwise positions are printed as integer
// values (file set specific offsets).
//
// A non-nil [FieldFilter] f may be provided to control the output:
// struct fields for which f(fieldname, fieldvalue) is true are
// printed; all others are filtered from the output. Unexported
// struct fields are never printed.
func Fprint(w io.Writer, fset *token.FileSet, x any, f FieldFilter) error {

//	func printFunc(object ObjectType, options GenerateOptions) ([]metav1.TableRow, error)
//
// where ObjectType is the type of the object that will be printed, and the first
// return value is an array of rows, with each row containing a number of cells that
// match the number of columns defined for that printer function.
func ValidateRowPrintHandlerFunc(printFunc reflect.Value) error {
	if printFunc.Kind() != reflect.Func {

/**
 * Utility to print {@link Failure}s in the format matching that of {@link Throwable#printStackTrace()}.
 * <p>
 * Failures with multiple causes are printed similarly to {@link org.gradle.internal.exceptions.MultiCauseException}.
 * <p>
 * The printer additionally allows reacting to each frame to be printed via a {@link FailurePrinterListener}.
 */
public class FailurePrinter {

    public static String printToString(Failure failure) {

	o.validator = func() (validation.Schema, error) {
		directive, err := cmdutil.GetValidationDirective(cmd)
		if err != nil {
			return nil, err
		}
		return f.Validator(directive)
	}

	// build the printer
	o.Printer, err = o.PrintFlags.ToPrinter()
	return err
}

// RunConvert implements the generic Convert command
func (o *ConvertOptions) RunConvert() error {
	b := o.builder().
		WithScheme(scheme.Scheme).

                    { declarationRenderer.nameRenderer.renderName(analysisSession, typeParameter, declarationRenderer, printer) },
                )
            }
        }

        override fun renderWhereClause(
            analysisSession: KaSession,
            symbol: KaDeclarationSymbol,
            declarationRenderer: KaDeclarationRenderer,
            printer: PrettyPrinter,
        ) {

}

public fun <S> renderAnnotationsModifiersAndContextReceivers(
    analysisSession: KaSession,
    symbol: S,
    declarationRenderer: KaDeclarationRenderer,
    printer: PrettyPrinter,
    keywords: List<KtKeywordToken>,
) where S : KaAnnotated, S : KaDeclarationSymbol {
    printer {
        renderContextReceivers(analysisSession, symbol, declarationRenderer, printer)

            declarationRenderer: KaDeclarationRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                " ".separated(
                    { declarationRenderer.annotationRenderer.renderAnnotations(analysisSession, symbol, printer) },
                    { declarationRenderer.modifiersRenderer.renderDeclarationModifiers(analysisSession, symbol, printer) },

            else -> return
        }

        printer.append(" /* = ")
        renderTypeAsIs(expandedType, printer)
        printer.append(" */")
    }

    private fun KaSession.renderExpandedType(type: KaType, printer: PrettyPrinter) {
        renderTypeAsIs(type.fullyExpandedType, printer)
    }

    private fun KaSession.renderAbbreviatedTypeComment(type: KaType, printer: PrettyPrinter) {