// Encode '+' as '%2B' since we permit ' ' to be encoded as either '+' or '%20'.
      writeUtf8(if (alreadyEncoded) "+" else "%2B")
    } else if (codePoint < 0x20 ||
      codePoint == 0x7f ||
      codePoint >= 0x80 &&
      !unicodeAllowed ||
      codePoint.toChar() in encodeSet ||
      codePoint == '%'.code &&
      (!alreadyEncoded || strict && !input.isPercentEncoded(i, limit))
    ) {

                si++;
                uni[ui] |= ch & 0x3F;
                if ((ch & 0xC0) != 0x80 || uni[ui] < 0x80) {
                    throw new IOException("Invalid UTF-8 sequence");
                }
            } else if ((ch & 0xF0) == 0xE0) {
                if (slim - si < 3) {
                    break;
                }
                uni[ui] = (char) ((ch & 0x0F) << 12);
                ch = src[si] & 0xFF;

        dst[dstIndex + OPCODE_OFFSET] = (byte) ((this.isResponse ? 0x80 : 0x00) + (this.opCode << 3 & 0x78)
                + (this.isAuthAnswer ? 0x04 : 0x00) + (this.isTruncated ? 0x02 : 0x00) + (this.isRecurDesired ? 0x01 : 0x00));
        dst[dstIndex + OPCODE_OFFSET + 1] =
                (byte) ((this.isRecurAvailable ? 0x80 : 0x00) + (this.isBroadcast ? 0x10 : 0x00) + (this.resultCode & 0x0F));

        writeInt2(nameTrnId, dst, dstIndex);
        dst[dstIndex + OPCODE_OFFSET] = (byte) ((isResponse ? 0x80 : 0x00) + (opCode << 3 & 0x78) + (isAuthAnswer ? 0x04 : 0x00)
                + (isTruncated ? 0x02 : 0x00) + (isRecurDesired ? 0x01 : 0x00));
        dst[dstIndex + OPCODE_OFFSET + 1] = (byte) ((isRecurAvailable ? 0x80 : 0x00) + (isBroadcast ? 0x10 : 0x00) + (resultCode & 0x0F));
        writeInt2(questionCount, dst, start + QUESTION_OFFSET);

	for _, c := range s {
		if c >= 0x80 || c == 0x00 {
			return false
		}
	}
	return true
}

// toASCII converts the input to an ASCII C-style string.
// This is a best effort conversion, so invalid characters are dropped.
func toASCII(s string) string {
	if isASCII(s) {
		return s
	}
	b := make([]byte, 0, len(s))
	for _, c := range s {
		if c < 0x80 && c != 0x00 {
			b = append(b, byte(c))
		}
	}

        if (resultCode != 0 || opCode != QUERY) {
            return 0;
        }
        final boolean groupName = ((src[srcIndex] & 0x80) == 0x80) == true;
        final int nodeType = (src[srcIndex] & 0x60) >> 5;
        srcIndex += 2;
        final int address = readInt4(src, srcIndex);
        if (address != 0) {

        if (this.resultCode != 0 || this.opCode != QUERY) {
            return 0;
        }
        final boolean groupName = ((src[srcIndex] & 0x80) == 0x80) == true;
        final int nodeType = (src[srcIndex] & 0x60) >> 5;
        srcIndex += 2;
        final int address = readInt4(src, srcIndex);
        if (address != 0) {

        for (char c : chars) {
            if (c < 0x80) {
                bytes[byteIndex++] = (byte) c;
            } else if (c < 0x800) {
                bytes[byteIndex++] = (byte) (0xC0 | (c >> 6));
                bytes[byteIndex++] = (byte) (0x80 | (c & 0x3F));
            } else {
                bytes[byteIndex++] = (byte) (0xE0 | (c >> 12));
                bytes[byteIndex++] = (byte) (0x80 | ((c >> 6) & 0x3F));

          return 0x80;
        } else if (userFriendly.matches("(?i)(?:French|Latin|Western.*European)")) {
          // Mostly 1-byte UTF-8 sequences, mixed with occasional 2-byte
          // sequences - "Western European" text
          return 0x90;
        } else if (userFriendly.matches("(?i)(?:Branch.*Prediction.*Hostile)")) {
          // Defeat branch predictor for: c < 0x80 ; branch taken 50% of the time.

                si++;
                uni[ui] |= ch & 0x3F;
                if ((ch & 0xC0) != 0x80 || uni[ui] < 0x80) {
                    throw new IOException("Invalid UTF-8 sequence");
                }
            } else if ((ch & 0xF0) == 0xE0) {
                if (slim - si < 3) {
                    break;
                }
                uni[ui] = (char) ((ch & 0x0F) << 12);
                ch = src[si] & 0xFF;