(command.CommandList
  children: [
    (C {<set>} {<-o>} {<nounset>})
    (C {<set>} {<-o>} {<pipefail>})
    (C {<set>} {<-o>} {<errexit>})
    (command.ShFunction
      name: filter-py
      body: (BraceGroup children:[(C {<grep>} {<-E>} {<-v>} {(SQ <'__init__.py$|_test.py$'>)})])
    )
    (command.ShFunction
      name: oil-osh-files
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {<ls>} 
                          (word.BracedTree
                            parts: [
                              (word_part.BracedTuple
                                words: [{<bin>} {<osh>} {<core>}]
                              )
                              <'/'>
                              <Id.Lit_Star '*'>
                              <.py>
                            ]
                          ) {<'native/'> <Id.Lit_Star '*'> <.c>} 
                          (word.BracedTree
                            parts: [<'osh/'> (word_part.BracedTuple words:[{<osh>} {<types>}]) <.asdl>]
                          ) {<'core/runtime.asdl'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
                (C {<filter-py>})
                (C {<grep>} {<-E>} {<-v>} {(SQ <'_gen.py$|test_lib.py'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: asdl-cloc
      body: 
        (BraceGroup
          children: [
            (C {<python>} {<-c>} 
              {
                (SQ <'\n'> <'import sys\n'> <'\n'> <'total = 0\n'> <'for path in sys.argv[1:]:\n'> 
                  <'  num_lines = 0\n'> <'  with open(path) as f:\n'> <'    for line in f:\n'> <'      line = line.strip()\n'> 
                  <'      if not line or line.startswith("--"):\n'> <'        continue\n'> <'      num_lines += 1\n'> <'\n'> <'  print "%5d %s" % (num_lines, path)\n'> 
                  <'  total += num_lines\n'> <'\n'> <'print "%5d %s" % (total, "total")\n'>
                )
              } {(DQ ($ Id.VSub_At '$@'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: oil-osh-cloc
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {(SQ <'OIL AND OSH (non-blank non-comment lines)'>)})
            (C {<echo>})
            (command.Pipeline
              children: [
                (C {<oil-osh-files>})
                (C {<xargs>} {<cloc>} {<--quiet>} {(DQ ($ Id.VSub_At '$@'))})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'ASDL SCHEMAS (non-blank non-comment lines)'>)})
            (C {<asdl-cloc>} {<'osh/osh.asdl'>} {<'core/runtime.asdl'>})
          ]
        )
    )
    (command.ShFunction
      name: all
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {(SQ <'BUILD AUTOMATION'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      <'build/'>
                      <Id.Lit_Star '*'>
                      <.>
                      (word_part.BracedTuple words:[{<mk>} {<sh>} {<py>}])
                    ]
                  ) {<Makefile>} {<Id.Lit_Star '*'> <.mk>} {<configure>} {<install>}
                )
                (C {<filter-py>})
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'TEST AUTOMATION'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      <'test/'>
                      <Id.Lit_Star '*'>
                      <.>
                      (word_part.BracedTuple words:[{<sh>} {<py>} {<R>}])
                    ]
                  )
                )
                (C {<filter-py>})
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'RELEASE AUTOMATION'>)})
            (command.Pipeline
              children: [(C {<wc>} {<-l>} {<'scripts/release.sh'>}) (C {<sort>} {<--numeric>})]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <BENCHMARKS>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      <'benchmarks/'>
                      <Id.Lit_Star '*'>
                      <.>
                      (word_part.BracedTuple words:[{<sh>} {<py>} {<R>}])
                    ]
                  )
                )
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'SPEC TESTS'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} {<'spec/'> <Id.Lit_Star '*'> <.test.sh>})
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'GOLD TESTS'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} {<'gold/'> <Id.Lit_Star '*'> <.sh>})
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <ASDL>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      <'asdl/'>
                      (word_part.BracedTuple
                        words: [
                          {<asdl_> <Id.Lit_Star '*'>}
                          {<Id.KW_Const const>}
                          {<py_meta>}
                          {<encode>}
                          {<format>}
                        ]
                      )
                      <.py>
                    ]
                  )
                )
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'CODE GENERATORS'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} {<'asdl/gen_'> <Id.Lit_Star '*'> <.py>} 
                  {<Id.Lit_Star '*'> <'/'> <Id.Lit_Star '*'> <_gen.py>}
                )
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'GENERATED CODE'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      <'_devbuild/gen/'>
                      <Id.Lit_Star '*'>
                      <.>
                      (word_part.BracedTuple words:[{<py>} {<h>}])
                    ]
                  )
                )
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <TOOLS>)})
            (command.Pipeline
              children: [
                (C {<ls>} {<'tools/'> <Id.Lit_Star '*'> <.py>})
                (C {<filter-py>})
                (C {<xargs>} {<wc>} {<-l>})
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <WEB>)})
            (command.Pipeline
              children: [
                (C {<ls>} {<'web/'> <Id.Lit_Star '*'> <.js>} 
                  (word.BracedTree
                    parts: [
                      <'web/'>
                      <Id.Lit_Star '*'>
                      <'/'>
                      <Id.Lit_Star '*'>
                      <.>
                      (word_part.BracedTuple words:[{<js>} {<py>}])
                    ]
                  )
                )
                (C {<xargs>} {<wc>} {<-l>})
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'OTHER UNIT TESTS'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      (word_part.BracedTuple
                        words: [{<build>} {<test>} {<asdl>} {<tools>}]
                      )
                      <'/'>
                      <Id.Lit_Star '*'>
                      <_test.py>
                    ]
                  )
                )
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'OIL UNIT TESTS'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      (word_part.BracedTuple
                        words: [{<osh>} {<core>} {<native>} {<tools>}]
                      )
                      <'/'>
                      <Id.Lit_Star '*'>
                      <_test.py>
                    ]
                  )
                )
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'OIL AND OSH'>)})
            (command.Pipeline
              children: [(C {<oil-osh-files>}) (C {<xargs>} {<wc>} {<-l>}) (C {<sort>} {<--numeric>})]
              negated: F
            )
            (C {<echo>})
            (command.ControlFlow token:<Id.ControlFlow_Return return>)
            (C {<echo>} {(SQ <DOCS>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} {<README.md>} {<'doc/'> <Id.Lit_Star '*'>})
                (C {<sort>} {<--numeric>})
              ]
              negated: F
            )
            (C {<echo>})
          ]
        )
    )
    (command.ShFunction
      name: parser
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {(SQ <'AST and IDs'>)})
            (command.Pipeline
              children: [(C {<wc>} {<-l>} {<'osh/osh.asdl'>} {<'core/id_kind.py'>}) (C {<sort>} {<-n>})]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'Lexer / Parser'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      <'osh/'>
                      (word_part.BracedTuple
                        words: [{<Id.Lit_Star '*'> <_parse.py>} {<lex.py>} {<parse_lib.py>}]
                      )
                    ]
                  ) {<'core/word.py'>}
                )
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'Compiler / Middle End'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [<'core/'> (word_part.BracedTuple words:[{<braces>} {<word_compile>}]) <.py>]
                  )
                )
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <'Common Algorithms'>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [<'core/'> (word_part.BracedTuple words:[{<tdop>} {<lexer>}]) <.py>]
                  )
                )
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <Utilities>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [<'core/'> (word_part.BracedTuple words:[{<alloc>} {<ui>} {<reader>}]) <.py>]
                  )
                )
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
            (C {<echo>})
          ]
        )
    )
    (command.ShFunction
      name: parser-port
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} {<'core/tdop.py'>} {<'osh/'> <Id.Lit_Star '*'> <_parse.py>})
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: runtime
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {(SQ <Runtime>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [<'core/'> (word_part.BracedTuple words:[{<process>} {<state>}]) <.py>]
                  ) {<'core/runtime.asdl'>}
                )
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <Evaluators>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      <'core/'>
                      <Id.Lit_Star '*'>
                      <Id.Lit_Underscore _>
                      (word_part.BracedTuple words:[{<exec>} {<eval>}])
                      <.py>
                    ]
                  )
                )
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
            (C {<echo>})
            (C {<echo>} {(SQ <Builtins>)})
            (C {<wc>} {<-l>} 
              (word.BracedTree
                parts: [<'core/'> (word_part.BracedTuple words:[{<builtin>} {<test_builtin>}]) <.py>]
              )
            )
            (C {<echo>})
            (C {<echo>} {(SQ <Libraries>)})
            (command.Pipeline
              children: [
                (C {<wc>} {<-l>} 
                  (word.BracedTree
                    parts: [
                      <'core/'>
                      (word_part.BracedTuple
                        words: [{<args>} {<glob_>} {<legacy>} {<libstr>}]
                      )
                      <.py>
                    ]
                  )
                )
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
            (C {<echo>})
          ]
        )
    )
    (command.ShFunction
      name: instructions
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'bin='> <'_tmp/oil'>})
            (command.Pipeline
              children: [
                (C {<objdump>} {<-d>} {($ Id.VSub_DollarName '$bin')})
                (C {<cut>} {<-f3>})
                (C {<grep>} {<-oE>} {(DQ <'^[a-z]+'>)})
                (C {<sort>})
                (C {<uniq>} {<-c>})
                (C {<sort>} {<-n>})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: hist
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [(C {<sort>}) (C {<uniq>} {<-c>}) (C {<sort>} {<-n>})]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: stdlib-imports
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<oil-osh-files>})
                (C {<xargs>} {<grep>} {<--no-filename>} {(SQ <'^import'>)})
                (C {<hist>})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: imports
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<oil-osh-files>})
                (C {<xargs>} {<grep>} {<--no-filename>} {<-w>} {<Id.KW_Import import>})
                (C {<hist>})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: top-level
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<grep>} {(SQ <'^[a-zA-Z]'>)} 
                  (word.BracedTree
                    parts: [
                      (word_part.BracedTuple words:[{<core>} {<osh>}])
                      <'/'>
                      <Id.Lit_Star '*'>
                      <.py>
                    ]
                  )
                )
                (C {<grep>} {<-v>} {(SQ <_test.py>)})
                (C {<egrep>} {<-v>} {(SQ <':import|from|class|def'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: _python-symbols
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'main='> ($ Id.VSub_Number '$1')})
            (C {<local>} {<Id.Lit_VarLike 'name='> ($ Id.VSub_Number '$2')})
            (C {<local>} 
              {<Id.Lit_VarLike 'out='> <'_tmp/'> (${ Id.VSub_Name name) <-python-symbols.txt>}
            )
            (command.Pipeline
              children: [
                (command.Simple
                  words: [{($ Id.VSub_DollarName '$main')}]
                  more_env: [(env_pair name:CALLGRAPH val:{<1>} spids:[1303])]
                  do_fork: T
                )
                (C {<tee>} {($ Id.VSub_DollarName '$out')})
              ]
              negated: F
            )
            (C {<wc>} {<-l>} {($ Id.VSub_DollarName '$out')})
            (C {<echo>})
            (C {<echo>} {(DQ <'Wrote '> ($ Id.VSub_DollarName '$out'))})
          ]
        )
    )
    (command.ShFunction
      name: oil-python-symbols
      body: (BraceGroup children:[(C {<_python-symbols>} {<'bin/oil.py'>} {<oil>})])
    )
    (command.ShFunction
      name: opy-python-symbols
      body: (BraceGroup children:[(C {<_python-symbols>} {<'bin/opy_.py'>} {<opy>})])
    )
    (command.ShFunction
      name: old-style-classes
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [(C {<oil-python-symbols>}) (C {<grep>} {<-v>} {(SQ <'<'>)})]
              negated: F
            )
          ]
        )
    )
    (C {(DQ ($ Id.VSub_At '$@'))})
  ]
)