(command.CommandList
  children: [
    (C {(set)} {(-o)} {(nounset)})
    (C {(set)} {(-o)} {(pipefail)})
    (C {(set)} {(-o)} {(errexit)})
    (command.Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:THIS_DIR)
          op: Equal
          rhs: 
            {
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [
                      (command.AndOr
                        ops: [Op_DAmp]
                        children: [
                          (C {(cd)} 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(dirname)} {($ VSub_Number '$0')})]
                                  )
                                left_token: <Left_DollarParen '$('>
                              )
                            }
                          )
                          (C {(pwd)})
                        ]
                      )
                    ]
                  )
                left_token: <Left_DollarParen '$('>
              )
            }
        )
      ]
    )
    (C {(source)} {($ VSub_DollarName '$THIS_DIR') (/common.sh)})
    (command.FuncDef
      name: opyc
      body: 
        (command.BraceGroup
          children: [(C {(python)} {(bin/opy_.pyc)} {(opyc)} {(DQ ($ VSub_At '$@'))})]
        )
    )
    (command.FuncDef
      name: oil-opy
      body: (command.BraceGroup children:[(C {(_tmp/oil-opy/bin/oil)} {(DQ ($ VSub_At '$@'))})])
    )
    (command.FuncDef
      name: oil-unit
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:dir)
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Number 1>
                        suffix_op: 
                          (suffix_op.StringUnary
                            op_id: VTest_ColonHyphen
                            arg_word: {(_tmp) (Lit_Slash /) (repo-with-opy)}
                          )
                      )
                    }
                )
              ]
            )
            (command.Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:vm)
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Number 2>
                        suffix_op: (suffix_op.StringUnary op_id:VTest_ColonHyphen arg_word:{(cpython)})
                      )
                    }
                )
              ]
            )
            (C {(pushd)} {($ VSub_DollarName '$dir')})
            (command.Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:n) op:Equal rhs:{(0)})]
            )
            (command.Assignment
              keyword: Assign_Local
              flags: [-a]
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:failures) op:Equal rhs:{(word_part.ArrayLiteralPart)})]
            )
            (command.ForEach
              iter_name: t
              iter_words: [
                (word.BracedWordTree
                  parts: [
                    (word_part.BracedTuple words:[{(asdl)} {(core)} {(osh)}])
                    (/)
                    (Lit_Other '*')
                    (_test.pyc)
                  ]
                )
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {(echo)} {($ VSub_DollarName '$t')})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {($ VSub_DollarName '$vm')} {(Lit_Other '=')} {(byterun)})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(set)} {(Lit_Other '+') (o)} {(errexit)})
                            (C {(set)} {(Lit_Other '+') (o)} {(nounset)})
                            (C {(opyc)} {(run)} {($ VSub_DollarName '$t')})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:status)
                                  op: Equal
                                  rhs: {($ VSub_QMark '$?')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {($ VSub_DollarName '$status')} {(-ne)} {(0)})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:failures)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.ArrayLiteralPart
                                                words: [
                                                  {
                                                    (DQ 
                                                      (word_part.BracedVarSub
                                                        token: <VSub_Name failures>
                                                        bracket_op: 
                                                          (bracket_op.WholeArray
                                                            op_id: Lit_At
                                                          )
                                                      )
                                                    )
                                                  }
                                                  {($ VSub_DollarName '$t')}
                                                ]
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.DParen
                              child: 
                                (arith_expr.UnaryAssign
                                  op_id: Node_PostDPlus
                                  child: (lhs_expr.LhsName name:n)
                                )
                            )
                          ]
                        )
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {($ VSub_DollarName '$vm')} {(Lit_Other '=')} {(cpython)})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.SimpleCommand
                              words: [{(python)} {($ VSub_DollarName '$t')}]
                              more_env: [(env_pair name:PYTHONPATH val:{(.)})]
                            )
                          ]
                        )
                      ]
                      else_action: [(C {(die)} {(DQ ('Invalid VM ') ($ VSub_DollarName '$vm'))})]
                    )
                  ]
                )
            )
            (C {(popd)})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {($ VSub_DollarName '$vm')} {(Lit_Other '=')} {(byterun)})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ('Ran ') ($ VSub_DollarName '$n') (' tests, ') 
                          (word_part.BracedVarSub
                            token: <VSub_Name failures>
                            prefix_op: VSub_Pound
                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                          ) (' failures')
                        )
                      }
                    )
                    (C {(echo)} 
                      {
                        (DQ 
                          (word_part.BracedVarSub
                            token: <VSub_Name failures>
                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.FuncDef
      name: oil-unit-byterun
      body: (command.BraceGroup children:[(C {(oil-unit)} {(SQ )} {(byterun)})])
    )
    (command.Assignment
      keyword: Assign_Readonly
      flags: [-a]
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:FAILED)
          op: Equal
          rhs: 
            {
              (word_part.ArrayLiteralPart
                words: [
                  {(asdl/arith_parse_test.pyc)}
                  {(core/glob_test.pyc)}
                  {(core/lexer_gen_test.pyc)}
                  {(osh/lex_test.pyc)}
                ]
              )
            }
        )
      ]
    )
    (command.FuncDef
      name: oil-byterun-failed
      body: 
        (command.BraceGroup
          children: [
            (command.ForEach
              iter_name: t
              iter_words: [
                {
                  (DQ 
                    (word_part.BracedVarSub
                      token: <VSub_Name FAILED>
                      bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                    )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {(echo)})
                    (C {(echo)} {(---)})
                    (C {(echo)} {(---)} {($ VSub_DollarName '$t')})
                    (C {(echo)} {(---)})
                    (C {(pushd)} {(_tmp/oil-opy)})
                    (C {(opyc)} {(run)} {($ VSub_DollarName '$t')})
                    (C {(popd)})
                  ]
                )
            )
          ]
        )
    )
    (command.FuncDef
      name: byterun-unit
      body: 
        (command.BraceGroup
          children: [
            (C {(pushd)} {($ VSub_DollarName '$THIS_DIR') (/..)})
            (command.ForEach
              iter_name: t
              iter_words: [{(opy/byterun/test_) (Lit_Other '*') (.py)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {(echo)})
                    (C {(echo)} {(DQ ('*** ') ($ VSub_DollarName '$t'))})
                    (C {(echo)})
                    (command.SimpleCommand
                      words: [{($ VSub_DollarName '$t')}]
                      more_env: [(env_pair name:PYTHONPATH val:{(.)})]
                    )
                  ]
                )
            )
            (C {(popd)})
          ]
        )
    )
    (command.FuncDef
      name: generator-exception
      body: 
        (command.BraceGroup
          children: [
            (C {(testdata/generator_exception.py)})
            (C {(../bin/opyc)} {(run)} {(testdata/generator_exception.py)})
          ]
        )
    )
    (command.FuncDef
      name: generator-exception-diff
      body: 
        (command.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.SimpleCommand
              words: [{(../bin/opyc)} {(dis)} {(testdata/generator_exception.pyc)}]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(_tmp/ge-cpython.txt)}
                )
              ]
            )
            (command.SimpleCommand
              words: [{(../bin/opyc)} {(dis)} {(_tmp/ge-opy.pyc)}]
              redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(_tmp/ge-opy.txt)})]
            )
            (C {(diff)} {(-u)} 
              (word.BracedWordTree
                parts: [(_tmp/ge-) (word_part.BracedTuple words:[{(cpython)} {(opy)}]) (.txt)]
              )
            )
          ]
        )
    )
    (command.FuncDef
      name: regex-compile
      body: 
        (command.BraceGroup
          children: [
            (C {(testdata/regex_compile.py)})
            (C {(echo)} {(---)})
            (C {(../bin/opyc)} {(run)} {(testdata/regex_compile.py)})
          ]
        )
    )
    (command.FuncDef
      name: re-dis
      body: 
        (command.BraceGroup
          children: [(C {(../bin/opyc)} {(dis)} {(/usr/lib/python2.7/sre_parse.pyc)})]
        )
    )
    (command.FuncDef
      name: spec
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:action)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (C {(shift)})
            (C {(pushd)} {($ VSub_DollarName '$THIS_DIR') (/..)})
            (command.Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:stub)
                  op: Equal
                  rhs: {(opy/_tmp/repo-with-opy/bin/osh-byterun)}
                )
              ]
            )
            (command.SimpleCommand
              words: [{(test/spec.sh)} {($ VSub_DollarName '$action')} {(DQ ($ VSub_At '$@'))}]
              more_env: [(env_pair name:OSH_OVM val:{($ VSub_DollarName '$stub')})]
            )
            (C {(popd)})
          ]
        )
    )
    (command.FuncDef
      name: opy-speed-test
      body: 
        (command.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)})
            (command.Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:n) op:Equal rhs:{(10000)})]
            )
            (C {(echo)} {(PYTHON)})
            (command.TimeBlock
              pipeline: (C {(python)} {(_tmp/speed.opyc)} {($ VSub_DollarName '$n')})
            )
            (C {(echo)} {(OPY)})
            (command.TimeBlock
              pipeline: (C {(opyc-run)} {(_tmp/speed.opyc)} {($ VSub_DollarName '$n')})
            )
            (C {(echo)} {(PYTHON)})
            (command.TimeBlock
              pipeline: (C {(python)} {(_tmp/speed_main.pyc)} {($ VSub_DollarName '$n')})
            )
            (C {(echo)} {(OPY)})
            (command.TimeBlock
              pipeline: (C {(opyc-run)} {(_tmp/speed_main.pyc)} {($ VSub_DollarName '$n')})
            )
          ]
        )
    )
    (command.FuncDef
      name: gold
      body: 
        (command.BraceGroup
          children: [
            (command.ForEach
              iter_name: script
              iter_words: [{(gold/) (Lit_Other '*') (.py)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.SimpleCommand
                      words: [{($ VSub_DollarName '$script')}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(_tmp/gold-cpython.txt)}
                        )
                        (redir.Redir
                          op: <Redir_GreatAnd '2>&'>
                          fd: 2
                          arg_word: {(1)}
                        )
                      ]
                    )
                    (command.SimpleCommand
                      words: [{(../bin/opyc)} {(run)} {($ VSub_DollarName '$script')}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(_tmp/gold-opy-byterun.txt)}
                        )
                        (redir.Redir
                          op: <Redir_GreatAnd '2>&'>
                          fd: 2
                          arg_word: {(1)}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(diff)} {(-u)} 
                                  (word.BracedWordTree
                                    parts: [
                                      (_tmp/gold-)
                                      (word_part.BracedTuple
                                        words: [{(cpython)} {(opy-byterun)}]
                                      )
                                      (.txt)
                                    ]
                                  )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(echo)} {(DQ ('OK ') ($ VSub_DollarName '$script'))})]
                        )
                      ]
                      else_action: [
                        (C {(echo)} {(DQ ('FAIL ') ($ VSub_DollarName '$script'))})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(1)}
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (C {(DQ ($ VSub_At '$@'))})
  ]
)