(command.CommandList
  children: [
    (C {<Id.Lit_Colon ':'>} {<generate>} {<the>} {<ksh>} {<math>} {<builtin>} {<table>})
    (C {<Id.Lit_Colon ':'>} {<include>} {<math.tab>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'command='> name:command)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Number 0)}
          spids: [82]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'iffeflags='> name:iffeflags)
          op: assign_op.Equal
          rhs: {(DQ <'-n -v'>)}
          spids: [85]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'iffehdrs='> name:iffehdrs)
          op: assign_op.Equal
          rhs: {(DQ <'math.h ieeefp.h'>)}
          spids: [90]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'iffelibs='> name:iffelibs)
          op: assign_op.Equal
          rhs: {(DQ <-lm>)}
          spids: [95]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'table='> name:table)
          op: assign_op.Equal
          rhs: {<'/dev/null'>}
          spids: [100]
        )
      ]
      redirects: []
    )
    (C {<eval>} {($ Id.VSub_Number 1)})
    (C {<shift>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'table='> name:table)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Number 1)}
          spids: [110]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'names='> name:names)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [114]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tests='> name:tests)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [116]
        )
      ]
      redirects: []
    )
    (C {<Id.Lit_Colon ':'>} {<check>} {<long>} {<double>})
    (C {<eval>} 
      {
        (command_sub
          left_token: <Id.Left_Backtick '`'>
          child: 
            (command.Simple
              words: [
                {<iffe>}
                {($ Id.VSub_DollarName iffeflags)}
                {<-c>}
                {(DQ ($ Id.VSub_DollarName cc))}
                {<->}
                {<typ>}
                {<long.double>}
              ]
              redirects: [
                (redir
                  op: <Id.Redir_GreatAnd '2>&'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {($ Id.VSub_DollarName stderr)}
                )
              ]
              more_env: []
              do_fork: T
            )
          right: <Id.Backtick_Right '`'>
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} {<check>} {<ast_standards.h>})
    (C {<eval>} 
      {
        (command_sub
          left_token: <Id.Left_Backtick '`'>
          child: 
            (C {<iffe>} {($ Id.VSub_DollarName iffeflags)} {<-F>} {<ast_standards.h>} {<-c>} 
              {(DQ ($ Id.VSub_DollarName cc))} {<->} {<tst>} {<use_ast_standards>} {<-lm>} {(SQ <'note{'>)} {(SQ <'math.h needs ast_standards.h'>)} 
              {(SQ <'}end'>)} {(SQ <'link{'>)} {(SQ <'#include <math.h>'>)} {(SQ <'#ifndef isgreater'>)} 
              {(SQ <'#define isgreater(a,b) 0'>)} {(SQ <'#endif'>)} {(SQ <'int main() { return isgreater(0.0,1.0); }'>)} {(SQ <'}end'>)}
            )
          right: <Id.Backtick_Right '`'>
        )
      }
    )
    (command.Case
      to_match: {($ Id.VSub_DollarName _use_ast_standards)}
      arms: [
        (case_arm
          pat_list: [{<1>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'iffeflags='> name:iffeflags)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName iffeflags) <' -F ast_standards.h'>)}
                  spids: [238]
                )
              ]
              redirects: []
            )
          ]
          spids: [235 236 244 -1]
        )
      ]
      redirects: []
    )
    (C {<Id.Lit_Colon ':'>} {<read>} {<the>} {<table>})
    (command.Simple
      words: [{<exec>}]
      redirects: [
        (redir
          op: <Id.Redir_Less '<'>
          loc: (redir_loc.Fd fd:0)
          arg: {($ Id.VSub_DollarName table)}
        )
      ]
      more_env: []
      do_fork: T
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: (condition.Shell commands:[(C {<read>} {<type>} {<args>} {<name>} {<aka>} {<comment>})])
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {($ Id.VSub_DollarName type)}
              arms: [
                (case_arm
                  pat_list: [{<Id.Lit_LBracket '['> <Id.KW_Fi fi> <Id.Lit_RBracket ']'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'names='> name:names)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName names) <' '> ($ Id.VSub_DollarName name))}
                          spids: [292]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tests='> name:tests)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName tests) <','> ($ Id.VSub_DollarName name))}
                          spids: [300]
                        )
                      ]
                      redirects: []
                    )
                    (command.Case
                      to_match: {($ Id.VSub_DollarName _typ_long_double)}
                      arms: [
                        (case_arm
                          pat_list: [{<1>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tests='> name:tests)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName tests) <','> (${ Id.VSub_Name name) <l>)
                                    }
                                  spids: [318]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [315 316 328 -1]
                        )
                      ]
                      redirects: []
                    )
                    (C {<eval>} 
                      {<TYPE_> ($ Id.VSub_DollarName name) <Id.Lit_Equals '='> 
                        ($ Id.VSub_DollarName type)
                      } {<ARGS_> ($ Id.VSub_DollarName name) <Id.Lit_Equals '='> ($ Id.VSub_DollarName args)} 
                      {<AKA_> ($ Id.VSub_DollarName name) <Id.Lit_Equals '='> 
                        ($ Id.VSub_DollarName aka)
                      }
                    )
                  ]
                  spids: [287 290 352 -1]
                )
              ]
              redirects: []
            )
          ]
        )
      redirects: []
    )
    (C {<Id.Lit_Colon ':'>} {<check>} {<the>} {<math>} {<library>})
    (C {<eval>} 
      {
        (command_sub
          left_token: <Id.Left_Backtick '`'>
          child: 
            (command.Simple
              words: [
                {<iffe>}
                {($ Id.VSub_DollarName iffeflags)}
                {<-c>}
                {(DQ ($ Id.VSub_DollarName cc))}
                {<->}
                {<lib>}
                {($ Id.VSub_DollarName tests)}
                {($ Id.VSub_DollarName iffehdrs)}
                {($ Id.VSub_DollarName iffelibs)}
              ]
              redirects: [
                (redir
                  op: <Id.Redir_GreatAnd '2>&'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {($ Id.VSub_DollarName stderr)}
                )
              ]
              more_env: []
              do_fork: T
            )
          right: <Id.Backtick_Right '`'>
        )
      }
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'lib='> name:lib)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [400]
        )
      ]
      redirects: []
    )
    (command.ForEach
      iter_names: [name]
      iterable: (for_iter.Words words:[{($ Id.VSub_DollarName names)}])
      body: 
        (command.DoGroup
          children: [
            (C {<eval>} {<Id.Lit_VarLike 'x='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name name) <l>} 
              {<Id.Lit_VarLike 'y='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name name)}
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName x)}
              arms: [
                (case_arm
                  pat_list: [{<1>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'lib='> name:lib)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName lib) <','> (${ Id.VSub_Name name) <l>)}
                          spids: [444]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [441 442 454 -1]
                )
              ]
              redirects: []
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName y)}
              arms: [
                (case_arm
                  pat_list: [{<1>}]
                  action: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName x)}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'lib='> name:lib)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName lib) <','> (${ Id.VSub_Name name))}
                                  spids: [481]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [477 479 490 -1]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [467 468 496 -1]
                )
              ]
              redirects: []
            )
          ]
        )
      redirects: []
    )
    (C {<eval>} 
      {
        (command_sub
          left_token: <Id.Left_Backtick '`'>
          child: 
            (command.Simple
              words: [
                {<iffe>}
                {($ Id.VSub_DollarName iffeflags)}
                {<-c>}
                {(DQ ($ Id.VSub_DollarName cc))}
                {<->}
                {<dat> <Id.Lit_Comma ','> <npt> <Id.Lit_Comma ','> <mac>}
                {($ Id.VSub_DollarName lib)}
                {($ Id.VSub_DollarName iffehdrs)}
                {($ Id.VSub_DollarName iffelibs)}
              ]
              redirects: [
                (redir
                  op: <Id.Redir_GreatAnd '2>&'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {($ Id.VSub_DollarName stderr)}
                )
              ]
              more_env: []
              do_fork: T
            )
          right: <Id.Backtick_Right '`'>
        )
      }
    )
    (command.Simple
      words: [{<cat>}]
      redirects: [
        (redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<Id.KW_Bang '!'>}
              here_end_span_id: 553
              stdin_parts: [
                <'#pragma prototyped\n'>
                <'\n'>
                <'/* : : generated by '>
                ($ Id.VSub_DollarName command)
                <' from '>
                ($ Id.VSub_DollarName table)
                <' : : */\n'>
                <'\n'>
                <'typedef Sfdouble_t (*Math_f)(Sfdouble_t,...);\n'>
                <'\n'>
              ]
            )
        )
      ]
      more_env: []
      do_fork: T
    )
    (command.Case
      to_match: {($ Id.VSub_DollarName _use_ast_standards)}
      arms: [
        (case_arm
          pat_list: [{<1>}]
          action: [(C {<echo>} {(DQ <'#include <ast_standards.h>'>)})]
          spids: [560 561 569 -1]
        )
      ]
      redirects: []
    )
    (C {<echo>} {(DQ <'#include <math.h>'>)})
    (command.Case
      to_match: {($ Id.VSub_DollarName _hdr_ieeefp)}
      arms: [
        (case_arm
          pat_list: [{<1>}]
          action: [(C {<echo>} {(DQ <'#include <ieeefp.h>'>)})]
          spids: [585 586 594 -1]
        )
      ]
      redirects: []
    )
    (C {<echo>})
    (C {<Id.Lit_Colon ':'>} {<generate>} {<the>} {<intercept>} {<functions>} {<and>} {<table>} {<entries>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'nl='> name:nl)
          op: assign_op.Equal
          rhs: {(SQ <'\n'>)}
          spids: [618]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ht='> name:ht)
          op: assign_op.Equal
          rhs: {(SQ <'\t'>)}
          spids: [623]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tab='> name:tab)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [628]
        )
      ]
      redirects: []
    )
    (command.ForEach
      iter_names: [name]
      iterable: (for_iter.Words words:[{($ Id.VSub_DollarName names)}])
      body: 
        (command.DoGroup
          children: [
            (C {<eval>} {<Id.Lit_VarLike 'x='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name name) <l>} 
              {<Id.Lit_VarLike 'y='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name name)} {<Id.Lit_VarLike 'r='> (SQ <'$'>) <TYPE_> (${ Id.VSub_Name name)} 
              {<Id.Lit_VarLike 'a='> (SQ <'$'>) <ARGS_> (${ Id.VSub_Name name)} {<Id.Lit_VarLike 'aka='> (SQ <'$'>) <AKA_> (${ Id.VSub_Name name)}
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName x) <Id.Lit_Colon ':'> ($ Id.VSub_DollarName y)}
              arms: [
                (case_arm
                  pat_list: [{<1> <Id.Lit_Colon ':'> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name name) <l>}
                          spids: [703]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 't='> name:t)
                          op: assign_op.Equal
                          rhs: {<Sfdouble_t>}
                          spids: [710]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'local='> name:local)
                          op: assign_op.Equal
                          rhs: (rhs_word.Empty)
                          spids: [714]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [698 701 717 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name name)}
                          spids: [725]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 't='> name:t)
                          op: assign_op.Equal
                          rhs: {<double>}
                          spids: [731]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'local='> name:local)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName _typ_long_double)}
                          spids: [735]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [720 723 739 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName aka)}
                      arms: [
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name aka>
                                        var_name: aka
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VOp1_DPercent '%%'>
                                            arg_word: {<'='> <Id.Lit_Other '*'>}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                  spids: [757]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'v='> name:v)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name aka>
                                        var_name: aka
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VOp1_Pound '#'>
                                            arg_word: {<Id.Lit_Other '*'> <'='>}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                  spids: [766]
                                )
                              ]
                              redirects: []
                            )
                            (C {<eval>} 
                              {<Id.Lit_VarLike 'x='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name f) <l>} {<Id.Lit_VarLike 'y='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name f)}
                            )
                            (command.Case
                              to_match: 
                                {($ Id.VSub_DollarName x) <Id.Lit_Colon ':'> ($ Id.VSub_DollarName y)}
                              arms: [
                                (case_arm
                                  pat_list: [{<1> <Id.Lit_Colon ':'> <Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                                          op: assign_op.Equal
                                          rhs: {(${ Id.VSub_Name f) <l>}
                                          spids: [811]
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  spids: [806 809 818 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1>}]
                                  action: []
                                  spids: [821 824 826 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [829 830 835 -1]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'L='> name:L)
                                  op: assign_op.Equal
                                  rhs: {<local_> ($ Id.VSub_DollarName name)}
                                  spids: [841]
                                )
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r='> name:r)
                                  op: assign_op.Equal
                                  rhs: {<int>}
                                  spids: [845]
                                )
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'R='> name:R)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [848]
                                )
                              ]
                              redirects: []
                            )
                            (C {<echo>} 
                              {
                                (DQ <'#ifdef '> ($ Id.VSub_DollarName v) (${ Id.VSub_Name nl) 
                                  <'static '> ($ Id.VSub_DollarName r) <' '> ($ Id.VSub_DollarName L) <'(Sfdouble_t x) { return '> 
                                  ($ Id.VSub_DollarName f) <'(x) == '> ($ Id.VSub_DollarName v) <'; }'> (${ Id.VSub_Name nl) <'#endif'>
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tab='> name:tab)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName tab) ($ Id.VSub_DollarName nl) 
                                        <'#ifdef '> ($ Id.VSub_DollarName v) ($ Id.VSub_DollarName nl) ($ Id.VSub_DollarName ht) 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                          ch: '"'
                                        ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\') <0> (${ Id.VSub_Name R) 
                                        (${ Id.VSub_Name a) (${ Id.VSub_Name name) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <','> 
                                        ($ Id.VSub_DollarName ht) <'(Math_f)'> (${ Id.VSub_Name L) <','> (${ Id.VSub_Name nl) <'#endif'>
                                      )
                                    }
                                  spids: [876]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [752 755 911 -1]
                        )
                      ]
                      redirects: []
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Continue continue>)
                  ]
                  spids: [742 743 920 -1]
                )
              ]
              redirects: []
            )
            (C {<eval>} {<Id.Lit_VarLike 'n='> (SQ <'$'>) <_npt_> ($ Id.VSub_DollarName f)} 
              {<Id.Lit_VarLike 'm='> (SQ <'$'>) <_mac_> ($ Id.VSub_DollarName f)} {<Id.Lit_VarLike 'd='> (SQ <'$'>) <_dat_> ($ Id.VSub_DollarName f)}
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName r)}
              arms: [
                (case_arm
                  pat_list: [{<i>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'L='> name:L)
                          op: assign_op.Equal
                          rhs: {<int>}
                          spids: [960]
                        )
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r='> name:r)
                          op: assign_op.Equal
                          rhs: {<int>}
                          spids: [963]
                        )
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'R='> name:R)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [966]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [957 958 969 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'L='> name:L)
                          op: assign_op.Equal
                          rhs: {<Sfdouble_t>}
                          spids: [975]
                        )
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r='> name:r)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName t)}
                          spids: [978]
                        )
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'R='> name:R)
                          op: assign_op.Equal
                          rhs: {<0>}
                          spids: [981]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [972 973 984 -1]
                )
              ]
              redirects: []
            )
            (command.Case
              to_match: 
                {($ Id.VSub_DollarName d) <Id.Lit_Colon ':'> ($ Id.VSub_DollarName m) 
                  <Id.Lit_Colon ':'> ($ Id.VSub_DollarName n)
                }
              arms: [
                (case_arm
                  pat_list: [
                    {<1> <Id.Lit_Colon ':'> <Id.Lit_Star '*'> <Id.Lit_Colon ':'> <Id.Lit_Star '*'>}
                    {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1> <Id.Lit_Colon ':'> <Id.Lit_Star '*'>}
                  ]
                  action: []
                  spids: [1001 1012 1015 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1>}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'extern '> ($ Id.VSub_DollarName r) <' '> ($ Id.VSub_DollarName f) 
                                <'('>
                              )
                            }
                          spids: [1025]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                          op: assign_op.Equal
                          rhs: (rhs_word.Empty)
                          spids: [1035]
                        )
                      ]
                      redirects: []
                    )
                    (command.ForEach
                      iter_names: [p]
                      iterable: (for_iter.Words words:[{<1>} {<2>} {<3>} {<4>} {<5>} {<6>} {<7>}])
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName code) (${ Id.VSub_Name sep) 
                                        ($ Id.VSub_DollarName t)
                                      )
                                    }
                                  spids: [1061]
                                )
                              ]
                              redirects: []
                            )
                            (command.Case
                              to_match: {($ Id.VSub_DollarName a)}
                              arms: [
                                (case_arm
                                  pat_list: [{($ Id.VSub_DollarName p)}]
                                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                                  spids: [1078 1079 1083 -1]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                                  op: assign_op.Equal
                                  rhs: {(DQ <','>)}
                                  spids: [1089]
                                )
                              ]
                              redirects: []
                            )
                          ]
                        )
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName code) <');'>)}
                          spids: [1098]
                        )
                      ]
                      redirects: []
                    )
                    (C {<echo>} {(DQ ($ Id.VSub_DollarName code))})
                  ]
                  spids: [1018 1023 1112 -1]
                )
              ]
              redirects: []
            )
            (command.Case
              to_match: 
                {($ Id.VSub_DollarName local) <Id.Lit_Colon ':'> ($ Id.VSub_DollarName m) 
                  <Id.Lit_Colon ':'> ($ Id.VSub_DollarName n) <Id.Lit_Colon ':'> ($ Id.VSub_DollarName d)
                }
              arms: [
                (case_arm
                  pat_list: [
                    {<1> <Id.Lit_Colon ':'> <Id.Lit_Star '*'> <Id.Lit_Colon ':'> <Id.Lit_Star '*'> 
                      <Id.Lit_Colon ':'> <Id.Lit_Star '*'>
                    }
                    {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1> <Id.Lit_Colon ':'> <Id.Lit_Star '*'> 
                      <Id.Lit_Colon ':'> <Id.Lit_Star '*'>
                    }
                    {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1> 
                      <Id.Lit_Colon ':'>
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'args='> name:args)
                          op: assign_op.Equal
                          rhs: (rhs_word.Empty)
                          spids: [1156]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'static '> ($ Id.VSub_DollarName L) <' local_'> 
                                ($ Id.VSub_DollarName f) <'('>
                              )
                            }
                          spids: [1159]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                          op: assign_op.Equal
                          rhs: (rhs_word.Empty)
                          spids: [1169]
                        )
                      ]
                      redirects: []
                    )
                    (command.ForEach
                      iter_names: [p]
                      iterable: 
                        (for_iter.Words
                          words: [{<1>} {<2>} {<3>} {<4>} {<5>} {<6>} {<7>} {<8>} {<9>}]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'args='> name:args)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName args) (${ Id.VSub_Name sep) <a> 
                                        ($ Id.VSub_DollarName p)
                                      )
                                    }
                                  spids: [1199]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName code) (${ Id.VSub_Name sep) 
                                        <'Sfdouble_t a'> ($ Id.VSub_DollarName p)
                                      )
                                    }
                                  spids: [1210]
                                )
                              ]
                              redirects: []
                            )
                            (command.Case
                              to_match: {($ Id.VSub_DollarName a)}
                              arms: [
                                (case_arm
                                  pat_list: [{($ Id.VSub_DollarName p)}]
                                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                                  spids: [1228 1229 1233 -1]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                                  op: assign_op.Equal
                                  rhs: {(DQ <','>)}
                                  spids: [1239]
                                )
                              ]
                              redirects: []
                            )
                          ]
                        )
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName code) <'){return '> ($ Id.VSub_DollarName f) 
                                <'('> ($ Id.VSub_DollarName args) <');}'>
                              )
                            }
                          spids: [1248]
                        )
                      ]
                      redirects: []
                    )
                    (C {<echo>} {(DQ ($ Id.VSub_DollarName code))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                          op: assign_op.Equal
                          rhs: {<local_> ($ Id.VSub_DollarName f)}
                          spids: [1266]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [1131 1153 1271 -1]
                )
              ]
              redirects: []
            )
            (command.ForEach
              iter_names: [x]
              iterable: 
                (for_iter.Words
                  words: [{($ Id.VSub_DollarName name)} {($ Id.VSub_DollarName aka)}]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tab='> name:tab)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName tab) ($ Id.VSub_DollarName nl) 
                                ($ Id.VSub_DollarName ht) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\\\'>
                                  ch: '\\'
                                ) <0> (${ Id.VSub_Name R) (${ Id.VSub_Name a) (${ Id.VSub_Name x) 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\"'>
                                  ch: '"'
                                ) <','> ($ Id.VSub_DollarName ht) <'(Math_f)'> ($ Id.VSub_DollarName f) <','>
                              )
                            }
                          spids: [1290]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
          ]
        )
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tab='> name:tab)
          op: assign_op.Equal
          rhs: 
            {
              (DQ ($ Id.VSub_DollarName tab) ($ Id.VSub_DollarName nl) ($ Id.VSub_DollarName ht) 
                (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <','> ($ Id.VSub_DollarName ht) 
                ($ Id.VSub_DollarName ht) <'(Math_f)0'>
              )
            }
          spids: [1320]
        )
      ]
      redirects: []
    )
    (command.Simple
      words: [{<cat>}]
      redirects: [
        (redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<Id.KW_Bang '!'>}
              here_end_span_id: 1350
              stdin_parts: [
                <'\n'>
                <'/*\n'>
                <' * first byte is two-digit octal number.  Last digit is number of args\n'>
                <' * first digit is 0 if return value is double, 1 for integer\n'>
                <' */\n'>
                <'const struct mathtab shtab_math[] =\n'>
                <'{'>
                ($ Id.VSub_DollarName tab)
                <'\n'>
                <'};\n'>
              ]
            )
        )
      ]
      more_env: []
      do_fork: T
    )
  ]
)