(command.If
  arms: [
    (if_arm
      cond: [
        (command.Sentence
          child: 
            (C {(Lit_Other '[')} {(-z)} {(DQ (${ VSub_Name __mal_printer_included__))} {(Lit_Other ']')})
          terminator: <Op_Semi ';'>
        )
      ]
      action: [
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:__mal_printer_included)
              op: Equal
              rhs: {(true)}
            )
          ]
        )
        (C {(source)} 
          {
            (word_part.CommandSubPart
              command_list: (command.CommandList children:[(C {(dirname)} {($ VSub_Number '$0')})])
              left_token: <Left_CommandSub '$('>
            ) (/types.sh)
          }
        )
        (command.FuncDef
          name: _pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:print_readably)
                      op: Equal
                      rhs: {(DQ (${ VSub_Number 2))}
                    )
                  ]
                )
                (command.Sentence
                  child: (C {(_obj_type)} {(DQ (${ VSub_Number 1))})
                  terminator: <Op_Semi ';'>
                )
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:ot)
                      op: Equal
                      rhs: {(DQ (${ VSub_Name r))}
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.BoolUnary
                                  op_id: BoolUnary_z
                                  child: {(DQ (${ VSub_Name ot))}
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (C {(_error)} {(DQ ("_pr_str failed on '") (${ VSub_Number 1) ("'"))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:r)
                              op: Equal
                              rhs: {(DQ ('<') (${ VSub_Number 1) ('>'))}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  else_action: [
                    (C {(eval)} {(${ VSub_Name ot) (_pr_str)} {(DQ (${ VSub_Number 1))} 
                      {(DQ (${ VSub_Name print_readably))}
                    )
                  ]
                )
              ]
            )
        )
        (command.FuncDef
          name: nil_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Sentence
                  child: 
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:r) op:Equal rhs:{(DQ (nil))})]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
            )
        )
        (command.FuncDef
          name: true_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Sentence
                  child: 
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:r) op:Equal rhs:{(DQ (true))})]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
            )
        )
        (command.FuncDef
          name: false_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Sentence
                  child: 
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:r) op:Equal rhs:{(DQ (false))})]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
            )
        )
        (command.FuncDef
          name: number_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Sentence
                  child: 
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:r)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.BracedVarSub
                                  token: <VSub_Name ANON>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: (arith_expr.ArithWord w:{(DQ (${ VSub_Number 1))})
                                    )
                                )
                              )
                            }
                        )
                      ]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
            )
        )
        (command.FuncDef
          name: symbol_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:r)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.BracedVarSub
                              token: <VSub_Name ANON>
                              bracket_op: 
                                (bracket_op.ArrayIndex
                                  expr: (arith_expr.ArithWord w:{(DQ (${ VSub_Number 1))})
                                )
                            )
                          )
                        }
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:r)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.BracedVarSub
                              token: <VSub_Name r>
                              suffix_op: 
                                (suffix_op.PatSub
                                  pat: {(__STAR__)}
                                  replace: {('*')}
                                  replace_mode: Lit_Slash
                                )
                            )
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
        (command.FuncDef
          name: keyword_pr_str
          body: (command.BraceGroup children:[(C {(string_pr_str)} {(DQ (${ VSub_Number 1))})])
        )
        (command.FuncDef
          name: _raw_string_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:s)
                      op: Equal
                      rhs: {(DQ (${ VSub_Number 1))}
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:print_readably)
                      op: Equal
                      rhs: {(DQ (${ VSub_Number 2))}
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.BoolBinary
                                  op_id: BoolBinary_GlobEqual
                                  left: 
                                    {
                                      (DQ 
                                        (word_part.BracedVarSub
                                          token: <VSub_Name s>
                                          suffix_op: 
                                            (suffix_op.Slice
                                              begin: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                                              length: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                            )
                                        )
                                      )
                                    }
                                  right: {(DQ (${ VSub_Name __keyw))}
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:r)
                              op: Equal
                              rhs: 
                                {
                                  (DQ (':') 
                                    (word_part.BracedVarSub
                                      token: <VSub_Name s>
                                      suffix_op: 
                                        (suffix_op.Slice
                                          begin: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                        )
                                    )
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.BoolBinary
                                  op_id: BoolBinary_GlobEqual
                                  left: 
                                    {
                                      (DQ 
                                        (word_part.BracedVarSub
                                          token: <VSub_Name s>
                                          suffix_op: 
                                            (suffix_op.Slice
                                              begin: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                                              length: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                                            )
                                        )
                                      )
                                    }
                                  right: {(DQ (${ VSub_Name __keyw))}
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:r)
                              op: Equal
                              rhs: 
                                {
                                  (DQ (':') 
                                    (word_part.BracedVarSub
                                      token: <VSub_Name s>
                                      suffix_op: 
                                        (suffix_op.Slice
                                          begin: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                                        )
                                    )
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (C {(Lit_Other '[')} {(DQ (${ VSub_Name print_readably))} 
                              {(Lit_Other '=') (Lit_Other '=')} {(DQ (yes))} {(Lit_Other ']')}
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:s)
                              op: Equal
                              rhs: 
                                {
                                  (DQ 
                                    (word_part.BracedVarSub
                                      token: <VSub_Name s>
                                      suffix_op: 
                                        (suffix_op.PatSub
                                          pat: 
                                            {
                                              (word_part.EscapedLiteralPart
                                                token: <Lit_EscapedChar '\\\\'>
                                              )
                                            }
                                          replace: 
                                            {
                                              (word_part.EscapedLiteralPart
                                                token: <Lit_EscapedChar '\\\\'>
                                              ) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>)
                                            }
                                          replace_mode: Lit_Slash
                                        )
                                    )
                                  )
                                }
                            )
                          ]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:s)
                              op: Equal
                              rhs: 
                                {
                                  (DQ 
                                    (word_part.BracedVarSub
                                      token: <VSub_Name s>
                                      suffix_op: 
                                        (suffix_op.PatSub
                                          pat: 
                                            {
                                              (word_part.EscapedLiteralPart
                                                token: <Lit_EscapedChar '\\"'>
                                              )
                                            }
                                          replace: 
                                            {
                                              (word_part.EscapedLiteralPart
                                                token: <Lit_EscapedChar '\\\\'>
                                              ) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>)
                                            }
                                          replace_mode: Lit_Slash
                                        )
                                    )
                                  )
                                }
                            )
                          ]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:r)
                              op: Equal
                              rhs: 
                                {
                                  (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                                    (word_part.BracedVarSub
                                      token: <VSub_Name s>
                                      suffix_op: 
                                        (suffix_op.PatSub
                                          pat: 
                                            {
                                              (word_part.SingleQuotedPart
                                                left: <Left_DollarSingleQuote "$'">
                                                tokens: [<Char_OneChar '\\n'>]
                                              )
                                            }
                                          replace: 
                                            {
                                              (word_part.EscapedLiteralPart
                                                token: <Lit_EscapedChar '\\\\'>
                                              ) (n)
                                            }
                                          replace_mode: Lit_Slash
                                        )
                                    ) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>)
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  else_action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:r)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name s))}
                        )
                      ]
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:r)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.BracedVarSub
                              token: <VSub_Name r>
                              suffix_op: 
                                (suffix_op.PatSub
                                  pat: {(__STAR__)}
                                  replace: 
                                    {
                                      (word_part.SingleQuotedPart
                                        left: <Left_DollarSingleQuote "$'">
                                        tokens: [<Char_Literals '*'>]
                                      )
                                    }
                                  replace_mode: Lit_Slash
                                )
                            )
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
        (command.FuncDef
          name: string_pr_str
          body: 
            (command.BraceGroup
              children: [
                (C {(_raw_string_pr_str)} 
                  {
                    (DQ 
                      (word_part.BracedVarSub
                        token: <VSub_Name ANON>
                        bracket_op: 
                          (bracket_op.ArrayIndex
                            expr: (arith_expr.ArithWord w:{(DQ (${ VSub_Number 1))})
                          )
                      )
                    )
                  } {(DQ (${ VSub_Number 2))}
                )
              ]
            )
        )
        (command.FuncDef
          name: function_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Sentence
                  child: 
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:r)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.BracedVarSub
                                  token: <VSub_Name ANON>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: (arith_expr.ArithWord w:{(DQ (${ VSub_Number 1))})
                                    )
                                )
                              )
                            }
                        )
                      ]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
            )
        )
        (command.FuncDef
          name: bash_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:r)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(Assign_Declare declare)} {(-f)} {(-p)} {(${ VSub_Number 1)})
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                            )
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
        (command.FuncDef
          name: hash_map_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:print_readably)
                      op: Equal
                      rhs: {(DQ (${ VSub_Number 2))}
                    )
                  ]
                )
                (command.Sentence
                  child: 
                    (command.Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:res) op:Equal rhs:{(DQ )})]
                    )
                  terminator: <Op_Semi ';'>
                )
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(lhs_expr.LhsName name:val) op:Equal rhs:{(DQ )})]
                )
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:hm)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.BracedVarSub
                              token: <VSub_Name ANON>
                              bracket_op: 
                                (bracket_op.ArrayIndex
                                  expr: (arith_expr.ArithWord w:{(DQ (${ VSub_Number 1))})
                                )
                            )
                          )
                        }
                    )
                  ]
                )
                (C {(eval)} {(Assign_Local local)} 
                  {(Lit_VarLike 'keys=') 
                    (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('{!') 
                      (${ VSub_Name hm) ('[@]}')
                    )
                  }
                )
                (command.ForEach
                  iter_name: key
                  iter_words: [{(${ VSub_Name keys)}]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(_raw_string_pr_str)} {(DQ (${ VSub_Name key))} 
                          {(DQ (${ VSub_Name print_readably))}
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:res)
                              op: Equal
                              rhs: {(DQ (${ VSub_Name res) (' ') (${ VSub_Name r))}
                            )
                          ]
                        )
                        (C {(eval)} 
                          {(Lit_VarLike 'val=') 
                            (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('{') 
                              (${ VSub_Name hm) ('[') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (${ VSub_Name key) 
                              (word_part.EscapedLiteralPart
                                token: <Lit_EscapedChar '\\"'>
                              ) (']}')
                            )
                          }
                        )
                        (C {(_pr_str)} {(DQ (${ VSub_Name val))} {(DQ (${ VSub_Name print_readably))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:res)
                              op: Equal
                              rhs: {(DQ (${ VSub_Name res) (' ') (${ VSub_Name r))}
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:r)
                      op: Equal
                      rhs: 
                        {
                          (DQ ('{') 
                            (word_part.BracedVarSub
                              token: <VSub_Name res>
                              suffix_op: 
                                (suffix_op.Slice
                                  begin: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                )
                            ) ('}')
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
        (command.FuncDef
          name: vector_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:print_readably)
                      op: Equal
                      rhs: {(DQ (${ VSub_Number 2))}
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(lhs_expr.LhsName name:res) op:Equal rhs:{(DQ )})]
                )
                (command.ForEach
                  iter_name: elem
                  iter_words: [
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name ANON>
                        bracket_op: 
                          (bracket_op.ArrayIndex
                            expr: (arith_expr.ArithWord w:{(DQ (${ VSub_Number 1))})
                          )
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(_pr_str)} {(DQ (${ VSub_Name elem))} {(DQ (${ VSub_Name print_readably))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:res)
                              op: Equal
                              rhs: {(DQ (${ VSub_Name res) (' ') (${ VSub_Name r))}
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:r)
                      op: Equal
                      rhs: 
                        {
                          (DQ ('[') 
                            (word_part.BracedVarSub
                              token: <VSub_Name res>
                              suffix_op: 
                                (suffix_op.Slice
                                  begin: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                )
                            ) (']')
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
        (command.FuncDef
          name: list_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:print_readably)
                      op: Equal
                      rhs: {(DQ (${ VSub_Number 2))}
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(lhs_expr.LhsName name:res) op:Equal rhs:{(DQ )})]
                )
                (command.ForEach
                  iter_name: elem
                  iter_words: [
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name ANON>
                        bracket_op: 
                          (bracket_op.ArrayIndex
                            expr: (arith_expr.ArithWord w:{(DQ (${ VSub_Number 1))})
                          )
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(_pr_str)} {(DQ (${ VSub_Name elem))} {(DQ (${ VSub_Name print_readably))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:res)
                              op: Equal
                              rhs: {(DQ (${ VSub_Name res) (' ') (${ VSub_Name r))}
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:r)
                      op: Equal
                      rhs: 
                        {
                          (DQ ('(') 
                            (word_part.BracedVarSub
                              token: <VSub_Name res>
                              suffix_op: 
                                (suffix_op.Slice
                                  begin: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                )
                            ) (')')
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
        (command.FuncDef
          name: atom_pr_str
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:print_readably)
                      op: Equal
                      rhs: {(DQ (${ VSub_Number 2))}
                    )
                  ]
                )
                (C {(_pr_str)} 
                  {
                    (DQ 
                      (word_part.BracedVarSub
                        token: <VSub_Name ANON>
                        bracket_op: 
                          (bracket_op.ArrayIndex
                            expr: (arith_expr.ArithWord w:{(DQ (${ VSub_Number 1))})
                          )
                      )
                    )
                  } {(DQ (${ VSub_Name print_readably))}
                )
                (command.Sentence
                  child: 
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:r)
                          op: Equal
                          rhs: {(DQ ('(atom ') (${ VSub_Name r) (')'))}
                        )
                      ]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
            )
        )
      ]
    )
  ]
)