(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:json)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (SimpleCommand
                        redirects: [
                          (Redir
                            op_id: Redir_Less
                            fd: 16777215
                            arg_word: {(/dev/stdin)}
                            spids: [5]
                          )
                        ]
                      )
                    ]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [4 7]
              )
            }
          spids: [3]
        )
        (assign_pair
          lhs: (LhsName name:oldlang)
          op: Equal
          rhs: {($ VSub_Name '$LANG')}
          spids: [9]
        )
        (assign_pair lhs:(LhsName name:LANG) op:Equal rhs:{(C)} spids:[12])
      ]
      spids: [3]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:str)
          op: Equal
          rhs: {(SQ <'("(\\\\.|[^\\\\"])*")'>)}
          spids: [15]
        )
      ]
      spids: [15]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:num)
          op: Equal
          rhs: {(DQ ('(-?(0|[1-9][0-9]*)(') (Lit_Other '\\') ('.[0-9]+)?([eE][+-]?[0-9]+)?)'))}
          spids: [23]
        )
      ]
      spids: [23]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:val)
          op: Equal
          rhs: {(DQ ('((str|num|obj|arr)[a-j]+|true|false|null)'))}
          spids: [30]
        )
      ]
      spids: [30]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:arr)
          op: Equal
          rhs: 
            {(DQ (Lit_Other '\\') ('[(') ($ VSub_Name '$val') ('(,') ($ VSub_Name '$val') (')*)?]'))}
          spids: [35]
        )
      ]
      spids: [35]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:obj)
          op: Equal
          rhs: 
            {
              (DQ (Lit_Other '\\') ('{(str[a-j]+:') ($ VSub_Name '$val') ('(,str[a-j]+:') 
                ($ VSub_Name '$val') (')*)?}')
              )
            }
          spids: [45]
        )
      ]
      spids: [45]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:tr)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {(Lit_LBrace '{') (a..j) (Lit_RBrace '}') (Lit_LBrace '{') (a..j) (Lit_RBrace '}') 
                    (Lit_LBrace '{') (a..j) (Lit_RBrace '}')
                  }
                ]
              )
            }
          spids: [55]
        )
      ]
      spids: [55]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-n]
      pairs: [(assign_pair lhs:(LhsName name:match) op:Equal spids:[75])]
      spids: [71]
    )
    (FuncDef
      name: push
      body: 
        (BraceGroup
          children: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Declare
                  flags: [-gn]
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:list)
                      op: Equal
                      rhs: {(${ VSub_Name type) (_list)}
                      spids: [89]
                    )
                  ]
                  spids: [85]
                )
              terminator: <Op_Semi ';'>
            )
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:list)
                      op: PlusEqual
                      rhs: 
                        {
                          (ArrayLiteralPart
                            words: [
                              {
                                (DQ 
                                  (BracedVarSub
                                    token: <VSub_Name BASH_REMATCH>
                                    bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 1)}))
                                    spids: [99 104]
                                  )
                                )
                              }
                            ]
                          )
                        }
                      spids: [96]
                    )
                  ]
                  spids: [96]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          spids: [83]
        )
      spids: [78 82]
    )
    (FuncDef
      name: match
      body: 
        (ForEach
          iter_name: match
          iter_words: [{(str)} {(num)} {(obj)} {(arr)}]
          do_arg_iter: F
          body: 
            (DoGroup
              children: [
                (AndOr
                  ops: [Op_DAmp]
                  children: [
                    (DBracket
                      expr: 
                        (LogicalAnd
                          left: 
                            (BoolBinary
                              op_id: BoolBinary_GlobNEqual
                              left: 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name match>
                                    prefix_op: VSub_Bang
                                    spids: [140 143]
                                  )
                                }
                              right: {(str)}
                            )
                          right: 
                            (LogicalNot
                              child: 
                                (BoolBinary
                                  op_id: BoolBinary_ne
                                  left: {(i) (Lit_Other '+') (Lit_Other '+')}
                                  right: {(0)}
                                )
                            )
                        )
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:json)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Name json>
                                suffix_op: 
                                  (PatSub
                                    pat: 
                                      {('[') 
                                        (SingleQuotedPart
                                          left: <Left_DollarSingleQuote "$'">
                                          tokens: [
                                            <Char_Literals ' '>
                                            <Char_OneChar '\\t'>
                                            <Char_OneChar '\\n'>
                                            <Char_OneChar '\\r'>
                                          ]
                                        ) (']')
                                      }
                                    do_all: T
                                    do_prefix: F
                                    do_suffix: F
                                  )
                                spids: [166 178]
                              )
                            }
                          spids: [165]
                        )
                      ]
                      spids: [165]
                    )
                  ]
                )
                (AndOr
                  ops: [Op_DAmp]
                  children: [
                    (DBracket
                      expr: 
                        (BoolBinary
                          op_id: BoolBinary_EqualTilde
                          left: {($ VSub_Name '$json')}
                          right: {($ VSub_Name '$match') ('(') (.) (Lit_Other '*') (')')}
                        )
                    )
                    (BraceGroup
                      children: [
                        (Sentence
                          child: 
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:type)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name match>
                                        prefix_op: VSub_Bang
                                        spids: [200 203]
                                      )
                                    }
                                  spids: [199]
                                )
                              ]
                              spids: [199]
                            )
                          terminator: <Op_Semi ';'>
                        )
                        (Sentence
                          child: (ControlFlow token:<ControlFlow_Return return>)
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      spids: [197]
                    )
                  ]
                )
              ]
              spids: [132 212]
            )
          spids: [122 130]
        )
      spids: [111 115]
    )
    (While
      cond: [(Sentence child:(C {(match)}) terminator:<Op_Semi ';'>)]
      body: 
        (DoGroup
          children: [
            (C {(push)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:json)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name json>
                        suffix_op: 
                          (StringUnary
                            op_id: VOp1_Percent
                            arg_word: {(DQ ($ VSub_Name '$BASH_REMATCH'))}
                          )
                        spids: [229 235]
                      ) ($ VSub_Name '$type') 
                      (BracedVarSub
                        token: <VSub_Name tr>
                        bracket_op: 
                          (ArrayIndex
                            expr: 
                              (ArithBinary
                                op_id: Arith_Minus
                                left: 
                                  (ArithWord
                                    w: 
                                      {
                                        (BracedVarSub
                                          token: <VSub_Name list>
                                          prefix_op: VSub_Pound
                                          bracket_op: (WholeArray op_id:Lit_At)
                                          spids: [240 246]
                                        )
                                      }
                                  )
                                right: (ArithWord w:{(Lit_Digits 1)})
                              )
                          )
                        spids: [237 250]
                      ) 
                      (BracedVarSub
                        token: <VSub_Name BASH_REMATCH>
                        bracket_op: 
                          (ArrayIndex
                            expr: 
                              (ArithUnary
                                op_id: Node_UnaryMinus
                                child: (ArithWord w:{(Lit_Digits 1)})
                              )
                          )
                        spids: [251 257]
                      )
                    }
                  spids: [228]
                )
              ]
              spids: [228]
            )
          ]
          spids: [220 259]
        )
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (DBracket
          expr: 
            (BoolBinary
              op_id: BoolBinary_EqualTilde
              left: {($ VSub_Name '$json')}
              right: {(Lit_Other '^') ($ VSub_Name '$val') (Lit_Other '$')}
            )
        )
        (ControlFlow token:<ControlFlow_Exit exit>)
      ]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-A]
      pairs: [(assign_pair lhs:(LhsName name:rt) op:Equal spids:[290])]
      spids: [286]
    )
    (ForEach
      iter_name: i
      iter_words: [
        {
          (DQ 
            (BracedVarSub
              token: <VSub_Name tr>
              bracket_op: (WholeArray op_id:Lit_At)
              spids: [305 310]
            )
          )
        }
      ]
      do_arg_iter: F
      body: 
        (DoGroup
          children: [
            (Sentence
              child: 
                (DParen
                  child: 
                    (BinaryAssign
                      op_id: Arith_Equal
                      left: (LhsIndexedName name:rt index:(ArithWord w:{($ VSub_Name '$i')}))
                      right: (UnaryAssign op_id:Node_PostDPlus child:(LhsName name:j))
                    )
                )
              terminator: <Op_Semi ';'>
            )
          ]
          spids: [314 328]
        )
      spids: [303 312]
    )
    (Sentence child:(C {(set)} {(-f)}) terminator:<Op_Semi ';'>)
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:LANG)
          op: Equal
          rhs: {($ VSub_Name '$oldlang')}
          spids: [335]
        )
        (assign_pair
          lhs: (LhsName name:IFS)
          op: Equal
          rhs: {(Lit_Other ':') (Lit_Comma ',')}
          spids: [338]
        )
        (assign_pair
          lhs: (LhsName name:regex)
          op: Equal
          rhs: {(SQ <'(\\\\[nftrb]|\\\\\\\\|\\\\u[a-f0-9]{4})'>)}
          spids: [342]
        )
      ]
      spids: [335]
    )
    (C {(shopt)} {(-s)} {(nocasematch)})
    (FuncDef
      name: print
      body: 
        (Case
          to_match: {($ VSub_Number '$1')}
          arms: [
            (case_arm
              pat_list: [{(null)} {(true)} {(false)}]
              action: [(C {(printf)} {(DQ ($ VSub_Number '$1'))})]
              spids: [366 371 379 16777215]
            )
            (case_arm
              pat_list: [{(str) (Lit_Other '*')}]
              action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:tmp)
                      op: Equal
                      rhs: 
                        {
                          (BracedVarSub
                            token: <VSub_Name str_list>
                            bracket_op: 
                              (ArrayIndex
                                expr: 
                                  (ArithBinary
                                    op_id: Arith_LBracket
                                    left: (ArithVarRef name:rt)
                                    right: 
                                      (ArithWord
                                        w: 
                                          {
                                            (BracedVarSub
                                              token: <VSub_Number 1>
                                              suffix_op: (Slice begin:(ArithWord w:{(Lit_Digits 3)}))
                                              spids: [392 396]
                                            )
                                          }
                                      )
                                  )
                              )
                            spids: [387 399]
                          )
                        }
                      spids: [386]
                    )
                  ]
                  spids: [386]
                )
                (While
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_EqualTilde
                              left: {($ VSub_Name '$tmp')}
                              right: {($ VSub_Name '$regex') ('(') (.) (Lit_Other '*') (')')}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  body: 
                    (DoGroup
                      children: [
                        (C {(printf)} {(Lit_Other '%') (s)} 
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name tmp>
                                suffix_op: 
                                  (StringUnary
                                    op_id: VOp1_Percent
                                    arg_word: {(DQ ($ VSub_Name '$BASH_REMATCH'))}
                                  )
                                spids: [428 434]
                              )
                            )
                          }
                        )
                        (Case
                          to_match: 
                            {
                              (BracedVarSub
                                token: <VSub_Name BASH_REMATCH>
                                bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 1)}))
                                spids: [440 445]
                              )
                            }
                          arms: [
                            (case_arm
                              pat_list: [{(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (u0008)}]
                              action: [(C {(printf)} {(SQ <'\\\\b'>)})]
                              spids: [450 452 460 16777215]
                            )
                            (case_arm
                              pat_list: [{(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (u0009)}]
                              action: [(C {(printf)} {(SQ <'\\\\t'>)})]
                              spids: [462 464 472 16777215]
                            )
                            (case_arm
                              pat_list: [{(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (u000a)}]
                              action: [(C {(printf)} {(SQ <'\\\\n'>)})]
                              spids: [475 477 485 16777215]
                            )
                            (case_arm
                              pat_list: [{(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (u000c)}]
                              action: [(C {(printf)} {(SQ <'\\\\f'>)})]
                              spids: [487 489 497 16777215]
                            )
                            (case_arm
                              pat_list: [{(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (u000d)}]
                              action: [(C {(printf)} {(SQ <'\\\\r'>)})]
                              spids: [500 502 510 16777215]
                            )
                            (case_arm
                              pat_list: [{(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (u0022)}]
                              action: [(C {(printf)} {(SQ <'\\\\"'>)})]
                              spids: [512 514 522 16777215]
                            )
                            (case_arm
                              pat_list: [{(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (u005c)}]
                              action: [(C {(printf)} {(SQ <'\\\\\\\\'>)})]
                              spids: [525 527 535 16777215]
                            )
                            (case_arm
                              pat_list: [
                                {(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\\\'>
                                  )
                                }
                                {(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (Lit_Other '[') 
                                  (nftrb) (Lit_Other ']')
                                }
                                {(EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (u00) 
                                  (Lit_Other '[') (01) (Lit_Other ']') (Lit_Other '?')
                                }
                              ]
                              action: [
                                (C {(printf)} {(Lit_Other '%') (s)} 
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Name BASH_REMATCH>
                                        bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 1)}))
                                        spids: [560 565]
                                      )
                                    )
                                  }
                                )
                              ]
                              spids: [538 552 568 16777215]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (C {(printf)} {(Lit_Other '%') (b)} 
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Name BASH_REMATCH>
                                        bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 1)}))
                                        spids: [580 585]
                                      )
                                    )
                                  }
                                )
                              ]
                              spids: [571 572 16777215 589]
                            )
                          ]
                          spids: [438 447 589]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:tmp)
                              op: Equal
                              rhs: 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name BASH_REMATCH>
                                    bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 2)}))
                                    spids: [593 598]
                                  )
                                }
                              spids: [592]
                            )
                          ]
                          spids: [592]
                        )
                      ]
                      spids: [419 601]
                    )
                )
                (C {(printf)} {(Lit_Other '%') (s)} {(DQ ($ VSub_Name '$tmp'))})
              ]
              spids: [382 384 613 16777215]
            )
            (case_arm
              pat_list: [{(num) (Lit_Other '*')}]
              action: [
                (C {(printf)} {(Lit_Other '%') (s)} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name num_list>
                        bracket_op: 
                          (ArrayIndex
                            expr: 
                              (ArithBinary
                                op_id: Arith_LBracket
                                left: (ArithVarRef name:rt)
                                right: 
                                  (ArithWord
                                    w: 
                                      {
                                        (BracedVarSub
                                          token: <VSub_Number 1>
                                          suffix_op: (Slice begin:(ArithWord w:{(Lit_Digits 3)}))
                                          spids: [634 638]
                                        )
                                      }
                                  )
                              )
                          )
                        spids: [629 641]
                      )
                    )
                  }
                )
              ]
              spids: [619 621 644 16777215]
            )
            (case_arm
              pat_list: [{(arr) (Lit_Other '*')}]
              action: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:array)
                      op: Equal
                      rhs: 
                        {
                          (ArrayLiteralPart
                            words: [
                              {
                                (BracedVarSub
                                  token: <VSub_Name arr_list>
                                  bracket_op: 
                                    (ArrayIndex
                                      expr: 
                                        (ArithBinary
                                          op_id: Arith_LBracket
                                          left: (ArithVarRef name:rt)
                                          right: 
                                            (ArithWord
                                              w: 
                                                {
                                                  (BracedVarSub
                                                    token: <VSub_Number 1>
                                                    suffix_op: 
                                                      (Slice
                                                        begin: (ArithWord w:{(Lit_Digits 3)})
                                                      )
                                                    spids: [660 664]
                                                  )
                                                }
                                            )
                                        )
                                    )
                                  spids: [655 667]
                                )
                              }
                            ]
                          )
                        }
                      spids: [653]
                    )
                  ]
                  spids: [651]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DParen
                              child: 
                                (ArithUnary
                                  op_id: Arith_Bang
                                  child: 
                                    (ArithWord
                                      w: 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name array>
                                            prefix_op: VSub_Pound
                                            bracket_op: (WholeArray op_id:Lit_At)
                                            spids: [675 681]
                                          )
                                        }
                                    )
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [(C {(printf)} {(DQ ('[]'))})]
                      spids: [16777215 686]
                    )
                  ]
                  else_action: [
                    (Sentence
                      child: 
                        (DParen
                          child: 
                            (BinaryAssign
                              op_id: Arith_PlusEqual
                              left: (LhsName name:indent)
                              right: (ArithWord w:{(Lit_Digits 2)})
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ ('[') (Lit_Other '\\') (n))})
                    (While
                      cond: [
                        (Sentence
                          child: 
                            (DParen
                              child: 
                                (ArithBinary
                                  op_id: Arith_Great
                                  left: 
                                    (ArithWord
                                      w: 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name array>
                                            prefix_op: VSub_Pound
                                            bracket_op: (WholeArray op_id:Lit_At)
                                            spids: [718 724]
                                          )
                                        }
                                    )
                                  right: (ArithWord w:{(Lit_Digits 1)})
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (DoGroup
                          children: [
                            (Sentence
                              child: (C {(printf)} {(DQ ('%*s'))} {(DQ ($ VSub_Name '$indent'))})
                              terminator: <Op_Semi ';'>
                            )
                            (Sentence
                              child: (C {(print)} {(DQ ($ VSub_Name '$array'))})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(printf)} {(DQ (',') (Lit_Other '\\') (n))})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:array)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (DQ 
                                              (BracedVarSub
                                                token: <VSub_Name array>
                                                bracket_op: (WholeArray op_id:Lit_At)
                                                suffix_op: (Slice begin:(ArithWord w:{(Lit_Digits 1)}))
                                                spids: [764 771]
                                              )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [761]
                                )
                              ]
                              spids: [761]
                            )
                          ]
                          spids: [731 776]
                        )
                    )
                    (Sentence
                      child: (C {(printf)} {(DQ ('%*s'))} {(DQ ($ VSub_Name '$indent'))})
                      terminator: <Op_Semi ';'>
                    )
                    (C {(print)} {(DQ ($ VSub_Name '$array'))})
                    (C {(printf)} {(DQ (Lit_Other '\\') ('n%*s]'))} 
                      {
                        (DQ 
                          (ArithSubPart
                            anode: 
                              (BinaryAssign
                                op_id: Arith_MinusEqual
                                left: (LhsName name:indent)
                                right: (ArithWord w:{(Lit_Digits 2)})
                              )
                            spids: [805 810]
                          )
                        )
                      }
                    )
                  ]
                  spids: [695 814]
                )
              ]
              spids: [647 649 816 16777215]
            )
            (case_arm
              pat_list: [{(obj) (Lit_Other '*')}]
              action: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:object)
                      op: Equal
                      rhs: 
                        {
                          (ArrayLiteralPart
                            words: [
                              {
                                (BracedVarSub
                                  token: <VSub_Name obj_list>
                                  bracket_op: 
                                    (ArrayIndex
                                      expr: 
                                        (ArithBinary
                                          op_id: Arith_LBracket
                                          left: (ArithVarRef name:rt)
                                          right: 
                                            (ArithWord
                                              w: 
                                                {
                                                  (BracedVarSub
                                                    token: <VSub_Number 1>
                                                    suffix_op: 
                                                      (Slice
                                                        begin: (ArithWord w:{(Lit_Digits 3)})
                                                      )
                                                    spids: [832 836]
                                                  )
                                                }
                                            )
                                        )
                                    )
                                  spids: [827 839]
                                )
                              }
                            ]
                          )
                        }
                      spids: [825]
                    )
                  ]
                  spids: [823]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DParen
                              child: 
                                (ArithUnary
                                  op_id: Arith_Bang
                                  child: 
                                    (ArithWord
                                      w: 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name object>
                                            prefix_op: VSub_Pound
                                            bracket_op: (WholeArray op_id:Lit_At)
                                            spids: [847 853]
                                          )
                                        }
                                    )
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [(C {(printf)} {(DQ ('{}'))})]
                      spids: [16777215 858]
                    )
                  ]
                  else_action: [
                    (Sentence
                      child: 
                        (DParen
                          child: 
                            (BinaryAssign
                              op_id: Arith_PlusEqual
                              left: (LhsName name:indent)
                              right: (ArithWord w:{(Lit_Digits 2)})
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ ('{') (Lit_Other '\\') (n))})
                    (While
                      cond: [
                        (Sentence
                          child: 
                            (DParen
                              child: 
                                (ArithBinary
                                  op_id: Arith_Great
                                  left: 
                                    (ArithWord
                                      w: 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name object>
                                            prefix_op: VSub_Pound
                                            bracket_op: (WholeArray op_id:Lit_At)
                                            spids: [890 896]
                                          )
                                        }
                                    )
                                  right: (ArithWord w:{(Lit_Digits 2)})
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (DoGroup
                          children: [
                            (Sentence
                              child: (C {(printf)} {(DQ ('%*s'))} {(DQ ($ VSub_Name '$indent'))})
                              terminator: <Op_Semi ';'>
                            )
                            (Sentence
                              child: (C {(print)} {(DQ ($ VSub_Name '$object'))})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(printf)} {(DQ (': '))})
                            (Sentence
                              child: 
                                (C {(print)} 
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Name object>
                                        bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 1)}))
                                        spids: [934 939]
                                      )
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(printf)} {(DQ (',') (Lit_Other '\\') (n))})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:object)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (DQ 
                                              (BracedVarSub
                                                token: <VSub_Name object>
                                                bracket_op: (WholeArray op_id:Lit_At)
                                                suffix_op: (Slice begin:(ArithWord w:{(Lit_Digits 2)}))
                                                spids: [955 962]
                                              )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [952]
                                )
                              ]
                              spids: [952]
                            )
                          ]
                          spids: [903 967]
                        )
                    )
                    (Sentence
                      child: (C {(printf)} {(DQ ('%*s'))} {(DQ ($ VSub_Name '$indent'))})
                      terminator: <Op_Semi ';'>
                    )
                    (Sentence
                      child: (C {(print)} {(DQ ($ VSub_Name '$object'))})
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ (': '))})
                    (Sentence
                      child: 
                        (C {(print)} 
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name object>
                                bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 1)}))
                                spids: [998 1003]
                              )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ (Lit_Other '\\') (n))})
                    (C {(printf)} {(DQ ('%*s}'))} 
                      {
                        (DQ 
                          (ArithSubPart
                            anode: 
                              (BinaryAssign
                                op_id: Arith_MinusEqual
                                left: (LhsName name:indent)
                                right: (ArithWord w:{(Lit_Digits 2)})
                              )
                            spids: [1022 1027]
                          )
                        )
                      }
                    )
                  ]
                  spids: [867 1031]
                )
              ]
              spids: [819 821 1033 16777215]
            )
          ]
          spids: [359 363 1036]
        )
      spids: [353 357]
    )
    (ForEach
      iter_name: arg
      do_arg_iter: T
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {($ VSub_Name '$arg')}
              arms: [
                (case_arm
                  pat_list: [{(obj) (Lit_Other '*')}]
                  action: [
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobEqual
                              left: {($ VSub_Name '$json')}
                              right: {(obj) (Lit_Other '*')}
                            )
                        )
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:json)
                                      op: Equal
                                      rhs: {(null)}
                                      spids: [1078]
                                    )
                                  ]
                                  spids: [1078]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Break break>)
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [1076]
                        )
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:json)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Name obj_list>
                                bracket_op: 
                                  (ArrayIndex
                                    expr: 
                                      (ArithBinary
                                        op_id: Arith_LBracket
                                        left: (ArithVarRef name:rt)
                                        right: 
                                          (ArithWord
                                            w: 
                                              {
                                                (BracedVarSub
                                                  token: <VSub_Name json>
                                                  suffix_op: 
                                                    (Slice
                                                      begin: (ArithWord w:{(Lit_Digits 3)})
                                                    )
                                                  spids: [1094 1098]
                                                )
                                              }
                                          )
                                      )
                                  )
                                spids: [1089 1101]
                              )
                            }
                          spids: [1088]
                        )
                        (assign_pair
                          lhs: (LhsName name:object)
                          op: Equal
                          rhs: {(ArrayLiteralPart words:[{($ VSub_Name '$json')}])}
                          spids: [1103]
                        )
                      ]
                      spids: [1088]
                    )
                    (While
                      cond: [
                        (Sentence
                          child: 
                            (DParen
                              child: 
                                (ArithWord
                                  w: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name object>
                                        prefix_op: VSub_Pound
                                        bracket_op: (WholeArray op_id:Lit_At)
                                        spids: [1112 1118]
                                      )
                                    }
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobEqual
                                              left: 
                                                {
                                                  (BracedVarSub
                                                    token: <VSub_Name str_list>
                                                    bracket_op: 
                                                      (ArrayIndex
                                                        expr: 
                                                          (ArithBinary
                                                            op_id: Arith_LBracket
                                                            left: (ArithVarRef name:rt)
                                                            right: 
                                                              (ArithWord
                                                                w: 
                                                                  {
                                                                    (BracedVarSub
                                                                      token: <VSub_Name object>
                                                                      suffix_op: 
                                                                        (Slice
                                                                          begin: 
                                                                            (ArithWord
                                                                              w: {(Lit_Digits 3)}
                                                                            )
                                                                        )
                                                                      spids: [1135 1139]
                                                                    )
                                                                  }
                                                              )
                                                          )
                                                      )
                                                    spids: [1130 1142]
                                                  )
                                                }
                                              right: 
                                                {
                                                  (DQ 
                                                    (BracedVarSub
                                                      token: <VSub_Name arg>
                                                      suffix_op: 
                                                        (Slice
                                                          begin: (ArithWord w:{(Lit_Digits 5)})
                                                        )
                                                      spids: [1147 1151]
                                                    )
                                                  )
                                                }
                                            )
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:json)
                                          op: Equal
                                          rhs: 
                                            {
                                              (BracedVarSub
                                                token: <VSub_Name object>
                                                bracket_op: 
                                                  (ArrayIndex
                                                    expr: (ArithWord w:{(Lit_Digits 1)})
                                                  )
                                                spids: [1161 1166]
                                              )
                                            }
                                          spids: [1160]
                                        )
                                      ]
                                      spids: [1160]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                      arg_word: {(2)}
                                    )
                                  ]
                                  spids: [16777215 1157]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:object)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (DQ 
                                                  (BracedVarSub
                                                    token: <VSub_Name object>
                                                    bracket_op: (WholeArray op_id:Lit_At)
                                                    suffix_op: 
                                                      (Slice
                                                        begin: (ArithWord w:{(Lit_Digits 2)})
                                                      )
                                                    spids: [1179 1186]
                                                  )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1176]
                                    )
                                  ]
                                  spids: [1176]
                                )
                              ]
                              spids: [1174 1191]
                            )
                          ]
                          spids: [1123 1194]
                        )
                    )
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:json)
                              op: Equal
                              rhs: {(null)}
                              spids: [1197]
                            )
                          ]
                          spids: [1197]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (ControlFlow token:<ControlFlow_Break break>)
                  ]
                  spids: [1059 1061 1203 16777215]
                )
                (case_arm
                  pat_list: [{(arr) (Lit_Other '*')}]
                  action: [
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobEqual
                              left: {($ VSub_Name '$json')}
                              right: {(arr) (Lit_Other '*')}
                            )
                        )
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:json)
                                      op: Equal
                                      rhs: {(null)}
                                      spids: [1225]
                                    )
                                  ]
                                  spids: [1225]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Break break>)
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [1223]
                        )
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:json)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Name arr_list>
                                bracket_op: 
                                  (ArrayIndex
                                    expr: 
                                      (ArithBinary
                                        op_id: Arith_LBracket
                                        left: (ArithVarRef name:rt)
                                        right: 
                                          (ArithWord
                                            w: 
                                              {
                                                (BracedVarSub
                                                  token: <VSub_Name json>
                                                  suffix_op: 
                                                    (Slice
                                                      begin: (ArithWord w:{(Lit_Digits 3)})
                                                    )
                                                  spids: [1241 1245]
                                                )
                                              }
                                          )
                                      )
                                  )
                                spids: [1236 1248]
                              )
                            }
                          spids: [1235]
                        )
                        (assign_pair
                          lhs: (LhsName name:array)
                          op: Equal
                          rhs: {(ArrayLiteralPart words:[{($ VSub_Name '$json')}])}
                          spids: [1250]
                        )
                      ]
                      spids: [1235]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (DParen
                          child: 
                            (ArithBinary
                              op_id: Arith_GreatEqual
                              left: 
                                (ArithWord
                                  w: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name array>
                                        prefix_op: VSub_Pound
                                        bracket_op: (WholeArray op_id:Lit_At)
                                        spids: [1257 1263]
                                      )
                                    }
                                )
                              right: 
                                (ArithWord
                                  w: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name arg>
                                        suffix_op: (Slice begin:(ArithWord w:{(Lit_Digits 5)}))
                                        spids: [1267 1271]
                                      )
                                    }
                                )
                            )
                        )
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:json)
                                      op: Equal
                                      rhs: {(null)}
                                      spids: [1280]
                                    )
                                  ]
                                  spids: [1280]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Break break>)
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [1278]
                        )
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:json)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Name array>
                                bracket_op: 
                                  (ArrayIndex
                                    expr: 
                                      (ArithWord
                                        w: 
                                          {
                                            (BracedVarSub
                                              token: <VSub_Name arg>
                                              suffix_op: (Slice begin:(ArithWord w:{(Lit_Digits 5)}))
                                              spids: [1294 1298]
                                            )
                                          }
                                      )
                                  )
                                spids: [1291 1300]
                              )
                            }
                          spids: [1290]
                        )
                      ]
                      spids: [1290]
                    )
                  ]
                  spids: [1206 1208 1302 16777215]
                )
              ]
              spids: [1052 1056 1305]
            )
          ]
          spids: [1046 1307]
        )
      spids: [16777215 16777215]
    )
    (Sentence child:(C {(print)} {(DQ ($ VSub_Name '$json'))}) terminator:<Op_Semi ';'>)
    (C {(echo)})
  ]
)