(command.CommandList
  children: [
    (command.ShFunction
      name: validNum
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:num)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [44]
                )
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:max)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [47]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$num'))} 
                              {<Id.Lit_Equals '='>} {(DQ <X>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [61 79]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-z>} 
                              {
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<echo>} {($ Id.VSub_DollarName '$num')})
                                        (C {<sed>} {(SQ <'s/[[:digit:]]//g'>)})
                                      ]
                                      negated: F
                                    )
                                )
                              } {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})]
                  spids: [87 113]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$num')} {<-gt>} 
                              {($ Id.VSub_DollarName '$max')} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})]
                  spids: [125 139]
                )
              ]
              else_action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
            )
          ]
        )
    )
    (command.ShFunction
      name: validDay
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: 
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<echo>} {($ Id.VSub_Number '$1')})
                          (C {<tr>} {(SQ <'[:upper:]'>)} {(SQ <'[:lower:]'>)})
                        ]
                        negated: F
                      )
                  )
                }
              arms: [
                (case_arm
                  pat_list: [
                    {<sun> <Id.Lit_Star '*'>}
                    {<mon> <Id.Lit_Star '*'>}
                    {<tue> <Id.Lit_Star '*'>}
                    {<wed> <Id.Lit_Star '*'>}
                    {<thu> <Id.Lit_Star '*'>}
                    {<fri> <Id.Lit_Star '*'>}
                    {<sat> <Id.Lit_Star '*'>}
                  ]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [203 223 229 -1]
                )
                (case_arm
                  pat_list: [{<X>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [232 233 239 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})]
                  spids: [245 246 -1 253]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: validMon
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: 
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<echo>} {($ Id.VSub_Number '$1')})
                          (C {<tr>} {(SQ <'[:upper:]'>)} {(SQ <'[:lower:]'>)})
                        ]
                        negated: F
                      )
                  )
                }
              arms: [
                (case_arm
                  pat_list: [
                    {<jan> <Id.Lit_Star '*'>}
                    {<feb> <Id.Lit_Star '*'>}
                    {<mar> <Id.Lit_Star '*'>}
                    {<apr> <Id.Lit_Star '*'>}
                    {<may>}
                    {<jun> <Id.Lit_Star '*'>}
                    {<jul> <Id.Lit_Star '*'>}
                    {<aug> <Id.Lit_Star '*'>}
                  ]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [294 316 322 -1]
                )
                (case_arm
                  pat_list: [
                    {<sep> <Id.Lit_Star '*'>}
                    {<oct> <Id.Lit_Star '*'>}
                    {<nov> <Id.Lit_Star '*'>}
                    {<dec> <Id.Lit_Star '*'>}
                  ]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [325 336 342 -1]
                )
                (case_arm
                  pat_list: [{<X>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [345 346 352 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})]
                  spids: [358 359 365 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: fixvars
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sourceline)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ ($ Id.VSub_DollarName '$min') <' '> ($ Id.VSub_DollarName '$hour') <' '> 
                        ($ Id.VSub_DollarName '$dom') <' '> ($ Id.VSub_DollarName '$mon') <' '> ($ Id.VSub_DollarName '$dow') <' '> 
                        ($ Id.VSub_DollarName '$command')
                      )
                    }
                  spids: [389]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:min)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$min'))})
                              (C {<tr>} {(SQ <'*'>)} {(SQ <X>)})
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [405]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:hour)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$hour'))})
                              (C {<tr>} {(SQ <'*'>)} {(SQ <X>)})
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [430]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:dom)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$dom'))})
                              (C {<tr>} {(SQ <'*'>)} {(SQ <X>)})
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [455]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:mon)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$mon'))})
                              (C {<tr>} {(SQ <'*'>)} {(SQ <X>)})
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [480]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:dow)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$dow'))})
                              (C {<tr>} {(SQ <'*'>)} {(SQ <X>)})
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [505]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {($ Id.VSub_Pound '$#')} {<-ne>} {<1>} 
                          {<Id.Lit_RBracket ']'>}
                        )
                        (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-r>} {($ Id.VSub_Number '$1')} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.Sentence
              child: 
                (command.Simple
                  words: [{<echo>} {(DQ <'Usage: '> ($ Id.VSub_Number '$0') <' usercrontabfile'>)}]
                  redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [532 558]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:lines)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [584]
        )
        (assign_pair
          lhs: (sh_lhs_expr.Name name:entries)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [587]
        )
        (assign_pair
          lhs: (sh_lhs_expr.Name name:totalerrors)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [590]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [(C {<read>} {<min>} {<hour>} {<dom>} {<mon>} {<dow>} {<command>})]
        )
      body: 
        (command.DoGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:lines)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.ArithSub
                          anode: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Plus
                              left: {($ Id.VSub_DollarName '$lines')}
                              right: {<Id.Lit_Digits 1>}
                            )
                        )
                      )
                    }
                  spids: [617]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:errors)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [633]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$min'))} {<-o>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name min>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        tok: <Id.VOp1_Percent '%'>
                                        arg_word: 
                                          {
                                            (braced_var_sub
                                              token: <Id.VSub_Name min>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  tok: <Id.VOp1_Pound '#'>
                                                  arg_word: {<Id.Lit_Other '?'>}
                                                )
                                            )
                                          }
                                      )
                                  )
                                )
                              } {<Id.Lit_Equals '='>} {(DQ <'#'>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(command.ControlFlow token:<Id.ControlFlow_Continue continue>)]
                  spids: [639 673]
                )
              ]
            )
            (command.DParen
              child: 
                (arith_expr.UnaryAssign
                  op_id: Id.Node_PostDPlus
                  child: <Id.Lit_ArithVarLike entries>
                )
            )
            (C {<fixvars>})
            (command.ForEach
              iter_name: minslice
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<echo>} {(DQ ($ Id.VSub_DollarName '$min'))})
                          (C {<sed>} {(SQ <'s/[,-]/ /g'>)})
                        ]
                        negated: F
                      )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<validNum>} {($ Id.VSub_DollarName '$minslice')} {<60>})
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ <'Line '> (${ Id.VSub_Name lines) <': Invalid minute value '> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\"'>
                                  ) ($ Id.VSub_DollarName '$minslice') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:errors)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [777]
                                )
                              ]
                            )
                          ]
                          spids: [748 760]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: hrslice
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<echo>} {(DQ ($ Id.VSub_DollarName '$hour'))})
                          (C {<sed>} {(SQ <'s/[,-]/ /g'>)})
                        ]
                        negated: F
                      )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<validNum>} {($ Id.VSub_DollarName '$hrslice')} {<24>})
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ <'Line '> (${ Id.VSub_Name lines) <': Invalid hour value '> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\"'>
                                  ) ($ Id.VSub_DollarName '$hrslice') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:errors)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [851]
                                )
                              ]
                            )
                          ]
                          spids: [821 833]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: domslice
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<echo>} {($ Id.VSub_DollarName '$dom')})
                          (C {<sed>} {(SQ <'s/[,-]/ /g'>)})
                        ]
                        negated: F
                      )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<validNum>} {($ Id.VSub_DollarName '$domslice')} {<31>})
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ <'Line '> (${ Id.VSub_Name lines) <': Invalid day of month value '> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\"'>
                                  ) ($ Id.VSub_DollarName '$domslice') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:errors)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [921]
                                )
                              ]
                            )
                          ]
                          spids: [892 904]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: monslice
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<echo>} {(DQ ($ Id.VSub_DollarName '$mon'))})
                          (C {<sed>} {(SQ <'s/[,-]/ /g'>)})
                        ]
                        negated: F
                      )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<validNum>} {($ Id.VSub_DollarName '$monslice')} {<12>})
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (C {<validMon>} 
                                                  {(DQ ($ Id.VSub_DollarName '$monslice'))}
                                                )
                                              ]
                                              negated: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<echo>} 
                                      {
                                        (DQ <'Line '> (${ Id.VSub_Name lines) 
                                          <': Invalid month value '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) ($ Id.VSub_DollarName '$monslice') 
                                          (word_part.EscapedLiteral
                                            token: <Id.Lit_EscapedChar '\\"'>
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:errors)
                                          op: assign_op.Equal
                                          rhs: {<1>}
                                          spids: [1016]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [987 999]
                                )
                              ]
                            )
                          ]
                          spids: [972 984]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: dowslice
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<echo>} {(DQ ($ Id.VSub_DollarName '$dow'))})
                          (C {<sed>} {(SQ <'s/[,-]/ /g'>)})
                        ]
                        negated: F
                      )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<validNum>} {($ Id.VSub_DollarName '$dowslice')} {<7>})
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (C {<validDay>} {($ Id.VSub_DollarName '$dowslice')})
                                              ]
                                              negated: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<echo>} 
                                      {
                                        (DQ <'Line '> (${ Id.VSub_Name lines) 
                                          <': Invalid day of week value '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) ($ Id.VSub_DollarName '$dowslice') 
                                          (word_part.EscapedLiteral
                                            token: <Id.Lit_EscapedChar '\\"'>
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:errors)
                                          op: assign_op.Equal
                                          rhs: {<1>}
                                          spids: [1104]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1077 1087]
                                )
                              ]
                            )
                          ]
                          spids: [1062 1074]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$errors')} {<-gt>} {<0>} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} 
                      {
                        (DQ <'>>>> '> (${ Id.VSub_Name lines) <': '> 
                          ($ Id.VSub_DollarName '$sourceline')
                        )
                      }
                    )
                    (C {<echo>} {(DQ )})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:totalerrors)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.ArithSub
                                  anode: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Plus
                                      left: {($ Id.VSub_DollarName '$totalerrors')}
                                      right: {<Id.Lit_Digits 1>}
                                    )
                                )
                              )
                            }
                          spids: [1153]
                        )
                      ]
                    )
                  ]
                  spids: [1118 1132]
                )
              ]
            )
          ]
        )
      redirects: [(redir op:<Id.Redir_Less '<'> loc:(redir_loc.Fd fd:0) arg:{($ Id.VSub_Number '$1')})]
    )
    (C {<echo>} 
      {
        (DQ <'Done. Found '> ($ Id.VSub_DollarName '$totalerrors') <' errors in '> 
          ($ Id.VSub_DollarName '$entries') <' crontab entries.'>
        )
      }
    )
    (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<0>})
  ]
)