* little-endian byte order.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override
  public void writeInt(int v) throws IOException {
    out.write(0xFF & v);
    out.write(0xFF & (v >> 8));
    out.write(0xFF & (v >> 16));
    out.write(0xFF & (v >> 24));
  }

  /**
   * Writes a {@code long} as specified by {@link DataOutputStream#writeLong(long)}, except using
   * little-endian byte order.
   *

func (z *healingTracker) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 25
	// write "ID"
	err = en.Append(0xde, 0x0, 0x19, 0xa2, 0x49, 0x44)
	if err != nil {
		return
	}
	err = en.WriteString(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "PoolIndex"
	err = en.Append(0xa9, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x6e, 0x64, 0x65, 0x78)
	if err != nil {

func (z *CondCheck) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 7
	// write "ObjectInfo"
	err = en.Append(0x87, 0xaa, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x6e, 0x66, 0x6f)
	if err != nil {
		return
	}
	err = z.ObjectInfo.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "ObjectInfo")
		return
	}
	// write "IfMatch"
	err = en.Append(0xa7, 0x49, 0x66, 0x4d, 0x61, 0x74, 0x63, 0x68)

import java.nio.channels.FileChannel
import okio.Buffer

/**
 * Read and write a target file. Unlike Okio's built-in `Okio.source(java.io.File file)` and `Okio.sink(java.io.File file)`
 * this class offers:
 *
 *  * **Read/write:** read and write using the same operator.
 *  * **Random access:** access any position within the file.
 *  * **Shared channels:** read and write a file channel that's shared between

  }

  @Test fun `decode raw sequence`() {
    val buffer =
      Buffer()
        .write("300A".decodeHex())
        .write("1505".decodeHex())
        .write("Smith".encodeUtf8())
        .write("01".decodeHex())
        .write("01".decodeHex())
        .write("FF".decodeHex())

    val derReader = DerReader(buffer)

    derReader.read("test") { header ->

				// concurrently, check for it before we
				// write the filler byte.
				select {
				case err := <-doneCh:
					if err != nil {
						write([]byte{1})
						write([]byte(err.Error()))
					} else {
						write([]byte{0})
					}
					return
				default:
				}

				// Response not ready, write a filler byte.
				write([]byte{32})
				if canWrite {
					w.(http.Flusher).Flush()

func (c *DeadlineConn) Read(b []byte) (n int, err error) {
	c.setReadDeadline()
	n, err = c.Conn.Read(b)
	return n, err
}

// Write - writes data to the connection.
func (c *DeadlineConn) Write(b []byte) (n int, err error) {
	c.setWriteDeadline()
	n, err = c.Conn.Write(b)
	return n, err
}

// WithReadDeadline sets a new read side net.Conn deadline.

      )
    val bufferA = Buffer()
    val bufferB = Buffer()
    bufferA.writeUtf8("Dodgson!\n")
    operatorA.write(0, bufferA, 9)
    bufferB.writeUtf8("You shouldn't use my name.\n")
    operatorB.write(9, bufferB, 27)
    bufferA.writeUtf8("Dodgson, we've got Dodgson here!\n")
    operatorA.write(36, bufferA, 33)
    operatorB.read(0, bufferB, 9)
    assertThat(bufferB.readUtf8()).isEqualTo("Dodgson!\n")

    // Write the first headers frame.
    writeMedium(frame, (headerBlock.size / 2).toInt() + paddingLength + 1)
    frame.writeByte(Http2.TYPE_HEADERS)
    frame.writeByte(FLAG_PADDED)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.writeByte(paddingLength)
    frame.write(headerBlock, headerBlock.size / 2)
    frame.write(padding)

<p>
Note that if there are no read-write or write-write data races on memory location <i>x</i>,
then any read <i>r</i> on <i>x</i> has only one possible <i>W</i>(<i>r</i>):
the single <i>w</i> that immediately precedes it in the happens before order.
</p>

<p>
More generally, it can be shown that any Go program that is data-race-free,
meaning it has no program executions with read-write or write-write data races,