case '.':
			if continuousBacktick > 0 || !selfQuoted {
				shiftDelimiter = 0
				underQuoted = false
				continuousBacktick = 0
				writer.WriteByte('`')
			}
			writer.WriteByte(v)
			continue
		default:
			if shiftDelimiter-continuousBacktick <= 0 && !underQuoted {
				writer.WriteByte('`')
				underQuoted = true
				if selfQuoted = continuousBacktick > 0; selfQuoted {
					continuousBacktick -= 1
				}
			}

type Delete struct {
	Modifier string
}

func (d Delete) Name() string {
	return "DELETE"
}

func (d Delete) Build(builder Builder) {
	builder.WriteString("DELETE")

	if d.Modifier != "" {
		builder.WriteByte(' ')
		builder.WriteString(d.Modifier)
	}
}

func (d Delete) MergeClause(clause *Clause) {
	clause.Name = ""
	clause.Expression = d

    /* Write out various test values NORMALLY */
    out.write(new byte[] {-100, 100});
    out.writeBoolean(true);
    out.writeBoolean(false);
    out.writeByte(100);
    out.writeByte(-100);
    out.writeByte((byte) 200);
    out.writeChar('a');
    out.writeShort((short) -30000);
    out.writeShort((short) 50000);
    out.writeInt(0xCAFEBABE);
    out.writeLong(0xDEADBEEFCAFEBABEL);

          throw ProtocolException("unexpected address: " + toSocket.localAddress)
        }

        // Write the reply.
        fromSink.writeByte(VERSION_5)
        fromSink.writeByte(REPLY_SUCCEEDED)
        fromSink.writeByte(0)
        fromSink.writeByte(ADDRESS_TYPE_IPV4)
        fromSink.write(localAddress)
        fromSink.writeShort(toSocket.localPort)
        fromSink.emit()

			write(v.Raw, v.Alias)
		}
	case []clause.Column:
		writer.WriteByte('(')
		for idx, d := range v {
			if idx > 0 {
				writer.WriteByte(',')
			}
			stmt.QuoteTo(writer, d)
		}
		writer.WriteByte(')')
	case clause.Expr:
		v.Build(stmt)
	case string:
		stmt.DB.Dialector.QuoteTo(writer, v)
	case []string:
		writer.WriteByte('(')
		for idx, d := range v {
			if idx > 0 {

        // Mapped inline to the sequence: [b2].
        sink.writeByte(ranges[rangesIndex + 2].code)
      }
      123 -> {
        // Mapped inline to the sequence: [b2a].
        sink.writeByte(ranges[rangesIndex + 2].code or 0x80)
      }
      124 -> {
        // Mapped inline to the sequence: [b2, b3].
        sink.writeByte(ranges[rangesIndex + 2].code)
        sink.writeByte(ranges[rangesIndex + 3].code)
      }
      125 -> {

    assertThat(Buffer().writeUtf8("Слава Україні!").isProbablyUtf8(16L)).isTrue()
    assertThat(Buffer().writeByte(0x80).isProbablyUtf8(16L)).isTrue()
    assertThat(Buffer().writeByte(0x00).isProbablyUtf8(16L)).isFalse()
    assertThat(Buffer().writeByte(0xc0).isProbablyUtf8(16L)).isFalse()
  }

  @Test fun doesNotConsumeBuffer() {
    val buffer = Buffer()
    buffer.writeUtf8("hello ".repeat(1024))

  ): Long {
    var byteCount = 0L
    val buffer: Buffer = if (countBytes) Buffer() else sink!!.buffer

    for (i in 0 until encodedNames.size) {
      if (i > 0) buffer.writeByte('&'.code)
      buffer.writeUtf8(encodedNames[i])
      buffer.writeByte('='.code)
      buffer.writeUtf8(encodedValues[i])
    }

    if (countBytes) {
      byteCount = buffer.size
      buffer.clear()
    }

    return byteCount
  }

          val utf8ByteCount = label.utf8Size()
          require(utf8ByteCount == label.length.toLong()) { "non-ascii hostname: $host" }
          nameBuf.writeByte(utf8ByteCount.toInt())
          nameBuf.writeUtf8(label)
        }
        nameBuf.writeByte(0) // end

        nameBuf.copyTo(this, 0, nameBuf.size)
        writeShort(type)
        writeShort(1) // CLASS_IN
      }.readByteString()

        if (value < prefixMask) {
          out.writeByte(bits or value)
          return
        }

        // Write the mask to start a multibyte value.
        out.writeByte(bits or prefixMask)
        value -= prefixMask

        // Write 7 bits at a time 'til we're done.
        while (value >= 0x80) {
          val b = value and 0x7f
          out.writeByte(b or 0x80)
          value = value ushr 7
        }