fi := (*funcinl)(unsafe.Pointer(fn))
		return fi.startLine
	}
	return fn.funcInfo().startLine
}

// findmoduledatap looks up the moduledata for a PC.
//
// It is nosplit because it's part of the isgoexception
// implementation.
//
//go:nosplit
func findmoduledatap(pc uintptr) *moduledata {
	for datap := &firstmoduledata; datap != nil; datap = datap.next {
		if datap.minpc <= pc && pc < datap.maxpc {

	// will work.
	return true
}

// isAbortPC reports whether pc is the program counter at which
// runtime.abort raises a signal.
//
// It is nosplit because it's part of the isgoexception
// implementation.
//
//go:nosplit
func isAbortPC(pc uintptr) bool {
	f := findfunc(pc)
	if !f.valid() {
		return false
	}
	return f.funcID == abi.FuncID_abort

        outputStream.writeFloat(value);
    }

    @Override
    public void writeDouble(double value) throws IOException {
        outputStream.writeDouble(value);
    }

    @Override
    public void writeBoolean(boolean value) throws IOException {
        outputStream.writeBoolean(value);
    }

    @Override
    public void writeString(CharSequence value) throws IOException {

  }

  public void testCloseExceptionsSuppressed_whenExceptionThrownFromTryBlock() throws IOException {
    Closer closer = new Closer(suppressor);

    IOException tryException = new IOException();
    IOException c1Exception = new IOException();
    IOException c2Exception = new IOException();

    TestCloseable c1 = closer.register(TestCloseable.throwsOnClose(c1Exception));

import org.gradle.api.NonNullApi;

import java.io.IOException;

@NonNullApi
public class EncoderExtensions {
    public static void writeLengthPrefixedShorts(Encoder encoder, short[] array) throws IOException {
        encoder.writeInt(array.length);
        writeShorts(encoder, array);
    }

    public static void writeShorts(Encoder encoder, short[] array) throws IOException {
        for (short e : array) {

 * limitations under the License.
 */

package org.gradle.internal.serialize;

import org.gradle.api.NonNullApi;

import java.io.IOException;

@NonNullApi
public class DecoderExtensions {

    public static short[] readLengthPrefixedShorts(Decoder decoder) throws IOException {
        int length = decoder.readInt();
        short[] array = new short[length];
        readShorts(decoder, array);
        return array;

    }

    @Override
    public void writeBytes(byte[] bytes) throws IOException {
        writeBytes(bytes, 0, bytes.length);
    }

    @Override
    public void writeBinary(byte[] bytes) throws IOException {
        writeBinary(bytes, 0, bytes.length);
    }

    @Override
    public void writeBinary(byte[] bytes, int offset, int count) throws IOException {
        writeSmallInt(count);
        writeBytes(bytes, offset, count);

     * @param strict a strict object.
     * @return Metadata
     * @throws IOException            IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     *                                any.
     */
    public Metadata read(Reader reader, boolean strict) throws IOException, XmlPullParserException {
        try {
            return new Metadata(delegate.read(reader, strict));

     */
    long readLong() throws EOFException, IOException;

    /**
     * Reads a signed 64 bit int value. Can read any value that was written using {@link Encoder#writeSmallLong(long)}.
     *
     * @throws EOFException when the end of the byte stream is reached before the int value can be fully read.
     */
    long readSmallLong() throws EOFException, IOException;

    /**

    }
  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)