/*
ZHOU Cheng <c.zhou@live.com>
2019-5-18 22:48:21
*/
package main

import (
    "fmt"
    "math/big"
    "regexp"
    "strings"
)

var zero = big.NewInt(0)
var one = big.NewInt(1)
var ten = big.NewInt(10)

func getBigInt(s string) *big.Int {
    i, _ := new(big.Int).SetString(s, 10)
    return i
}

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

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

// 获取填充 0 的长度为 n 的数值字符串
func getZeroString(value *big.Int, n int) string {
    s := value.String()
    for n = n - len(s); n > 0; n-- {
        s = "0" + s
    }
    return s
}

// 长度为 bit，在 a 中偏移量为 offset 的 num 是否符合条件。不符合返回 zero
func validateBitAndOffset(bit, offset int, a string) *big.Int {
    // 零开头的，不符合要求，直接返回 zero
    if strings.HasPrefix(a[offset:], "0") {
        return zero
    }

    // 当目前的长度少于期望的长度，使用前面的值来填充
    if offset+bit > len(a) {
        missBit := offset + bit - len(a)
        prevStr := a[offset-missBit : offset]
        p := new(big.Int)
        // 全 9 特殊处理，填充 0
        if match, _ := regexp.MatchString("^9*$", prevStr); match {
            p.SetInt64(0)
        } else {
            p.SetString(prevStr, 10)
            p.Add(p, one)
        }
        a += getZeroString(p, missBit)
    }

    num := getBigInt(a[offset : offset+bit])
    n := new(big.Int)
    var left, right int
    // 检测左边是否满足条件
    n.Sub(num, one)
    right = offset
    for right > 0 {
        if n.Cmp(one) < 0 {
            return zero
        }
        nStr := n.String()
        left = max(0, right-len(nStr))
        if a[left:right] != nStr[len(nStr)-(right-left):] {
            return zero
        }
        right -= len(nStr)
        n.Sub(n, one)
    }
    // 检测右边是否满足条件
    n.Add(num, one)
    left = offset + bit
    length := len(a)
    for left < length {
        nStr := n.String()
        right = min(length, left+len(nStr))
        if a[left:right] != nStr[0:right-left] {
            return zero
        }
        left += len(nStr)
        n.Add(n, one)
    }
    return num
}

// 计算数字出现的位置
func getNumberPosition(num *big.Int, offset int) *big.Int {
    result := big.NewInt(0 - int64(offset))
    if num.Cmp(ten) < 0 {
        result.Add(result, num)
        return result
    }

    length := len(num.String())
    start := big.NewInt(1)
    for i := 1; i < length; i++ {
        count := big.NewInt(9)
        count.Mul(count, start)
        count.Mul(count, big.NewInt(int64(i)))
        result.Add(result, count)
        start.Mul(start, ten)
    }

    start.Sub(num, start)
    curr := big.NewInt(int64(length))
    curr.Mul(curr, start)
    curr.Add(curr, big.NewInt(1))
    result.Add(result, curr)
    return result
}

func main() {
    var a string
    _, _ = fmt.Scanf("%s", &a)

    // 全 0 特殊处理
    if match, _ := regexp.MatchString("^0*$", a); match {
        num := getBigInt("1" + a)
        fmt.Println(getNumberPosition(num, -1))
        return
    }

    best := big.NewInt(0)
    for i, j := 1, len(a); i <= j; i++ {
        for offset := i - 1; offset >= 0; offset-- {
            num := validateBitAndOffset(i, offset, a)
            if num.Cmp(zero) > 0 {
                curr := getNumberPosition(num, offset)
                if best.Cmp(zero) == 0 || best.Cmp(curr) > 0 {
                    best = curr
                }
            }
        }
        // 当前位数寻找到最优结果，打印并结束循环
        if best.Cmp(zero) > 0 {
            fmt.Println(best.String())
            break
        }
    }
}

func filterExpression(expression string) string {
    // 只允许 a 数字 + - * ^ ( )
    reg, _ := regexp.Compile("[a\\d\\+\\-\\*\\^\\(\\)]+")
    mapping := func(r rune) rune {
        if reg.MatchString(string(r)) {
            return r
        }
        return -1
    }
    return strings.Map(mapping, expression)
}

operatorOrder["+"] = 1
operatorOrder["-"] = 1
operatorOrder["*"] = 2
operatorOrder["^"] = 3
operatorOrder["("] = 4
operatorOrder[")"] = 0

const prime = 16769023

func powerMod(x, y int64) int64 {
    var i int64 = 1
    for j := x; y > 0; j = j * j % prime {
        if y&1 == 1 {
            i = i * j % prime
        }
        y = y >> 1
    }
    return i
}

func multiMod(x, y int64) int64 {
    return x * y % prime
}

/*
ZHOU Cheng <c.zhou@live.com>
2019-5-11 16:12:46
*/
package main

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

var operatorOrder = map[string]int{}

const Number = "1234567890"
const Mark = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

func filterExpression(expression string) string {
    // 只允许 a 数字 + - * ^ ( )
    reg, _ := regexp.Compile("[a\\d\\+\\-\\*\\^\\(\\)]+")
    mapping := func(r rune) rune {
        if reg.MatchString(string(r)) {
            return r
        }
        return -1
    }
    return strings.Map(mapping, expression)
}

func getNumOrOperator(expression string, offset int) (string, int) {
    c := expression[offset : offset+1]
    if c == "a" {
        return c, offset + 1
    }
    if _, ok := operatorOrder[c]; ok {
        return c, offset + 1
    }
    length := len(expression)
    number := ""
    for ; offset < length; offset++ {
        c := expression[offset : offset+1]
        if !strings.Contains(Number, c) {
            break
        }
        number += c
    }
    return number, offset
}

const prime = 16769023

func powerMod(x, y int64) int64 {
    var i int64 = 1
    for j := x; y > 0; j = j * j % prime {
        if y&1 == 1 {
            i = i * j % prime
        }
        y = y >> 1
    }
    return i
}

func multiMod(x, y int64) int64 {
    return x * y % prime
}

func calculateValue(val1, val2 int64, op string) int64 {
    switch op {
    case "+":
        return val1 + val2
    case "-":
        return val1 - val2
    case "*":
        return multiMod(val1, val2)
    case "^":
        return powerMod(val1, val2)
    default:
        return 0
    }
}

func calculateExpression(expression string, value int64) int64 {
    numStack := [50]int64{}
    numStackTop := 0
    opStack := [50]string{}
    opStackTop := 0

    curStr := ""
    offset := 0
    length := len(expression)
    for ; offset < length; {
        curStr, offset = getNumOrOperator(expression, offset)
        if curStr == "a" {
            numStackTop++
            numStack[numStackTop] = value
            continue
        }
        if _, ok := operatorOrder[curStr]; ok {
            curOrder, _ := operatorOrder[curStr]
            for opStackTop > 0 {
                topOrder, _ := operatorOrder[opStack[opStackTop]]
                // 如果优先级小于前面操作符，计算上一个值
                if curOrder <= topOrder && opStack[opStackTop] != "(" {
                    num1, num2 := numStack[numStackTop-1], numStack[numStackTop]
                    numStackTop -= 2
                    topOp := opStack[opStackTop]
                    opStackTop--

                    numStackTop++
                    numStack[numStackTop] = calculateValue(num1, num2, topOp)
                } else {
                    break
                }
            }
            opStackTop++
            opStack[opStackTop] = curStr

            // 检测结尾如果是 )，弹出两个括号。
            if opStack[opStackTop] == ")" {
                opStackTop--
                // 详细判断，兼容一个错误的测试用例
                if opStackTop > 0 && opStack[opStackTop] == "(" {
                    opStackTop--
                }
            }
            continue
        }
        // 最后处理数字
        num, _ := strconv.ParseInt(curStr, 10, 64)
        numStackTop++
        numStack[numStackTop] = num
    }

    // 还需要计算一次
    for ; opStackTop > 0; {
        num1, num2 := numStack[numStackTop-1], numStack[numStackTop]
        numStackTop -= 2
        op := opStack[opStackTop]
        opStackTop--

        numStackTop++
        numStack[numStackTop] = calculateValue(num1, num2, op)
    }
    return numStack[numStackTop]
}

func main() {
    scanner := bufio.NewScanner(os.Stdin)

    scanner.Scan()
    baseExpression := scanner.Text()
    baseExpression = filterExpression(baseExpression)

    scanner.Scan()
    nStr := scanner.Text()
    n, _ := strconv.Atoi(nStr)

    operatorOrder["+"] = 1
    operatorOrder["-"] = 1
    operatorOrder["*"] = 2
    operatorOrder["^"] = 3
    operatorOrder["("] = 4
    operatorOrder[")"] = 0

    const caseNum = 3
    values := [caseNum]int64{1, 3, 5}
    result := [caseNum]int64{}
    for i := 0; i < caseNum; i++ {
        result[i] = calculateExpression(baseExpression, values[i])
    }

    for offset := 0; offset < n; offset++ {
        scanner.Scan()
        expression := scanner.Text()
        expression = filterExpression(expression)
        equal := true
        for i := 0; equal && i < caseNum; i++ {
            r := calculateExpression(expression, values[i])
            if r != result[i] {
                equal = false
                break
            }
        }
        if equal {
            fmt.Print(Mark[offset : offset+1])
        }
    }
}