(command.CommandList
  children: [
    (command.CommandList
      children: [
        (command.Sentence
          child: 
            (C {<.>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name srcdir>
                    suffix_op: (suffix_op.Unary tok:<Id.VTest_Equals '='> arg_word:{<.>})
                  ) <'/tests/init.sh'>
                )
              }
            )
          terminator: <Id.Op_Semi _>
        )
        (C {<path_prepend_>} {<'./src'>})
      ]
    )
    (C {<print_ver_>} {<cp>} {<mv>})
    (command.ShFunction
      name: cleanup_
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<rm>} {<-rf>} {(DQ ($ Id.VSub_DollarName '$other_partition_tmpdir'))})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (C {<.>} {(DQ ($ Id.VSub_DollarName '$abs_srcdir') <'/tests/other-fs-tmpdir'>)})
    (C {<require_local_dir_>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:pwd_tmp)
          op: assign_op.Equal
          rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<pwd>}))}
          spids: [104]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.Subshell
          child: (C {<unset>} {<CDPATH>})
          redirects: [
            (redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})
            (redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})
          ]
        )
        (C {<unset>} {<CDPATH>})
      ]
    )
    (command.Simple
      words: [{<exec>}]
      redirects: [(redir op:<Id.Redir_Great '1>'> loc:(redir_loc.Fd fd:1) arg:{<actual>})]
      do_fork: T
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:contents)
          op: assign_op.Equal
          rhs: {<XYZ>}
          spids: [175]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:loc_reg)
          op: assign_op.Equal
          rhs: {<loc_reg>}
          spids: [179]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:loc_sl)
          op: assign_op.Equal
          rhs: {<loc_sl>}
          spids: [182]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:rem_reg)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName '$other_partition_tmpdir') <'/rem_reg'>}
          spids: [185]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:rem_sl)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName '$other_partition_tmpdir') <'/rem_sl'>}
          spids: [189]
        )
      ]
    )
    (command.ForEach
      iter_name: copy
      iter_words: [{<cp>} {<mv>}]
      do_arg_iter: F
      body: 
        (command.DoGroup
          children: [
            (command.ForEach
              iter_name: args
              iter_words: [
                {(SQ <'loc_reg rem_sl'>)}
                {(SQ <'rem_sl loc_reg'>)}
                {(SQ <'loc_sl rem_reg'>)}
                {(SQ <'rem_reg loc_sl'>)}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ForEach
                      iter_name: options
                      iter_words: [
                        {(SQ )}
                        {<--rem>}
                        {(SQ <'--rem -d'>)}
                        {(SQ <'--rem -b'>)}
                        {<-b>}
                        {<-bd>}
                        {<-d>}
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$options'))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {<Id.Lit_Star '*'> <d> <Id.Lit_Star '*'>}
                                    {<Id.Lit_Star '*'> <--rem> <Id.Lit_Star '*'>}
                                  ]
                                  action: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<test>} {($ Id.VSub_DollarName '$copy')} 
                                          {<Id.Lit_Equals '='>} {<mv>}
                                        )
                                        (command.ControlFlow
                                          token: <Id.ControlFlow_Continue continue>
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [282 289 302 -1]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<rm>} {<-rf>} {<dir>})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fail)
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                      spids: [315]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<rm>} {<-f>} 
                                  {(DQ ($ Id.VSub_DollarName '$other_partition_tmpdir')) <'/'> 
                                    <Id.Lit_Star '*'>
                                  }
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fail)
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                      spids: [331]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<mkdir>} {<dir>})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fail)
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                      spids: [341]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<cd>} {<dir>})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fail)
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                      spids: [351]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$args'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'> <loc_reg> <Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:reg_abs)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: (C {<pwd>})
                                                ) <'/'> ($ Id.VSub_DollarName '$loc_reg')
                                              )
                                            }
                                          spids: [368]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [363 366 377 -1]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$args'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'> <rem_reg> <Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:reg_abs)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$rem_reg')}
                                          spids: [395]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [390 393 398 -1]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$args'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'> <loc_sl> <Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:slink)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$loc_sl')}
                                          spids: [416]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [411 414 419 -1]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$args'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'> <rem_sl> <Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:slink)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$rem_sl')}
                                          spids: [437]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [432 435 440 -1]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [{<echo>} {($ Id.VSub_DollarName '$contents')}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(DQ ($ Id.VSub_DollarName '$reg_abs'))}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fail)
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                      spids: [458]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<ln>} {<-nsf>} {(DQ ($ Id.VSub_DollarName '$reg_abs'))} 
                                  {($ Id.VSub_DollarName '$slink')}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fail)
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                      spids: [474]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:actual_args)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {($ Id.VSub_DollarName '$args')})
                                              (C {<sed>} {(SQ <'s,^,$,;s/ / $/'>)})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  spids: [478]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:actual_args)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval>} {<echo>} {($ Id.VSub_DollarName '$actual_args')})
                                      )
                                    }
                                  spids: [492]
                                )
                              ]
                            )
                            (command.Pipeline
                              children: [
                                (command.Subshell
                                  child: 
                                    (command.Subshell
                                      child: 
                                        (command.CommandList
                                          children: [
                                            (command.Simple
                                              words: [
                                                {($ Id.VSub_DollarName '$copy')}
                                                {($ Id.VSub_DollarName '$options')}
                                                {($ Id.VSub_DollarName '$actual_args')}
                                              ]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Great '2>'>
                                                  loc: (redir_loc.Fd fd:2)
                                                  arg: {<.err>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:copy_status)
                                                  op: assign_op.Equal
                                                  rhs: {($ Id.VSub_QMark '$?')}
                                                  spids: [523]
                                                )
                                              ]
                                            )
                                            (C {<echo>} {($ Id.VSub_DollarName '$copy_status')} 
                                              {($ Id.VSub_DollarName '$copy')} {($ Id.VSub_DollarName '$options')} {($ Id.VSub_DollarName '$args')}
                                            )
                                            (command.AndOr
                                              ops: [Id.Op_DAmp]
                                              children: [
                                                (C {<test>} {<-s>} {<.err>})
                                                (BraceGroup
                                                  children: [
                                                    (command.Pipeline
                                                      children: [
                                                        (C {<echo>} {(SQ <' ['>)})
                                                        (C {<tr>} {<-d>} {(SQ <'\\n'>)})
                                                      ]
                                                      negated: F
                                                    )
                                                    (command.Pipeline
                                                      children: [
                                                        (C {<sed>} 
                                                          {(SQ <'s/^[^:][^:]*\\(..\\):/\\1:/;s,'>) 
                                                            (DQ 
                                                              ($ Id.VSub_DollarName 
'$other_partition_tmpdir'
                                                              ) <'/,,'>
                                                            )
                                                          } {<.err>}
                                                        )
                                                        (C {<tr>} {<-d>} {(SQ <'\\n'>)})
                                                      ]
                                                      negated: F
                                                    )
                                                    (C {<echo>} {(SQ <']'>)})
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:ls)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (command.Pipeline
                                                            children: [
                                                              (C {<ls>} {<-gG>} 
                                                                {<--ignore> <Id.Lit_Equals '='> <.err>} {<.>}
                                                              )
                                                              (C {<sed>} {<-e>} {(SQ <'/^total /d'>)} 
                                                                {<-e>} {(DQ <'s,'> ($ Id.VSub_DollarName '$other_partition_tmpdir') <'/,,'>)} {<-e>} 
                                                                {
                                                                  (DQ <'s,'> 
                                                                    ($ Id.VSub_DollarName '$pwd_tmp') <'/,,'>
                                                                  )
                                                                } {<-e>} {(SQ <'s/^[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *//'>)}
                                                              )
                                                            ]
                                                            negated: F
                                                          )
                                                      )
                                                    }
                                                  spids: [621]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:ls2)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (command.AndOr
                                                            ops: [Id.Op_DAmp]
                                                            children: [
                                                              (C {<cd>} 
                                                                {
                                                                  (DQ 
                                                                    ($ Id.VSub_DollarName 
'$other_partition_tmpdir'
                                                                    )
                                                                  )
                                                                }
                                                              )
                                                              (command.Pipeline
                                                                children: [
                                                                  (C {<ls>} {<-gG>} 
                                                                    {<--ignore> <Id.Lit_Equals '='> 
                                                                      <.err>
                                                                    } {<.>}
                                                                  )
                                                                  (C {<sed>} {<-e>} {(SQ <'/^total /d'>)} 
                                                                    {<-e>} {(DQ <'s,'> ($ Id.VSub_DollarName '$other_partition_tmpdir') <'/,,'>)} {<-e>} 
                                                                    {
                                                                      (DQ <'s,'> 
                                                                        ($ Id.VSub_DollarName 
'$pwd_tmp'
                                                                        ) <'/,,'>
                                                                      )
                                                                    } {<-e>} {(SQ <'s/^[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *//'>)}
                                                                  )
                                                                ]
                                                                negated: F
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                  spids: [677]
                                                )
                                              ]
                                            )
                                            (C {<echo>} 
                                              {(DQ <' ('>) ($ Id.VSub_DollarName '$ls') (DQ <') ('>) 
                                                ($ Id.VSub_DollarName '$ls2') (DQ <')'>)
                                              }
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.Sentence
                                                          child: 
                                                            (C {<test>} 
                                                              {($ Id.VSub_DollarName '$copy_status')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                                                            )
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.ForEach
                                                      iter_name: f
                                                      iter_words: [
                                                        {($ Id.VSub_DollarName '$actual_args')}
                                                      ]
                                                      do_arg_iter: F
                                                      body: 
                                                        (command.DoGroup
                                                          children: [
                                                            (command.AndOr
                                                              ops: [Id.Op_DPipe]
                                                              children: [
                                                                (C {<test>} {<-f>} 
                                                                  {($ Id.VSub_DollarName '$f')}
                                                                )
                                                                (BraceGroup
                                                                  children: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {<echo>} 
                                                                          {
                                                                            (DQ <' '> 
                                                                              ($ Id.VSub_DollarName 
'$copy'
                                                                              ) <' FAILED but removed '> ($ Id.VSub_DollarName '$f')
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Id.Op_Semi _>
                                                                    )
                                                                    (command.Sentence
                                                                      child: 
                                                                        (command.ControlFlow
                                                                          token: 
                                                                            <
Id.ControlFlow_Continue continue
                                                                            >
                                                                        )
                                                                      terminator: <Id.Op_Semi _>
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.Case
                                                              to_match: 
                                                                {
                                                                  (DQ 
                                                                    (command_sub
                                                                      left_token: 
                                                                        <Id.Left_DollarParen '$('>
                                                                      child: 
                                                                        (C {<cat>} 
                                                                          {
                                                                            ($ Id.VSub_DollarName 
'$f'
                                                                            )
                                                                          }
                                                                        )
                                                                    )
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {
                                                                      (DQ 
                                                                        ($ Id.VSub_DollarName 
'$contents'
                                                                        )
                                                                      )
                                                                    }
                                                                  ]
                                                                  spids: [828 831 833 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{<Id.Lit_Star '*'>}]
                                                                  action: [
                                                                    (C {<echo>} 
                                                                      {
                                                                        (DQ <' '> 
                                                                          ($ Id.VSub_DollarName 
'$copy'
                                                                          ) <' FAILED but modified '> ($ Id.VSub_DollarName '$f')
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [836 837 847 -1]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  ]
                                                  spids: [761 773]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.Sentence
                                                          child: 
                                                            (C {<test>} 
                                                              {($ Id.VSub_DollarName '$copy')} {<Id.Lit_Equals '='>} {<cp>}
                                                            )
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.ForEach
                                                      iter_name: f
                                                      iter_words: [
                                                        {($ Id.VSub_DollarName '$actual_args')}
                                                      ]
                                                      do_arg_iter: F
                                                      body: 
                                                        (command.DoGroup
                                                          children: [
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: 
                                                                    (condition.Shell
                                                                      commands: [
                                                                        (command.Sentence
                                                                          child: 
                                                                            (C {<test>} {<-f>} 
                                                                              {
                                                                                ($ 
Id.VSub_DollarName '$f'
                                                                                )
                                                                              }
                                                                            )
                                                                          terminator: <Id.Op_Semi _>
                                                                        )
                                                                      ]
                                                                    )
                                                                  action: [
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: 
                                                                            (condition.Shell
                                                                              commands: [
                                                                                (command.Sentence
                                                                                  child: 
                                                                                    (C {<test>} 
                                                                                      {
                                                                                        ($ 
Id.VSub_DollarName '$copy_status'
                                                                                        )
                                                                                      } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                                                                                    )
                                                                                  terminator: 
                                                                                    <Id.Op_Semi _>
                                                                                )
                                                                              ]
                                                                            )
                                                                          action: [(C {<test>})]
                                                                          spids: [906 918]
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.Case
                                                                      to_match: 
                                                                        {
                                                                          (DQ 
                                                                            (command_sub
                                                                              left_token: 
                                                                                <
Id.Left_DollarParen '$('
                                                                                >
                                                                              child: 
                                                                                (C {<cat>} 
                                                                                  {
                                                                                    ($ 
Id.VSub_DollarName '$f'
                                                                                    )
                                                                                  }
                                                                                )
                                                                            )
                                                                          )
                                                                        }
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {
                                                                              (DQ 
                                                                                ($ 
Id.VSub_DollarName '$contents'
                                                                                )
                                                                              )
                                                                            }
                                                                          ]
                                                                          spids: [940 943 945 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {<Id.Lit_Star '*'>}
                                                                          ]
                                                                          action: [
                                                                            (C {<echo>} 
                                                                              {
                                                                                (DQ <' '> 
                                                                                  ($ 
Id.VSub_DollarName '$copy'
                                                                                  ) <' FAILED'>
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                          spids: [948 949 958 -1]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                  spids: [894 903]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {<echo>} {(DQ <' symlink-loop'>)})
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  ]
                                                  spids: [860 871]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                )
                                (C {<sed>} {(SQ <'s/  *$//'>)})
                              ]
                              negated: F
                            )
                            (C {<cd>} {<..>})
                          ]
                        )
                    )
                    (C {<echo>})
                  ]
                )
            )
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {($ Id.VSub_DollarName '$fail')} {<Id.Lit_Equals '='>} {<1>})
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.Subshell
                  child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
                )
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence
              child: (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              terminator: <Id.Op_Semi _>
            )
          ]
        )
      ]
    )
    (command.Simple
      words: [{<cat>}]
      redirects: [
        (redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\E'>) <OF>}
              here_end_span_id: 1151
              stdin_parts: [
                <'1 cp loc_reg rem_sl\n'>
                <' [cp: \'loc_reg\' and \'rem_sl\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'0 cp --rem loc_reg rem_sl\n'>
                <' (loc_reg) (rem_sl)\n'>
                <'0 cp --rem -d loc_reg rem_sl\n'>
                <' (loc_reg) (rem_sl)\n'>
                <'0 cp --rem -b loc_reg rem_sl\n'>
                <' (loc_reg) (rem_sl rem_sl~ -> dir/loc_reg)\n'>
                <'0 cp -b loc_reg rem_sl\n'>
                <' (loc_reg) (rem_sl rem_sl~ -> dir/loc_reg)\n'>
                <'0 cp -bd loc_reg rem_sl\n'>
                <' (loc_reg) (rem_sl rem_sl~ -> dir/loc_reg)\n'>
                <'1 cp -d loc_reg rem_sl\n'>
                <' [cp: \'loc_reg\' and \'rem_sl\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'\n'>
                <'1 cp rem_sl loc_reg\n'>
                <' [cp: \'rem_sl\' and \'loc_reg\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'1 cp --rem rem_sl loc_reg\n'>
                <' [cp: \'rem_sl\' and \'loc_reg\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'1 cp --rem -d rem_sl loc_reg\n'>
                <' [cp: \'rem_sl\' and \'loc_reg\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'1 cp --rem -b rem_sl loc_reg\n'>
                <' [cp: \'rem_sl\' and \'loc_reg\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'1 cp -b rem_sl loc_reg\n'>
                <' [cp: \'rem_sl\' and \'loc_reg\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'0 cp -bd rem_sl loc_reg\n'>
                <' (loc_reg -> dir/loc_reg loc_reg~) (rem_sl -> dir/loc_reg)\n'>
                <' symlink-loop\n'>
                <' symlink-loop\n'>
                <'1 cp -d rem_sl loc_reg\n'>
                <' [cp: \'rem_sl\' and \'loc_reg\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'\n'>
                <'1 cp loc_sl rem_reg\n'>
                <' [cp: \'loc_sl\' and \'rem_reg\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'1 cp --rem loc_sl rem_reg\n'>
                <' [cp: \'loc_sl\' and \'rem_reg\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'1 cp --rem -d loc_sl rem_reg\n'>
                <' [cp: \'loc_sl\' and \'rem_reg\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'1 cp --rem -b loc_sl rem_reg\n'>
                <' [cp: \'loc_sl\' and \'rem_reg\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'1 cp -b loc_sl rem_reg\n'>
                <' [cp: \'loc_sl\' and \'rem_reg\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'0 cp -bd loc_sl rem_reg\n'>
                <' (loc_sl -> rem_reg) (rem_reg -> rem_reg rem_reg~)\n'>
                <' symlink-loop\n'>
                <' symlink-loop\n'>
                <'1 cp -d loc_sl rem_reg\n'>
                <' [cp: \'loc_sl\' and \'rem_reg\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'\n'>
                <'1 cp rem_reg loc_sl\n'>
                <' [cp: \'rem_reg\' and \'loc_sl\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'0 cp --rem rem_reg loc_sl\n'>
                <' (loc_sl) (rem_reg)\n'>
                <'0 cp --rem -d rem_reg loc_sl\n'>
                <' (loc_sl) (rem_reg)\n'>
                <'0 cp --rem -b rem_reg loc_sl\n'>
                <' (loc_sl loc_sl~ -> rem_reg) (rem_reg)\n'>
                <'0 cp -b rem_reg loc_sl\n'>
                <' (loc_sl loc_sl~ -> rem_reg) (rem_reg)\n'>
                <'0 cp -bd rem_reg loc_sl\n'>
                <' (loc_sl loc_sl~ -> rem_reg) (rem_reg)\n'>
                <'1 cp -d rem_reg loc_sl\n'>
                <' [cp: \'rem_reg\' and \'loc_sl\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'\n'>
                <'0 mv loc_reg rem_sl\n'>
                <' () (rem_sl)\n'>
                <'0 mv -b loc_reg rem_sl\n'>
                <' () (rem_sl rem_sl~ -> dir/loc_reg)\n'>
                <'\n'>
                <'1 mv rem_sl loc_reg\n'>
                <' [mv: \'rem_sl\' and \'loc_reg\' are the same file]\n'>
                <' (loc_reg) (rem_sl -> dir/loc_reg)\n'>
                <'0 mv -b rem_sl loc_reg\n'>
                <' (loc_reg -> dir/loc_reg loc_reg~) ()\n'>
                <'\n'>
                <'1 mv loc_sl rem_reg\n'>
                <' [mv: \'loc_sl\' and \'rem_reg\' are the same file]\n'>
                <' (loc_sl -> rem_reg) (rem_reg)\n'>
                <'0 mv -b loc_sl rem_reg\n'>
                <' () (rem_reg -> rem_reg rem_reg~)\n'>
                <'\n'>
                <'0 mv rem_reg loc_sl\n'>
                <' (loc_sl) ()\n'>
                <'0 mv -b rem_reg loc_sl\n'>
                <' (loc_sl loc_sl~ -> rem_reg) ()\n'>
                <'\n'>
              ]
            )
        )
        (redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expected>})
      ]
      do_fork: T
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<compare>} {<expected>} {<actual>}]
          redirects: [(redir op:<Id.Redir_GreatAnd '1>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
          do_fork: T
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:fail)
              op: assign_op.Equal
              rhs: {<1>}
              spids: [1167]
            )
          ]
        )
      ]
    )
    (C {<Exit>} {($ Id.VSub_DollarName '$fail')})
  ]
)