24点运算

let str = "1 2 3 4";
let temp = ["+", "-", "*", "/"];
while ((str = readline())) {
  function test(str, current, target, arr, indexArr, count) {
    if (count == arr.length) {
      if (current == target) {
        return str;
      } else {
        return false;
      }
    } else if (count < arr.length) {
      let re = false;
      for (let i = 0; i < indexArr.length; i++) {
        if (!indexArr[i]) {
          indexArr[i] = 1;
          if (count == 0) {
            re =
              re ||
              test(arr[i], transfer(arr[i]), target, arr, indexArr, count + 1);
          } else {
            for (let j = 0; j < 4; j++) {
              let last = current;
              switch (j) {
                case 0:
                  last += transfer(arr[i]);
                  break;
                case 1:
                  last -= transfer(arr[i]);
                  break;
                case 2:
                  last *= transfer(arr[i]);
                  break;
                case 3:
                  last /= transfer(arr[i]);
                  break;
              }
              re =
                re ||
                test(
                  str + temp[j] + arr[i],
                  last,
                  target,
                  arr,
                  indexArr,
                  count + 1
                );
            }
          }
          indexArr[i] = 0;
        }
      }
      return re;
    }
  }
  function transfer(it) {
    switch (it) {
      case "J":
        return 11;
      case "Q":
        return 12;
      case "K":
        return 13;
      case "A":
        return 1;
      default:
        return Number(it);
    }
  }
  let flag = true;
  str = str.split(" ").map((it) => {
    if (it == "joker" || it == "JOKER") {
      flag = false;
    }
    return it;
  });
  if (flag) {
    let re = test("", 0, 24, str, Array(str.length), 0);
    if (!re) {
      console.log("NONE");
    } else {
      console.log(re);
    }
  } else {
    console.log("ERROR");
  }
}

function f6(arr){
    /* 大小王返回Error */
    if(arr.indexOf('joker')!=-1||arr.indexOf('joker')!=-1||arr.length!=4) return 'ERROR'

    let computed = ['+','-','*','/']
    let com_arr = [] //存放计算符号穷举值

    /*输入值*/
    let data  = arr
    let data_arr = []  //存放数组穷举值

    /*穷举所有可能 存在重复  长度为三*/
    for (let i in computed){
        for (let j in computed){
            for (let l in computed){
                 com_arr.push([computed[i],computed[j],computed[l]])
            }
        }
    }
    //穷举所有数字组合数据 有重复
    for (let i in data){
        for (let j in data){
            for (let l in data){
                for (let k in data){
                    data_arr.push([data[i],data[j],data[l],data[k]])
                }
            }
        }
    }

    /*去重复*/
    let new_data = []
    for (let i in data_arr){
        let set = new Set(data_arr[i])
        let res = [...set]
        if(res.length == data.length){
            new_data.push(data_arr[i])
        }
    }

    // 计算结果集
    let result = []
   for (let i in com_arr){
        for (let k in new_data){
            if(eval(`((${com_str(new_data[k][0])}${com_arr[i][0]}${com_str(new_data[k][1])})${com_arr[i][1]}${com_str(new_data[k][2])})${com_arr[i][2]}${com_str(new_data[k][3])}`) == 24){
                result.push(`${new_data[k][0]}${com_arr[i][0]}${new_data[k][1]}${com_arr[i][1]}${new_data[k][2]}${com_arr[i][2]}${new_data[k][3]}`)
            }
        }
    }

    // 转换权重值
    function com_str(str){
        let num = str
        switch (str) {
            case 'J':
                num = 11
                break
            case 'Q':
                num = 12
                break
            case 'K':
                num = 13
                break
            case 'A':
                num = 1
                break
        }
        return Number(num)
    }
    // 返回结果
    if(result.length) {
        return result[0]
    }else{
        return 'NONE'
    }
}

while(line=readline()){
    let lines = line.split(' ');
    print(f6(lines));
}