storageRESTSrcVolume     = "source-volume"
	storageRESTSrcPath       = "source-path"
	storageRESTDstVolume     = "destination-volume"
	storageRESTDstPath       = "destination-path"
	storageRESTOffset        = "offset"
	storageRESTLength        = "length"
	storageRESTCount         = "count"
	storageRESTBitrotAlgo    = "bitrot-algo"
	storageRESTBitrotHash    = "bitrot-hash"
	storageRESTDiskID        = "disk-id"

	} else {
		fmt.Fprintf(stdout, "%s\n", e.Name)
	}
}

// output copies the entry to the specified writer.
func (ar *Archive) output(e *archive.Entry, w io.Writer) {
	r := io.NewSectionReader(ar.a.File(), e.Offset, e.Size)
	n, err := io.Copy(w, r)
	if err != nil {
		log.Fatal(err)
	}
	if n != e.Size {
		log.Fatal("short file")
	}
}

// match reports whether the entry matches the argument list.

    @Override
    InternalProblemBuilder lineInFileLocation(String path, int line, int column, int length);

    @Override
    InternalProblemBuilder offsetInFileLocation(String path, int offset, int length);

    @Override
    InternalProblemBuilder pluginLocation(String pluginId);

    @Override
    InternalProblemBuilder stackLocation();

    @Override

  int WriteToBuffer(char** buffer);

 private:
  // Data buffer to store contents of strings, not including headers.
  std::vector<char> data_;
  // Offset of the starting index of each string in data buffer.
  std::vector<size_t> offset_;
  // Max length in number of characters that we permit the total
  // buffer containing the concatenation of all added strings to be.

		} else {
			// set fake sentinel position to infinity so that
			// all comments get processed before the sentinel
			const infinity = 1 << 30
			qpos.Offset = infinity
			qpos.Line = infinity
		}

		// process comments before current node
		for r.end.Offset <= qpos.Offset {
			// determine recent node group
			if top := stack.pop(r.comment.Pos()); top != nil {
				pg = top
				pgend = fset.Position(pg.End())
			}

//go:build unix || (js && wasm) || wasip1

package syscall

import (
	"internal/byteorder"
	"internal/goarch"
	"runtime"
	"unsafe"
)

// readInt returns the size-bytes unsigned integer in native byte order at offset off.
func readInt(b []byte, off, size uintptr) (u uint64, ok bool) {
	if len(b) < int(off+size) {
		return 0, false
	}
	if goarch.BigEndian {
		return readIntBE(b[off:], size), true
	}

	f.writeCount++
	if f.writeLimit < 0 || c < f.writeLimit {
		return f.slws.Write(p)
	}
	return 0, fmt.Errorf("manufactured write error")
}

func (f *failingWriter) Seek(offset int64, whence int) (int64, error) {
	return f.slws.Seek(offset, whence)
}

func (f *failingWriter) reset(lim int) {
	f.writeCount = 0
	f.writeLimit = lim
	f.slws = slicewriter.WriteSeeker{}
}

    @Override
    InternalProblemSpec lineInFileLocation(String path, int line, int column, int length);

    @Override
    InternalProblemSpec offsetInFileLocation(String path, int offset, int length);

    @Override
    InternalProblemSpec pluginLocation(String pluginId);

    @Override
    InternalProblemSpec stackLocation();

    @Override
    InternalProblemSpec details(String details);

	// The hot path is inlined at every call site.
	// Placing done first allows more compact instructions on some architectures (amd64/386),
	// and fewer instructions (to calculate offset) on other architectures.
	done atomic.Uint32
	m    Mutex
}

// Do calls the function f if and only if Do is being called for the
// first time for this instance of [Once]. In other words, given
//
//	var once Once

// that are known to the runtime.
//
// The first local is a bool called retValid with a whole pointer-word reserved
// for it on the stack. The purpose of this word is so that the runtime knows
// whether the stack-allocated return space contains valid values for stack
// scanning.
//
// The second local is an abi.RegArgs value whose offset is also known to the