err = w.Close()
		if err != nil {
			// we cannot write an error to the writer anymore as the Encode call was successful.
			utilruntime.HandleError(fmt.Errorf("apiserver was unable to close cleanly the response writer: %v", err))
		}
		return
	}

	// make a best effort to write the object if a failure is detected
	utilruntime.HandleError(fmt.Errorf("apiserver was unable to write a JSON response: %v", err))
	status := ErrorToAPIStatus(err)

	"path"
	"slices"
	"strings"
	"time"
)

// Writer provides sequential writing of a tar archive.
// [Writer.WriteHeader] begins a new file with the provided [Header],
// and then Writer can be treated as an io.Writer to supply that file's data.
type Writer struct {
	w    io.Writer
	pad  int64      // Amount of padding to write after current file entry
	curr fileWriter // Writer for current file entry

}

// Write encodes p using quoted-printable encoding and writes it to the
// underlying [io.Writer]. It limits line length to 76 characters. The encoded
// bytes are not necessarily flushed until the [Writer] is closed.
func (w *Writer) Write(p []byte) (n int, err error) {
	for i, b := range p {
		switch {
		// Simple writes are done in batch.
		case b >= '!' && b <= '~' && b != '=':
			continue

// NewWriter creates a new byte format writer.
func NewWriter(w io.Writer, v version.Version) (*Writer, error) {
	_, err := version.WriteHeader(w, v)
	return &Writer{w: w, v: v, specs: v.Specs()}, err
}

// WriteEvent writes a single event to the trace wire format stream.
func (w *Writer) WriteEvent(e Event) error {
	// Check version.
	if e.Version != w.v {

        this.fileComment = fileComment;
    } //-- void setFileComment(String)

    /**
     * Method write.
     *
     * @param writer a writer object
     * @param ${rootLcapName} a ${root.name} object
     * @throws java.io.IOException java.io.IOException if any
     */
    public void write(Writer writer, ${root.name} ${rootLcapName}) throws java.io.IOException {
        XmlSerializer serializer = new MXSerializer();

// is a *[Writer].
func NewWriter(w io.Writer, order Order, litWidth int) io.WriteCloser {
	return newWriter(w, order, litWidth)
}

func newWriter(dst io.Writer, order Order, litWidth int) *Writer {
	w := new(Writer)
	w.init(dst, order, litWidth)
	return w
}

func (w *Writer) init(dst io.Writer, order Order, litWidth int) {
	switch order {
	case LSB:

	"io"
	"strings"
	"unicode/utf8"

	"github.com/fatih/color"
)

type ColoredTableWriter struct {
	writer     io.Writer
	header     Row
	rows       []Row
	addRowFunc func(obj interface{}) Row
}

func NewStyleWriter(writer io.Writer) *ColoredTableWriter {
	return &ColoredTableWriter{
		writer: writer,
		rows:   make([]Row, 0),
		header: Row{},
	}
}

type BuildRowFunc func(obj interface{}) Row

		out.Write64(uint64(r.Xadd))

	case objabi.R_LOONG64_TLS_LE_HI:
		out.Write64(uint64(sectoff))
		out.Write64(uint64(elf.R_LARCH_TLS_LE_HI20) | uint64(elfsym)<<32)
		out.Write64(uint64(r.Xadd))

	case objabi.R_CALLLOONG64:
		out.Write64(uint64(sectoff))
		out.Write64(uint64(elf.R_LARCH_B26) | uint64(elfsym)<<32)
		out.Write64(uint64(r.Xadd))

	case objabi.R_LOONG64_TLS_IE_HI:
		out.Write64(uint64(sectoff))

			return i
		}
	}
	return -1
}

// writer is a buffered writer.
type writer interface {
	Flush() error
	io.Writer
	io.ByteWriter
}

// encoder encodes an image to the GIF format.
type encoder struct {
	// w is the writer to write to. err is the first error encountered during
	// writing. All attempted writes after the first error become no-ops.
	w   writer
	err error

}

// NewSDSWriter generates a new instance which conforms to SDSWriter interface
func NewSDSWriter(w io.Writer, format Format) SDSWriter {
	return &sdsWriter{
		w:      w,
		output: format,
	}
}

// sdsWriter is provided concrete implementation of SDSWriter
type sdsWriter struct {
	w      io.Writer
	output Format
}