Polycarp has a string $$$s$$$ consisting of lowercase Latin letters.He encodes it using the following algorithm.He goes through the letters of the string $$$s$$$ from left to right and for each letter Polycarp considers its number in the alphabet:  if the letter number is single-digit number (less than $$$10$$$), then just writes it out;  if the letter number is a two-digit number (greater than or equal to $$$10$$$), then it writes it out and adds the number 0 after. For example, if the string $$$s$$$ is code, then Polycarp will encode this string as follows:  'c' — is the $$$3$$$-rd letter of the alphabet. Consequently, Polycarp adds 3 to the code (the code becomes equal to 3);  'o' — is the $$$15$$$-th letter of the alphabet. Consequently, Polycarp adds 15 to the code and also 0 (the code becomes 3150);  'd' — is the $$$4$$$-th letter of the alphabet. Consequently, Polycarp adds 4 to the code (the code becomes 31504);  'e' — is the $$$5$$$-th letter of the alphabet. Therefore, Polycarp adds 5 to the code (the code becomes 315045). Thus, code of string code is 315045.You are given a string $$$t$$$ resulting from encoding the string $$$s$$$. Your task is to decode it (get the original string $$$s$$$ by $$$t$$$).

The first line of the input contains an integer $$$q$$$ ($$$1 \le q \le 10^4$$$) — the number of test cases in the input. The descriptions of the test cases follow. The first line of description of each test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of the given code. The second line of the description of each test case contains a string $$$t$$$ of length $$$n$$$ — the given code. It is guaranteed that there exists such a string of lowercase Latin letters, as a result of encoding which the string $$$t$$$ is obtained.

For each test case output the required string $$$s$$$ — the string that gives string $$$t$$$ as the result of encoding. It is guaranteed that such a string always exists. It can be shown that such a string is always unique.

code
aj
abacaba
ll
codeforces
aaaak
aaaaj
aaaaa
zf

NoteThe first test case is explained above.In the second test case, the answer is aj. Indeed, the number of the letter a is equal to $$$1$$$, so 1 will be appended to the code. The number of the letter j is $$$10$$$, so 100 will be appended to the code. The resulting code is 1100.There are no zeros in the third test case, which means that the numbers of all letters are less than $$$10$$$ and are encoded as one digit. The original string is abacaba.In the fourth test case, the string $$$s$$$ is equal to ll. The letter l has the number $$$12$$$ and is encoded as 120. So ll is indeed 120120.

package main

import (
	"bufio"
	"fmt"
	"os"
)

// fmt.Println('a'-96, 'b'-96, 'c'-96, 'd'-96, 'e'-96)
// fmt.Println(s[i] - 96)
// fmt.Println(string(byte(3 + 96)))
// fmt.Println('0'-48, '1'-48, '2'-48, '3'-48, '4'-48, '5'-48, "...", '9'-48)

func main() {
	reader := bufio.NewReader(os.Stdin)
	// writer := bufio.NewWriter(os.Stdout)

	var q int
	// fmt.Scanln(&q)
	fmt.Fscanln(reader, &q)

	for l := 0; l < q; l++ {
		var n int
		fmt.Fscanln(reader, &n)
		// fmt.Scanln(&n)
		var s string
		fmt.Fscanln(reader, &s)
		// fmt.Scanln(&s)

		var i int
		var res string
		for i < len(s) {

			if i+2 < len(s) && s[i+2] == '0' {
				if i+3 < len(s) && s[i+3] == '0' {
					// case when sequential 00
					d := s[i] - 48
					res += string(byte(d + 96))
					i += 1
					continue
				}
				d := (s[i]-48)*10 + (s[i+1] - 48)
				res += string(byte(d + 96))
				i += 3
			} else {
				d := s[i] - 48
				res += string(byte(d + 96))
				i += 1
			}
		}
		fmt.Println(res)

	}
}

// func findIndexesOfZeros(s string) []int {
// 	res := make([]int, 0, len(s)/2)

// 	for i := range s {
// 		if s[i] == '0' {
// 			if i > 0 && s[i-1] == '0' {
// 				// case when sequential 00
// 				res = res[:len(res)-1]
// 			}
// 			res = append(res, i)
// 		}
// 	}

// 	return res
// }

package main

import (
	"bufio"
	"fmt"
	"os"
)

// fmt.Println('a'-96, 'b'-96, 'c'-96, 'd'-96, 'e'-96)
// fmt.Println(s[i] - 96)
// fmt.Println(string(byte(3 + 96)))

func main() {
	reader := bufio.NewReader(os.Stdin)
	// writer := bufio.NewWriter(os.Stdout)
	// fmt.Println('0'-48, '1'-48, '2'-48, '3'-48, '4'-48, '5'-48, "...", '9'-48)

	var q int
	// fmt.Scanln(&q)
	fmt.Fscanln(reader, &q)

	for l := 0; l < q; l++ {
		var n int
		fmt.Fscanln(reader, &n)
		// fmt.Scanln(&n)
		var s string
		fmt.Fscanln(reader, &s)
		// fmt.Scanln(&s)

		var i int
		var res string
		for i < len(s) {

			if i+2 < len(s) && s[i+2] == '0' {
				if i+3 < len(s) && s[i+3] == '0' {
					// case when sequential 00
					d := s[i] - 48
					res += string(byte(d + 96))
					i += 1
					continue
				}
				d := (s[i]-48)*10 + (s[i+1] - 48)
				res += string(byte(d + 96))
				i += 3
			} else {
				d := s[i] - 48
				res += string(byte(d + 96))
				i += 1
			}
		}
		fmt.Println(res)

	}
}

// func findIndexesOfZeros(s string) []int {
// 	res := make([]int, 0, len(s)/2)

// 	for i := range s {
// 		if s[i] == '0' {
// 			if i > 0 && s[i-1] == '0' {
// 				// case when sequential 00
// 				res = res[:len(res)-1]
// 			}
// 			res = append(res, i)
// 		}
// 	}

// 	return res
// }

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"os"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var T int
	fmt.Fscan(in, &T)
	for t := 0; t < T; t++ {
		var n int
		var s string
		fmt.Fscan(in, &n, &s)

		var buf bytes.Buffer
		for i := 0; i < n; i++ {
			if s[i] == '0' {
				continue
			}

			d := s[i] - '0'
			if i+3 < n && s[i+2] == '0' && s[i+3] != '0' || i == n-3 && s[i+2] == '0' {
				d = (s[i]-'0')*10 + (s[i+1] - '0')
				i++
			}
			buf.WriteByte('a' + d - 1)
		}
		fmt.Fprintln(out, buf.String())
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	var testCases int

	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)

	defer writer.Flush()

	fmt.Fscan(reader, &testCases)

	for testCase := 0; testCase < testCases; testCase++ {
		var n int
		var encodedFormat string
		fmt.Fscan(reader, &n)
		fmt.Fscan(reader, &encodedFormat)

		output := solveB(n, encodedFormat)

		fmt.Fprintln(writer, output)
	}
}

func solveB(n int, encodedFormat string) string {

	result := []byte{}

	for i := n - 1; i >= 0; i-- {
		currentDigit := 0

		if encodedFormat[i]-'0' == 0 {
			currentDigit = int(encodedFormat[i-2]-'0') * 10
			currentDigit += int(encodedFormat[i-1] - '0')
			i -= 2
		} else {
			currentDigit = int(encodedFormat[i] - '0')
		}
		// result
		// if currentDigit>
		currentDigit += 96
		result = append(result, byte(currentDigit))
	}
	rLen := len(result)
	for i := 0; i < rLen/2; i++ {
		result[i], result[(rLen-1)-i] = result[(rLen-1)-i], result[i]
	}
	return string(result)
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func toChar(i int) string {
	return string(rune('a' - 1 + i))
}
func main() {
	var T int
	var N int
	var S string
	var res string

	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &T)
	for T > 0 {
		fmt.Fscan(in, &N)
		fmt.Fscan(in, &S)
		res = ""
		for i := len(S) - 1; i >= 0; i-- {
			char := S[i]
			if char == '0' {
				subStr := S[i-2 : i+1]
				charPos, _ := strconv.Atoi(subStr)
				charRes := toChar(charPos / 10)
				res = charRes + res
				i -= 2
			} else {
				charPos, _ := strconv.Atoi(string(char))
				charRes := toChar(charPos)
				res = charRes + res
			}
		}
		fmt.Println(res)
		T--

	}

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
	"unicode/utf8"
)

type Number interface {
	int | int8 | int16 | int32 | int64 | float32 | float64 | byte | uint | uint16 | uint32 | uint64
}

var (
	scanner  *bufio.Scanner
	byWord   bool   //tokenization flag for scanWordsOrLines
	eof      bool   //flag whether reached end-of-file
	splitter string //scan delimiter for Ints(), etc.
)

func nthAlpabet(n int) byte {
	return byte('a' + n - 1)
}

func reverse(s string) string {
	size := len(s)
	buf := make([]byte, size)
	for start := 0; start < size; {
		r, n := utf8.DecodeRuneInString(s[start:])
		start += n
		utf8.EncodeRune(buf[size-start:], r)
	}
	return string(buf)
}

func toInt(b byte) int {
	return int(b - '0')
}

// main
func main() {
	for q := Int(); q > 0; q-- {
		n := Int()
		code := Word()
		ans := make([]byte, 0)
		for i := n - 1; i >= 0; i-- {
			if code[i] == '0' {
				ans = append(ans, nthAlpabet(10*toInt(code[i-2])+toInt(code[i-1])))
				i -= 2
			} else {
				ans = append(ans, nthAlpabet(toInt(code[i])))
			}
		}
		fmt.Println(reverse(string(ans)))
	}
}

// numeric library
func abs[T Number](a T) T {
	if a > 0 {
		return a
	}
	return -a
}

func min[T Number](a, b T) T {
	if a < b {
		return a
	}
	return b
}

func max[T Number](a, b T) T {
	if a > b {
		return a
	}
	return b
}

// stdin functions
func init() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(scanWordsOrLines)
	eof = false
	splitter = " "
}

// its behavior can be changed by byWord variable.
func scanWordsOrLines(data []byte, atEOF bool) (advance int, token []byte, err error) {
	if byWord {
		return bufio.ScanWords(data, atEOF)
	}
	return bufio.ScanLines(data, atEOF)
}

// byword arg changes how to scan.
func text(byword bool) string {
	byWord = byword
	if scanner.Scan() {
		return scanner.Text()
	}
	eof = true //reached end of file
	return ""
}

// EOF returns if scanner cursor has reached end-of-line or not.
func EOF() bool {
	return eof
}

// Word returns word like "dog" or "foobar" at the cursor.
func Word() string {
	return text(true)
}

// Words returns word array like ["dog", "foobar"] at the line.
func Words() []string {
	return strings.Split(Line(), splitter)
}

// Line returns whole line like "dog foobar" at the cursor.
func Line() string {
	return text(false)
}

// Lines returns array of all lines from the current cursor to end-of-file.
func Lines() []string {
	var ret []string
	for {
		l := Line()
		if EOF() {
			break
		}
		ret = append(ret, l)
	}
	return ret
}

func Byte() byte {
	return byte(Uint8())
}

// auto-generated code
func Int() int {
	ret, _ := strconv.ParseInt(Word(), 10, 0)
	return int(ret)
}

func Ints() []int {
	words := Words()
	n := len(words)
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseInt(words[i], 10, 0)
		ret[i] = int(v)
	}
	return ret
}

func Ints2() (int, int) {
	return Int(), Int()
}

func Ints3() (int, int, int) {
	return Int(), Int(), Int()
}

func Ints4() (int, int, int, int) {
	return Int(), Int(), Int(), Int()
}

func Ints5() (int, int, int, int, int) {
	return Int(), Int(), Int(), Int(), Int()
}

func Ints6() (int, int, int, int, int, int) {
	return Int(), Int(), Int(), Int(), Int(), Int()
}

func Ints7() (int, int, int, int, int, int, int) {
	return Int(), Int(), Int(), Int(), Int(), Int(), Int()
}

func Ints8() (int, int, int, int, int, int, int, int) {
	return Int(), Int(), Int(), Int(), Int(), Int(), Int(), Int()
}

func Ints9() (int, int, int, int, int, int, int, int, int) {
	return Int(), Int(), Int(), Int(), Int(), Int(), Int(), Int(), Int()
}

func IntsN(n int) []int {
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		ret[i] = Int()
	}
	return ret
}

func Int8() int8 {
	ret, _ := strconv.ParseInt(Word(), 10, 8)
	return int8(ret)
}

func Int8s() []int8 {
	words := Words()
	n := len(words)
	ret := make([]int8, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseInt(words[i], 10, 8)
		ret[i] = int8(v)
	}
	return ret
}

func Int8s2() (int8, int8) {
	return Int8(), Int8()
}

func Int8s3() (int8, int8, int8) {
	return Int8(), Int8(), Int8()
}

func Int8s4() (int8, int8, int8, int8) {
	return Int8(), Int8(), Int8(), Int8()
}

func Int8s5() (int8, int8, int8, int8, int8) {
	return Int8(), Int8(), Int8(), Int8(), Int8()
}

func Int8s6() (int8, int8, int8, int8, int8, int8) {
	return Int8(), Int8(), Int8(), Int8(), Int8(), Int8()
}

func Int8s7() (int8, int8, int8, int8, int8, int8, int8) {
	return Int8(), Int8(), Int8(), Int8(), Int8(), Int8(), Int8()
}

func Int8s8() (int8, int8, int8, int8, int8, int8, int8, int8) {
	return Int8(), Int8(), Int8(), Int8(), Int8(), Int8(), Int8(), Int8()
}

func Int8s9() (int8, int8, int8, int8, int8, int8, int8, int8, int8) {
	return Int8(), Int8(), Int8(), Int8(), Int8(), Int8(), Int8(), Int8(), Int8()
}

func Int8sN(n int) []int8 {
	ret := make([]int8, n)
	for i := 0; i < n; i++ {
		ret[i] = Int8()
	}
	return ret
}

func Int16() int16 {
	ret, _ := strconv.ParseInt(Word(), 10, 16)
	return int16(ret)
}

func Int16s() []int16 {
	words := Words()
	n := len(words)
	ret := make([]int16, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseInt(words[i], 10, 16)
		ret[i] = int16(v)
	}
	return ret
}

func Int16s2() (int16, int16) {
	return Int16(), Int16()
}

func Int16s3() (int16, int16, int16) {
	return Int16(), Int16(), Int16()
}

func Int16s4() (int16, int16, int16, int16) {
	return Int16(), Int16(), Int16(), Int16()
}

func Int16s5() (int16, int16, int16, int16, int16) {
	return Int16(), Int16(), Int16(), Int16(), Int16()
}

func Int16s6() (int16, int16, int16, int16, int16, int16) {
	return Int16(), Int16(), Int16(), Int16(), Int16(), Int16()
}

func Int16s7() (int16, int16, int16, int16, int16, int16, int16) {
	return Int16(), Int16(), Int16(), Int16(), Int16(), Int16(), Int16()
}

func Int16s8() (int16, int16, int16, int16, int16, int16, int16, int16) {
	return Int16(), Int16(), Int16(), Int16(), Int16(), Int16(), Int16(), Int16()
}

func Int16s9() (int16, int16, int16, int16, int16, int16, int16, int16, int16) {
	return Int16(), Int16(), Int16(), Int16(), Int16(), Int16(), Int16(), Int16(), Int16()
}

func Int16sN(n int) []int16 {
	ret := make([]int16, n)
	for i := 0; i < n; i++ {
		ret[i] = Int16()
	}
	return ret
}

func Int32() int32 {
	ret, _ := strconv.ParseInt(Word(), 10, 32)
	return int32(ret)
}

func Int32s() []int32 {
	words := Words()
	n := len(words)
	ret := make([]int32, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseInt(words[i], 10, 32)
		ret[i] = int32(v)
	}
	return ret
}

func Int32s2() (int32, int32) {
	return Int32(), Int32()
}

func Int32s3() (int32, int32, int32) {
	return Int32(), Int32(), Int32()
}

func Int32s4() (int32, int32, int32, int32) {
	return Int32(), Int32(), Int32(), Int32()
}

func Int32s5() (int32, int32, int32, int32, int32) {
	return Int32(), Int32(), Int32(), Int32(), Int32()
}

func Int32s6() (int32, int32, int32, int32, int32, int32) {
	return Int32(), Int32(), Int32(), Int32(), Int32(), Int32()
}

func Int32s7() (int32, int32, int32, int32, int32, int32, int32) {
	return Int32(), Int32(), Int32(), Int32(), Int32(), Int32(), Int32()
}

func Int32s8() (int32, int32, int32, int32, int32, int32, int32, int32) {
	return Int32(), Int32(), Int32(), Int32(), Int32(), Int32(), Int32(), Int32()
}

func Int32s9() (int32, int32, int32, int32, int32, int32, int32, int32, int32) {
	return Int32(), Int32(), Int32(), Int32(), Int32(), Int32(), Int32(), Int32(), Int32()
}

func Int32sN(n int) []int32 {
	ret := make([]int32, n)
	for i := 0; i < n; i++ {
		ret[i] = Int32()
	}
	return ret
}

func Int64() int64 {
	ret, _ := strconv.ParseInt(Word(), 10, 64)
	return int64(ret)
}

func Int64s() []int64 {
	words := Words()
	n := len(words)
	ret := make([]int64, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseInt(words[i], 10, 64)
		ret[i] = int64(v)
	}
	return ret
}

func Int64s2() (int64, int64) {
	return Int64(), Int64()
}

func Int64s3() (int64, int64, int64) {
	return Int64(), Int64(), Int64()
}

func Int64s4() (int64, int64, int64, int64) {
	return Int64(), Int64(), Int64(), Int64()
}

func Int64s5() (int64, int64, int64, int64, int64) {
	return Int64(), Int64(), Int64(), Int64(), Int64()
}

func Int64s6() (int64, int64, int64, int64, int64, int64) {
	return Int64(), Int64(), Int64(), Int64(), Int64(), Int64()
}

func Int64s7() (int64, int64, int64, int64, int64, int64, int64) {
	return Int64(), Int64(), Int64(), Int64(), Int64(), Int64(), Int64()
}

func Int64s8() (int64, int64, int64, int64, int64, int64, int64, int64) {
	return Int64(), Int64(), Int64(), Int64(), Int64(), Int64(), Int64(), Int64()
}

func Int64s9() (int64, int64, int64, int64, int64, int64, int64, int64, int64) {
	return Int64(), Int64(), Int64(), Int64(), Int64(), Int64(), Int64(), Int64(), Int64()
}

func Int64sN(n int) []int64 {
	ret := make([]int64, n)
	for i := 0; i < n; i++ {
		ret[i] = Int64()
	}
	return ret
}

func Uint() uint {
	ret, _ := strconv.ParseUint(Word(), 10, 0)
	return uint(ret)
}

func Uints() []uint {
	words := Words()
	n := len(words)
	ret := make([]uint, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseUint(words[i], 10, 0)
		ret[i] = uint(v)
	}
	return ret
}

func Uints2() (uint, uint) {
	return Uint(), Uint()
}

func Uints3() (uint, uint, uint) {
	return Uint(), Uint(), Uint()
}

func Uints4() (uint, uint, uint, uint) {
	return Uint(), Uint(), Uint(), Uint()
}

func Uints5() (uint, uint, uint, uint, uint) {
	return Uint(), Uint(), Uint(), Uint(), Uint()
}

func Uints6() (uint, uint, uint, uint, uint, uint) {
	return Uint(), Uint(), Uint(), Uint(), Uint(), Uint()
}

func Uints7() (uint, uint, uint, uint, uint, uint, uint) {
	return Uint(), Uint(), Uint(), Uint(), Uint(), Uint(), Uint()
}

func Uints8() (uint, uint, uint, uint, uint, uint, uint, uint) {
	return Uint(), Uint(), Uint(), Uint(), Uint(), Uint(), Uint(), Uint()
}

func Uints9() (uint, uint, uint, uint, uint, uint, uint, uint, uint) {
	return Uint(), Uint(), Uint(), Uint(), Uint(), Uint(), Uint(), Uint(), Uint()
}

func UintsN(n int) []uint {
	ret := make([]uint, n)
	for i := 0; i < n; i++ {
		ret[i] = Uint()
	}
	return ret
}

func Uint8() uint8 {
	ret, _ := strconv.ParseUint(Word(), 10, 8)
	return uint8(ret)
}

func Uint8s() []uint8 {
	words := Words()
	n := len(words)
	ret := make([]uint8, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseUint(words[i], 10, 8)
		ret[i] = uint8(v)
	}
	return ret
}

func Uint8s2() (uint8, uint8) {
	return Uint8(), Uint8()
}

func Uint8s3() (uint8, uint8, uint8) {
	return Uint8(), Uint8(), Uint8()
}

func Uint8s4() (uint8, uint8, uint8, uint8) {
	return Uint8(), Uint8(), Uint8(), Uint8()
}

func Uint8s5() (uint8, uint8, uint8, uint8, uint8) {
	return Uint8(), Uint8(), Uint8(), Uint8(), Uint8()
}

func Uint8s6() (uint8, uint8, uint8, uint8, uint8, uint8) {
	return Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8()
}

func Uint8s7() (uint8, uint8, uint8, uint8, uint8, uint8, uint8) {
	return Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8()
}

func Uint8s8() (uint8, uint8, uint8, uint8, uint8, uint8, uint8, uint8) {
	return Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8()
}

func Uint8s9() (uint8, uint8, uint8, uint8, uint8, uint8, uint8, uint8, uint8) {
	return Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8(), Uint8()
}

func Uint8sN(n int) []uint8 {
	ret := make([]uint8, n)
	for i := 0; i < n; i++ {
		ret[i] = Uint8()
	}
	return ret
}

func Uint16() uint16 {
	ret, _ := strconv.ParseUint(Word(), 10, 16)
	return uint16(ret)
}

func Uint16s() []uint16 {
	words := Words()
	n := len(words)
	ret := make([]uint16, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseUint(words[i], 10, 16)
		ret[i] = uint16(v)
	}
	return ret
}

func Uint16s2() (uint16, uint16) {
	return Uint16(), Uint16()
}

func Uint16s3() (uint16, uint16, uint16) {
	return Uint16(), Uint16(), Uint16()
}

func Uint16s4() (uint16, uint16, uint16, uint16) {
	return Uint16(), Uint16(), Uint16(), Uint16()
}

func Uint16s5() (uint16, uint16, uint16, uint16, uint16) {
	return Uint16(), Uint16(), Uint16(), Uint16(), Uint16()
}

func Uint16s6() (uint16, uint16, uint16, uint16, uint16, uint16) {
	return Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16()
}

func Uint16s7() (uint16, uint16, uint16, uint16, uint16, uint16, uint16) {
	return Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16()
}

func Uint16s8() (uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16) {
	return Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16()
}

func Uint16s9() (uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16) {
	return Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16(), Uint16()
}

func Uint16sN(n int) []uint16 {
	ret := make([]uint16, n)
	for i := 0; i < n; i++ {
		ret[i] = Uint16()
	}
	return ret
}

func Uint32() uint32 {
	ret, _ := strconv.ParseUint(Word(), 10, 32)
	return uint32(ret)
}

func Uint32s() []uint32 {
	words := Words()
	n := len(words)
	ret := make([]uint32, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseUint(words[i], 10, 32)
		ret[i] = uint32(v)
	}
	return ret
}

func Uint32s2() (uint32, uint32) {
	return Uint32(), Uint32()
}

func Uint32s3() (uint32, uint32, uint32) {
	return Uint32(), Uint32(), Uint32()
}

func Uint32s4() (uint32, uint32, uint32, uint32) {
	return Uint32(), Uint32(), Uint32(), Uint32()
}

func Uint32s5() (uint32, uint32, uint32, uint32, uint32) {
	return Uint32(), Uint32(), Uint32(), Uint32(), Uint32()
}

func Uint32s6() (uint32, uint32, uint32, uint32, uint32, uint32) {
	return Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32()
}

func Uint32s7() (uint32, uint32, uint32, uint32, uint32, uint32, uint32) {
	return Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32()
}

func Uint32s8() (uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32) {
	return Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32()
}

func Uint32s9() (uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32) {
	return Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32(), Uint32()
}

func Uint32sN(n int) []uint32 {
	ret := make([]uint32, n)
	for i := 0; i < n; i++ {
		ret[i] = Uint32()
	}
	return ret
}

func Uint64() uint64 {
	ret, _ := strconv.ParseUint(Word(), 10, 64)
	return uint64(ret)
}

func Uint64s() []uint64 {
	words := Words()
	n := len(words)
	ret := make([]uint64, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseUint(words[i], 10, 64)
		ret[i] = uint64(v)
	}
	return ret
}

func Uint64s2() (uint64, uint64) {
	return Uint64(), Uint64()
}

func Uint64s3() (uint64, uint64, uint64) {
	return Uint64(), Uint64(), Uint64()
}

func Uint64s4() (uint64, uint64, uint64, uint64) {
	return Uint64(), Uint64(), Uint64(), Uint64()
}

func Uint64s5() (uint64, uint64, uint64, uint64, uint64) {
	return Uint64(), Uint64(), Uint64(), Uint64(), Uint64()
}

func Uint64s6() (uint64, uint64, uint64, uint64, uint64, uint64) {
	return Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64()
}

func Uint64s7() (uint64, uint64, uint64, uint64, uint64, uint64, uint64) {
	return Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64()
}

func Uint64s8() (uint64, uint64, uint64, uint64, uint64, uint64, uint64, uint64) {
	return Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64()
}

func Uint64s9() (uint64, uint64, uint64, uint64, uint64, uint64, uint64, uint64, uint64) {
	return Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64(), Uint64()
}

func Uint64sN(n int) []uint64 {
	ret := make([]uint64, n)
	for i := 0; i < n; i++ {
		ret[i] = Uint64()
	}
	return ret
}

func Float32() float32 {
	ret, _ := strconv.ParseFloat(Word(), 32)
	return float32(ret)
}

func Float32s() []float32 {
	words := Words()
	n := len(words)
	ret := make([]float32, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseFloat(words[i], 32)
		ret[i] = float32(v)
	}
	return ret
}

func Float32s2() (float32, float32) {
	return Float32(), Float32()
}

func Float32s3() (float32, float32, float32) {
	return Float32(), Float32(), Float32()
}

func Float32s4() (float32, float32, float32, float32) {
	return Float32(), Float32(), Float32(), Float32()
}

func Float32s5() (float32, float32, float32, float32, float32) {
	return Float32(), Float32(), Float32(), Float32(), Float32()
}

func Float32s6() (float32, float32, float32, float32, float32, float32) {
	return Float32(), Float32(), Float32(), Float32(), Float32(), Float32()
}

func Float32s7() (float32, float32, float32, float32, float32, float32, float32) {
	return Float32(), Float32(), Float32(), Float32(), Float32(), Float32(), Float32()
}

func Float32s8() (float32, float32, float32, float32, float32, float32, float32, float32) {
	return Float32(), Float32(), Float32(), Float32(), Float32(), Float32(), Float32(), Float32()
}

func Float32s9() (float32, float32, float32, float32, float32, float32, float32, float32, float32) {
	return Float32(), Float32(), Float32(), Float32(), Float32(), Float32(), Float32(), Float32(), Float32()
}

func Float32sN(n int) []float32 {
	ret := make([]float32, n)
	for i := 0; i < n; i++ {
		ret[i] = Float32()
	}
	return ret
}

func Float64() float64 {
	ret, _ := strconv.ParseFloat(Word(), 64)
	return float64(ret)
}

func Float64s() []float64 {
	words := Words()
	n := len(words)
	ret := make([]float64, n)
	for i := 0; i < n; i++ {
		v, _ := strconv.ParseFloat(words[i], 64)
		ret[i] = float64(v)
	}
	return ret
}

func Float64s2() (float64, float64) {
	return Float64(), Float64()
}

func Float64s3() (float64, float64, float64) {
	return Float64(), Float64(), Float64()
}

func Float64s4() (float64, float64, float64, float64) {
	return Float64(), Float64(), Float64(), Float64()
}

func Float64s5() (float64, float64, float64, float64, float64) {
	return Float64(), Float64(), Float64(), Float64(), Float64()
}

func Float64s6() (float64, float64, float64, float64, float64, float64) {
	return Float64(), Float64(), Float64(), Float64(), Float64(), Float64()
}

func Float64s7() (float64, float64, float64, float64, float64, float64, float64) {
	return Float64(), Float64(), Float64(), Float64(), Float64(), Float64(), Float64()
}

func Float64s8() (float64, float64, float64, float64, float64, float64, float64, float64) {
	return Float64(), Float64(), Float64(), Float64(), Float64(), Float64(), Float64(), Float64()
}

func Float64s9() (float64, float64, float64, float64, float64, float64, float64, float64, float64) {
	return Float64(), Float64(), Float64(), Float64(), Float64(), Float64(), Float64(), Float64(), Float64()
}

func Float64sN(n int) []float64 {
	ret := make([]float64, n)
	for i := 0; i < n; i++ {
		ret[i] = Float64()
	}
	return ret
}

func Words2() (string, string) {
	return Word(), Word()
}

func Words3() (string, string, string) {
	return Word(), Word(), Word()
}

func Words4() (string, string, string, string) {
	return Word(), Word(), Word(), Word()
}

func Words5() (string, string, string, string, string) {
	return Word(), Word(), Word(), Word(), Word()
}

func Words6() (string, string, string, string, string, string) {
	return Word(), Word(), Word(), Word(), Word(), Word()
}

func Words7() (string, string, string, string, string, string, string) {
	return Word(), Word(), Word(), Word(), Word(), Word(), Word()
}

func Words8() (string, string, string, string, string, string, string, string) {
	return Word(), Word(), Word(), Word(), Word(), Word(), Word(), Word()
}

func Words9() (string, string, string, string, string, string, string, string, string) {
	return Word(), Word(), Word(), Word(), Word(), Word(), Word(), Word(), Word()
}

func WordsN(n int) []string {
	ret := make([]string, n)
	for i := 0; i < n; i++ {
		ret[i] = Word()
	}
	return ret
}

func Lines2() (string, string) {
	return Line(), Line()
}

func Lines3() (string, string, string) {
	return Line(), Line(), Line()
}

func Lines4() (string, string, string, string) {
	return Line(), Line(), Line(), Line()
}

func Lines5() (string, string, string, string, string) {
	return Line(), Line(), Line(), Line(), Line()
}

func Lines6() (string, string, string, string, string, string) {
	return Line(), Line(), Line(), Line(), Line(), Line()
}

func Lines7() (string, string, string, string, string, string, string) {
	return Line(), Line(), Line(), Line(), Line(), Line(), Line()
}

func Lines8() (string, string, string, string, string, string, string, string) {
	return Line(), Line(), Line(), Line(), Line(), Line(), Line(), Line()
}

func Lines9() (string, string, string, string, string, string, string, string, string) {
	return Line(), Line(), Line(), Line(), Line(), Line(), Line(), Line(), Line()
}

func LinesN(n int) []string {
	ret := make([]string, n)
	for i := 0; i < n; i++ {
		ret[i] = Line()
	}
	return ret
}

func Bytes2() (byte, byte) {
	return Byte(), Byte()
}

func Bytes3() (byte, byte, byte) {
	return Byte(), Byte(), Byte()
}

func Bytes4() (byte, byte, byte, byte) {
	return Byte(), Byte(), Byte(), Byte()
}

func Bytes5() (byte, byte, byte, byte, byte) {
	return Byte(), Byte(), Byte(), Byte(), Byte()
}

func Bytes6() (byte, byte, byte, byte, byte, byte) {
	return Byte(), Byte(), Byte(), Byte(), Byte(), Byte()
}

func Bytes7() (byte, byte, byte, byte, byte, byte, byte) {
	return Byte(), Byte(), Byte(), Byte(), Byte(), Byte(), Byte()
}

func Bytes8() (byte, byte, byte, byte, byte, byte, byte, byte) {
	return Byte(), Byte(), Byte(), Byte(), Byte(), Byte(), Byte(), Byte()
}

func Bytes9() (byte, byte, byte, byte, byte, byte, byte, byte, byte) {
	return Byte(), Byte(), Byte(), Byte(), Byte(), Byte(), Byte(), Byte(), Byte()
}

func BytesN(n int) []byte {
	ret := make([]byte, n)
	for i := 0; i < n; i++ {
		ret[i] = Byte()
	}
	return ret
}

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func run(r_ io.Reader, w_ io.Writer) {
	in := bufio.NewReader(r_)
	out := bufio.NewWriter(w_)
	defer out.Flush()

	var t, n int
	var s string
	fmt.Fscan(in, &t)
	for t > 0 {
		t--

		fmt.Fscan(in, &n)
		fmt.Fscan(in, &s)
		rs := ""
		for i := n - 1; i >= 0; i-- {
			if s[i] > '0' {
				rs = string(s[i]-'1'+'a') + rs
			} else {
				if i-2 >= 0 {
					rs = string((s[i-2]-'0')*10+(s[i-1]-'1')+'a') + rs
					i -= 2
				} else {
					rs = string(s[i]-'1'+'a') + rs
				}
			}
		}
		fmt.Fprintln(out, rs)
	}
}

func main() {
	run(os.Stdin, os.Stdout)
}

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"
)

func main() {
	data, _ := ioutil.ReadAll(os.Stdin)
	ctroki := strings.Split(string(data), "\r\n")
	n, _ := strconv.Atoi(ctroki[0])
	pos := 2

	var wg sync.WaitGroup
	wg.Add(n)
	ch := make(chan struct{})

	go func() {
		wg.Wait()
		close(ch)
	}()
	timeout := 5 * time.Second

	output := make([]string, n)
	for i := 0; i < n; i++ {
		if ctroki[pos] == "" {
			continue
		}
		go atomicTotal(&output[i], ctroki[pos], &wg)

		pos = pos + 2
	}
	select {
	case <-time.After(timeout):
		fmt.Println(strings.Join(output, "\n"))
	case <-ch:
		fmt.Println(strings.Join(output, "\n"))
	}

}

func atomicTotal(output *string, nabor string, wg *sync.WaitGroup) {
	defer wg.Done()
	*output = recurs(nabor)
}

func recurs(str string) string {

	if str[len(str)-1] != '0' {
		if len(str) > 1 {
			return recurs(str[:len(str)-1]) + btoi(str[len(str)-1:])
		}
		return btoi(str)
	}

	if len(str) > 3 {
		return recurs(str[:len(str)-3]) + btoi(str[len(str)-3:len(str)-1])
	}
	return btoi(str[:len(str)-1])
}

func btoi(b string) string {
	alfa := 'a'
	n, _ := strconv.Atoi(b)
	for n > 1 {
		n--
		alfa++
	}
	return string(alfa)
}

package main

import (
	"bufio"
	. "fmt"
	"os"
)

func main() {
	in, out := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var tests = 1
	Fscan(in, &tests)

	var run_case func()
	run_case = func() {
		var n int
		Fscan(in, &n)
		var s string
		Fscan(in, &s)
		//
		ans := []byte{}
		i := n - 1
		for i >= 0 {
			if s[i] == '0' {
				ans = append(ans, (s[i-2]-'0')*10+(s[i-1]-'0')-1+'a')
				i -= 3
			} else {
				ans = append(ans, (s[i]-'0')-1+'a')
				i -= 1
			}
		}
		for i := 0; i < len(ans)/2; i++ {
			ans[i], ans[len(ans)-i-1] = ans[len(ans)-i-1], ans[i]
		}
		Fprintln(out, string(ans))
	}

	for i := 0; i < tests; i++ {
		run_case()
	}
}

package main
import(
    "fmt"
    "bufio"
    "os"
    "strconv"
)
func main() {
	in:= bufio.NewReader(os.Stdin)
	out:= bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var alphabet = []string{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"}
	var t int
	fmt.Fscan(in,&t)
	for i:=0;i<t;i++{
		var n int
		fmt.Fscan(in,&n)
		var number string
		fmt.Fscan(in,&number)
		var list []int
		if string(number[len(number)-1]) != "0" {
			for k:=len(number)-1;k>=0;k--{
				if string(number[k]) == "0" {
					break
				} else {
					holder,_:= strconv.Atoi(string(number[k]))
					list= append(list,holder)
				}
			}
		}
		for j:=len(number)-1;j>0;j--{
			if string(number[j]) == "0"{
				for k:=j-2;k>=0;k--{
					if string(number[k]) == "0" {
						break
					} else {
						if k == j-2 {
							holder,_:= strconv.Atoi(string(number[k:j]))
							list= append(list, holder)
						} else {
							holder,_:= strconv.Atoi(string(number[k]))
							list= append(list,holder)
						}
					}
				}
				j--
			}
		}
		for j:=len(list)-1;j>=0;j--{
			fmt.Fprintf(out,"%v",alphabet[list[j]-1])
		}
		fmt.Fprintln(out,)
	}
}

// https://codeforces.com/problemset/problem/1729/B

// 1729B - Decode String

// Polycarp has a string s consisting of lowercase Latin letters.
// He encodes it using the following algorithm.
// He goes through the letters of the string s from left to right and for each letter Polycarp considers its number in the alphabet:
//  • if the letter number is single-digit number (less than 10), then just writes it out;
//  • if the letter number is a two-digit number (greater than or equal to 10), then it writes it out and adds the number 0 after.
// For example, if the string s is code, then Polycarp will encode this string as follows:
//  • 'c' — is the 3-rd letter of the alphabet. Consequently, Polycarp adds 3 to the code (the code becomes equal to 3);
//  • 'o' — is the 15-th letter of the alphabet. Consequently, Polycarp adds 15 to the code and also 0 (the code becomes 3150);
//  • 'd' — is the 4-th letter of the alphabet. Consequently, Polycarp adds 4 to the code (the code becomes 31504);
//  • 'e' — is the 5-th letter of the alphabet. Therefore, Polycarp adds 5 to the code (the code becomes 315045).
// Thus, code of string code is 315045.
// You are given a string t resulting from encoding the string s. Your task is to decode it (get the original string s by t).

// Input
// The first line of the input contains an integer q (1≤q≤10^4) — the number of test cases in the input.
// The descriptions of the test cases follow.
// The first line of description of each test case contains one integer n (1≤n≤50) — the length of the given code.
// The second line of the description of each test case contains a string t of length n — the given code. It is guaranteed that there exists such a string of lowercase Latin letters, as a result of encoding which the string t is obtained.

// Output
// For each test case output the required string s — the string that gives string t as the result of encoding. It is guaranteed that such a string always exists. It can be shown that such a string is always unique.

// Example
// input
// 9
// 6
// 315045
// 4
// 1100
// 7
// 1213121
// 6
// 120120
// 18
// 315045615018035190
// 7
// 1111110
// 7
// 1111100
// 5
// 11111
// 4
// 2606
// output
// code
// aj
// abacaba
// ll
// codeforces
// aaaak
// aaaaj
// aaaaa
// zf

// Note

// The first test case is explained above.
// In the second test case, the answer is aj. Indeed, the number of the letter a is equal to 1, so 1 will be appended to the code. The number of the letter j is 10, so 100 will be appended to the code. The resulting code is 1100.
// There are no zeros in the third test case, which means that the numbers of all letters are less than 10 and are encoded as one digit. The original string is abacaba.
// In the fourth test case, the string s is equal to ll. The letter l has the number 12 and is encoded as 120. So ll is indeed 120120.

// Tutorial

// The idea is as follows: we will go from the end of the string t and get the original string s.
// Note that if the current digit is 0, then a letter with a two-digit number has been encoded. Then we take a substring of length three from the end, discard 0 and get the number of the original letter.
// Otherwise, the current number ≠0, then a letter with a one-digit number was encoded. We easily reconstruct the original letter.
// Next, discard the already processed characters and repeat the process until the encoded string is complete.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	var reader = bufio.NewReader(os.Stdin)
	var writer = bufio.NewWriter(os.Stdout)
	var c int
	var q, n, i, j uint
	var t string
	var s []byte

	for c, _ = fmt.Fscan(reader, &q); c == 1; c, _ = fmt.Fscan(reader, &q) {
		for ; q > 0; q-- {
			fmt.Fscan(reader, &n, &t)
			s = make([]byte, 0)

			for i = n; i > 0; i-- {
				if t[i-1] != '0' {
					s = append(s, byte('a'+((t[i-1])-'0')-1))
				} else { // t[i-1] == '0'
					s = append(s, byte('a'+((t[i-3]-'0')*10+(t[i-2]-'0'))-1))
					i -= 2
				}
			}

			for i, j = 0, uint(len(s)); i+1 < j; i, j = i+1, j-1 {
				s[i], s[j-1] = s[j-1], s[i]
			}

			fmt.Fprintln(writer, string(s))
		}
	}

	writer.Flush()
}

package main

import (
        "bufio"
        "fmt"
        "os"
        "strconv"
        "strings"
)

func main() {
        reader := bufio.NewReader(os.Stdin)
        testCnt, _ := reader.ReadString('\n')
        testCnt = strings.TrimSpace(testCnt)
        testCntI, _ := strconv.Atoi(testCnt)
        for i := 0; i < testCntI; i++ {
                codeLen, _ := reader.ReadString('\n')
                code, _ := reader.ReadString('\n')
                solution(codeLen, code)
        }
}

func solution(cLen, code string) {
        cLen = strings.TrimSpace(cLen)
  codeLen, _ := strconv.Atoi(cLen)
        code = strings.TrimSpace(code)
  //fmt.Println(codeLen, code)
  res := ""
  for i:=codeLen-1; i>=0; i-- {
    chr := ""
    // found XX+0
    if code[i] == '0' {
      i--
      chr = string(code[i]) + chr
      i--
      chr = string(code[i]) + chr
    } else {
      chr = string(code[i])
    }
    chrCode, _ := strconv.Atoi(chr)
    chrCode = chrCode + 96
    //fmt.Println("chr code: ", chr, chrCode)

    res = string(rune(chrCode)) + res
  }
    fmt.Println(res)
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var alpha string = "abcdefghijklmnopqrstuvwxyz"

func decodeString(str string) string {
	result := ""
	var chOrd string
	takeTwo := false
	i := len(str) - 1
	for i >= 0 {
		if takeTwo {
			chOrd = string(str[i-1]) + string(str[i])
			i -= 2
			takeTwo = false
		} else {
			if string(str[i]) == "0" {
				takeTwo = true
				i--
				continue
			} else {
				chOrd = string(str[i])
				i--
			}
		}
		order, _ := strconv.Atoi(chOrd)
		result = string(alpha[order-1]) + result
	}
	return result
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	nrTests, _ := strconv.Atoi(scanner.Text())
	tests := make([]string, nrTests)
	for i := 0; i < nrTests; i++ {
		scanner.Scan()
		scanner.Text()
		scanner.Scan()
		tests[i] = scanner.Text()
	}
	for _, test := range tests {
		fmt.Println(decodeString(test))
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
)

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanws(a ...interface{})           { fmt.Fscan(reader, a...) }

func main() {

	defer writer.Flush()

	var tc int
	var n int
	var s string

	scanws(&tc)
	for t := 1; t <= tc; t++ {
		scanws(&n)
		scanws(&s)
		var ans []byte
		n = len(s)
		for i := n - 1; i >= 0; i-- {
			if s[i] == '0' {
				a := int(s[i-1] - '0')
				b := int((s[i-2] - '0') * 10)
				c := a + b
				ans = append(ans, byte(c+'a'-1))
				i -= 2
			} else {
				a := int(s[i] - '0')
				ans = append(ans, byte(a+'a'-1))
			}
		}
		n = len(ans)
		for i := n - 1; i >= 0; i-- {
			printf("%c", ans[i])
		}
		printf("\n")
	}

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type CF1729B struct {
	sc        *bufio.Reader
	split     []string
	index     int
	separator string
}

func (in *CF1729B) GetLine() string {
	line, err := in.sc.ReadString('\n')
	if err != nil {
		fmt.Println("error line:", line, " err: ", err)
	}
	in.split = []string{}
	in.index = 0
	return line
}
func (in *CF1729B) load() {
	if len(in.split) <= in.index {
		in.split = strings.Split(in.GetLine(), in.separator)
		in.index = 0
	}
}

func (in *CF1729B) NextInt() int {
	in.load()
	val, _ := strconv.Atoi(strings.TrimSpace(in.split[in.index]))
	in.index++
	return val
}

func (in *CF1729B) NextInt64() int64 {
	in.load()
	val, _ := strconv.ParseInt(strings.TrimSpace(in.split[in.index]), 10, 64)
	in.index++
	return val
}

func (in *CF1729B) NextString() string {
	in.load()
	val := strings.TrimSpace(in.split[in.index])
	in.index++
	return val
}

/**
Run solve the problem CF1729B
Date: 9/13/2022
User: wotan
URL: https://codeforces.com/problemset/problem/1729/B
Problem: CF1729B
**/
func (in *CF1729B) Run() {
	for t := in.NextInt(); t > 0; t-- {
		n := in.NextInt()
		str := in.NextString()
		sol := ""
		for i := n - 1; i >= 0; {
			if str[i] == '0' && i-2 >= 0 {
				val := int(str[i-1]-'0') + int(str[i-2]-'0')*10
				sol = string(rune(val+'a'-1)) + sol
				i -= 3
			} else {
				val := str[i]
				sol = string(rune(val-'0'+'a'-1)) + sol
				i -= 1
			}
		}
		fmt.Println(sol)
	}
}

func NewCF1729B(r *bufio.Reader) *CF1729B {
	return &CF1729B{
		sc:        r,
		split:     []string{},
		index:     0,
		separator: " ",
	}
}

func main() {
	NewCF1729B(bufio.NewReader(os.Stdin)).Run()
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	q := readInt64()
	for i := int64(0); i < q; i++ {
		_ = readInt64()
		s := readString()
		var res []byte
		for j := len(s) - 1; j >= 0; {
			symb := s[j]
			var letterN string
			if symb == '0' {
				letterN = s[j-2 : j]
				j -= 3
			} else {
				letterN = s[j : j+1]
				j -= 1
			}

			n, _ := strconv.Atoi(letterN)
			charToAppend := 'a' - 1 + n
			res = append([]byte{byte(charToAppend)}, res...)
		}

		fmt.Println(string(res))
	}
}

var in = bufio.NewReader(os.Stdin)

func readInt64() int64 {
	nStr, _ := in.ReadString('\n')
	nStr = strings.ReplaceAll(nStr, "\r", "")
	nStr = strings.ReplaceAll(nStr, "\n", "")
	n, _ := strconv.ParseInt(nStr, 10, 64)
	return n
}

func readString() string {
	line, _ := in.ReadString('\n')
	line = strings.ReplaceAll(line, "\r", "")
	line = strings.ReplaceAll(line, "\n", "")
	return line
}

func readLineNumbs() []string {
	line, _ := in.ReadString('\n')
	line = strings.ReplaceAll(line, "\r", "")
	line = strings.ReplaceAll(line, "\n", "")
	numbs := strings.Split(line, " ")
	return numbs
}

func readArrInt64() []int64 {
	numbs := readLineNumbs()
	arr := make([]int64, len(numbs))
	for i, n := range numbs {
		val, _ := strconv.ParseInt(n, 10, 64)
		arr[i] = val
	}
	return arr
}

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	defer writer.Flush()
	var t, n int
	var numstr string
	scanws(&t)
	for ; t > 0; t-- {
		scanws(&n)
		scanws(&numstr)
		printf("%s\n", solve(numstr))
	}
}

func solve(str string) string {
	var num, n, i int
	var runes []rune
	var secretword string

	runes = []rune(str)
	n = len(runes)

	i = n - 1
	for i >= 0 {
		if i > 1 && runes[i] == '0' {
			num = runeToInt(runes[i-2 : i]...)
			i -= 3
		} else {
			num = runeToInt(runes[i])
			i--
		}
		secretword = fmt.Sprintf("%c", rune(97+num-1)) + secretword
	}

	return secretword
}

func runeToInt(s ...rune) int {
	var out int
	for _, el := range s {
		out = out*10 + int(el-'0')
	}
	return out
}

// IO
var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanws(a ...interface{}) { fmt.Fscan(reader, a...) }

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
)

func main() {
	// f, err := os.OpenFile("data.txt", os.O_RDONLY, 0644)
	// if err != nil {
	// 	os.Exit(-2)
	// }

	// r := bufio.NewReader(f)
	w := bufio.NewWriter(os.Stdout)
	r := bufio.NewReader(os.Stdin)
	Solve(r, w, w.Flush)
}

func Solve(reader io.Reader, writer io.Writer, Flush func() error) {
	var t int
	fmt.Fscanln(reader, &t)

	start := int('a' - 1)
	for ; t > 0; t-- {
		var n int
		var s string
		fmt.Fscanln(reader, &n)
		fmt.Fscanln(reader, &s)

		codes := make([]int, 0)
		for i := n - 1; i >= 0; {
			v := i - 2
			if v >= 0 && s[i] == '0' {
				code, _ := strconv.Atoi(s[v:i])
				codes = append(codes, start+code)
				i -= 3
				continue
			}
			code, _ := strconv.Atoi(s[i : i+1])
			codes = append(codes, start+code)
			i--
		}
		for i := len(codes) - 1; i >= 0; i-- {
			fmt.Fprintf(writer, "%c", codes[i])
		}
		fmt.Fprintln(writer)
	}
	Flush()
}

/*
	A template for Go on codeforces.com
	Author: Yakov, frvr.ru
*/

package main

import (
	"bufio"
	"fmt"

	//"math"
	"os"
	"reflect"
	"strconv"
	"strings"
)

func main() {
	// START WRITING YOUR SOLUTION HERE:
	// writeLine(typeOf(readInt()))
	t := readInt()
	for j := 0; j < t; j++ {
		n := readInt()
		s := readString()
		i := 0
		var ans string
		map1 := map[int]string{
			1: "a", 2: "b", 3: "c", 4: "d", 5: "e", 6: "f", 7: "g", 8: "h", 9: "i", 10: "j", 11: "k", 12: "l", 13: "m", 14: "n", 15: "o", 16: "p", 17: "q", 18: "r", 19: "s", 20: "t", 21: "u", 22: "v", 23: "w", 24: "x", 25: "y", 26: "z"}

		for i < n {
			var a string
			if ((i + 2) < n) && s[i+2] == '0' {
				j := 0
				if i+3 < n {
					if s[i+3] == '0' {
						a = string(s[i])
						i++
					} else {
						for j < 3 {
							a += string(s[i])
							j++
							i++
						}
						a = a[:len(a)-1]
					}
				} else {
					for j < 3 {
						a += string(s[i])
						j++
						i++
					}
					a = a[:len(a)-1]
				}
			} else {
				a = string(s[i])
				i++
			}
			//fmt.Printf("a====>%v\n", a)
			val, _ := strconv.Atoi(a)
			if len(ans) == 0 {
				ans = map1[val]
			} else {
				ans += map1[val]
			}
		}
		writeLine(ans)
	}

}

/* ~~~~~~~~~~ */
/* ~~~~~~~~~~ */
/* ~~~~~~~~~~ */

var in = bufio.NewReader(os.Stdin)

type float = float32
type double = float64
type long = int64
type ulong = uint64

func typeOf(arg interface{}) string {
	switch reflect.TypeOf(arg).Kind() {
	case reflect.Int:
		return "int"
	case reflect.Int8:
		return "int8"
	case reflect.Int16:
		return "int16"
	case reflect.Int32:
		return "int32"
	case reflect.Int64:
		return "int64"
	case reflect.Uint:
		return "uint"
	case reflect.Uint8:
		return "uint8"
	case reflect.Uint16:
		return "uint16"
	case reflect.Uint32:
		return "uint32"
	case reflect.Uint64:
		return "uint64"
	case reflect.Float32:
		return "float32"
	case reflect.Float64:
		return "float64"
	case reflect.Complex64:
		return "complex64"
	case reflect.Complex128:
		return "complex128"
	case reflect.Bool:
		return "bool"
	case reflect.String:
		return "string"
	case reflect.Chan:
		return "chan"
	case reflect.Ptr:
		return "ptr"
	case reflect.Uintptr:
		return "uintptr"
	case reflect.UnsafePointer:
		return "unsafeptr"
	case reflect.Interface:
		return "interface"
	case reflect.Array:
		return "array"
	case reflect.Slice:
		return "slice"
	case reflect.Map:
		return "map"
	case reflect.Struct:
		return "struct"
	case reflect.Func:
		return "func"
	case reflect.Invalid:
		return "invalid"
	default:
		return "nil"
	}
}

/* ~~~~~~~~~~ */

func _scln() string {
	ln, _ := in.ReadString('\n')
	return strings.Trim(ln, " \r\n")
}
func _sc(s []string) string {
	if len(s) == 0 {
		return _scln()
	}
	return s[0]
}

func readLine() string              { return _scln() }
func readString() string            { return _scln() }
func readStrings() []string         { return strings.Split(_scln(), " ") }
func readBool(s ...string) bool     { t, _ := strconv.ParseBool(_sc(s)); return t }
func readByte(s ...string) byte     { t, _ := strconv.ParseUint(_sc(s), 10, 8); return byte(t) }
func readDouble(s ...string) double { t, _ := strconv.ParseFloat(_sc(s), 64); return t }
func readFloat(s ...string) float   { t, _ := strconv.ParseFloat(_sc(s), 32); return float32(t) }
func readInt(s ...string) int       { t, _ := strconv.Atoi(_sc(s)); return t }
func readLong(s ...string) long     { t, _ := strconv.ParseInt(_sc(s), 10, 64); return t }
func readULong(s ...string) ulong   { t, _ := strconv.ParseUint(_sc(s), 10, 64); return t }

/* ~~~~~~~~~~ */

// Too much overhead with universal method using interface{}, wait for the generics,
// but for now — just don't look at the redundancy of the code after that commentary :)

func readBools() []bool {
	strs := readStrings()
	arr := make([]bool, len(strs))
	for i, s := range strs {
		arr[i] = readBool(s)
	}
	return arr
}
func readBytes() []byte {
	strs := readStrings()
	arr := make([]byte, len(strs))
	for i, s := range strs {
		arr[i] = readByte(s)
	}
	return arr
}
func readDoubles() []double {
	strs := readStrings()
	arr := make([]double, len(strs))
	for i, s := range strs {
		arr[i] = readDouble(s)
	}
	return arr
}
func readFloats() []float {
	strs := readStrings()
	arr := make([]float, len(strs))
	for i, s := range strs {
		arr[i] = readFloat(s)
	}
	return arr
}
func readInts() []int {
	strs := readStrings()
	arr := make([]int, len(strs))
	for i, s := range strs {
		arr[i] = readInt(s)
	}
	return arr
}
func readLongs() []long {
	strs := readStrings()
	arr := make([]long, len(strs))
	for i, s := range strs {
		arr[i] = readLong(s)
	}
	return arr
}
func readULongs() []ulong {
	strs := readStrings()
	arr := make([]ulong, len(strs))
	for i, s := range strs {
		arr[i] = readULong(s)
	}
	return arr
}

/* ~~~~~~~~~~ */

func write(arg ...interface{})                 { fmt.Print(arg...) }
func writeLine(arg ...interface{})             { fmt.Println(arg...) }
func writeFormat(f string, arg ...interface{}) { fmt.Printf(f, arg...) }

package main

import (
	"bufio"
	"fmt"
	"os"
)

var in *bufio.Reader
var out *bufio.Writer

////////////////////////////////////////////////

func solve() {
	n := ReadInt()
	s := ReadString()

	ans := make([]rune, 0)
	for i := n - 1; i >= 0; {
		if s[i] == '0' {
			x := (s[i-2]-'0')*10 + (s[i-1] - '0') - 1
			ans = append(ans, rune('a'+x))
			i -= 3
		} else {
			ans = append(ans, rune('a'+(s[i]-'0')-1))
			i -= 1
		}
	}
	for i := len(ans) - 1; i >= 0; i-- {
		Print(string(ans[i]))
	}
	Println()
}

func main() {
	in = bufio.NewReader(os.Stdin)
	out = bufio.NewWriter(os.Stdout)
	defer out.Flush()

	t := 1
	t = ReadInt()

	for i := 0; i < t; i++ {
		solve()
	}
}

func ReadInt() int {
	var x int
	fmt.Fscan(in, &x)
	return x
}

func ReadInts(n int) []int {
	a := make([]int, n)
	for i, _ := range a {
		a[i] = ReadInt()
	}
	return a
}

func ReadString() string {
	var x string
	fmt.Fscan(in, &x)
	return x
}

func Print(a ...any) {
	fmt.Fprint(out, a...)
}

func Println(a ...any) {
	fmt.Fprintln(out, a...)
}

type IntPair struct {
	x int
	y int
}

func Iota(a []int, start int) {
	for i := 0; i < len(a); i++ {
		a[i] = start
		start++
	}
}

func NextPermutation(a []int) bool {
	n := len(a)
	pos := n - 2
	for ; pos >= 0; pos-- {
		if a[pos] < a[pos+1] {
			break
		}
	}
	if pos == -1 {
		return false
	}
	for i := n - 1; i >= 0; i-- {
		if a[i] > a[pos] {
			a[i], a[pos] = a[pos], a[i]
			Reverse(a[pos+1 : n])
			break
		}
	}
	return true
}

func Reverse(a []int) {
	n := len(a)
	for i := 0; i < n/2; i++ {
		a[i], a[n-i-1] = a[n-i-1], a[i]
	}
}

func RemoveIf(a []int, cond func(int) bool) []int {
	n := len(a)
	pos := 0
	for i := 0; i < n; i++ {
		if !cond(a[i]) {
			a[pos] = a[i]
			pos++
		}
	}
	return a[0:pos]
}

func Min(a int, b int) int {
	if a < b {
		return a
	} else {
		return b
	}
}

func Max(a int, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func Abs(x int) int {
	if x < 0 {
		return -x
	} else {
		return x
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var (
	in  = bufio.NewReader(os.Stdin)
	out = bufio.NewWriter(os.Stdout)
)

func main() {

	defer out.Flush()

	q := 0
	if _, err := fmt.Fscan(in, &q); err != nil {
		return
	}

	for ; q > 0; q-- {
		n := 0
		if _, err := fmt.Fscan(in, &n); err != nil {
			return
		}
		t := ""
		if _, err := fmt.Fscan(in, &t); err != nil {
			return
		}
		t += "11111"
		s := ""
		for i := 0; i < n; i++ {
			if t[i+2] == '0' && t[i+3] != '0' {
				num, _ := strconv.Atoi(t[i : i+2])
				s += string(num + 'a' - 1)
				i += 2
			} else {
				s += string(t[i] - '0' + 'a' - 1)
			}
		}
		fmt.Println(s)
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var in, out = bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)

func solve() string {
	var l int
	var s string
	var res string
	fmt.Fscan(in, &l, &s)

	for i := l - 1; i >= 0; i-- {
		if s[i] == '0' {
			sym, _ := strconv.Atoi(s[i-2 : i])
			r := 'a' - 1 + rune(sym)
			res = string(r) + res
			i -= 2
		} else {
			r, _ := strconv.Atoi(string(s[i]))
			res = string('a'-1+rune(r)) + res
		}
	}

	return res
}

func main() {
	defer out.Flush()
	var t int
	for fmt.Fscanln(in, &t); t > 0; t-- {
		fmt.Fprintln(out, solve())
	}
}

// util functions
func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func makeMatrix(n, m int) [][]int {
	x := make([][]int, n)
	for i := range x {
		x[i] = make([]int, m)
	}
	return x
}

package main

import (
	"fmt"
)

// fmt.Println('a'-96, 'b'-96, 'c'-96, 'd'-96, 'e'-96)
// fmt.Println(s[i] - 96)
// fmt.Println(string(byte(3 + 96)))

func main() {

	fmt.Println('0'-48, '1'-48, '2'-48, '3'-48, '4'-48, '5'-48, "...", '9'-48)

	var q int
	fmt.Scanln(&q)

	for l := 0; l < q; l++ {
		var n int
		fmt.Scanln(&n)
		var s string
		fmt.Scanln(&s)

		var i int
		for i < len(s) {

			if i+2 < len(s) && s[i+2] == '0' {
				if i+3 < len(s) && s[i+3] == '0' {
					// case when sequential 00
					d := int(s[i] - 48)
					// d, _ := strconv.Atoi(string(s[i]))
					fmt.Print(string(byte(d + 96)))
					i += 1
					continue
				}
				d := int(s[i]-48)*10 + int(s[i+1]-48)
				// d, _ := strconv.Atoi(s[i : i+2])
				fmt.Print(string(byte(d + 96)))
				i += 3
			} else {
				d := int(s[i] - 48)
				// d, _ := strconv.Atoi(string(s[i]))
				fmt.Print(string(byte(d + 96)))
				i += 1
			}
		}
		fmt.Println()

	}
}

// func findIndexesOfZeros(s string) []int {
// 	res := make([]int, 0, len(s)/2)

// 	for i := range s {
// 		if s[i] == '0' {
// 			if i > 0 && s[i-1] == '0' {
// 				// case when sequential 00
// 				res = res[:len(res)-1]
// 			}
// 			res = append(res, i)
// 		}
// 	}

// 	return res
// }

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	var testCases int

	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)

	defer writer.Flush()

	fmt.Fscan(reader, &testCases)

	for testCase := 0; testCase < testCases; testCase++ {
		var n int
		var encodedFormat string
		fmt.Fscan(reader, &n)
		fmt.Fscan(reader, &encodedFormat)

		output := solveB(n, encodedFormat)

		fmt.Fprintln(writer, output)
	}
}

func solveB(n int, encodedFormat string) string {

	result := make([]byte, n)

	for i := n - 1; i >= 0; i-- {
		currentDigit := 0

		if encodedFormat[i]-'0' == 0 {
			currentDigit = int(encodedFormat[i-2]-'0') * 10
			currentDigit += int(encodedFormat[i-1] - '0')
			i -= 2
		} else {
			currentDigit = int(encodedFormat[i] - '0')
		}
		// result
		// if currentDigit>
		currentDigit += 96
		result[i] = byte(currentDigit)
	}

	return string(result)
}

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	var testCases int

	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)

	defer writer.Flush()

	fmt.Fscan(reader, &testCases)

	for testCase := 0; testCase < testCases; testCase++ {
		var n int
		var encodedFormat string
		fmt.Fscan(reader, &n)
		fmt.Fscan(reader, &encodedFormat)

		output := solveB(n, encodedFormat)

		fmt.Fprintln(writer, output)
	}
}

func solveB(n int, encodedFormat string) string {

	result := make([]rune, n)

	for i := n - 1; i >= 0; i-- {
		currentDigit := 0

		if encodedFormat[i]-'0' == 0 {
			currentDigit = int(encodedFormat[i-2]-'0') * 10
			currentDigit += int(encodedFormat[i-1] - '0')
			i -= 2
		} else {
			currentDigit = int(encodedFormat[i] - '0')
		}
		// result
		// if currentDigit>
		currentDigit += 96
		result[i] = rune(currentDigit)
	}

	return string(result)
}

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func run(r_ io.Reader, w_ io.Writer) {
	in := bufio.NewReader(r_)
	out := bufio.NewWriter(w_)
	defer out.Flush()

	var t, n int
	var s string
	fmt.Fscan(in, &t)
	for t > 0 {
		t--

		fmt.Fscan(in, &n)
		fmt.Fscan(in, &s)
		rs := ""
		for i := n - 1; i >= 0; i-- {
			if s[i] > '2' {
				rs = string(s[i]-'1'+'a') + rs
			} else {
				if i-2 >= 0 {
					rs = string((s[i-2]-'0')*10+(s[i-1]-'1')+'a') + rs
					i -= 2
				} else {
					rs = string(s[i]-'1'+'a') + rs
				}
			}
		}
		fmt.Fprintln(out, rs)
	}
}

func main() {
	run(os.Stdin, os.Stdout)
}

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"
)

func main() {
	data, _ := ioutil.ReadAll(os.Stdin)
	ctroki := strings.Split(string(data), "\r\n")
	n, _ := strconv.Atoi(ctroki[0])
	pos := 2

	var wg sync.WaitGroup
	wg.Add(n)
	ch := make(chan struct{})

	go func() {
		wg.Wait()
		close(ch)
	}()
	timeout := 5 * time.Second

	output := make([]string, n)
	for i := 0; i < n; i++ {
		if ctroki[pos] == "" {
			continue
		}
		go atomicTotal(&output[i], ctroki[pos], &wg)

		pos = pos + 2
	}
	select {
	case <-time.After(timeout):
		fmt.Println(strings.Join(output, "\n"))
	case <-ch:
		fmt.Println(strings.Join(output, "\n"))
	}

}

func atomicTotal(output *string, nabor string, wg *sync.WaitGroup) {
	defer wg.Done()
	*output = recurs(nabor)
}

func recurs(str string) string {

	if str[len(str)-1] != '0' {
		if len(str) > 1 {
			return recurs(str[:len(str)-1]) + btoi(str[len(str)-1:])
		}
		return btoi(str)
	}

	if len(str) > 3 {
		return recurs(str[:len(str)-3]) + btoi(str[len(str)-3:len(str)-1])
	}
	return btoi(str[:len(str)-1])
}

func btoi(b string) string {
	alfa := 'a'
	n, err := strconv.Atoi(b)
	fmt.Println(b, n, err)
	for n > 1 {
		n--
		alfa++
	}
	return string(alfa)
}

package main

import (
	"bufio"
	. "fmt"
	"os"
)

func main() {
	in, out := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var tests = 1
	Fscan(in, &tests)

	var run_case func()
	run_case = func() {
		var n int
		Fscan(in, &n)
		var s string
		Fscan(in, &s)
		//
		Fprintln(out, s)
		ans := []byte{}
		i := n - 1
		for i >= 0 {
			if s[i] == '0' {
				ans = append(ans, (s[i-2]-'0')*10+(s[i-1]-'0')-1+'a')
				i -= 3
			} else {
				ans = append(ans, (s[i]-'0')-1+'a')
				i -= 1
			}
		}
		for i := 0; i < len(ans)/2; i++ {
			ans[i], ans[len(ans)-i-1] = ans[len(ans)-i-1], ans[i]
		}
		Fprintln(out, string(ans))
	}

	for i := 0; i < tests; i++ {
		run_case()
	}
}