// 2.
    "disallowed_STD3_mapped ".encodeUtf8(),
    // 3.
    "disallowed_STD3_valid ".encodeUtf8(),
    // 4.
    "ignored ".encodeUtf8(),
    // 5.
    "mapped ".encodeUtf8(),
    // 6.
    "valid ".encodeUtf8(),
  )

internal const val TYPE_DEVIATION = 0
internal const val TYPE_DISALLOWED = 1
internal const val TYPE_DISALLOWED_STD3_MAPPED = 2

    }
  }
  return result.readUtf8()
}

/**
 * Returns the canonical address for [address]. If [address] is an IPv6 address that is mapped to an
 * IPv4 address, this returns the IPv4-mapped address. Otherwise, this returns [address].
 *
 * https://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses
 */
internal fun canonicalizeInetAddress(address: ByteArray): ByteArray {
  return when {

        sourceCodePoint1 = unionWith.sourceCodePoint1,
        type = type,
        mappedTo = mappedTo,
      )
  }

  return result
}

internal fun canonicalizeType(type: Int): Int {
  return when (type) {
    TYPE_IGNORED -> TYPE_IGNORED

    TYPE_MAPPED,
    TYPE_DISALLOWED_STD3_MAPPED,
    -> TYPE_MAPPED

    TYPE_DEVIATION,
    TYPE_DISALLOWED_STD3_VALID,
    TYPE_VALID,

      Mapping(0x0233, 0x0239, TYPE_VALID, ByteString.EMPTY),
      Mapping(0x023a, 0x023a, TYPE_MAPPED, "b".encodeUtf8()),
    )
  }

  @Test fun simplifyDoesNotCombineWhenMappedTargetsAreDifferent() {
    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0041, 0x0041, TYPE_MAPPED, "a".encodeUtf8()),
          Mapping(0x0042, 0x0042, TYPE_MAPPED, "b".encodeUtf8()),
        ),
      ),

 *    119 : Ignored.
 *    120 : Valid.
 *    121 : Disallowed
 *    122 : Mapped inline to the sequence: [b2].
 *    123 : Mapped inline to the sequence: [b2a].
 *    124 : Mapped inline to the sequence: [b2, b3].
 *    125 : Mapped inline to the sequence: [b2a, b3].
 *    126 : Mapped inline to the sequence: [b2, b3a].
 *    127 : Mapped inline to the sequence: [b2a, b3a].
 *
 * The range goes until the beginning of the next range.

internal fun Int.toHexString(): String = Integer.toHexString(this)

@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "NOTHING_TO_INLINE")
internal inline fun Any.wait() = (this as Object).wait()

@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "NOTHING_TO_INLINE")
internal inline fun Any.notify() = (this as Object).notify()

@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "NOTHING_TO_INLINE")
internal inline fun Any.notifyAll() = (this as Object).notifyAll()

      }
    }

    return mapResult.readUtf8()
  }
}

interface CodePointMapping {
  /**
   * Returns a (possibly-empty) string that [codePoint] maps to, or null if [codePoint] is not
   * mapped.
   */
  operator fun get(codePoint: Int): String?
}

interface CodePointSet {
  operator fun contains(codePoint: Int): Boolean

0046          ; mapped                 ; 0066          # 1.1  LATIN CAPITAL LETTER F
0047          ; mapped                 ; 0067          # 1.1  LATIN CAPITAL LETTER G
0048          ; mapped                 ; 0068          # 1.1  LATIN CAPITAL LETTER H
0049          ; mapped                 ; 0069          # 1.1  LATIN CAPITAL LETTER I
004A          ; mapped                 ; 006A          # 1.1  LATIN CAPITAL LETTER J

    assertThat("localhost".toCanonicalHost()).isEqualTo("localhost")
    assertThat("☃.net".toCanonicalHost()).isEqualTo("xn--n3h.net")

    // IPv4 Compatible or Mapped addresses
    assertThat("::192.168.0.1".toCanonicalHost()).isEqualTo("::c0a8:1")
    assertThat("::FFFF:192.168.0.1".toCanonicalHost()).isEqualTo("192.168.0.1")

     * Wait a duration in nanoseconds. Unlike [java.lang.Object.wait] this interprets 0 as
     * "don't wait" instead of "wait forever".
     */
    @Throws(InterruptedException::class)
    @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
    override fun coordinatorWait(
      taskRunner: TaskRunner,
      nanos: Long,
    ) {
      taskRunner.lock.assertHeld()
      if (nanos > 0) {
        taskRunner.condition.awaitNanos(nanos)