(command.CommandList
  children: [
    (C {<set>} {<-o>} {<nounset>})
    (C {<set>} {<-o>} {<pipefail>})
    (C {<set>} {<-o>} {<errexit>})
    (C {<readonly>} 
      {<Id.Lit_VarLike 'THIS_DIR='> 
        (command_sub
          left_token: <Id.Left_DollarParen '$('>
          child: 
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<cd>} 
                  {
                    (command_sub
                      left_token: <Id.Left_DollarParen '$('>
                      child: (C {<dirname>} {($ Id.VSub_Number '$0')})
                    )
                  }
                )
                (C {<pwd>})
              ]
            )
        )
      }
    )
    (C {<source>} {($ Id.VSub_DollarName '$THIS_DIR') <'/common.sh'>})
    (command.ShFunction
      name: opyc
      body: 
        (BraceGroup
          children: [(C {<python>} {<'bin/opy_.pyc'>} {<opyc>} {(DQ ($ Id.VSub_At '$@'))})]
        )
    )
    (command.ShFunction
      name: oil-opy
      body: (BraceGroup children:[(C {<'_tmp/oil-opy/bin/oil'>} {(DQ ($ Id.VSub_At '$@'))})])
    )
    (command.ShFunction
      name: oil-unit
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'dir='> 
                (braced_var_sub
                  token: <Id.VSub_Number 1>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VTest_ColonHyphen ':-'>
                      arg_word: {<_tmp> <Id.Lit_Slash '/'> <repo-with-opy>}
                    )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'vm='> 
                (braced_var_sub
                  token: <Id.VSub_Number 2>
                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<cpython>})
                )
              }
            )
            (C {<pushd>} {($ Id.VSub_DollarName '$dir')})
            (C {<local>} {<Id.Lit_VarLike 'n='> <0>})
            (C {<local>} {<-a>} {<Id.Lit_VarLike 'failures='> (sh_array_literal left:<Id.Op_LParen _>)})
            (command.ForEach
              iter_name: t
              iter_words: [
                (word.BracedTree
                  parts: [
                    (word_part.BracedTuple words:[{<asdl>} {<core>} {<osh>}])
                    <'/'>
                    <Id.Lit_Star '*'>
                    <_test.pyc>
                  ]
                )
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<echo>} {($ Id.VSub_DollarName '$t')})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<test>} {($ Id.VSub_DollarName '$vm')} {<Id.Lit_Equals '='>} 
                                      {<byterun>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<set>} {<Id.Lit_Other '+'> <o>} {<errexit>})
                            (C {<set>} {<Id.Lit_Other '+'> <o>} {<nounset>})
                            (C {<opyc>} {<run>} {($ Id.VSub_DollarName '$t')})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:status)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_QMark '$?')}
                                  spids: [265]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<test>} {($ Id.VSub_DollarName '$status')} {<-ne>} {<0>})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:failures)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: <Id.Op_LParen _>
                                                words: [
                                                  {
                                                    (DQ 
                                                      (braced_var_sub
                                                        token: <Id.VSub_Name failures>
                                                        bracket_op: 
                                                          (bracket_op.WholeArray
                                                            op_id: Id.Lit_At
                                                          )
                                                      )
                                                    )
                                                  }
                                                  {($ Id.VSub_DollarName '$t')}
                                                ]
                                              )
                                            }
                                          spids: [284]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [270 281]
                                )
                              ]
                            )
                            (command.DParen
                              child: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Node_PostDPlus
                                  child: <Id.Lit_ArithVarLike n>
                                )
                            )
                          ]
                          spids: [215 226]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<test>} {($ Id.VSub_DollarName '$vm')} {<Id.Lit_Equals '='>} 
                                      {<cpython>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [{<python>} {($ Id.VSub_DollarName '$t')}]
                              more_env: [(env_pair name:PYTHONPATH val:{<.>} spids:[326])]
                              do_fork: T
                            )
                          ]
                          spids: [312 323]
                        )
                      ]
                      else_action: [(C {<die>} {(DQ <'Invalid VM '> ($ Id.VSub_DollarName '$vm'))})]
                    )
                  ]
                )
            )
            (C {<popd>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<test>} {($ Id.VSub_DollarName '$vm')} {<Id.Lit_Equals '='>} {<byterun>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} 
                      {
                        (DQ <'Ran '> ($ Id.VSub_DollarName '$n') <' tests, '> 
                          (braced_var_sub
                            token: <Id.VSub_Name failures>
                            prefix_op: (Id.VSub_Pound)
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                          ) <' failures'>
                        )
                      }
                    )
                    (C {<echo>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name failures>
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                          )
                        )
                      }
                    )
                  ]
                  spids: [360 371]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: oil-unit-byterun
      body: (BraceGroup children:[(C {<oil-unit>} {(SQ )} {<byterun>})])
    )
    (C {<readonly>} {<-a>} 
      {<Id.Lit_VarLike 'FAILED='> 
        (sh_array_literal
          left: <Id.Op_LParen _>
          words: [
            {<'asdl/arith_parse_test.pyc'>}
            {<'core/glob_test.pyc'>}
            {<'core/lexer_gen_test.pyc'>}
            {<'osh/lex_test.pyc'>}
          ]
        )
      }
    )
    (command.ShFunction
      name: oil-byterun-failed
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: t
              iter_words: [
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name FAILED>
                      bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                    )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<echo>})
                    (C {<echo>} {<--->})
                    (C {<echo>} {<--->} {($ Id.VSub_DollarName '$t')})
                    (C {<echo>} {<--->})
                    (C {<pushd>} {<'_tmp/oil-opy'>})
                    (C {<opyc>} {<run>} {($ Id.VSub_DollarName '$t')})
                    (C {<popd>})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: byterun-unit
      body: 
        (BraceGroup
          children: [
            (C {<pushd>} {($ Id.VSub_DollarName '$THIS_DIR') <'/..'>})
            (command.ForEach
              iter_name: t
              iter_words: [{<'opy/byterun/test_'> <Id.Lit_Star '*'> <.py>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<echo>})
                    (C {<echo>} {(DQ <'*** '> ($ Id.VSub_DollarName '$t'))})
                    (C {<echo>})
                    (command.Simple
                      words: [{($ Id.VSub_DollarName '$t')}]
                      more_env: [(env_pair name:PYTHONPATH val:{<.>} spids:[591])]
                      do_fork: T
                    )
                  ]
                )
            )
            (C {<popd>})
          ]
        )
    )
    (command.ShFunction
      name: generator-exception
      body: 
        (BraceGroup
          children: [
            (C {<'testdata/generator_exception.py'>})
            (C {<'../bin/opyc'>} {<run>} {<'testdata/generator_exception.py'>})
          ]
        )
    )
    (command.ShFunction
      name: generator-exception-diff
      body: 
        (BraceGroup
          children: [
            (C {<rm>} {<-f>} {<-v>} {<'testdata/generator_exception.pyc'>})
            (C {<'testdata/generator_exception.py'>})
            (C {<pushd>} {<testdata>})
            (C {<python>} {<-c>} {(SQ <'import generator_exception'>)})
            (C {<popd>})
            (C {<echo>} {<--->})
            (C {<'../bin/opyc'>} {<compile>} {<'testdata/generator_exception.py'>} {<'_tmp/ge-opy.pyc'>})
            (command.Simple
              words: [{<'../bin/opyc'>} {<dis>} {<'testdata/generator_exception.pyc'>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'_tmp/ge-cpython.txt'>}
                )
              ]
              do_fork: T
            )
            (command.Simple
              words: [{<'../bin/opyc'>} {<dis>} {<'_tmp/ge-opy.pyc'>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'_tmp/ge-opy.txt'>}
                )
              ]
              do_fork: T
            )
            (C {<diff>} {<-u>} 
              (word.BracedTree
                parts: [<'_tmp/ge-'> (word_part.BracedTuple words:[{<cpython>} {<opy>}]) <.txt>]
              )
            )
          ]
        )
    )
    (command.ShFunction
      name: regex-compile
      body: 
        (BraceGroup
          children: [
            (C {<'testdata/regex_compile.py'>})
            (C {<echo>} {<--->})
            (C {<'../bin/opyc'>} {<run>} {<'testdata/regex_compile.py'>})
          ]
        )
    )
    (command.ShFunction
      name: re-dis
      body: 
        (BraceGroup
          children: [(C {<'../bin/opyc'>} {<dis>} {<'/usr/lib/python2.7/sre_parse.pyc'>})]
        )
    )
    (command.ShFunction
      name: spec
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'action='> ($ Id.VSub_Number '$1')})
            (C {<shift>})
            (C {<pushd>} {($ Id.VSub_DollarName '$THIS_DIR') <'/..'>})
            (C {<local>} {<Id.Lit_VarLike 'stub='> <'opy/_tmp/repo-with-opy/bin/osh-byterun'>})
            (command.Simple
              words: [{<'test/spec.sh'>} {($ Id.VSub_DollarName '$action')} {(DQ ($ Id.VSub_At '$@'))}]
              more_env: [(env_pair name:OSH_OVM val:{($ Id.VSub_DollarName '$stub')} spids:[834])]
              do_fork: T
            )
            (C {<popd>})
          ]
        )
    )
    (command.ShFunction
      name: opy-speed-test
      body: 
        (BraceGroup
          children: [
            (C {<opyc-compile>} {<'testdata/speed.py'>} {<'_tmp/speed.pyc'>})
            (C {<opyc-compile>} {<'testdata/speed_main.py'>} {<'_tmp/speed_main.pyc'>})
            (C {<cp>} {<'_tmp/speed.pyc'>} {<'_tmp/speed.opyc'>})
            (C {<local>} {<Id.Lit_VarLike 'n='> <10000>})
            (C {<echo>} {<PYTHON>})
            (command.TimeBlock
              pipeline: (C {<python>} {<'_tmp/speed.opyc'>} {($ Id.VSub_DollarName '$n')})
            )
            (C {<echo>} {<OPY>})
            (command.TimeBlock
              pipeline: (C {<opyc-run>} {<'_tmp/speed.opyc'>} {($ Id.VSub_DollarName '$n')})
            )
            (C {<echo>} {<PYTHON>})
            (command.TimeBlock
              pipeline: (C {<python>} {<'_tmp/speed_main.pyc'>} {($ Id.VSub_DollarName '$n')})
            )
            (C {<echo>} {<OPY>})
            (command.TimeBlock
              pipeline: (C {<opyc-run>} {<'_tmp/speed_main.pyc'>} {($ Id.VSub_DollarName '$n')})
            )
          ]
        )
    )
    (command.ShFunction
      name: gold
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: script
              iter_words: [{<'gold/'> <Id.Lit_Star '*'> <.py>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Simple
                      words: [{($ Id.VSub_DollarName '$script')}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<'_tmp/gold-cpython.txt'>}
                        )
                        (redir
                          op: <Id.Redir_GreatAnd '2>&'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<1>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<'../bin/opyc'>} {<run>} {($ Id.VSub_DollarName '$script')}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<'_tmp/gold-opy-byterun.txt'>}
                        )
                        (redir
                          op: <Id.Redir_GreatAnd '2>&'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<1>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<diff>} {<-u>} 
                                      (word.BracedTree
                                        parts: [
                                          <'_tmp/gold-'>
                                          (word_part.BracedTuple
                                            words: [{<cpython>} {<opy-byterun>}]
                                          )
                                          <.txt>
                                        ]
                                      )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<echo>} {(DQ <'OK '> ($ Id.VSub_DollarName '$script'))})]
                          spids: [1040 1055]
                        )
                      ]
                      else_action: [
                        (C {<echo>} {(DQ <'FAIL '> ($ Id.VSub_DollarName '$script'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<1>}
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (C {(DQ ($ Id.VSub_At '$@'))})
  ]
)