int index = offset + SmbConstants.SIGNATURE_OFFSET;
            for ( int i = 0; i < 8; i++ )
                data[ index + i ] = 0;
            SMBUtil.writeInt4(this.signSequence, data, index);
            update(data, offset, length);
            System.arraycopy(digest(), 0, data, index, 8);
            if ( this.bypass ) {
                this.bypass = false;

            builder.add(readIsolatable(decoder));
        }
    }

    private void writeIsolatableSequence(Encoder encoder, Collection<Isolatable<?>> elements) throws Exception {
        encoder.writeInt(elements.size());
        for (Isolatable<?> isolatable : elements) {
            writeIsolatable(encoder, isolatable);
        }
    }

    private Object readState(Decoder decoder) throws Exception {

	if err != nil {
		err = msgp.WrapError(err, "DeadlineMS")
		return
	}
	err = en.WriteUint8(uint8(z.Handler))
	if err != nil {
		err = msgp.WrapError(err, "Handler")
		return
	}
	err = en.WriteUint8(uint8(z.Op))
	if err != nil {
		err = msgp.WrapError(err, "Op")
		return
	}
	err = en.WriteUint8(uint8(z.Flags))
	if err != nil {
		err = msgp.WrapError(err, "Flags")
		return
	}

func InitSlice(n *ir.Name, noff int64, lsym *obj.LSym, lencap int64) {
	s := n.Linksym()
	s.WriteAddr(base.Ctxt, noff, types.PtrSize, lsym, 0)
	s.WriteInt(base.Ctxt, noff+types.SliceLenOffset, types.PtrSize, lencap)
	s.WriteInt(base.Ctxt, noff+types.SliceCapOffset, types.PtrSize, lencap)
}

func InitSliceBytes(nam *ir.Name, off int64, s string) {
	if nam.Op() != ir.ONAME {

	return ctxt.LookupInit(name, func(s *LSym) {
		s.Size = 16
		if ctxt.Arch.ByteOrder == binary.LittleEndian {
			s.WriteInt(ctxt, 0, 8, lo)
			s.WriteInt(ctxt, 8, 8, hi)
		} else {
			s.WriteInt(ctxt, 0, 8, hi)
			s.WriteInt(ctxt, 8, 8, lo)
		}
		s.Type = objabi.SRODATA
		s.Set(AttrLocal, true)
		s.Set(AttrContentAddressable, true)
		ctxt.constSyms = append(ctxt.constSyms, s)

            if (expectedContent == null) {
                encoder.writeInt(-1);
            } else {
                encoder.writeInt(expectedContent.length);
                encoder.writeBytes(expectedContent);
            }
            byte[] actualContent = value.getDetails().getActualContent();
            if (actualContent == null) {
                encoder.writeInt(-1);
            } else {

        var someInt: Int? = null
    ) : Serializable

    open class ExternalizableBean(var value: Int = 0) : Externalizable {

        override fun writeExternal(out: ObjectOutput) {
            out.writeInt(value)
        }

        override fun readExternal(`in`: ObjectInput) {
            value = `in`.readInt()
        }
    }

    ByteArrayDataOutput out = ByteStreams.newDataOutput();
    out.writeInt(0x12345678);
    out.writeInt(0x76543210);
    assertThat(out.toByteArray()).isEqualTo(bytes);
  }

  public void testNewDataOutput_sized() {
    ByteArrayDataOutput out = ByteStreams.newDataOutput(4);
    out.writeInt(0x12345678);
    out.writeInt(0x76543210);
    assertThat(out.toByteArray()).isEqualTo(bytes);
  }

	if err != nil {
		err = msgp.WrapError(err, "fileNotFound")
		return
	}
	// write "stat"
	err = en.Append(0xa4, 0x73, 0x74, 0x61, 0x74)
	if err != nil {
		return
	}
	err = en.WriteUint8(uint8(z.status))
	if err != nil {
		err = msgp.WrapError(err, "status")
		return
	}
	// write "rec"
	err = en.Append(0xa3, 0x72, 0x65, 0x63)
	if err != nil {
		return
	}

  }

  @Test
  fun writeSingleByteInt() {
    hpackWriter!!.writeInt(10, 31, 0)
    assertBytes(10)
    hpackWriter!!.writeInt(10, 31, 0xe0)
    assertBytes(0xe0 or 10)
  }

  @Test
  fun writeMultibyteInt() {
    hpackWriter!!.writeInt(1337, 31, 0)
    assertBytes(31, 154, 10)
    hpackWriter!!.writeInt(1337, 31, 0xe0)
    assertBytes(0xe0 or 31, 154, 10)
  }

  @Test