(command.CommandList
  children: [
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>} {<generate>} {<the>} {<ksh>} {<math>} {<builtin>} {<table>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>} {<include>} {<math.tab>}]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'command='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'command='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'command='> name:command)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Number 0)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'iffeflags='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'iffeflags='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'iffeflags='> name:iffeflags)
          op: assign_op.Equal
          rhs: {(DQ <'-n -v'>)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'iffehdrs='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'iffehdrs='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'iffehdrs='> name:iffehdrs)
          op: assign_op.Equal
          rhs: {(DQ <math.h>)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'iffelibs='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'iffelibs='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'iffelibs='> name:iffelibs)
          op: assign_op.Equal
          rhs: {(DQ <-lm>)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'table='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'table='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'table='> name:table)
          op: assign_op.Equal
          rhs: {<'/dev/null'>}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <eval>
      more_env: []
      words: [{<eval>} {($ Id.VSub_Number 1)}]
      redirects: []
      do_fork: T
    )
    (command.Simple blame_tok:<shift> more_env:[] words:[{<shift>}] redirects:[] do_fork:T)
    (command.ShAssignment
      left: <Id.Lit_VarLike 'table='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'table='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'table='> name:table)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Number 1)}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>} {<check>} {<long>} {<double>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <eval>
      more_env: []
      words: [
        {<eval>}
        {
          (CommandSub
            left_token: <Id.Left_Backtick '`'>
            child: 
              (command.Simple
                blame_tok: <iffe>
                more_env: []
                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)}
                  )
                ]
                do_fork: T
              )
            right: <Id.Backtick_Right '`'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>} {<check>} {<ast_standards.h>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <eval>
      more_env: []
      words: [
        {<eval>}
        {
          (CommandSub
            left_token: <Id.Left_Backtick '`'>
            child: 
              (command.Simple
                blame_tok: <iffe>
                more_env: []
                words: [
                  {<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'>)}
                ]
                redirects: []
                do_fork: T
              )
            right: <Id.Backtick_Right '`'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName _use_ast_standards)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <1>
          pattern: (pat.Words words:[{<1>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'iffeflags='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'iffeflags='>
                  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'>)}
                )
              ]
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Simple
      blame_tok: <eval>
      more_env: []
      words: [
        {<eval>}
        {
          (CommandSub
            left_token: <Id.Left_Backtick '`'>
            child: 
              (command.Simple
                blame_tok: <iffe>
                more_env: []
                words: [
                  {<iffe>}
                  {($ Id.VSub_DollarName iffeflags)}
                  {<-c>}
                  {(DQ ($ Id.VSub_DollarName cc))}
                  {<->}
                  {<tst>}
                  {<use_ieeefp>}
                  {<-lm>}
                  {(SQ <'note{'>)}
                  {(SQ <'ieeefp.h plays nice'>)}
                  {(SQ <'}end'>)}
                  {(SQ <'link{'>)}
                  {(SQ <'#include <math.h>'>)}
                  {(SQ <'#include <ieeefp.h>'>)}
                  {(SQ <'int main() { return 0; }'>)}
                  {(SQ <'}end'>)}
                ]
                redirects: []
                do_fork: T
              )
            right: <Id.Backtick_Right '`'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName _use_ieeefp)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <1>
          pattern: (pat.Words words:[{<1>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'iffehdrs='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'iffehdrs='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'iffehdrs='> name:iffehdrs)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName iffehdrs) <' ieeefp.h'>)}
                )
              ]
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>} {<read>} {<the>} {<table>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <exec>
      more_env: []
      words: [{<exec>}]
      redirects: [
        (Redir
          op: <Id.Redir_Less '<'>
          loc: (redir_loc.Fd fd:0)
          arg: {($ Id.VSub_DollarName table)}
        )
      ]
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'ifs='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'ifs='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ifs='> name:ifs)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName IFS)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'libs='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'libs='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'libs='> name:libs)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'names='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'names='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'names='> name:names)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'nums='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'nums='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'nums='> name:nums)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <read>
              more_env: []
              words: [{<read>} {<type>} {<args>} {<name>} {<aka>}]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName type)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Lit_LBracket '['>
                  pattern: (pat.Words words:[{<Id.Lit_LBracket '['> <fix> <Id.Lit_RBracket ']'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'names='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'names='>
                          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))}
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'libs='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'libs='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'libs='> name:libs)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName libs) <','> ($ Id.VSub_DollarName name))}
                        )
                      ]
                      redirects: []
                    )
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName _typ_long_double)})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <1>
                          pattern: (pat.Words words:[{<1>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'libs='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'libs='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'libs='> name:libs)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName libs) <','> (${ Id.VSub_Name name) <l>)
                                    }
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.ForEach
                      keyword: <Id.KW_For for>
                      iter_names: [a]
                      iterable: (for_iter.Words words:[{($ Id.VSub_DollarName aka)}])
                      body: 
                        (command.DoGroup
                          left: <Id.KW_Do do>
                          children: [
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: (case_arg.Word w:{($ Id.VSub_DollarName a)})
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <Id.Left_SingleQuote '\''>
                                  pattern: (pat.Words words:[{(SQ <'{'>) <Id.Lit_Star '*'>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: 
                                    (pat.Words
                                      words: [
                                        {<Id.Lit_Star '*'> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}
                                      ]
                                    )
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'IFS='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'IFS='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'IFS='>
                                              name: IFS
                                            )
                                          op: assign_op.Equal
                                          rhs: {(SQ <'=|'>)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Simple
                                      blame_tok: <set>
                                      more_env: []
                                      words: [{<set>} {($ Id.VSub_DollarName a)}]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'IFS='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'IFS='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'IFS='>
                                              name: IFS
                                            )
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName ifs)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Case
                                      case_kw: <Id.KW_Case case>
                                      to_match: 
                                        (case_arg.Word
                                          w: {(DQ <','> ($ Id.VSub_DollarName libs))}
                                        )
                                      arms_start: <Id.KW_In in>
                                      arms: [
                                        (CaseArm
                                          left: <Id.Lit_Star '*'>
                                          pattern: 
                                            (pat.Words
                                              words: [
                                                {<Id.Lit_Star '*'> <Id.Lit_Comma ','> 
                                                  ($ Id.VSub_Number 1) <Id.Lit_Comma ','> <Id.Lit_Star '*'>
                                                }
                                              ]
                                            )
                                          middle: <Id.Right_CasePat _>
                                          action: []
                                          right: <Id.Op_DSemi _>
                                        )
                                        (CaseArm
                                          left: <Id.Lit_Star '*'>
                                          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'names='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'names='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'names='>
                                                      name: names
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ Id.VSub_DollarName names) <' '> 
                                                        ($ Id.VSub_Number 1)
                                                      )
                                                    }
                                                )
                                              ]
                                              redirects: []
                                            )
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'libs='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'libs='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'libs='>
                                                      name: libs
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ Id.VSub_DollarName libs) <','> 
                                                        ($ Id.VSub_Number 1)
                                                      )
                                                    }
                                                )
                                              ]
                                              redirects: []
                                            )
                                            (command.Case
                                              case_kw: <Id.KW_Case case>
                                              to_match: 
                                                (case_arg.Word
                                                  w: {($ Id.VSub_DollarName _typ_long_double)}
                                                )
                                              arms_start: <Id.KW_In in>
                                              arms: [
                                                (CaseArm
                                                  left: <1>
                                                  pattern: (pat.Words words:[{<1>}])
                                                  middle: <Id.Right_CasePat _>
                                                  action: [
                                                    (command.ShAssignment
                                                      left: <Id.Lit_VarLike 'libs='>
                                                      pairs: [
                                                        (AssignPair
                                                          left: <Id.Lit_VarLike 'libs='>
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              left: <Id.Lit_VarLike 'libs='>
                                                              name: libs
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ Id.VSub_DollarName libs) <','> 
                                                                (${ Id.VSub_Number 1) <l>
                                                              )
                                                            }
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                  ]
                                                  right: <Id.Op_DSemi _>
                                                )
                                              ]
                                              arms_end: <Id.KW_Esac esac>
                                              redirects: []
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                      ]
                                      arms_end: <Id.KW_Esac esac>
                                      redirects: []
                                    )
                                    (command.Simple
                                      blame_tok: <shift>
                                      more_env: []
                                      words: [{<shift>}]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.WhileUntil
                                      keyword: <Id.KW_While while>
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Simple
                                              blame_tok: <Id.Lit_Colon ':'>
                                              more_env: []
                                              words: [{<Id.Lit_Colon ':'>}]
                                              redirects: []
                                              do_fork: T
                                            )
                                          ]
                                        )
                                      body: 
                                        (command.DoGroup
                                          left: <Id.KW_Do do>
                                          children: [
                                            (command.Case
                                              case_kw: <Id.KW_Case case>
                                              to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
                                              arms_start: <Id.KW_In in>
                                              arms: [
                                                (CaseArm
                                                  left: <0>
                                                  pattern: (pat.Words words:[{<0>}])
                                                  middle: <Id.Right_CasePat _>
                                                  action: [
                                                    (command.ControlFlow
                                                      keyword: <Id.ControlFlow_Break break>
                                                    )
                                                  ]
                                                  right: <Id.Op_DSemi _>
                                                )
                                              ]
                                              arms_end: <Id.KW_Esac esac>
                                              redirects: []
                                            )
                                            (command.Case
                                              case_kw: <Id.KW_Case case>
                                              to_match: 
                                                (case_arg.Word
                                                  w: {(DQ <','> ($ Id.VSub_DollarName nums))}
                                                )
                                              arms_start: <Id.KW_In in>
                                              arms: [
                                                (CaseArm
                                                  left: <Id.Lit_Star '*'>
                                                  pattern: 
                                                    (pat.Words
                                                      words: [
                                                        {<Id.Lit_Star '*'> <Id.Lit_Comma ','> 
                                                          ($ Id.VSub_Number 1) <Id.Lit_Comma ','> <Id.Lit_Star '*'>
                                                        }
                                                      ]
                                                    )
                                                  middle: <Id.Right_CasePat _>
                                                  action: []
                                                  right: <Id.Op_DSemi _>
                                                )
                                                (CaseArm
                                                  left: <Id.Lit_Star '*'>
                                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                                  middle: <Id.Right_CasePat _>
                                                  action: [
                                                    (command.ShAssignment
                                                      left: <Id.Lit_VarLike 'nums='>
                                                      pairs: [
                                                        (AssignPair
                                                          left: <Id.Lit_VarLike 'nums='>
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              left: <Id.Lit_VarLike 'nums='>
                                                              name: nums
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ Id.VSub_DollarName nums) <','> 
                                                                ($ Id.VSub_Number 1)
                                                              )
                                                            }
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                  ]
                                                  right: <Id.Op_DSemi _>
                                                )
                                              ]
                                              arms_end: <Id.KW_Esac esac>
                                              redirects: []
                                            )
                                            (command.Simple
                                              blame_tok: <shift>
                                              more_env: []
                                              words: [{<shift>}]
                                              redirects: []
                                              do_fork: T
                                            )
                                          ]
                                          right: <Id.KW_Done done>
                                        )
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                          ]
                          right: <Id.KW_Done done>
                        )
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <eval>
                      more_env: []
                      words: [
                        {<eval>}
                        {<TYPE_> ($ Id.VSub_DollarName name) <Id.Lit_Equals '='> (SQ <'$type'>)}
                        {<ARGS_> ($ Id.VSub_DollarName name) <Id.Lit_Equals '='> (SQ <'$args'>)}
                        {<AKA_> ($ Id.VSub_DollarName name) <Id.Lit_Equals '='> (SQ <'$aka'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>} {<check>} {<the>} {<math>} {<library>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <eval>
      more_env: []
      words: [
        {<eval>}
        {
          (CommandSub
            left_token: <Id.Left_Backtick '`'>
            child: 
              (command.Simple
                blame_tok: <iffe>
                more_env: []
                words: [
                  {<iffe>}
                  {($ Id.VSub_DollarName iffeflags)}
                  {<-c>}
                  {(DQ ($ Id.VSub_DollarName cc))}
                  {<->}
                  {<lib>}
                  {($ Id.VSub_DollarName libs)}
                  {($ 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)}
                  )
                ]
                do_fork: T
              )
            right: <Id.Backtick_Right '`'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'lib='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'lib='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'lib='> name:lib)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [name]
      iterable: (for_iter.Words words:[{($ Id.VSub_DollarName names)}])
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [
                {<eval>}
                {<Id.Lit_VarLike 'x='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name name) <l>}
                {<Id.Lit_VarLike 'y='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name name)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName x)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <1>
                  pattern: (pat.Words words:[{<1>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'lib='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'lib='>
                          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>)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName y)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <1>
                  pattern: (pat.Words words:[{<1>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName x)})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <Id.Left_SingleQuote '\''>
                          pattern: (pat.Words words:[{(SQ )}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'lib='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'lib='>
                                  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))}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Simple
      blame_tok: <eval>
      more_env: []
      words: [
        {<eval>}
        {
          (CommandSub
            left_token: <Id.Left_Backtick '`'>
            child: 
              (command.Simple
                blame_tok: <iffe>
                more_env: []
                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)}
                  )
                ]
                do_fork: T
              )
            right: <Id.Backtick_Right '`'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <eval>
      more_env: []
      words: [
        {<eval>}
        {
          (CommandSub
            left_token: <Id.Left_Backtick '`'>
            child: 
              (command.Simple
                blame_tok: <iffe>
                more_env: []
                words: [
                  {<iffe>}
                  {($ Id.VSub_DollarName iffeflags)}
                  {<-c>}
                  {(DQ ($ Id.VSub_DollarName cc))}
                  {<->}
                  {<num>}
                  {($ Id.VSub_DollarName nums)}
                  {($ 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)}
                  )
                ]
                do_fork: T
              )
            right: <Id.Backtick_Right '`'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      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_tok: <Id.Undefined_Tok ''>
              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'>
              ]
            )
        )
      ]
      do_fork: T
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName _use_ast_standards)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <1>
          pattern: (pat.Words words:[{<1>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [{<echo>} {(DQ <'#include <ast_standards.h>'>)}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {(DQ <'#include <math.h>'>)}]
      redirects: []
      do_fork: T
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName _hdr_ieeefp)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <1>
          pattern: (pat.Words words:[{<1>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [{<echo>} {(DQ <'#include <ieeefp.h>'>)}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Simple blame_tok:<echo> more_env:[] words:[{<echo>}] redirects:[] do_fork:T)
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [
        {<Id.Lit_Colon ':'>}
        {<generate>}
        {<the>}
        {<intercept>}
        {<functions>}
        {<and>}
        {<table>}
        {<entries>}
      ]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'nl='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'nl='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'nl='> name:nl)
          op: assign_op.Equal
          rhs: {(SQ <'\n'>)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'ht='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'ht='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ht='> name:ht)
          op: assign_op.Equal
          rhs: {(SQ <'\t'>)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'tab='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'tab='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tab='> name:tab)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [name]
      iterable: (for_iter.Words words:[{($ Id.VSub_DollarName names)}])
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [
                {<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)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName r)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <i>
                  pattern: (pat.Words words:[{<i>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'L='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'L='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'L='> name:L)
                          op: assign_op.Equal
                          rhs: {<int>}
                        )
                        (AssignPair
                          left: <Id.Lit_VarLike 'R='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'R='> name:R)
                          op: assign_op.Equal
                          rhs: {<1>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <x>
                  pattern: (pat.Words words:[{<x>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'L='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'L='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'L='> name:L)
                          op: assign_op.Equal
                          rhs: {<Sfdouble_t>}
                        )
                        (AssignPair
                          left: <Id.Lit_VarLike 'R='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'R='> name:R)
                          op: assign_op.Equal
                          rhs: {<4>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'L='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'L='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'L='> name:L)
                          op: assign_op.Equal
                          rhs: {<Sfdouble_t>}
                        )
                        (AssignPair
                          left: <Id.Lit_VarLike 'R='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'R='> name:R)
                          op: assign_op.Equal
                          rhs: {<0>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'F='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'F='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'F='> name:F)
                  op: assign_op.Equal
                  rhs: {<local_> ($ Id.VSub_DollarName name)}
                )
              ]
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: 
                (case_arg.Word
                  w: {($ Id.VSub_DollarName x) <Id.Lit_Colon ':'> ($ Id.VSub_DollarName y)}
                )
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <1>
                  pattern: (pat.Words words:[{<1> <Id.Lit_Colon ':'> <Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'f='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'f='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name name) <l>}
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 't='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 't='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 't='> name:t)
                          op: assign_op.Equal
                          rhs: {<Sfdouble_t>}
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'local='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'local='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'local='> name:local)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'f='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'f='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name name)}
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 't='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 't='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 't='> name:t)
                          op: assign_op.Equal
                          rhs: {<double>}
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'local='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'local='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'local='> name:local)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName _typ_long_double)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'body='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'body='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'body='> name:body)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                    (command.ForEach
                      keyword: <Id.KW_For for>
                      iter_names: [k]
                      iterable: (for_iter.Words words:[{($ Id.VSub_DollarName aka)}])
                      body: 
                        (command.DoGroup
                          left: <Id.KW_Do do>
                          children: [
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: (case_arg.Word w:{($ Id.VSub_DollarName body)})
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <Id.Lit_QMark '?'>
                                  pattern: (pat.Words words:[{<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'body='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'body='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'body='>
                                              name: body
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ ($ Id.VSub_DollarName body) <' '> 
                                                ($ Id.VSub_DollarName k)
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ControlFlow
                                      keyword: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: (case_arg.Word w:{($ Id.VSub_DollarName k)})
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <Id.Left_SingleQuote '\''>
                                  pattern: (pat.Words words:[{(SQ <'{'>) <Id.Lit_Star '*'>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'body='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'body='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'body='>
                                              name: body
                                            )
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName k)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: 
                                    (pat.Words
                                      words: [
                                        {<Id.Lit_Star '*'> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}
                                      ]
                                    )
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'IFS='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'IFS='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'IFS='>
                                              name: IFS
                                            )
                                          op: assign_op.Equal
                                          rhs: {(SQ <'=|'>)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Simple
                                      blame_tok: <set>
                                      more_env: []
                                      words: [{<set>} {($ Id.VSub_DollarName k)}]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'IFS='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'IFS='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'IFS='>
                                              name: IFS
                                            )
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName ifs)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'f='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'f='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_Number 1)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Simple
                                      blame_tok: <shift>
                                      more_env: []
                                      words: [{<shift>}]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'v='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'v='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'v='> name:v)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_Star '*')}
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Simple
                                      blame_tok: <eval>
                                      more_env: []
                                      words: [
                                        {<eval>}
                                        {<Id.Lit_VarLike 'x='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name f) 
                                          <l>
                                        }
                                        {<Id.Lit_VarLike 'y='> (SQ <'$'>) <_lib_> (${ Id.VSub_Name f)}
                                      ]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.Case
                                      case_kw: <Id.KW_Case case>
                                      to_match: 
                                        (case_arg.Word
                                          w: 
                                            {($ Id.VSub_DollarName x) <Id.Lit_Colon ':'> 
                                              ($ Id.VSub_DollarName y)
                                            }
                                        )
                                      arms_start: <Id.KW_In in>
                                      arms: [
                                        (CaseArm
                                          left: <1>
                                          pattern: 
                                            (pat.Words
                                              words: [{<1> <Id.Lit_Colon ':'> <Id.Lit_Star '*'>}]
                                            )
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'f='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'f='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'f='>
                                                      name: f
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {(${ Id.VSub_Name f) <l>}
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                        (CaseArm
                                          left: <Id.Lit_Star '*'>
                                          pattern: 
                                            (pat.Words
                                              words: [{<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1>}]
                                            )
                                          middle: <Id.Right_CasePat _>
                                          action: []
                                          right: <Id.Op_DSemi _>
                                        )
                                        (CaseArm
                                          left: <Id.Lit_Star '*'>
                                          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ControlFlow
                                              keyword: <Id.ControlFlow_Continue continue>
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                      ]
                                      arms_end: <Id.KW_Esac esac>
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'y='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'y='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'y='> name:y)
                                          op: assign_op.Equal
                                          rhs: (rhs_word__Empty)
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.WhileUntil
                                      keyword: <Id.KW_While while>
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Simple
                                              blame_tok: <Id.Lit_Colon ':'>
                                              more_env: []
                                              words: [{<Id.Lit_Colon ':'>}]
                                              redirects: []
                                              do_fork: T
                                            )
                                          ]
                                        )
                                      body: 
                                        (command.DoGroup
                                          left: <Id.KW_Do do>
                                          children: [
                                            (command.Case
                                              case_kw: <Id.KW_Case case>
                                              to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
                                              arms_start: <Id.KW_In in>
                                              arms: [
                                                (CaseArm
                                                  left: <0>
                                                  pattern: (pat.Words words:[{<0>}])
                                                  middle: <Id.Right_CasePat _>
                                                  action: [
                                                    (command.ControlFlow
                                                      keyword: <Id.ControlFlow_Break break>
                                                    )
                                                  ]
                                                  right: <Id.Op_DSemi _>
                                                )
                                              ]
                                              arms_end: <Id.KW_Esac esac>
                                              redirects: []
                                            )
                                            (command.Simple
                                              blame_tok: <eval>
                                              more_env: []
                                              words: [
                                                {<eval>}
                                                {<Id.Lit_VarLike 'x='> (SQ <'$'>) <_num_> 
                                                  ($ Id.VSub_Number 1)
                                                }
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                            (command.Case
                                              case_kw: <Id.KW_Case case>
                                              to_match: (case_arg.Word w:{($ Id.VSub_DollarName x)})
                                              arms_start: <Id.KW_In in>
                                              arms: [
                                                (CaseArm
                                                  left: <1>
                                                  pattern: (pat.Words words:[{<1>}])
                                                  middle: <Id.Right_CasePat _>
                                                  action: [
                                                    (command.Case
                                                      case_kw: <Id.KW_Case case>
                                                      to_match: 
                                                        (case_arg.Word
                                                          w: {($ Id.VSub_DollarName y)}
                                                        )
                                                      arms_start: <Id.KW_In in>
                                                      arms: [
                                                        (CaseArm
                                                          left: <Id.Lit_QMark '?'>
                                                          pattern: 
                                                            (pat.Words
                                                              words: [
                                                                {<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                                                              ]
                                                            )
                                                          middle: <Id.Right_CasePat _>
                                                          action: [
                                                            (command.ShAssignment
                                                              left: <Id.Lit_VarLike 'y='>
                                                              pairs: [
                                                                (AssignPair
                                                                  left: <Id.Lit_VarLike 'y='>
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      left: <Id.Lit_VarLike 'y='>
                                                                      name: y
                                                                    )
                                                                  op: assign_op.Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ Id.VSub_DollarName y) 
                                                                        <' || '>
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                              redirects: []
                                                            )
                                                          ]
                                                          right: <Id.Op_DSemi _>
                                                        )
                                                      ]
                                                      arms_end: <Id.KW_Esac esac>
                                                      redirects: []
                                                    )
                                                    (command.ShAssignment
                                                      left: <Id.Lit_VarLike 'y='>
                                                      pairs: [
                                                        (AssignPair
                                                          left: <Id.Lit_VarLike 'y='>
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              left: <Id.Lit_VarLike 'y='>
                                                              name: y
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: 
                                                            {
                                                              (DQ (${ Id.VSub_Name y) <'q == '> 
                                                                ($ Id.VSub_Number 1)
                                                              )
                                                            }
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                  ]
                                                  right: <Id.Op_DSemi _>
                                                )
                                              ]
                                              arms_end: <Id.KW_Esac esac>
                                              redirects: []
                                            )
                                            (command.Simple
                                              blame_tok: <shift>
                                              more_env: []
                                              words: [{<shift>}]
                                              redirects: []
                                              do_fork: T
                                            )
                                          ]
                                          right: <Id.KW_Done done>
                                        )
                                      redirects: []
                                    )
                                    (command.Case
                                      case_kw: <Id.KW_Case case>
                                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName y)})
                                      arms_start: <Id.KW_In in>
                                      arms: [
                                        (CaseArm
                                          left: <Id.Left_SingleQuote '\''>
                                          pattern: (pat.Words words:[{(SQ )}])
                                          middle: <Id.Right_CasePat _>
                                          action: []
                                          right: <Id.Op_DSemi _>
                                        )
                                        (CaseArm
                                          left: <Id.Lit_Star '*'>
                                          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'r='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'r='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'r='>
                                                      name: r
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {<int>}
                                                )
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'R='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'R='>
                                                      name: R
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {<1>}
                                                )
                                              ]
                                              redirects: []
                                            )
                                            (command.Simple
                                              blame_tok: <echo>
                                              more_env: []
                                              words: [
                                                {<echo>}
                                                {
                                                  (DQ <'static '> ($ Id.VSub_DollarName r) <' '> 
                                                    ($ Id.VSub_DollarName F) <'(Sfdouble_t a1) { '> ($ Id.VSub_DollarName r) <' q = '> ($ Id.VSub_DollarName f) <'(a1); return '> 
                                                    ($ Id.VSub_DollarName y) <'; }'>
                                                  )
                                                }
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'tab='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'tab='>
                                                  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 name) 
                                                        (word_part.EscapedLiteral
                                                          token: <Id.Lit_EscapedChar '\\"'>
                                                          ch: '"'
                                                        ) <','> ($ Id.VSub_DollarName ht) <'(Math_f)'> (${ Id.VSub_Name F) <','>
                                                      )
                                                    }
                                                )
                                              ]
                                              redirects: []
                                            )
                                            (command.ControlFlow
                                              keyword: <Id.ControlFlow_Break break>
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                      ]
                                      arms_end: <Id.KW_Esac esac>
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                          ]
                          right: <Id.KW_Done done>
                        )
                      redirects: []
                    )
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName body)})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <Id.Lit_QMark '?'>
                          pattern: (pat.Words words:[{<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'code='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'code='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'static '> ($ Id.VSub_DollarName L) <' '> 
                                        ($ Id.VSub_DollarName F) <'('>
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'sep='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'sep='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                                  op: assign_op.Equal
                                  rhs: (rhs_word__Empty)
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'ta='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'ta='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ta='> name:ta)
                                  op: assign_op.Equal
                                  rhs: (rhs_word__Empty)
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'tc='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'tc='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tc='> name:tc)
                                  op: assign_op.Equal
                                  rhs: (rhs_word__Empty)
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'td='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'td='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'td='> name:td)
                                  op: assign_op.Equal
                                  rhs: (rhs_word__Empty)
                                )
                              ]
                              redirects: []
                            )
                            (command.ForEach
                              keyword: <Id.KW_For for>
                              iter_names: [p]
                              iterable: 
                                (for_iter.Words
                                  words: [{<1>} {<2>} {<3>} {<4>} {<5>} {<6>} {<7>} {<8>} {<9>}]
                                )
                              body: 
                                (command.DoGroup
                                  left: <Id.KW_Do do>
                                  children: [
                                    (command.Case
                                      case_kw: <Id.KW_Case case>
                                      to_match: 
                                        (case_arg.Word
                                          w: 
                                            {($ Id.VSub_DollarName R) <Id.Lit_Colon ':'> 
                                              ($ Id.VSub_DollarName p)
                                            }
                                        )
                                      arms_start: <Id.KW_In in>
                                      arms: [
                                        (CaseArm
                                          left: <4>
                                          pattern: (pat.Words words:[{<4> <Id.Lit_Colon ':'> <2>}])
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'T='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'T='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'T='>
                                                      name: T
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {<int>}
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                        (CaseArm
                                          left: <Id.Lit_Star '*'>
                                          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'T='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'T='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'T='>
                                                      name: T
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {<Sfdouble_t>}
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                      ]
                                      arms_end: <Id.KW_Esac esac>
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'code='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'code='>
                                          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) <' a'> ($ Id.VSub_DollarName p)
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'ta='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'ta='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ta='> name:ta)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ ($ Id.VSub_DollarName ta) (${ Id.VSub_Name sep) <a> 
                                                ($ Id.VSub_DollarName p)
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'tc='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'tc='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tc='> name:tc)
                                          op: assign_op.Equal
                                          rhs: 
                                            {(DQ ($ Id.VSub_DollarName tc) (${ Id.VSub_Name sep) <0>)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'td='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'td='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'td='> name:td)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ (${ Id.VSub_Name td) ($ Id.VSub_DollarName T) <' a'> 
                                                ($ Id.VSub_DollarName p) <';'>
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Case
                                      case_kw: <Id.KW_Case case>
                                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName a)})
                                      arms_start: <Id.KW_In in>
                                      arms: [
                                        (CaseArm
                                          left: <Id.VSub_DollarName '$p'>
                                          pattern: (pat.Words words:[{($ Id.VSub_DollarName p)}])
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ControlFlow
                                              keyword: <Id.ControlFlow_Break break>
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                      ]
                                      arms_end: <Id.KW_Esac esac>
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'sep='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'sep='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'sep='>
                                              name: sep
                                            )
                                          op: assign_op.Equal
                                          rhs: {(DQ <','>)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.KW_Done done>
                                )
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike '_it_links_='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike '_it_links_='>
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike '_it_links_='>
                                      name: _it_links_
                                    )
                                  op: assign_op.Equal
                                  rhs: {<0>}
                                )
                              ]
                              redirects: []
                            )
                            (command.Simple
                              blame_tok: <eval>
                              more_env: []
                              words: [
                                {<eval>}
                                {
                                  (CommandSub
                                    left_token: <Id.Left_Backtick '`'>
                                    child: 
                                      (command.Simple
                                        blame_tok: <iffe>
                                        more_env: []
                                        words: [
                                          {<iffe>}
                                          {($ Id.VSub_DollarName iffeflags)}
                                          {<-c>}
                                          {(DQ ($ Id.VSub_DollarName cc))}
                                          {<->}
                                          {<tst>}
                                          {<it_links_>}
                                          {<note> <Id.Lit_LBrace '{'>}
                                          {($ Id.VSub_DollarName F)}
                                          {<Id.KW_Function function>}
                                          {<links>}
                                          {<Id.Lit_RBrace '}'> <end>}
                                          {<link> <Id.Lit_LBrace '{'>}
                                          {
                                            (DQ <'static '> ($ Id.VSub_DollarName L) <' '> 
                                              ($ Id.VSub_DollarName F) <'('> ($ Id.VSub_DollarName ta) <')'> ($ Id.VSub_DollarName td) (${ Id.VSub_Name body) 
                                              <'int main(){return '> ($ Id.VSub_DollarName F) <'('> ($ Id.VSub_DollarName tc) <')!=0;}'>
                                            )
                                          }
                                          {<Id.Lit_RBrace '}'> <end>}
                                          {<sfio.h>}
                                          {($ 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)}
                                          )
                                        ]
                                        do_fork: T
                                      )
                                    right: <Id.Backtick_Right '`'>
                                  )
                                }
                              ]
                              redirects: []
                              do_fork: T
                            )
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: (case_arg.Word w:{($ Id.VSub_DollarName _it_links_)})
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <1>
                                  pattern: (pat.Words words:[{<1>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'code='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'code='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'code='>
                                              name: code
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ ($ Id.VSub_DollarName code) <')'> 
                                                ($ Id.VSub_DollarName body)
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Simple
                                      blame_tok: <echo>
                                      more_env: []
                                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName code))}]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'tab='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'tab='>
                                          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 name) 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\"'>
                                                  ch: '"'
                                                ) <','> ($ Id.VSub_DollarName ht) <'(Math_f)'> (${ Id.VSub_Name F) <','>
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Continue continue>
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName r)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <i>
                  pattern: (pat.Words words:[{<i>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'r='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'r='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r='> name:r)
                          op: assign_op.Equal
                          rhs: {<int>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'r='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'r='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r='> name:r)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName t)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [
                {<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)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: 
                (case_arg.Word
                  w: 
                    {($ Id.VSub_DollarName d) <Id.Lit_Colon ':'> ($ Id.VSub_DollarName m) 
                      <Id.Lit_Colon ':'> ($ Id.VSub_DollarName n)
                    }
                )
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <1>
                  pattern: 
                    (pat.Words
                      words: [
                        {<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 '*'>}
                      ]
                    )
                  middle: <Id.Right_CasePat _>
                  action: []
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: 
                    (pat.Words
                      words: [
                        {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <Id.Lit_Star '*'> <Id.Lit_Colon ':'> <1>}
                      ]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'code='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'code='>
                          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) 
                                <'('>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'sep='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'sep='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                    (command.ForEach
                      keyword: <Id.KW_For for>
                      iter_names: [p]
                      iterable: (for_iter.Words words:[{<1>} {<2>} {<3>} {<4>} {<5>} {<6>} {<7>}])
                      body: 
                        (command.DoGroup
                          left: <Id.KW_Do do>
                          children: [
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: 
                                (case_arg.Word
                                  w: 
                                    {($ Id.VSub_DollarName p) <Id.Lit_Colon ':'> 
                                      ($ Id.VSub_DollarName f)
                                    }
                                )
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <2>
                                  pattern: 
                                    (pat.Words
                                      words: [{<2> <Id.Lit_Colon ':'> <ldexp> <Id.Lit_Star '*'>}]
                                    )
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'code='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'code='>
                                          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) 
                                                <int>
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'code='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'code='>
                                          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)
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: (case_arg.Word w:{($ Id.VSub_DollarName a)})
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <Id.VSub_DollarName '$p'>
                                  pattern: (pat.Words words:[{($ Id.VSub_DollarName p)}])
                                  middle: <Id.Right_CasePat _>
                                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'sep='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'sep='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                                  op: assign_op.Equal
                                  rhs: {(DQ <','>)}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.KW_Done done>
                        )
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'code='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'code='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName code) <');'>)}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <echo>
                      more_env: []
                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName code))}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: 
                (case_arg.Word
                  w: 
                    {($ 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_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <1>
                  pattern: 
                    (pat.Words
                      words: [
                        {<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 ':'>
                        }
                      ]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'args='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'args='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'args='> name:args)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'code='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'code='>
                          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) <'('>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'sep='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'sep='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                    (command.ForEach
                      keyword: <Id.KW_For for>
                      iter_names: [p]
                      iterable: 
                        (for_iter.Words
                          words: [{<1>} {<2>} {<3>} {<4>} {<5>} {<6>} {<7>} {<8>} {<9>}]
                        )
                      body: 
                        (command.DoGroup
                          left: <Id.KW_Do do>
                          children: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'args='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'args='>
                                  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)
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: 
                                (case_arg.Word
                                  w: 
                                    {($ Id.VSub_DollarName R) <Id.Lit_Colon ':'> 
                                      ($ Id.VSub_DollarName p)
                                    }
                                )
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <4>
                                  pattern: (pat.Words words:[{<4> <Id.Lit_Colon ':'> <2>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'T='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'T='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'T='> name:T)
                                          op: assign_op.Equal
                                          rhs: {<int>}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'T='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'T='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'T='> name:T)
                                          op: assign_op.Equal
                                          rhs: {<Sfdouble_t>}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'code='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'code='>
                                  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) <' a'> ($ Id.VSub_DollarName p)
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: (case_arg.Word w:{($ Id.VSub_DollarName a)})
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <Id.VSub_DollarName '$p'>
                                  pattern: (pat.Words words:[{($ Id.VSub_DollarName p)}])
                                  middle: <Id.Right_CasePat _>
                                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'sep='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'sep='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                                  op: assign_op.Equal
                                  rhs: {(DQ <','>)}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.KW_Done done>
                        )
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'code='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'code='>
                          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) <');}'>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <echo>
                      more_env: []
                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName code))}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'f='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'f='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'f='> name:f)
                          op: assign_op.Equal
                          rhs: {<local_> ($ Id.VSub_DollarName f)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [x]
              iterable: 
                (for_iter.Words
                  words: [{($ Id.VSub_DollarName name)} {($ Id.VSub_DollarName aka)}]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName x)})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <Id.Left_SingleQuote '\''>
                          pattern: (pat.Words words:[{(SQ <'{'>) <Id.Lit_Star '*'>}])
                          middle: <Id.Right_CasePat _>
                          action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <Id.Lit_Star '*'>
                          pattern: 
                            (pat.Words
                              words: [{<Id.Lit_Star '*'> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                            )
                          middle: <Id.Right_CasePat _>
                          action: [(command.ControlFlow keyword:<Id.ControlFlow_Continue continue>)]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'tab='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'tab='>
                          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) <','>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'tab='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'tab='>
          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'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      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_tok: <Id.Undefined_Tok ''>
              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'>
              ]
            )
        )
      ]
      do_fork: T
    )
  ]
)