(command.CommandList
  children: [
    (command.Sentence
      child: 
        (command.ShFunction
          name: zfs_cleanup_unmount
          body: 
            (BraceGroup
              children: [
                (command.ForEach
                  iter_name: PART
                  iter_words: [
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<ls>} {(${ Id.VSub_Name PARTDIR)})
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTDEV)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_Backtick '`'>
                                    child: 
                                      (command.Pipeline
                                        children: [
                                          (C {<echo>} {($ Id.VSub_DollarName '$PART')})
                                          (C {<sed>} {(SQ <'s|-|/|g'>)})
                                        ]
                                        negated: F
                                      )
                                  )
                                }
                              spids: [117]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTFS)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<1>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [135]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTMNT)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<2>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [167]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ZPOOLNAME)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<get_zpool_name>} {(DQ (${ Id.VSub_Name PARTDEV))})
                                  )
                                }
                              spids: [199]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$PARTFS'))} 
                                      {<Id.Lit_Equals '='>} {(DQ <ZFS>)} {<Id.Lit_RBracket ']'>}
                                    )
                                  ]
                                )
                              action: [
                                (command.ForEach
                                  iter_name: ZMNT
                                  iter_words: [
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {(${ Id.VSub_Name PARTMNT)})
                                              (C {<sed>} {(SQ <'s|,| |g'>)})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  ]
                                  do_arg_iter: F
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: 
                                                (condition.Shell
                                                  commands: [
                                                    (C {<Id.Lit_LBracket '['>} 
                                                      {(DQ (${ Id.VSub_Name ZMNT))} {<Id.Lit_Equals '='>} {(DQ <'/'>)} {<Id.Lit_RBracket ']'>}
                                                    )
                                                  ]
                                                )
                                              action: [
                                                (command.Pipeline
                                                  children: [
                                                    (command.Simple
                                                      words: [
                                                        {<cat>}
                                                        {(${ Id.VSub_Name FSMNT) 
                                                          <'/boot/loader.conf'>
                                                        }
                                                      ]
                                                      redirects: [
                                                        (redir
                                                          op: <Id.Redir_Great '2>'>
                                                          loc: (redir_loc.Fd fd:2)
                                                          arg: {<'/dev/null'>}
                                                        )
                                                      ]
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      words: [
                                                        {<grep>}
                                                        {<-q>}
                                                        {(DQ <'vfs.root.mountfrom='>)}
                                                      ]
                                                      redirects: [
                                                        (redir
                                                          op: <Id.Redir_Great '2>'>
                                                          loc: (redir_loc.Fd fd:2)
                                                          arg: {<'/dev/null'>}
                                                        )
                                                      ]
                                                      do_fork: T
                                                    )
                                                  ]
                                                  negated: F
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: 
                                                        (condition.Shell
                                                          commands: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {<Id.Lit_LBracket '['>} 
                                                                  {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} {<Id.Lit_RBracket ']'>}
                                                                )
                                                              terminator: <Id.Op_Semi _>
                                                            )
                                                          ]
                                                        )
                                                      action: [
                                                        (command.Simple
                                                          words: [
                                                            {<echo>}
                                                            {
                                                              (DQ <'vfs.root.mountfrom='> 
                                                                (word_part.EscapedLiteral
                                                                  token: <Id.Lit_EscapedChar '\\"'>
                                                                ) <'zfs:'> (${ Id.VSub_Name ZPOOLNAME) <'/ROOT/default'> 
                                                                (word_part.EscapedLiteral
                                                                  token: <Id.Lit_EscapedChar '\\"'>
                                                                )
                                                              )
                                                            }
                                                          ]
                                                          redirects: [
                                                            (redir
                                                              op: <Id.Redir_DGreat '>>'>
                                                              loc: (redir_loc.Fd fd:1)
                                                              arg: 
                                                                {(${ Id.VSub_Name FSMNT) 
                                                                  <'/boot/loader.conf'>
                                                                }
                                                            )
                                                          ]
                                                          do_fork: T
                                                        )
                                                      ]
                                                      spids: [318 332]
                                                    )
                                                  ]
                                                )
                                                (C {<export>} 
                                                  {<Id.Lit_VarLike 'FOUNDZFSROOT='> 
                                                    (DQ (${ Id.VSub_Name ZPOOLNAME))
                                                  }
                                                )
                                              ]
                                              spids: [264 283]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:FOUNDZFS)
                                      op: assign_op.Equal
                                      rhs: {(DQ <1>)}
                                      spids: [375]
                                    )
                                  ]
                                )
                              ]
                              spids: [212 229]
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name FOUNDZFS))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (command.Pipeline
                          children: [
                            (command.Simple
                              words: [{<cat>} {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                            (command.Simple
                              words: [{<grep>} {<-q>} {(SQ <'zfs_load="YES"'>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          negated: F
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} 
                                      {<Id.Lit_RBracket ']'>}
                                    )
                                  ]
                                )
                              action: [
                                (command.Simple
                                  words: [{<echo>} {(SQ <'zfs_load="YES"'>)}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_DGreat '>>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              spids: [434 447]
                            )
                          ]
                        )
                        (command.Pipeline
                          children: [
                            (command.Simple
                              words: [{<cat>} {(${ Id.VSub_Name FSMNT) <'/etc/rc.conf'>}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                            (command.Simple
                              words: [{<grep>} {<-q>} {(SQ <'zfs_enable="YES"'>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          negated: F
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} 
                                      {<Id.Lit_RBracket ']'>}
                                    )
                                  ]
                                )
                              action: [
                                (command.Simple
                                  words: [{<echo>} {(SQ <'zfs_enable="YES"'>)}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_DGreat '>>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(${ Id.VSub_Name FSMNT) <'/etc/rc.conf'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              spids: [490 503]
                            )
                          ]
                        )
                        (C {<sleep>} {<2>})
                        (C {<cp>} {<'/boot/zfs/'> <Id.Lit_Star '*'>} 
                          {(${ Id.VSub_Name FSMNT) <'/boot/zfs/'>}
                        )
                        (C {<cp>} {<'/etc/hostid'>} {(${ Id.VSub_Name FSMNT) <'/etc/hostid'>})
                      ]
                      spids: [388 403]
                    )
                  ]
                )
                (command.ForEach
                  iter_name: PART
                  iter_words: [
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<ls>} {(${ Id.VSub_Name PARTDIR)})
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTDEV)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_Backtick '`'>
                                    child: 
                                      (command.Pipeline
                                        children: [
                                          (C {<echo>} {($ Id.VSub_DollarName '$PART')})
                                          (C {<sed>} {(SQ <'s|-|/|g'>)})
                                        ]
                                        negated: F
                                      )
                                  )
                                }
                              spids: [586]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTFS)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<1>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [604]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTMNT)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<2>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [636]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTENC)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<3>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [668]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ZPOOLNAME)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<get_zpool_name>} {(DQ (${ Id.VSub_Name PARTDEV))})
                                  )
                                }
                              spids: [700]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$PARTFS'))} 
                                      {<Id.Lit_Equals '='>} {(DQ <ZFS>)} {<Id.Lit_RBracket ']'>}
                                    )
                                  ]
                                )
                              action: [
                                (command.Pipeline
                                  children: [
                                    (C {<echo>} {($ Id.VSub_DollarName '$ZPOOLEXPORTS')})
                                    (C {<grep>} {<-q>} {(DQ ($ Id.VSub_DollarName '$ZPOOLNAME') <' '>)})
                                  ]
                                  negated: F
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} 
                                                  {<-ne>} {<0>} {<Id.Lit_RBracket ']'>}
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [
                                        (C {<export>} 
                                          {<Id.Lit_VarLike 'ZPOOLEXPORTS='> 
                                            (DQ ($ Id.VSub_DollarName '$ZPOOLNAME') <' '> 
                                              ($ Id.VSub_DollarName '$ZPOOLEXPORTS')
                                            )
                                          }
                                        )
                                      ]
                                      spids: [754 768]
                                    )
                                  ]
                                )
                                (command.ForEach
                                  iter_name: ZMNT
                                  iter_words: [
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {(${ Id.VSub_Name PARTMNT)})
                                              (C {<sed>} {(SQ <'s|,| |g'>)})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  ]
                                  do_arg_iter: F
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:ZMNT)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (DQ 
                                                    (command_sub
                                                      left_token: <Id.Left_Backtick '`'>
                                                      child: 
                                                        (command.Pipeline
                                                          children: [
                                                            (C {<echo>} 
                                                              {($ Id.VSub_DollarName '$ZMNT')}
                                                            )
                                                            (C {<cut>} {<-d>} {(SQ <'('>)} {<-f>} {<1>})
                                                          ]
                                                          negated: F
                                                        )
                                                    )
                                                  )
                                                }
                                              spids: [817]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:PARTMNTREV)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (DQ (${ Id.VSub_Name ZMNT) <' '> 
                                                    (${ Id.VSub_Name PARTMNTREV)
                                                  )
                                                }
                                              spids: [843]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                )
                                (command.ForEach
                                  iter_name: ZMNT
                                  iter_words: [{(${ Id.VSub_Name PARTMNTREV)}]
                                  do_arg_iter: F
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: 
                                                (condition.Shell
                                                  commands: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {<Id.Lit_LBracket '['>} 
                                                          {(DQ (${ Id.VSub_Name ZMNT))} {<Id.Lit_Equals '='>} {(DQ <'/'>)} {<Id.Lit_RBracket ']'>}
                                                        )
                                                      terminator: <Id.Op_Semi _>
                                                    )
                                                  ]
                                                )
                                              action: [
                                                (command.Sentence
                                                  child: 
                                                    (command.ControlFlow
                                                      token: <Id.ControlFlow_Continue continue>
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                              spids: [873 893]
                                            )
                                          ]
                                        )
                                        (command.Pipeline
                                          children: [
                                            (C {<mount>})
                                            (C {<grep>} {<-q>} 
                                              {(DQ (${ Id.VSub_Name FSMNT) (${ Id.VSub_Name ZMNT))}
                                            )
                                          ]
                                          negated: F
                                        )
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: 
                                                (condition.Shell
                                                  commands: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {<Id.Lit_LBracket '['>} 
                                                          {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} {<Id.Lit_RBracket ']'>}
                                                        )
                                                      terminator: <Id.Op_Semi _>
                                                    )
                                                  ]
                                                )
                                              action: [
                                                (C {<rc_halt>} 
                                                  {
                                                    (DQ <'zfs unmount '> (${ Id.VSub_Name ZPOOLNAME) 
                                                      (${ Id.VSub_Name ZMNT)
                                                    )
                                                  }
                                                )
                                                (C {<rc_halt>} 
                                                  {
                                                    (DQ <'zfs set mountpoint='> (${ Id.VSub_Name ZMNT) 
                                                      <' '> (${ Id.VSub_Name ZPOOLNAME) (${ Id.VSub_Name ZMNT)
                                                    )
                                                  }
                                                )
                                              ]
                                              spids: [924 938]
                                            )
                                          ]
                                        )
                                        (C {<sleep>} {<2>})
                                      ]
                                    )
                                )
                              ]
                              spids: [713 730]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: setup_dedicated_boot_part
          body: 
            (BraceGroup
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ROOTFS)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Number 1))}
                      spids: [1002]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ROOTFSTYPE)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Number 2))}
                      spids: [1010]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:BOOTFS)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Number 3))}
                      spids: [1018]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:BOOTMNT)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Number 4))}
                      spids: [1026]
                    )
                  ]
                )
                (command.Simple
                  words: [
                    {<echo>}
                    {
                      (DQ <'vfs.root.mountfrom='> 
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\"'>
                        ) (${ Id.VSub_Name ROOTFSTYPE) <':'> (${ Id.VSub_Name ROOTFS) 
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\"'>
                        )
                      )
                    }
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}
                    )
                  ]
                  do_fork: T
                )
                (C {<rc_halt>} 
                  {
                    (DQ <'mkdir -p '> (${ Id.VSub_Name FSMNT) <'/'> (${ Id.VSub_Name BOOTMNT) <'/boot'>)
                  }
                )
                (C {<rc_halt>} 
                  {
                    (DQ <'mv '> (${ Id.VSub_Name FSMNT) <'/boot/* '> (${ Id.VSub_Name FSMNT) 
                      (${ Id.VSub_Name BOOTMNT) <'/boot/'>
                    )
                  }
                )
                (C {<rc_halt>} 
                  {
                    (DQ <'mv '> (${ Id.VSub_Name FSMNT) (${ Id.VSub_Name BOOTMNT) <'/boot '> 
                      (${ Id.VSub_Name FSMNT) <'/boot/'>
                    )
                  }
                )
                (C {<rc_halt>} {(DQ <'umount '> (${ Id.VSub_Name BOOTFS))})
                (C {<rc_halt>} 
                  {
                    (DQ <'mount '> (${ Id.VSub_Name BOOTFS) <' '> (${ Id.VSub_Name FSMNT) 
                      (${ Id.VSub_Name BOOTMNT)
                    )
                  }
                )
                (C {<rc_halt>} {(DQ <'rmdir '> (${ Id.VSub_Name FSMNT) <'/boot'>)})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:BOOTMNTNS)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_Backtick '`'>
                              child: 
                                (command.Pipeline
                                  children: [
                                    (C {<echo>} {(${ Id.VSub_Name BOOTMNT)})
                                    (C {<sed>} {(SQ <'s|/||g'>)})
                                  ]
                                  negated: F
                                )
                            )
                          )
                        }
                      spids: [1156]
                    )
                  ]
                )
                (C {<rc_halt>} 
                  {
                    (DQ <'chroot '> (${ Id.VSub_Name FSMNT) <' ln -s '> (${ Id.VSub_Name BOOTMNTNS) 
                      <'/boot /boot'>
                    )
                  }
                )
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: setup_fstab
          body: 
            (BraceGroup
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:FSTAB)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name FSMNT) <'/etc/fstab'>)}
                      spids: [1208]
                    )
                  ]
                )
                (command.Simple
                  words: [{<rm>} {(${ Id.VSub_Name FSTAB)}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (command.Simple
                  words: [{<echo>} {(DQ <'# Device\t\tMountpoint\t\tFStype\t\tOptions\tDump Pass'>)}]
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(${ Id.VSub_Name FSTAB)}
                    )
                  ]
                  do_fork: T
                )
                (command.ForEach
                  iter_name: PART
                  iter_words: [
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<ls>} {(${ Id.VSub_Name PARTDIR)})
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTDEV)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_Backtick '`'>
                                    child: 
                                      (command.Pipeline
                                        children: [
                                          (C {<echo>} {($ Id.VSub_DollarName '$PART')})
                                          (C {<sed>} {(SQ <'s|-|/|g'>)})
                                        ]
                                        negated: F
                                      )
                                  )
                                }
                              spids: [1273]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTFS)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<1>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [1291]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTMNT)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<2>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [1323]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTENC)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<3>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [1355]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTLABEL)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<cat>} 
                                              {(${ Id.VSub_Name PARTDIR) <'/'> (${ Id.VSub_Name PART)}
                                            )
                                            (C {<cut>} {<-d>} {(SQ <'#'>)} {<-f>} {<4>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [1387]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:EXT)
                              op: assign_op.Equal
                              rhs: {(DQ )}
                              spids: [1424]
                            )
                          ]
                        )
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$PARTFS')}
                          arms: [
                            (case_arm
                              pat_list: [{<UFS> <Id.Lit_Other '+'> <J>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:MNTOPTS)
                                      op: assign_op.Equal
                                      rhs: {(DQ <'rw,noatime,async'>)}
                                      spids: [1446]
                                    )
                                  ]
                                )
                              ]
                              spids: [1441 1444 1451 -1]
                            )
                            (case_arm
                              pat_list: [{<SWAP>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:MNTOPTS)
                                      op: assign_op.Equal
                                      rhs: {(DQ <sw>)}
                                      spids: [1457]
                                    )
                                  ]
                                )
                              ]
                              spids: [1454 1455 1462 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:MNTOPTS)
                                      op: assign_op.Equal
                                      rhs: {(DQ <'rw,noatime'>)}
                                      spids: [1468]
                                    )
                                  ]
                                )
                              ]
                              spids: [1465 1466 1473 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name PARTLABEL))} 
                                      {<Id.Lit_RBracket ']'>}
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:DEVICE)
                                      op: assign_op.Equal
                                      rhs: {(DQ <'label/'> (${ Id.VSub_Name PARTLABEL))}
                                      spids: [1503]
                                    )
                                  ]
                                )
                              ]
                              spids: [1485 1500]
                            )
                          ]
                          else_action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ (${ Id.VSub_Name PARTENC))} 
                                              {<Id.Lit_Equals '='>} {(DQ <ON>)} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:EXT)
                                          op: assign_op.Equal
                                          rhs: {(DQ <.eli>)}
                                          spids: [1542]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1519 1539]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ (${ Id.VSub_Name PARTFS))} 
                                              {<Id.Lit_Equals '='>} {(DQ <'UFS+J'>)} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:EXT)
                                          op: assign_op.Equal
                                          rhs: {(DQ (${ Id.VSub_Name EXT) <.journal>)}
                                          spids: [1575]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1552 1572]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:DEVICE)
                                  op: assign_op.Equal
                                  rhs: {(DQ (${ Id.VSub_Name PARTDEV) (${ Id.VSub_Name EXT))}
                                  spids: [1587]
                                )
                              ]
                            )
                          ]
                        )
                        (C {<check_for_mount>} {(DQ (${ Id.VSub_Name PARTMNT))} {(DQ <'/'>)})
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} 
                                          {<Id.Lit_RBracket ']'>}
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (C {<Id.Lit_LBracket '['>} 
                                                  {(DQ (${ Id.VSub_Name PARTFS))} {<Id.Lit_Equals '='>} {(DQ <ZFS>)} {<Id.Lit_RBracket ']'>}
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:ROOTFSTYPE)
                                              op: assign_op.Equal
                                              rhs: {(DQ <zfs>)}
                                              spids: [1660]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:ZPOOLNAME)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (C {<get_zpool_name>} 
                                                        {(DQ (${ Id.VSub_Name PARTDEV))}
                                                      )
                                                  )
                                                }
                                              spids: [1666]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:ROOTFS)
                                              op: assign_op.Equal
                                              rhs: {(DQ (${ Id.VSub_Name ZPOOLNAME) <'/ROOT/default'>)}
                                              spids: [1678]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [1637 1657]
                                    )
                                  ]
                                  else_action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:ROOTFS)
                                          op: assign_op.Equal
                                          rhs: {(DQ (${ Id.VSub_Name DEVICE))}
                                          spids: [1690]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:ROOTFSTYPE)
                                          op: assign_op.Equal
                                          rhs: {(DQ <ufs>)}
                                          spids: [1698]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1620 1634]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<Id.Lit_LBracket '['>} {(DQ (${ Id.VSub_Name PARTFS))} 
                                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <ZFS>)} {<Id.Lit_RBracket ']'>}
                                    )
                                  ]
                                )
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (C {<Id.Lit_LBracket '['>} 
                                                  {(DQ (${ Id.VSub_Name PARTFS))} {<Id.Lit_Equals '='>} {(DQ <'UFS+J'>)} {<Id.Lit_RBracket ']'>}
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<setup_gjournal>})]
                                      spids: [1743 1763]
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (C {<Id.Lit_LBracket '['>} 
                                                  {(DQ (${ Id.VSub_Name PARTMNT))} {<Id.Lit_Equals '='>} {(DQ <'/boot'>)} {<Id.Lit_RBracket ']'>}
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:BOOTFS)
                                              op: assign_op.Equal
                                              rhs: 
                                                {(DQ (${ Id.VSub_Name PARTDEV) (${ Id.VSub_Name EXT))}
                                              spids: [1800]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:BOOTMNT)
                                              op: assign_op.Equal
                                              rhs: {(DQ (${ Id.VSub_Name BOOT_PART_MOUNT))}
                                              spids: [1811]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:PARTMNT)
                                              op: assign_op.Equal
                                              rhs: {(DQ (${ Id.VSub_Name BOOTMNT))}
                                              spids: [1819]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [1777 1797]
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (C {<Id.Lit_LBracket '['>} {(DQ (${ Id.VSub_Name PARTFS))} 
                                              {<Id.Lit_Equals '='>} {(DQ <SWAP>)} {<Id.Lit_RBracket ']'>}
                                            )
                                          ]
                                        )
                                      action: [
                                        (command.Simple
                                          words: [
                                            {<echo>}
                                            {
                                              (DQ <'/dev/'> (${ Id.VSub_Name DEVICE) 
                                                <'\tnone\t\tswap\t'> (${ Id.VSub_Name MNTOPTS) <'\t0\t0'>
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (redir
                                              op: <Id.Redir_DGreat '>>'>
                                              loc: (redir_loc.Fd fd:1)
                                              arg: {(${ Id.VSub_Name FSTAB)}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                      ]
                                      spids: [1835 1854]
                                    )
                                  ]
                                  else_action: [
                                    (command.Simple
                                      words: [
                                        {<echo>}
                                        {
                                          (DQ <'/dev/'> (${ Id.VSub_Name DEVICE) <'\t'> 
                                            (${ Id.VSub_Name PARTMNT) <'\t\tufs\t'> (${ Id.VSub_Name MNTOPTS) <'\t1\t1'>
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_DGreat '>>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {(${ Id.VSub_Name FSTAB)}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                )
                              ]
                              spids: [1715 1735]
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$INSTALLTYPE'))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <FreeBSD>)} {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (command.Simple
                          words: [{<echo>} {(DQ <'procfs\t\t\t/proc\t\t\tprocfs\t\trw\t\t0\t0'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_DGreat '>>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(${ Id.VSub_Name FSTAB)}
                            )
                          ]
                          do_fork: T
                        )
                        (command.Simple
                          words: [
                            {<echo>}
                            {(DQ <'linprocfs\t\t/compat/linux/proc\tlinprocfs\trw\t\t0\t0'>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_DGreat '>>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(${ Id.VSub_Name FSTAB)}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      spids: [1924 1942]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-z>} 
                                  {(DQ (${ Id.VSub_Name BOOTMNT))} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (C {<setup_dedicated_boot_part>} {(DQ (${ Id.VSub_Name ROOTFS))} 
                          {(DQ (${ Id.VSub_Name ROOTFSTYPE))} {(DQ (${ Id.VSub_Name BOOTFS))} {(DQ (${ Id.VSub_Name BOOTMNT))}
                        )
                      ]
                      spids: [1979 1997]
                    )
                  ]
                )
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: setup_gmirror
          body: 
            (BraceGroup
              children: [
                (command.Pipeline
                  children: [
                    (command.Simple
                      words: [{<cat>} {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<grep>} {<-q>} {(SQ <'geom_mirror_load="YES"'>)}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  negated: F
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (command.Simple
                          words: [{<echo>} {(SQ <'geom_mirror_load="YES"'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_DGreat '>>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      spids: [2069 2082]
                    )
                  ]
                )
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: setup_geli_loading
          body: 
            (BraceGroup
              children: [
                (command.Simple
                  words: [{<mkdir>} {<-p>} {(${ Id.VSub_Name FSMNT) <'/boot/keys'>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (C {<cd>} {(${ Id.VSub_Name GELIKEYDIR)})
                (command.ForEach
                  iter_name: KEYFILE
                  iter_words: [{(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<ls>}))}]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PART)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<echo>} {(${ Id.VSub_Name KEYFILE)})
                                            (C {<cut>} {<-d>} {(SQ <.>)} {<-f>} {<1>})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [2164]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTDEV)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<echo>} {(${ Id.VSub_Name PART)})
                                            (C {<sed>} {(SQ <'s|-|/|g'>)})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [2192]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PARTNAME)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (C {<echo>} {(${ Id.VSub_Name PART)})
                                            (C {<sed>} {(SQ <'s|-dev-||g'>)})
                                          ]
                                          negated: F
                                        )
                                    )
                                  )
                                }
                              spids: [2214]
                            )
                          ]
                        )
                        (C {<rc_halt>} {(DQ <'geli configure -b '> (${ Id.VSub_Name PARTDEV))})
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-e>} 
                                          {
                                            (DQ (${ Id.VSub_Name PARTDIR) <'-enc/'> 
                                              (${ Id.VSub_Name PART) <-encpass>
                                            )
                                          } {<Id.Lit_RBracket ']'>}
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [
                                (command.Simple
                                  words: [
                                    {<echo>}
                                    {
                                      (DQ <geli_> (${ Id.VSub_Name PARTNAME) <'_keyfile0_load='> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) <YES> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_DGreat '>>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.Simple
                                  words: [
                                    {<echo>}
                                    {
                                      (DQ <geli_> (${ Id.VSub_Name PARTNAME) <'_keyfile0_type='> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) (${ Id.VSub_Name PARTNAME) <':geli_keyfile0'> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        )
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_DGreat '>>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.Simple
                                  words: [
                                    {<echo>}
                                    {
                                      (DQ <geli_> (${ Id.VSub_Name PARTNAME) <'_keyfile0_name='> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) <'/boot/keys/'> (${ Id.VSub_Name PARTNAME) <.key> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        )
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_DGreat '>>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (C {<rc_halt>} 
                                  {
                                    (DQ <'cp '> (${ Id.VSub_Name GELIKEYDIR) <'/'> 
                                      (${ Id.VSub_Name KEYFILE) <' '> (${ Id.VSub_Name FSMNT) <'/boot/keys/'> (${ Id.VSub_Name PARTNAME) <.key>
                                    )
                                  }
                                )
                              ]
                              spids: [2252 2275]
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.Pipeline
                  children: [
                    (command.Simple
                      words: [{<cat>} {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<grep>} {<-q>} {(SQ <'geom_eli_load="YES"'>)}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  negated: F
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (command.Simple
                          words: [{<echo>} {(SQ <'geom_eli_load="YES"'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_DGreat '>>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      spids: [2415 2428]
                    )
                  ]
                )
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: gen_hostname
          body: 
            (BraceGroup
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:RAND)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_Backtick '`'>
                              child: (C {<jot>} {<-r>} {<1>} {<1>} {<9000>})
                            )
                          )
                        }
                      spids: [2462]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$INSTALLTYPE'))} 
                              {<Id.Lit_Equals '='>} {(DQ <FreeBSD>)} {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:VAL)
                              op: assign_op.Equal
                              rhs: {(DQ <freebsd-> (${ Id.VSub_Name RAND))}
                              spids: [2501]
                            )
                          ]
                        )
                      ]
                      spids: [2481 2498]
                    )
                  ]
                  else_action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:VAL)
                          op: assign_op.Equal
                          rhs: {(DQ <pcbsd-> (${ Id.VSub_Name RAND))}
                          spids: [2514]
                        )
                      ]
                    )
                  ]
                )
                (C {<export>} {<VAL>})
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: setup_hostname
          body: 
            (BraceGroup
              children: [
                (C {<get_value_from_cfg>} {<hostname>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:HOSTNAME)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name VAL))}
                      spids: [2553]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ (${ Id.VSub_Name HOSTNAME))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (C {<gen_hostname>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:HOSTNAME)
                              op: assign_op.Equal
                              rhs: {(DQ (${ Id.VSub_Name VAL))}
                              spids: [2587]
                            )
                          ]
                        )
                      ]
                      spids: [2566 2581]
                    )
                  ]
                )
                (command.Pipeline
                  children: [
                    (C {<cat>} {(${ Id.VSub_Name FSMNT) <'/etc/rc.conf'>})
                    (command.Simple
                      words: [{<grep>} {<-v>} {(DQ <'hostname='>)}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(${ Id.VSub_Name FSMNT) <'/etc/rc.conf.new'>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  negated: F
                )
                (C {<mv>} {(${ Id.VSub_Name FSMNT) <'/etc/rc.conf.new'>} 
                  {(${ Id.VSub_Name FSMNT) <'/etc/rc.conf'>}
                )
                (C {<echo_log>} {(DQ <'Setting hostname: '> (${ Id.VSub_Name HOSTNAME))})
                (command.Simple
                  words: [
                    {<echo>}
                    {
                      (DQ <'hostname='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                        (${ Id.VSub_Name HOSTNAME) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                      )
                    }
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(${ Id.VSub_Name FSMNT) <'/etc/rc.conf'>}
                    )
                  ]
                  do_fork: T
                )
                (C {<sed>} {<-i>} {<-e>} 
                  {
                    (DQ <'s|my.domain|'> (${ Id.VSub_Name HOSTNAME) <' '> (${ Id.VSub_Name HOSTNAME) 
                      <'|g'>
                    )
                  } {(${ Id.VSub_Name FSMNT) <'/etc/hosts'>}
                )
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: setup_gjournal
          body: 
            (BraceGroup
              children: [
                (command.Pipeline
                  children: [
                    (command.Simple
                      words: [{<cat>} {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<grep>} {<-q>} {(SQ <'geom_journal_load="YES"'>)}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  negated: F
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (command.Simple
                          words: [{<echo>} {(SQ <'geom_journal_load="YES"'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_DGreat '>>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(${ Id.VSub_Name FSMNT) <'/boot/loader.conf'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      spids: [2742 2755]
                    )
                  ]
                )
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: set_root_pw
          body: 
            (BraceGroup
              children: [
                (C {<get_value_from_cfg_with_spaces>} {<rootPass>})
                (C {<local>} {<Id.Lit_VarLike 'PW='> (DQ (${ Id.VSub_Name VAL))})
                (C {<get_value_from_cfg_with_spaces>} {<rootEncPass>})
                (C {<local>} {<Id.Lit_VarLike 'ENCPW='> (DQ (${ Id.VSub_Name VAL))})
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ (${ Id.VSub_Name PW))} {<-a>} 
                                  {<-z>} {(DQ (${ Id.VSub_Name ENCPW))} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.Sentence
                          child: 
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      spids: [2832 2858]
                    )
                  ]
                )
                (C {<echo_log>} {(DQ <'Setting root password'>)})
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name PW))} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.Simple
                          words: [{<echo>} {(DQ (${ Id.VSub_Name PW))}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(${ Id.VSub_Name FSMNT) <'/.rootpw'>}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<run_chroot_cmd>} {(DQ <'cat /.rootpw | pw usermod root -h 0'>)})
                        (C {<rc_halt>} {(DQ <'rm '> (${ Id.VSub_Name FSMNT) <'/.rootpw'>)})
                      ]
                      spids: [2882 2898]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name ENCPW))} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.Simple
                          words: [{<echo>} {(DQ (${ Id.VSub_Name ENCPW))}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(${ Id.VSub_Name FSMNT) <'/.rootpw'>}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<run_chroot_cmd>} {(DQ <'cat /.rootpw | pw usermod root -H 0'>)})
                        (C {<rc_halt>} {(DQ <'rm '> (${ Id.VSub_Name FSMNT) <'/.rootpw'>)})
                      ]
                      spids: [2943 2959]
                    )
                  ]
                )
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Sentence
      child: 
        (command.ShFunction
          name: run_final_cleanup
          body: 
            (BraceGroup
              children: [
                (command.Simple
                  words: [{<ls>} {(${ Id.VSub_Name MIRRORCFGDIR) <'/'> <Id.Lit_Star '*'>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [(C {<setup_gmirror>})]
                      spids: [3030 3043]
                    )
                  ]
                )
                (command.Simple
                  words: [{<ls>} {(${ Id.VSub_Name GELIKEYDIR) <'/'> <Id.Lit_Star '*'>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [(C {<setup_geli_loading>})]
                      spids: [3076 3089]
                    )
                  ]
                )
                (C {<setup_hostname>})
                (C {<set_root_pw>})
                (C {<setup_fstab>})
              ]
            )
        )
      terminator: <Id.Op_Semi _>
    )
  ]
)