nonUTF8 bool
		flags   uint16
	}{
		{
			name:    "hi, hello",
			comment: "in the world",
			flags:   0x8,
		},
		{
			name:    "hi, こんにちわ",
			comment: "in the world",
			flags:   0x808,
		},
		{
			name:    "hi, こんにちわ",
			comment: "in the world",
			nonUTF8: true,
			flags:   0x8,
		},
		{
			name:    "hi, hello",
			comment: "in the 世界",
			flags:   0x808,
		},

    assertThat(Adapters.IA5_STRING.fromDer(bytes)).isEqualTo("hi")
    assertThat(Adapters.IA5_STRING.toDer("hi")).isEqualTo(bytes)
  }

  @Test fun `printable string`() {
    val bytes = "13026869".decodeHex()
    assertThat(Adapters.PRINTABLE_STRING.fromDer(bytes)).isEqualTo("hi")
    assertThat(Adapters.PRINTABLE_STRING.toDer("hi")).isEqualTo(bytes)
  }

  @Test fun `cannot decode utc time with offset`() {

    char c = 0;
    for (int hi = 0; hi < 256; hi++) {
      for (int lo = 0; lo < 256; lo++) {
        char result = Chars.fromByteArray(new byte[] {(byte) hi, (byte) lo});
        assertWithMessage(
                String.format(
                    Locale.ROOT,
                    "hi=%s, lo=%s, expected=%s, result=%s",
                    hi,
                    lo,
                    (int) c,

	MOVV	R1, R2		// 00011025
	MOVV	LO, R1		// 00000812
	MOVV	HI, R1		// 00000810
	MOVV	R1, LO		// 00200013
	MOVV	R1, HI		// 00200011


//	LMOVW rreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVW	R1, R2		// 00011004
	MOVW	LO, R1		// 00000812
	MOVW	HI, R1		// 00000810
	MOVW	R1, LO		// 00200013
	MOVW	R1, HI		// 00200011
	MOVWU	R14, R27	// 000ed83c001bd83e

//	LMOVH rreg ',' rreg

    val request = request().post("Hi?".toRequestBody(PLAIN)).build()
    val response = client.newCall(request).execute()
    response.body.close()
    applicationLogs
      .assertLogEqual("--> POST $url")
      .assertLogEqual("Content-Type: text/plain; charset=utf-8")
      .assertLogEqual("Content-Length: 3")
      .assertLogEqual("")
      .assertLogEqual("Hi?")
      .assertLogEqual("--> END POST (3-byte body)")

    assertThat(client.closed).isFalse()
    client.webSocket!!.close(1000, "Hi!")
    server.processNextFrame()
    client.listener.assertClosing(1000, "Hello!")
    server.listener.assertClosing(1000, "Hi!")
    client.webSocket!!.finishReader()
    server.webSocket!!.finishReader()
    client.listener.assertClosed(1000, "Hello!")
    server.listener.assertClosed(1000, "Hi!")
    taskFaker.runTasks()
    assertThat(client.closed).isTrue()

			di.Healing = info.Healing
			di.Scanning = info.Scanning
			di.State = diskErrToDriveState(err)
			di.FreeInodes = info.FreeInodes
			di.UsedInodes = info.UsedInodes
			if hi := disks[index].Healing(); hi != nil {
				hd := hi.toHealingDisk()
				di.HealInfo = &hd
			}
			di.Metrics = &madmin.DiskMetrics{
				LastMinute:              make(map[string]madmin.TimedAction, len(info.Metrics.LastMinute)),

        },
        "hindi_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}hi/stopwords.txt"
        },
        "hindi_keywords": {
          "type":       "keyword_marker",
          "keywords_path": "${fess.dictionary.path}hi/protwords.txt"
        },
        "hindi_stemmer": {
          "type":       "stemmer",
          "language":   "hindi"
        },

			// Parse the upper and lower bounds.
			lo := p.registerNumber(tok.String())
			hi := lo
			if p.peek() == '-' {
				p.next()
				hi = p.registerNumber(p.next().String())
			}
			if hi < lo {
				lo, hi = hi, lo
			}
			// Check there are no duplicates in the register list.
			for i := 0; lo <= hi && i < maxReg; i++ {
				if bits&(1<<lo) != 0 {
					p.errorf("register R%d already in list", lo)

		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"gl/protwords.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"hi/protwords.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"hu/protwords.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>