(command.CommandList
  children: [
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:json)
          op: Equal
          rhs: 
            {
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [
                      (command.SimpleCommand
                        redirects: [
                          (redir.Redir
                            op: <Redir_Less '<'>
                            fd: 16777215
                            arg_word: {(/dev/stdin)}
                          )
                        ]
                      )
                    ]
                  )
                left_token: <Left_CommandSub '$('>
              )
            }
        )
        (assign_pair
          lhs: (lhs_expr.LhsName name:oldlang)
          op: Equal
          rhs: {($ VSub_DollarName '$LANG')}
        )
        (assign_pair lhs:(lhs_expr.LhsName name:LANG) op:Equal rhs:{(C)})
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:str)
          op: Equal
          rhs: {(SQ <'("(\\\\.|[^\\\\"])*")'>)}
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:num)
          op: Equal
          rhs: {(DQ ('(-?(0|[1-9][0-9]*)(') (Lit_Other '\\') ('.[0-9]+)?([eE][+-]?[0-9]+)?)'))}
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:val)
          op: Equal
          rhs: {(DQ ('((str|num|obj|arr)[a-j]+|true|false|null)'))}
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:arr)
          op: Equal
          rhs: 
            {
              (DQ (Lit_Other '\\') ('[(') ($ VSub_DollarName '$val') ('(,') ($ VSub_DollarName '$val') 
                (')*)?]')
              )
            }
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:obj)
          op: Equal
          rhs: 
            {
              (DQ (Lit_Other '\\') ('{(str[a-j]+:') ($ VSub_DollarName '$val') ('(,str[a-j]+:') 
                ($ VSub_DollarName '$val') (')*)?}')
              )
            }
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:tr)
          op: Equal
          rhs: 
            {
              (word_part.ArrayLiteralPart
                words: [
                  {(Lit_LBrace '{') (a..j) (Lit_RBrace '}') (Lit_LBrace '{') (a..j) (Lit_RBrace '}') 
                    (Lit_LBrace '{') (a..j) (Lit_RBrace '}')
                  }
                ]
              )
            }
        )
      ]
    )
    (command.Assignment
      keyword: Assign_Declare
      flags: [-n]
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:match) op:Equal)]
    )
    (command.FuncDef
      name: push
      body: 
        (command.BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.Assignment
                  keyword: Assign_Declare
                  flags: [-gn]
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:list)
                      op: Equal
                      rhs: {(${ VSub_Name type) (_list)}
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
            (command.Sentence
              child: 
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:list)
                      op: PlusEqual
                      rhs: 
                        {
                          (word_part.ArrayLiteralPart
                            words: [
                              {
                                (DQ 
                                  (word_part.BracedVarSub
                                    token: <VSub_Name BASH_REMATCH>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                      )
                                  )
                                )
                              }
                            ]
                          )
                        }
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
        )
    )
    (command.FuncDef
      name: match
      body: 
        (command.ForEach
          iter_name: match
          iter_words: [{(str)} {(num)} {(obj)} {(arr)}]
          do_arg_iter: F
          body: 
            (command.DoGroup
              children: [
                (command.AndOr
                  ops: [Op_DAmp]
                  children: [
                    (command.DBracket
                      expr: 
                        (bool_expr.LogicalAnd
                          left: 
                            (bool_expr.BoolBinary
                              op_id: BoolBinary_GlobNEqual
                              left: 
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Name match>
                                    prefix_op: VSub_Bang
                                  )
                                }
                              right: {(str)}
                            )
                          right: 
                            (bool_expr.LogicalNot
                              child: 
                                (bool_expr.BoolBinary
                                  op_id: BoolBinary_ne
                                  left: {(i) (Lit_Other '+') (Lit_Other '+')}
                                  right: {(0)}
                                )
                            )
                        )
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:json)
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name json>
                                suffix_op: 
                                  (suffix_op.PatSub
                                    pat: 
                                      {('[') 
                                        (word_part.SingleQuotedPart
                                          left: <Left_DollarSingleQuote "$'">
                                          tokens: [
                                            <Char_Literals ' '>
                                            <Char_OneChar '\\t'>
                                            <Char_OneChar '\\n'>
                                            <Char_OneChar '\\r'>
                                          ]
                                        ) (']')
                                      }
                                    replace_mode: Lit_Slash
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Op_DAmp]
                  children: [
                    (command.DBracket
                      expr: 
                        (bool_expr.BoolBinary
                          op_id: BoolBinary_EqualTilde
                          left: {($ VSub_DollarName '$json')}
                          right: 
                            {($ VSub_DollarName '$match') (Lit_Other '(') (Lit_Other .) (Lit_Other '*') 
                              (Lit_Other ')')
                            }
                        )
                    )
                    (command.BraceGroup
                      children: [
                        (command.Sentence
                          child: 
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:type)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Name match>
                                        prefix_op: VSub_Bang
                                      )
                                    }
                                )
                              ]
                            )
                          terminator: <Op_Semi ';'>
                        )
                        (command.Sentence
                          child: (command.ControlFlow token:<ControlFlow_Return return>)
                          terminator: <Op_Semi ';'>
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
    )
    (command.WhileUntil
      keyword: <KW_While while>
      cond: [(command.Sentence child:(C {(match)}) terminator:<Op_Semi ';'>)]
      body: 
        (command.DoGroup
          children: [
            (C {(push)})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:json)
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name json>
                        suffix_op: 
                          (suffix_op.StringUnary
                            op_id: VOp1_Percent
                            arg_word: {(DQ ($ VSub_DollarName '$BASH_REMATCH'))}
                          )
                      ) ($ VSub_DollarName '$type') 
                      (word_part.BracedVarSub
                        token: <VSub_Name tr>
                        bracket_op: 
                          (bracket_op.ArrayIndex
                            expr: 
                              (arith_expr.ArithBinary
                                op_id: Arith_Minus
                                left: 
                                  (arith_expr.ArithWord
                                    w: 
                                      {
                                        (word_part.BracedVarSub
                                          token: <VSub_Name list>
                                          prefix_op: VSub_Pound
                                          bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                        )
                                      }
                                  )
                                right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                              )
                          )
                      ) 
                      (word_part.BracedVarSub
                        token: <VSub_Name BASH_REMATCH>
                        bracket_op: 
                          (bracket_op.ArrayIndex
                            expr: 
                              (arith_expr.ArithUnary
                                op_id: Node_UnaryMinus
                                child: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                              )
                          )
                      )
                    }
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (command.DBracket
          expr: 
            (bool_expr.BoolBinary
              op_id: BoolBinary_EqualTilde
              left: {($ VSub_DollarName '$json')}
              right: {(Lit_Other '^') ($ VSub_DollarName '$val') (Lit_Other '$')}
            )
        )
        (command.ControlFlow token:<ControlFlow_Exit exit>)
      ]
    )
    (command.Assignment
      keyword: Assign_Declare
      flags: [-A]
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:rt) op:Equal)]
    )
    (command.ForEach
      iter_name: i
      iter_words: [
        {
          (DQ 
            (word_part.BracedVarSub
              token: <VSub_Name tr>
              bracket_op: (bracket_op.WholeArray op_id:Lit_At)
            )
          )
        }
      ]
      do_arg_iter: F
      body: 
        (command.DoGroup
          children: [
            (command.Sentence
              child: 
                (command.DParen
                  child: 
                    (arith_expr.BinaryAssign
                      op_id: Arith_Equal
                      left: 
                        (lhs_expr.LhsIndexedName
                          name: rt
                          index: (arith_expr.ArithWord w:{($ VSub_DollarName '$i')})
                        )
                      right: 
                        (arith_expr.UnaryAssign
                          op_id: Node_PostDPlus
                          child: (lhs_expr.LhsName name:j)
                        )
                    )
                )
              terminator: <Op_Semi ';'>
            )
          ]
        )
    )
    (command.CommandList
      children: [
        (command.Sentence child:(C {(set)} {(-f)}) terminator:<Op_Semi ';'>)
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:LANG)
              op: Equal
              rhs: {($ VSub_DollarName '$oldlang')}
            )
            (assign_pair
              lhs: (lhs_expr.LhsName name:IFS)
              op: Equal
              rhs: {(Lit_Other ':') (Lit_Comma ',')}
            )
            (assign_pair
              lhs: (lhs_expr.LhsName name:regex)
              op: Equal
              rhs: {(SQ <'(\\\\[nftrb]|\\\\\\\\|\\\\u[a-f0-9]{4})'>)}
            )
          ]
        )
      ]
    )
    (C {(shopt)} {(-s)} {(nocasematch)})
    (command.FuncDef
      name: print
      body: 
        (command.Case
          to_match: {($ VSub_Number '$1')}
          arms: [
            (case_arm
              pat_list: [{(null)} {(true)} {(false)}]
              action: [(C {(printf)} {(DQ ($ VSub_Number '$1'))})]
            )
            (case_arm
              pat_list: [{(str) (Lit_Other '*')}]
              action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:tmp)
                      op: Equal
                      rhs: 
                        {
                          (word_part.BracedVarSub
                            token: <VSub_Name str_list>
                            bracket_op: 
                              (bracket_op.ArrayIndex
                                expr: 
                                  (arith_expr.ArithBinary
                                    op_id: Arith_LBracket
                                    left: (arith_expr.ArithVarRef token:<Lit_ArithVarLike rt>)
                                    right: 
                                      (arith_expr.ArithWord
                                        w: 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Number 1>
                                              suffix_op: 
                                                (suffix_op.Slice
                                                  begin: (arith_expr.ArithWord w:{(Lit_Digits 3)})
                                                )
                                            )
                                          }
                                      )
                                  )
                              )
                          )
                        }
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.BoolBinary
                              op_id: BoolBinary_EqualTilde
                              left: {($ VSub_DollarName '$tmp')}
                              right: 
                                {($ VSub_DollarName '$regex') (Lit_Other '(') (Lit_Other .) 
                                  (Lit_Other '*') (Lit_Other ')')
                                }
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(printf)} {(Lit_Other '%') (s)} 
                          {
                            (DQ 
                              (word_part.BracedVarSub
                                token: <VSub_Name tmp>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VOp1_Percent
                                    arg_word: {(DQ ($ VSub_DollarName '$BASH_REMATCH'))}
                                  )
                              )
                            )
                          }
                        )
                        (command.Case
                          to_match: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name BASH_REMATCH>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                  )
                              )
                            }
                          arms: [
                            (case_arm
                              pat_list: [
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (u0008)
                                }
                              ]
                              action: [(C {(printf)} {(SQ <'\\\\b'>)})]
                            )
                            (case_arm
                              pat_list: [
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (u0009)
                                }
                              ]
                              action: [(C {(printf)} {(SQ <'\\\\t'>)})]
                            )
                            (case_arm
                              pat_list: [
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (u000a)
                                }
                              ]
                              action: [(C {(printf)} {(SQ <'\\\\n'>)})]
                            )
                            (case_arm
                              pat_list: [
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (u000c)
                                }
                              ]
                              action: [(C {(printf)} {(SQ <'\\\\f'>)})]
                            )
                            (case_arm
                              pat_list: [
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (u000d)
                                }
                              ]
                              action: [(C {(printf)} {(SQ <'\\\\r'>)})]
                            )
                            (case_arm
                              pat_list: [
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (u0022)
                                }
                              ]
                              action: [(C {(printf)} {(SQ <'\\\\"'>)})]
                            )
                            (case_arm
                              pat_list: [
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (u005c)
                                }
                              ]
                              action: [(C {(printf)} {(SQ <'\\\\\\\\'>)})]
                            )
                            (case_arm
                              pat_list: [
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\\\'>
                                  )
                                }
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (Lit_Other '[') (nftrb) (Lit_Other ']')
                                }
                                {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) 
                                  (Lit_ArrayLhsOpen 'u00[') (01) (Lit_Other ']') (Lit_Other '?')
                                }
                              ]
                              action: [
                                (C {(printf)} {(Lit_Other '%') (s)} 
                                  {
                                    (DQ 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name BASH_REMATCH>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (C {(printf)} {(Lit_Other '%') (b)} 
                                  {
                                    (DQ 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name BASH_REMATCH>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:tmp)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Name BASH_REMATCH>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                                      )
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                )
                (C {(printf)} {(Lit_Other '%') (s)} {(DQ ($ VSub_DollarName '$tmp'))})
              ]
            )
            (case_arm
              pat_list: [{(num) (Lit_Other '*')}]
              action: [
                (C {(printf)} {(Lit_Other '%') (s)} 
                  {
                    (DQ 
                      (word_part.BracedVarSub
                        token: <VSub_Name num_list>
                        bracket_op: 
                          (bracket_op.ArrayIndex
                            expr: 
                              (arith_expr.ArithBinary
                                op_id: Arith_LBracket
                                left: (arith_expr.ArithVarRef token:<Lit_ArithVarLike rt>)
                                right: 
                                  (arith_expr.ArithWord
                                    w: 
                                      {
                                        (word_part.BracedVarSub
                                          token: <VSub_Number 1>
                                          suffix_op: 
                                            (suffix_op.Slice
                                              begin: (arith_expr.ArithWord w:{(Lit_Digits 3)})
                                            )
                                        )
                                      }
                                  )
                              )
                          )
                      )
                    )
                  }
                )
              ]
            )
            (case_arm
              pat_list: [{(arr) (Lit_Other '*')}]
              action: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:array)
                      op: Equal
                      rhs: 
                        {
                          (word_part.ArrayLiteralPart
                            words: [
                              {
                                (word_part.BracedVarSub
                                  token: <VSub_Name arr_list>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: 
                                        (arith_expr.ArithBinary
                                          op_id: Arith_LBracket
                                          left: (arith_expr.ArithVarRef token:<Lit_ArithVarLike rt>)
                                          right: 
                                            (arith_expr.ArithWord
                                              w: 
                                                {
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Slice
                                                        begin: 
                                                          (arith_expr.ArithWord
                                                            w: {(Lit_Digits 3)}
                                                          )
                                                      )
                                                  )
                                                }
                                            )
                                        )
                                    )
                                )
                              }
                            ]
                          )
                        }
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.ArithUnary
                                  op_id: Arith_Bang
                                  child: 
                                    (arith_expr.ArithWord
                                      w: 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Name array>
                                            prefix_op: VSub_Pound
                                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                          )
                                        }
                                    )
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [(C {(printf)} {(DQ ('[]'))})]
                    )
                  ]
                  else_action: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.BinaryAssign
                              op_id: Arith_PlusEqual
                              left: (lhs_expr.LhsName name:indent)
                              right: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ ('[') (Lit_Other '\\') (n))})
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.ArithBinary
                                  op_id: Arith_Great
                                  left: 
                                    (arith_expr.ArithWord
                                      w: 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Name array>
                                            prefix_op: VSub_Pound
                                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                          )
                                        }
                                    )
                                  right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Sentence
                              child: (C {(printf)} {(DQ ('%*s'))} {(DQ ($ VSub_DollarName '$indent'))})
                              terminator: <Op_Semi ';'>
                            )
                            (command.Sentence
                              child: (C {(print)} {(DQ ($ VSub_DollarName '$array'))})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(printf)} {(DQ (',') (Lit_Other '\\') (n))})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:array)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.ArrayLiteralPart
                                        words: [
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Name array>
                                                bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                                suffix_op: 
                                                  (suffix_op.Slice
                                                    begin: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                                  )
                                              )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.Sentence
                      child: (C {(printf)} {(DQ ('%*s'))} {(DQ ($ VSub_DollarName '$indent'))})
                      terminator: <Op_Semi ';'>
                    )
                    (C {(print)} {(DQ ($ VSub_DollarName '$array'))})
                    (C {(printf)} {(DQ (Lit_Other '\\') ('n%*s]'))} 
                      {
                        (DQ 
                          (word_part.ArithSubPart
                            anode: 
                              (arith_expr.BinaryAssign
                                op_id: Arith_MinusEqual
                                left: (lhs_expr.LhsName name:indent)
                                right: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (case_arm
              pat_list: [{(obj) (Lit_Other '*')}]
              action: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:object)
                      op: Equal
                      rhs: 
                        {
                          (word_part.ArrayLiteralPart
                            words: [
                              {
                                (word_part.BracedVarSub
                                  token: <VSub_Name obj_list>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: 
                                        (arith_expr.ArithBinary
                                          op_id: Arith_LBracket
                                          left: (arith_expr.ArithVarRef token:<Lit_ArithVarLike rt>)
                                          right: 
                                            (arith_expr.ArithWord
                                              w: 
                                                {
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Slice
                                                        begin: 
                                                          (arith_expr.ArithWord
                                                            w: {(Lit_Digits 3)}
                                                          )
                                                      )
                                                  )
                                                }
                                            )
                                        )
                                    )
                                )
                              }
                            ]
                          )
                        }
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.ArithUnary
                                  op_id: Arith_Bang
                                  child: 
                                    (arith_expr.ArithWord
                                      w: 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Name object>
                                            prefix_op: VSub_Pound
                                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                          )
                                        }
                                    )
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [(C {(printf)} {(DQ ('{}'))})]
                    )
                  ]
                  else_action: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.BinaryAssign
                              op_id: Arith_PlusEqual
                              left: (lhs_expr.LhsName name:indent)
                              right: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ ('{') (Lit_Other '\\') (n))})
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.ArithBinary
                                  op_id: Arith_Great
                                  left: 
                                    (arith_expr.ArithWord
                                      w: 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Name object>
                                            prefix_op: VSub_Pound
                                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                          )
                                        }
                                    )
                                  right: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Sentence
                              child: (C {(printf)} {(DQ ('%*s'))} {(DQ ($ VSub_DollarName '$indent'))})
                              terminator: <Op_Semi ';'>
                            )
                            (command.Sentence
                              child: (C {(print)} {(DQ ($ VSub_DollarName '$object'))})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(printf)} {(DQ (': '))})
                            (command.Sentence
                              child: 
                                (C {(print)} 
                                  {
                                    (DQ 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name object>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                          )
                                      )
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(printf)} {(DQ (',') (Lit_Other '\\') (n))})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:object)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.ArrayLiteralPart
                                        words: [
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Name object>
                                                bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                                suffix_op: 
                                                  (suffix_op.Slice
                                                    begin: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                                                  )
                                              )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.Sentence
                      child: (C {(printf)} {(DQ ('%*s'))} {(DQ ($ VSub_DollarName '$indent'))})
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: (C {(print)} {(DQ ($ VSub_DollarName '$object'))})
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ (': '))})
                    (command.Sentence
                      child: 
                        (C {(print)} 
                          {
                            (DQ 
                              (word_part.BracedVarSub
                                token: <VSub_Name object>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                  )
                              )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ (Lit_Other '\\') (n))})
                    (C {(printf)} {(DQ ('%*s}'))} 
                      {
                        (DQ 
                          (word_part.ArithSubPart
                            anode: 
                              (arith_expr.BinaryAssign
                                op_id: Arith_MinusEqual
                                left: (lhs_expr.LhsName name:indent)
                                right: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ForEach
      iter_name: arg
      do_arg_iter: T
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {($ VSub_DollarName '$arg')}
              arms: [
                (case_arm
                  pat_list: [{(obj) (Lit_Other '*')}]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.BoolBinary
                              op_id: BoolBinary_GlobEqual
                              left: {($ VSub_DollarName '$json')}
                              right: {(obj) (Lit_Other '*')}
                            )
                        )
                        (command.BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:json)
                                      op: Equal
                                      rhs: {(null)}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.Sentence
                              child: (command.ControlFlow token:<ControlFlow_Break break>)
                              terminator: <Op_Semi ';'>
                            )
                          ]
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:json)
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name obj_list>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: 
                                      (arith_expr.ArithBinary
                                        op_id: Arith_LBracket
                                        left: (arith_expr.ArithVarRef token:<Lit_ArithVarLike rt>)
                                        right: 
                                          (arith_expr.ArithWord
                                            w: 
                                              {
                                                (word_part.BracedVarSub
                                                  token: <VSub_Name json>
                                                  suffix_op: 
                                                    (suffix_op.Slice
                                                      begin: (arith_expr.ArithWord w:{(Lit_Digits 3)})
                                                    )
                                                )
                                              }
                                          )
                                      )
                                  )
                              )
                            }
                        )
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:object)
                          op: Equal
                          rhs: {(word_part.ArrayLiteralPart words:[{($ VSub_DollarName '$json')}])}
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.ArithWord
                                  w: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Name object>
                                        prefix_op: VSub_Pound
                                        bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                      )
                                    }
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.BoolBinary
                                              op_id: BoolBinary_GlobEqual
                                              left: 
                                                {
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Name str_list>
                                                    bracket_op: 
                                                      (bracket_op.ArrayIndex
                                                        expr: 
                                                          (arith_expr.ArithBinary
                                                            op_id: Arith_LBracket
                                                            left: 
                                                              (arith_expr.ArithVarRef
                                                                token: <Lit_ArithVarLike rt>
                                                              )
                                                            right: 
                                                              (arith_expr.ArithWord
                                                                w: 
                                                                  {
                                                                    (word_part.BracedVarSub
                                                                      token: <VSub_Name object>
                                                                      suffix_op: 
                                                                        (suffix_op.Slice
                                                                          begin: 
                                                                            (arith_expr.ArithWord
                                                                              w: {(Lit_Digits 3)}
                                                                            )
                                                                        )
                                                                    )
                                                                  }
                                                              )
                                                          )
                                                      )
                                                  )
                                                }
                                              right: 
                                                {
                                                  (DQ 
                                                    (word_part.BracedVarSub
                                                      token: <VSub_Name arg>
                                                      suffix_op: 
                                                        (suffix_op.Slice
                                                          begin: 
                                                            (arith_expr.ArithWord
                                                              w: {(Lit_Digits 5)}
                                                            )
                                                        )
                                                    )
                                                  )
                                                }
                                            )
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:json)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.BracedVarSub
                                                token: <VSub_Name object>
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                      arg_word: {(2)}
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:object)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.ArrayLiteralPart
                                            words: [
                                              {
                                                (DQ 
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Name object>
                                                    bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                                    suffix_op: 
                                                      (suffix_op.Slice
                                                        begin: 
                                                          (arith_expr.ArithWord
                                                            w: {(Lit_Digits 2)}
                                                          )
                                                      )
                                                  )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [(assign_pair lhs:(lhs_expr.LhsName name:json) op:Equal rhs:{(null)})]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (command.ControlFlow token:<ControlFlow_Break break>)
                  ]
                )
                (case_arm
                  pat_list: [{(arr) (Lit_Other '*')}]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.BoolBinary
                              op_id: BoolBinary_GlobEqual
                              left: {($ VSub_DollarName '$json')}
                              right: {(arr) (Lit_Other '*')}
                            )
                        )
                        (command.BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:json)
                                      op: Equal
                                      rhs: {(null)}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.Sentence
                              child: (command.ControlFlow token:<ControlFlow_Break break>)
                              terminator: <Op_Semi ';'>
                            )
                          ]
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:json)
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name arr_list>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: 
                                      (arith_expr.ArithBinary
                                        op_id: Arith_LBracket
                                        left: (arith_expr.ArithVarRef token:<Lit_ArithVarLike rt>)
                                        right: 
                                          (arith_expr.ArithWord
                                            w: 
                                              {
                                                (word_part.BracedVarSub
                                                  token: <VSub_Name json>
                                                  suffix_op: 
                                                    (suffix_op.Slice
                                                      begin: (arith_expr.ArithWord w:{(Lit_Digits 3)})
                                                    )
                                                )
                                              }
                                          )
                                      )
                                  )
                              )
                            }
                        )
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:array)
                          op: Equal
                          rhs: {(word_part.ArrayLiteralPart words:[{($ VSub_DollarName '$json')}])}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.DParen
                          child: 
                            (arith_expr.ArithBinary
                              op_id: Arith_GreatEqual
                              left: 
                                (arith_expr.ArithWord
                                  w: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Name array>
                                        prefix_op: VSub_Pound
                                        bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                      )
                                    }
                                )
                              right: 
                                (arith_expr.ArithWord
                                  w: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Name arg>
                                        suffix_op: 
                                          (suffix_op.Slice
                                            begin: (arith_expr.ArithWord w:{(Lit_Digits 5)})
                                          )
                                      )
                                    }
                                )
                            )
                        )
                        (command.BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:json)
                                      op: Equal
                                      rhs: {(null)}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.Sentence
                              child: (command.ControlFlow token:<ControlFlow_Break break>)
                              terminator: <Op_Semi ';'>
                            )
                          ]
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:json)
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name array>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: 
                                      (arith_expr.ArithWord
                                        w: 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Name arg>
                                              suffix_op: 
                                                (suffix_op.Slice
                                                  begin: (arith_expr.ArithWord w:{(Lit_Digits 5)})
                                                )
                                            )
                                          }
                                      )
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.CommandList
      children: [
        (command.Sentence
          child: (C {(print)} {(DQ ($ VSub_DollarName '$json'))})
          terminator: <Op_Semi ';'>
        )
        (C {(echo)})
      ]
    )
  ]
)