(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:LOCALRC)
          op: assign_op.Equal
          rhs: {<'/usr/etc/rc.local'>}
          spids: [28]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:MYLOCALRC)
          op: assign_op.Equal
          rhs: {<'/mnt/etc/rc.local'>}
          spids: [31]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ROOTMB)
          op: assign_op.Equal
          rhs: {<16>}
          spids: [34]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ROOTSECTS)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  child: 
                    (C {<expr>} {($ Id.VSub_DollarName '$ROOTMB')} {(SQ <'*'>)} {<1024>} {(SQ <'*'>)} {<2>})
                )
              )
            }
          spids: [37]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:USRKBFILE)
          op: assign_op.Equal
          rhs: {<'/.usrkb'>}
          spids: [60]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} 
                  {(DQ ($ Id.VSub_DollarName '$USRKBFILE'))} {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ <'Are you really running from CD?'>)})
            (C {<echo>} {(DQ <'No '> ($ Id.VSub_DollarName '$USRKBFILE') <' file.'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [63 77]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:USRKB)
          op: assign_op.Equal
          rhs: {(DQ (command_sub left_token:<Id.Left_Backtick '`'> child:(C {<cat>} {<'/.usrkb'>})))}
          spids: [101]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TOTALMB)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  child: 
                    (C {<expr>} {<3>} {<Id.Lit_Other '+'>} {($ Id.VSub_DollarName '$USRKB')} {<'/'>} 
                      {<1024>} {<Id.Lit_Other '+'>} {($ Id.VSub_DollarName '$ROOTMB')}
                    )
                )
              )
            }
          spids: [112]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ROOTFILES)
          op: assign_op.Equal
          rhs: {(DQ (command_sub left_token:<Id.Left_Backtick '`'> child:(C {<cat>} {<'/.rootfiles'>})))}
          spids: [135]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:USRFILES)
          op: assign_op.Equal
          rhs: {(DQ (command_sub left_token:<Id.Left_Backtick '`'> child:(C {<cat>} {<'/.usrfiles'>})))}
          spids: [146]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$TOTALMB'))} {<-lt>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ <'Are you really running from CD?'>)})
            (C {<echo>} {(DQ <'Something wrong with size estimate on CD.'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [158 172]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$ROOTFILES'))} {<-lt>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ <'Are you really running from CD?'>)})
            (C {<echo>} {(DQ <'Something wrong with root files count on CD.'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [197 211]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USRFILES'))} {<-lt>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ <'Are you really running from CD?'>)})
            (C {<echo>} {(DQ <'Something wrong with usr files count on CD.'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [236 250]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PATH)
          op: assign_op.Equal
          rhs: {<'/bin'> <Id.Lit_Colon ':'> <'/usr/bin'>}
          spids: [275]
        )
      ]
    )
    (C {<export>} {<PATH>})
    (command.ShFunction
      name: usage
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {(SQ <EOF>)}
                      here_end_span_id: 312
                      stdin_parts: [
                        <'Usage:\tsetup\t\t# Install a skeleton system on the hard disk.\n'>
                        <'\tsetup /usr\t# Install the rest of the system (binaries or sources).\n'>
                        <'\n'>
                        <'\t# To install from other things then floppies:\n'>
                        <'\n'>
                        <'\turlget http://... | setup /usr\t\t# Read from a web site.\n'>
                        <'\turlget ftp://... | setup /usr\t\t# Read from an FTP site.\n'>
                        <'\tmtools copy c0d0p0:... - | setup /usr\t# Read from the C: drive.\n'>
                        <'\tdosread c0d0p0 ... | setup /usr\t\t# Likewise if no mtools.\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: warn
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {<-e>} 
              {
                (DQ <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> 
                  <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> 
                  <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> 
                  <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> 
                  <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> 
                  <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> <Id.Lit_BadBackslash '\\'> <b> 
                  <Id.Lit_BadBackslash '\\'> <'b ! '> ($ Id.VSub_Number '$1')
                )
              }
            )
          ]
        )
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Sentence
              child: (C {<getopts>} {(SQ )} {<opt>})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
      body: 
        (command.DoGroup
          children: [(command.Sentence child:(C {<usage>}) terminator:<Id.Op_Semi _>)]
        )
    )
    (C {<shift>} 
      {
        (command_sub
          left_token: <Id.Left_Backtick '`'>
          child: (C {<expr>} {($ Id.VSub_DollarName '$OPTIND')} {<->} {<1>})
        )
      }
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USER'))} 
                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<root>} {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ <'Please run setup as root.'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [421 436]
        )
      ]
    )
    (command.Simple
      words: [{<exec>}]
      redirects: [
        (redir op:<Id.Redir_LessAnd '9<&'> loc:(redir_loc.Fd fd:9) arg:{<0>})
        (redir op:<Id.Redir_Less '<'> loc:(redir_loc.Fd fd:0) arg:{<'/etc/mtab'>})
      ]
      do_fork: T
    )
    (C {<read>} {<thisroot>} {<rest>})
    (C {<read>} {<fdusr>} {<rest>})
    (command.Simple
      words: [{<exec>}]
      redirects: [
        (redir op:<Id.Redir_LessAnd '0<&'> loc:(redir_loc.Fd fd:0) arg:{<9>})
        (redir op:<Id.Redir_LessAnd '9<&'> loc:(redir_loc.Fd fd:9) arg:{<->})
      ]
      do_fork: T
    )
    (command.Case
      to_match: 
        {($ Id.VSub_DollarName '$thisroot') <Id.Lit_Colon ':'> ($ Id.VSub_DollarName '$fdusr')}
      arms: [
        (case_arm
          pat_list: [{<'/dev/ram'> <Id.Lit_Colon ':'> <'/dev/fd0p2'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fdroot)
                  op: assign_op.Equal
                  rhs: {<'/dev/fd0'>}
                  spids: [509]
                )
              ]
            )
          ]
          spids: [504 507 516 -1]
        )
        (case_arm
          pat_list: [{<'/dev/ram'> <Id.Lit_Colon ':'> <'/dev/fd1p2'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fdroot)
                  op: assign_op.Equal
                  rhs: {<'/dev/fd1'>}
                  spids: [523]
                )
              ]
            )
          ]
          spids: [518 521 530 -1]
        )
        (case_arm
          pat_list: [{<'/dev/ram'> <Id.Lit_Colon ':'> <'/dev/fd'> <Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fdroot)
                  op: assign_op.Equal
                  rhs: {<unknown>}
                  spids: [538]
                )
              ]
            )
          ]
          spids: [532 536 545 -1]
        )
        (case_arm
          pat_list: [{<'/dev/fd'> <Id.Lit_Star '*'> <Id.Lit_Colon ':'> <'/dev/fd'> <Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fdroot)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$thisroot')}
                  spids: [554]
                )
              ]
            )
          ]
          spids: [547 552 561 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fdroot)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$thisroot')}
                  spids: [566]
                )
              ]
            )
          ]
          spids: [563 564 -1 572]
        )
      ]
    )
    (C {<echo>} {<-n>} 
      {
        (DQ <'\n'> 
          <'Welcome to the MINIX 3 setup script.  This script will guide you in setting up\n'> <'MINIX on your machine.  Please consult the manual for detailed instructions.\n'> <'\n'> 
          <'Note 1: If the screen blanks, hit CTRL+F3 to select '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'software scrolling'> 
          (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'.\n'> <'Note 2: If things go wrong then hit CTRL+C to abort and start over.\n'> 
          <'Note 3: Default answers, like [y], can simply be chosen by hitting ENTER.\n'> <'Note 4: If you see a colon (:) then you should hit ENTER to continue.\n'> <':'>
        )
      }
    )
    (C {<read>} {<ret>})
    (C {<echo>} {(DQ )})
    (C {<echo>} {(DQ <' --- Step 1: Select keyboard type --------------------------------------'>)})
    (C {<echo>} {(DQ )})
    (C {<echo>} {(DQ <'What type of keyboard do you have?  You can choose one of:'>)})
    (C {<echo>} {(DQ )})
    (command.Pipeline
      children: [
        (C {<ls>} {<-C>} {<'/usr/lib/keymaps'>})
        (C {<sed>} {<-e>} {(SQ <'s/\\.map//g'>)} {<-e>} {(SQ <'s/^/    /'>)})
      ]
      negated: F
    )
    (C {<echo>} {(DQ )})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:step1)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [662]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$step1'))} 
              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<ok>} {<Id.Lit_RBracket ']'>}
            )
          ]
        )
      body: 
        (command.DoGroup
          children: [
            (command.Sentence
              child: (C {<echo>} {<-n>} {(DQ <'Keyboard type? [us-std] '>)})
              terminator: <Id.Op_Semi _>
            )
            (C {<read>} {<keymap>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$keymap'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:keymap)
                      op: assign_op.Equal
                      rhs: {<us-std>}
                      spids: [708]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          words: [
                            {<loadkeys>}
                            {(DQ <'/usr/lib/keymaps/'> ($ Id.VSub_DollarName '$keymap') <.map>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '2>'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:step1)
                          op: assign_op.Equal
                          rhs: {<ok>}
                          spids: [729]
                        )
                      ]
                    )
                  ]
                  spids: [712 727]
                )
              ]
              else_action: [(C {<warn>} {(DQ <'invalid keyboard'>)})]
            )
          ]
        )
    )
    (C {<echo>} {(DQ )})
    (C {<echo>} {(DQ <' --- Step 2: Selecting full distribution -------------------------------'>)})
    (C {<echo>} {(DQ )})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:nobigsource)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [840]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:step3)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [848]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$step3'))} 
              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<ok>} {<Id.Lit_RBracket ']'>}
            )
          ]
        )
      body: 
        (command.DoGroup
          children: [
            (C {<echo>} {(DQ )})
            (C {<echo>} 
              {(DQ <' --- Step 3: Create or select a partition for MINIX 3 -------------------'>)}
            )
            (C {<echo>} {(DQ )})
            (C {<echo>} {(DQ <'Now you need to create a MINIX 3 partition on your hard disk.'>)})
            (C {<echo>} {(DQ <'You can also select one that\'s already there.'>)})
            (C {<echo>} {(DQ <' '>)})
            (C {<echo>} {(DQ <'If you have an existing installation, reinstalling will let you'>)})
            (C {<echo>} {(DQ <'keep your current partitioning and subpartitioning, and overwrite'>)})
            (C {<echo>} {(DQ <'everything except your s1 subpartition (/home). If you want to'>)})
            (C {<echo>} {(DQ <'reinstall, select your existing minix partition.'>)})
            (C {<echo>} {(DQ <' '>)})
            (C {<echo>} {(DQ <'Unless you are an expert, you are advised to use the automated'>)})
            (C {<echo>} {(DQ <'step-by-step help in setting up.'>)})
            (C {<echo>} {(DQ )})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ok)
                  op: assign_op.Equal
                  rhs: {(DQ )}
                  spids: [966]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$ok'))} {<Id.Lit_Equals '='>} {(DQ )} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<echo>} {<-n>} {(DQ <'Press ENTER for automatic mode, or type \'expert\': '>)})
                    (C {<read>} {<mode>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {<-z>} 
                                      {(DQ ($ Id.VSub_DollarName '$mode'))} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:auto)
                                      op: assign_op.Equal
                                      rhs: {(DQ <1>)}
                                      spids: [1019]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:ok)
                                      op: assign_op.Equal
                                      rhs: {(DQ <yes>)}
                                      spids: [1025]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [1004 1017]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$mode'))} 
                                      {<Id.Lit_Equals '='>} {<expert>} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:auto)
                                      op: assign_op.Equal
                                      rhs: {(DQ )}
                                      spids: [1052]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:ok)
                                      op: assign_op.Equal
                                      rhs: {(DQ <yes>)}
                                      spids: [1057]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [1035 1050]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$ok'))} 
                                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Sentence
                              child: (C {<warn>} {(DQ <'try again'>)})
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [1066 1082]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:primary)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [1099]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$auto'))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} {<-n>} 
                      {
                        (DQ <'\n'> <'MINIX needs one primary partition of '> 
                          ($ Id.VSub_DollarName '$TOTALMB') <' MB for a full install,\n'> <'plus what you want for /home.\n'> <'\n'> 
                          <
'If there is no free space on your disk then you have to choose an option:\n'
                          > <'   (1) Delete one or more partitions\n'> <'   (2) Allocate an existing partition to MINIX 3\n'> 
                          <'   (3) Exit setup and shrink a partition using a different OS\n'> <'\n'> <'To make this partition you will be put in the editor '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) <part> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'.  Follow the\n'> 
                          <
'advice under the \'!\' key to make a new partition of type MINIX.  Do not\n'
                          > <'touch an existing partition unless you know precisely what you are doing!\n'> 
                          <
'Please note the name of the partition (e.g. c0d0p1, c0d1p3, c1d1p0) you\n'
                          > <'make.  (See the devices section in usage(8) on MINIX device names.)\n'> <':'>
                        )
                      }
                    )
                    (C {<read>} {<ret>})
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$primary'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<part>})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                )
                              ]
                            )
                            (C {<echo>} {<-n>} 
                              {
                                (DQ <'\n'> 
                                  <
'Please finish the name of the primary partition you have created:\n'
                                  > <'(Just type ENTER if you want to rerun '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                                  <part> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <')                   /dev/'>
                                )
                              }
                            )
                            (C {<read>} {<primary>})
                          ]
                        )
                    )
                    (C {<echo>} {(DQ )})
                    (C {<echo>} 
                      {(DQ <'This is the point of no return.  You have selected to install MINIX'>)}
                    )
                    (C {<echo>} 
                      {
                        (DQ <'on partition /dev/'> ($ Id.VSub_DollarName '$primary') 
                          <'.  Please confirm that you want to use this'>
                        )
                      }
                    )
                    (C {<echo>} {(DQ <'selection to install MINIX.'>)})
                    (C {<echo>} {(DQ )})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:confirmation)
                          op: assign_op.Equal
                          rhs: {(DQ )}
                          spids: [1240]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-b>} 
                                  {(DQ <'/dev/'> ($ Id.VSub_DollarName '$primary'))} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ <'/dev/'> ($ Id.VSub_DollarName '$primary') 
                                  <' is not a block device.'>
                                )
                              }
                            )
                          ]
                          spids: [1246 1262]
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {<-z>} 
                              {(DQ ($ Id.VSub_DollarName '$confirmation'))} {<-o>} {(DQ ($ Id.VSub_DollarName '$confirmation'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<yes>} {<-a>} 
                              {(DQ ($ Id.VSub_DollarName '$confirmation'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<no>} {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<echo>} {<-n>} 
                              {
                                (DQ 
                                  <
'Are you sure you want to continue? Please enter \'yes\' or \'no\': '
                                  >
                                )
                              }
                            )
                            (C {<read>} {<confirmation>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} 
                                              {(DQ ($ Id.VSub_DollarName '$confirmation'))} {<Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:step3)
                                              op: assign_op.Equal
                                              rhs: {<ok>}
                                              spids: [1346]
                                            )
                                          ]
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  spids: [1329 1344]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:biosdrivename)
                          op: assign_op.Equal
                          rhs: {(DQ <'Actual BIOS device name unknown, due to expert mode.'>)}
                          spids: [1356]
                        )
                      ]
                    )
                  ]
                  spids: [1103 1116]
                )
              ]
              else_action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$auto'))} 
                              {<Id.Lit_Equals '='>} {(DQ <1>)} {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PF)
                              op: assign_op.Equal
                              rhs: {(DQ <'/tmp/pf'>)}
                              spids: [1389]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<autopart>} {<-m> ($ Id.VSub_DollarName '$TOTALMB')} 
                                      {<-f> ($ Id.VSub_DollarName '$PF')}
                                    )
                                  ]
                                )
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (C {<Id.Lit_LBracket '['>} {<-s>} 
                                              {(DQ ($ Id.VSub_DollarName '$PF'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          ]
                                        )
                                      action: [
                                        (C {<set>} 
                                          {
                                            (command_sub
                                              left_token: <Id.Left_Backtick '`'>
                                              child: (C {<cat>} {($ Id.VSub_DollarName '$PF')})
                                            )
                                          }
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:bd)
                                              op: assign_op.Equal
                                              rhs: {(DQ ($ Id.VSub_Number '$1'))}
                                              spids: [1435]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:bdn)
                                              op: assign_op.Equal
                                              rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                              spids: [1441]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:biosdrivename)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (DQ <'Probably, the right command is '> 
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\"'>
                                                    ) <'boot '> ($ Id.VSub_DollarName '$bdn') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <.>
                                                  )
                                                }
                                              spids: [1447]
                                            )
                                          ]
                                        )
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: 
                                                (condition.Shell
                                                  commands: [
                                                    (C {<Id.Lit_LBracket '['>} {<-b>} 
                                                      {(DQ <'/dev/'> ($ Id.VSub_DollarName '$bd'))} {<Id.Lit_RBracket ']'>}
                                                    )
                                                  ]
                                                )
                                              action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:primary)
                                                      op: assign_op.Equal
                                                      rhs: {(DQ ($ Id.VSub_DollarName '$bd'))}
                                                      spids: [1474]
                                                    )
                                                  ]
                                                )
                                              ]
                                              spids: [1458 1472]
                                            )
                                          ]
                                          else_action: [
                                            (C {<echo>} 
                                              {
                                                (DQ <'Funny device '> ($ Id.VSub_DollarName '$bd') 
                                                  <' from autopart.'>
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [1408 1421]
                                    )
                                  ]
                                  else_action: [
                                    (C {<echo>} {(DQ <'Didn\'t find output from autopart.'>)})
                                  ]
                                )
                              ]
                              spids: [1395 1406]
                            )
                          ]
                          else_action: [(C {<echo>} {(DQ <'Autopart tool failed. Trying again.'>)})]
                        )
                        (C {<atnormalize>})
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (C {<Id.Lit_LBracket '['>} {<-n>} 
                                          {(DQ ($ Id.VSub_DollarName '$primary'))} {<Id.Lit_RBracket ']'>}
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [
                                (command.Sentence
                                  child: 
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:step3)
                                          op: assign_op.Equal
                                          rhs: {<ok>}
                                          spids: [1548]
                                        )
                                      ]
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              spids: [1533 1546]
                            )
                          ]
                        )
                      ]
                      spids: [1365 1382]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-b>} 
                          {(DQ <'/dev/'> ($ Id.VSub_DollarName '$primary'))} {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} {<Doing>} {<step>} {<3>} {<again.>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:step3)
                          op: assign_op.Equal
                          rhs: {(DQ )}
                          spids: [1591]
                        )
                      ]
                    )
                  ]
                  spids: [1562 1578]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:devsize)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_Backtick '`'>
                              child: (C {<devsize>} {<'/dev/'> ($ Id.VSub_DollarName '$primary')})
                            )
                          )
                        }
                      spids: [1599]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$devsize'))} {<-lt>} 
                              {<1>} {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      action: [
                        (C {<echo>} 
                          {(DQ <'/dev/'> ($ Id.VSub_DollarName '$primary') <' is a 0-sized device.'>)}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:step3)
                              op: assign_op.Equal
                              rhs: {(DQ )}
                              spids: [1639]
                            )
                          ]
                        )
                      ]
                      spids: [1613 1628]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:root)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name primary) <s0>}
          spids: [1658]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:home)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name primary) <s1>}
          spids: [1664]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:usr)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name primary) <s2>}
          spids: [1670]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.Simple
          words: [{<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$root')}]
          redirects: [(redir op:<Id.Redir_Great '2>'> loc:(redir_loc.Fd fd:2) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (C {<echo>} {(DQ <'Unmounted '> ($ Id.VSub_DollarName '$root') <' for you.'>)})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.Simple
          words: [{<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$home')}]
          redirects: [(redir op:<Id.Redir_Great '2>'> loc:(redir_loc.Fd fd:2) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (C {<echo>} {(DQ <'Unmounted '> ($ Id.VSub_DollarName '$home') <' for you.'>)})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.Simple
          words: [{<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$usr')}]
          redirects: [(redir op:<Id.Redir_Great '2>'> loc:(redir_loc.Fd fd:2) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (C {<echo>} {(DQ <'Unmounted '> ($ Id.VSub_DollarName '$usr') <' for you.'>)})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:devsizemb)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  child: 
                    (C {<expr>} {($ Id.VSub_DollarName '$devsize')} {<'/'>} {<1024>} {<'/'>} {<2>})
                )
              )
            }
          spids: [1731]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:maxhome)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  child: 
                    (C {<expr>} {($ Id.VSub_DollarName '$devsizemb')} {<->} 
                      {($ Id.VSub_DollarName '$TOTALMB')} {<->} {<1>}
                    )
                )
              )
            }
          spids: [1750]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$devsizemb'))} {<-lt>} 
                  {(DQ ($ Id.VSub_DollarName '$TOTALMB'))} {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} 
              {
                (DQ <'The selected partition ('> ($ Id.VSub_DollarName '$devsizemb') 
                  <' MB) is too small.'>
                )
              }
            )
            (C {<echo>} {(DQ <'You\'ll need '> ($ Id.VSub_DollarName '$TOTALMB') <' MB at least.'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [1770 1786]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$maxhome'))} {<-lt>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ <'Note: you can\'t have /home with that size partition.'>)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:maxhome)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [1836]
                )
              ]
            )
          ]
          spids: [1813 1827]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TMPMP)
          op: assign_op.Equal
          rhs: {<'/m'>}
          spids: [1842]
        )
      ]
    )
    (command.Simple
      words: [{<mkdir>} {($ Id.VSub_DollarName '$TMPMP')}]
      redirects: [
        (redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})
        (redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})
      ]
      do_fork: T
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:confirm)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [1856]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$confirm'))} {<Id.Lit_Equals '='>} {(DQ )} 
              {<Id.Lit_RBracket ']'>}
            )
          ]
        )
      body: 
        (command.DoGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:auto)
                  op: assign_op.Equal
                  rhs: {(DQ )}
                  spids: [1879]
                )
              ]
            )
            (C {<echo>} {(DQ )})
            (C {<echo>} 
              {(DQ <' --- Step 4: Reinstall choice ------------------------------------------'>)}
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          words: [
                            {<mount>}
                            {<-r>}
                            {<'/dev/'> ($ Id.VSub_DollarName '$home')}
                            {($ Id.VSub_DollarName '$TMPMP')}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                            (redir
                              op: <Id.Redir_GreatAnd '2>&'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<1>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [{<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$home')}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<'/dev/null'>}
                        )
                        (redir
                          op: <Id.Redir_GreatAnd '2>&'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<1>}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<echo>} {(DQ )})
                    (C {<echo>} {(DQ <'You have selected an existing MINIX 3 partition.'>)})
                    (C {<echo>} {(DQ <'Type F for full installation (to overwrite entire partition)'>)})
                    (C {<echo>} 
                      {(DQ <'Type R for a reinstallation (existing /home will not be affected)'>)}
                    )
                    (C {<echo>} {(DQ )})
                    (C {<echo>} {<-n>} {(DQ <'(F)ull or (R)einstall? [R] '>)})
                    (C {<read>} {<conf>})
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$conf'))}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ )}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:confirm)
                                      op: assign_op.Equal
                                      rhs: {(DQ <ok>)}
                                      spids: [1988]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:auto)
                                      op: assign_op.Equal
                                      rhs: {(DQ <r>)}
                                      spids: [1994]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [1984 1986 2000 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<Id.Lit_LBracket '['> <Rr> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:confirm)
                                      op: assign_op.Equal
                                      rhs: {(DQ <ok>)}
                                      spids: [2009]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:auto)
                                      op: assign_op.Equal
                                      rhs: {(DQ <r>)}
                                      spids: [2015]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [2003 2007 2021 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<Id.Lit_LBracket '['> <Ff> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:confirm)
                                      op: assign_op.Equal
                                      rhs: {(DQ <ok>)}
                                      spids: [2030]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:auto)
                                  op: assign_op.Equal
                                  rhs: {(DQ )}
                                  spids: [2036]
                                )
                              ]
                            )
                          ]
                          spids: [2024 2028 2040 -1]
                        )
                      ]
                    )
                  ]
                  spids: [1896 1914]
                )
              ]
              else_action: [
                (C {<echo>} {(DQ )})
                (C {<echo>} {(DQ <'No old /home found. Doing full install.'>)})
                (C {<echo>} {(DQ )})
                (command.Sentence
                  child: 
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:confirm)
                          op: assign_op.Equal
                          rhs: {(DQ <ok>)}
                          spids: [2068]
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          ]
        )
    )
    (C {<rmdir>} {($ Id.VSub_DollarName '$TMPMP')})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:nohome)
          op: assign_op.Equal
          rhs: {(DQ <0>)}
          spids: [2086]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:homesize)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [2092]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {(DQ ($ Id.VSub_DollarName '$auto'))} 
                  {<Id.Lit_Equals '='>} {<r>} {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ )})
            (C {<echo>} 
              {(DQ <' --- Step 5: Select the size of /home ----------------------------------'>)}
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$homesize'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:defmb)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_Backtick '`'>
                                  child: (C {<expr>} {($ Id.VSub_DollarName '$maxhome')} {<'/'>} {<5>})
                                )
                              )
                            }
                          spids: [2152]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$defmb'))} 
                                  {<-gt>} {(DQ ($ Id.VSub_DollarName '$maxhome'))} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:defmb)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$maxhome')}
                                  spids: [2188]
                                )
                              ]
                            )
                          ]
                          spids: [2168 2185]
                        )
                      ]
                    )
                    (C {<echo>} {(DQ )})
                    (C {<echo>} 
                      {
                        (DQ <'MINIX will take up '> ($ Id.VSub_DollarName '$TOTALMB') 
                          <' MB, without /home.'>
                        )
                      }
                    )
                    (C {<echo>} {<-n>} 
                      {
                        (DQ <'How big do you want your /home to be in MB (0-'> 
                          ($ Id.VSub_DollarName '$maxhome') <') ? ['> ($ Id.VSub_DollarName '$defmb') <'] '>
                        )
                      }
                    )
                    (C {<read>} {<homesize>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$homesize'))} 
                                      {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:homesize)
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$defmb')}
                                      spids: [2248]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [2229 2246]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$homesize'))} 
                                  {<-lt>} {<1>} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:nohome)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [2272]
                                )
                              ]
                            )
                            (C {<echo>} {(DQ <'Ok, not making a /home.'>)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:homesize)
                                  op: assign_op.Equal
                                  rhs: {<0>}
                                  spids: [2283]
                                )
                              ]
                            )
                          ]
                          spids: [2255 2270]
                        )
                      ]
                      else_action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$homesize'))} 
                                      {<-gt>} {(DQ ($ Id.VSub_DollarName '$maxhome'))} {<Id.Lit_RBracket ']'>}
                                    )
                                  ]
                                )
                              action: [
                                (C {<echo>} {(DQ <'That won\'t fit!'>)})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:homesize)
                                      op: assign_op.Equal
                                      rhs: {(DQ )}
                                      spids: [2316]
                                    )
                                  ]
                                )
                              ]
                              spids: [2290 2307]
                            )
                          ]
                          else_action: [
                            (C {<echo>} {(DQ )})
                            (C {<echo>} {<-n>} {(DQ ($ Id.VSub_DollarName '$homesize') <' MB Ok? [Y] '>)})
                            (C {<read>} {<ok>})
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$ok'))} 
                                  {<Id.Lit_Equals '='>} {<Y>} {<-o>} {(DQ ($ Id.VSub_DollarName '$ok'))} {<Id.Lit_Equals '='>} {<y>} {<-o>} 
                                  {(DQ ($ Id.VSub_DollarName '$ok'))} {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:homesize)
                                      op: assign_op.Equal
                                      rhs: {(DQ )}
                                      spids: [2380]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<echo>} {(DQ )})
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:homemb)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$homesize') <' MB'>)}
                  spids: [2404]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:homesize)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_Backtick '`'>
                          child: 
                            (C {<expr>} {($ Id.VSub_DollarName '$homesize')} {(SQ <'*'>)} {<1024>} 
                              {(SQ <'*'>)} {<2>}
                            )
                        )
                      )
                    }
                  spids: [2411]
                )
              ]
            )
          ]
          spids: [2096 2112]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:homepart)
              op: assign_op.Equal
              rhs: 
                {
                  (DQ 
                    (command_sub
                      left_token: <Id.Left_Backtick '`'>
                      child: (C {<devsize>} {<'/dev/'> ($ Id.VSub_DollarName '$home')})
                    )
                  )
                }
              spids: [2437]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:homesize)
              op: assign_op.Equal
              rhs: 
                {
                  (DQ 
                    (command_sub
                      left_token: <Id.Left_Backtick '`'>
                      child: 
                        (C {<expr>} {($ Id.VSub_DollarName '$homepart')} {<'/'>} {<2>} {<'/'>} {<1024>})
                    )
                  )
                }
              spids: [2450]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$homesize'))} {<-gt>} 
                      {(DQ ($ Id.VSub_DollarName '$maxhome'))} {<Id.Lit_RBracket ']'>}
                    )
                  ]
                )
              action: [
                (C {<echo>} 
                  {
                    (DQ <'Sorry, but your /home is too big ('> ($ Id.VSub_DollarName '$homesize') 
                      <' MB) to leave enough'>
                    )
                  }
                )
                (C {<echo>} 
                  {
                    (DQ <'space on the rest of the partition ('> ($ Id.VSub_DollarName '$devsizemb') 
                      <' MB) for your'>
                    )
                  }
                )
                (C {<echo>} 
                  {(DQ <'selected installation size ('> ($ Id.VSub_DollarName '$TOTALMB') <' MB).'>)}
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
              ]
              spids: [2470 2487]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:homesize)
              op: assign_op.Equal
              rhs: {<exist>}
              spids: [2529]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:homemb)
              op: assign_op.Equal
              rhs: {(DQ <'current size'>)}
              spids: [2533]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:minblocksize)
          op: assign_op.Equal
          rhs: {<1>}
          spids: [2541]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:maxblocksize)
          op: assign_op.Equal
          rhs: {<64>}
          spids: [2544]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:blockdefault)
          op: assign_op.Equal
          rhs: {<4>}
          spids: [2547]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {(DQ ($ Id.VSub_DollarName '$auto'))} 
                  {<Id.Lit_Equals '='>} {(DQ <r>)} {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ )})
            (C {<echo>} 
              {(DQ <' --- Step 6: Select a block size ---------------------------------------'>)}
            )
            (C {<echo>} {(DQ )})
            (C {<echo>} 
              {
                (DQ <'The default file system block size is '> ($ Id.VSub_DollarName '$blockdefault') 
                  <' kB.'>
                )
              }
            )
            (C {<echo>} {(DQ )})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$blocksize'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {<echo>} {<-n>} 
                          {
                            (DQ <'Block size in kilobytes? ['> ($ Id.VSub_DollarName '$blockdefault') 
                              <'] '>
                            )
                          }
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<read>} {<blocksize>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$blocksize'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:blocksize)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$blockdefault')}
                              spids: [2652]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$blocksize'))} 
                                  {<-lt>} {($ Id.VSub_DollarName '$minblocksize')} {<-o>} {(DQ ($ Id.VSub_DollarName '$blocksize'))} {<-gt>} 
                                  {($ Id.VSub_DollarName '$maxblocksize')} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (C {<warn>} 
                              {
                                (DQ <'At least '> ($ Id.VSub_DollarName '$minblocksize') 
                                  <' kB and at most '> ($ Id.VSub_DollarName '$maxblocksize') <' kB please.'>
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:blocksize)
                                  op: assign_op.Equal
                                  rhs: {(DQ )}
                                  spids: [2696]
                                )
                              ]
                            )
                          ]
                          spids: [2656 2681]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
          spids: [2551 2569]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:blocksize)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$blockdefault')}
              spids: [2709]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:blocksizebytes)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  child: (C {<expr>} {($ Id.VSub_DollarName '$blocksize')} {(SQ <'*'>)} {<1024>})
                )
              )
            }
          spids: [2715]
        )
      ]
    )
    (C {<echo>} 
      {
        (DQ <'\n'> <'You have selected to (re)install MINIX 3 in the partition /dev/'> 
          ($ Id.VSub_DollarName '$primary') <'.\n'> <'The following subpartitions are now being created on /dev/'> 
          ($ Id.VSub_DollarName '$primary') <':\n'> <'\n'> <'    Root subpartition:\t/dev/'> ($ Id.VSub_DollarName '$root') <'\t'> 
          ($ Id.VSub_DollarName '$ROOTMB') <' MB\n'> <'    /home subpartition:\t/dev/'> ($ Id.VSub_DollarName '$home') <'\t'> 
          ($ Id.VSub_DollarName '$homemb') <'\n'> <'    /usr subpartition:\t/dev/'> ($ Id.VSub_DollarName '$usr') <'\trest of '> 
          ($ Id.VSub_DollarName '$primary') <'\n'>
        )
      }
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [
            {<installboot>}
            {<-m>}
            {<'/dev/'> ($ Id.VSub_DollarName '$primary')}
            {<'/usr/mdec/masterboot'>}
          ]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [
            {<partition>}
            {<'/dev/'> ($ Id.VSub_DollarName '$primary')}
            {<1>}
            {<81> <Id.Lit_Colon ':'> (${ Id.VSub_Name ROOTSECTS) <Id.Lit_Star '*'>}
            {<81> <Id.Lit_Colon ':'> ($ Id.VSub_DollarName '$homesize')}
            {<81> <Id.Lit_Colon ':'> <0> <Id.Lit_Other '+'>}
          ]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (C {<echo>} {(DQ <'Creating /dev/'> ($ Id.VSub_DollarName '$root') <' for / ..'>)})
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<mkfs>} {<'/dev/'> ($ Id.VSub_DollarName '$root')})
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$nohome'))} {<Id.Lit_Equals '='>} 
                  {<0>} {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} 
                          {(DQ ($ Id.VSub_DollarName '$auto'))} {<Id.Lit_Equals '='>} {<r>} {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} 
                      {(DQ <'Creating /dev/'> ($ Id.VSub_DollarName '$home') <' for /home ..'>)}
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<mkfs>} {<-B>} {($ Id.VSub_DollarName '$blocksizebytes')} 
                          {<'/dev/'> ($ Id.VSub_DollarName '$home')}
                        )
                        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
                      ]
                    )
                  ]
                  spids: [2852 2869]
                )
              ]
            )
          ]
          spids: [2835 2849]
        )
      ]
      else_action: [(C {<echo>} {(DQ <'Skipping /home'>)})]
    )
    (C {<echo>} {(DQ <'Creating /dev/'> ($ Id.VSub_DollarName '$usr') <' for /usr ..'>)})
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<mkfs>} {<-B>} {($ Id.VSub_DollarName '$blocksizebytes')} 
          {<'/dev/'> ($ Id.VSub_DollarName '$usr')}
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$nohome'))} {<Id.Lit_Equals '='>} 
                  {<0>} {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fshome)
                  op: assign_op.Equal
                  rhs: {(DQ <'home=/dev/'> ($ Id.VSub_DollarName '$home'))}
                  spids: [2946]
                )
              ]
            )
          ]
          spids: [2929 2943]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:fshome)
              op: assign_op.Equal
              rhs: {(DQ )}
              spids: [2954]
            )
          ]
        )
      ]
    )
    (C {<echo>} {(DQ )})
    (C {<echo>} {(DQ <' --- Step 7: Wait for files to be copied -------------------------------'>)})
    (C {<echo>} {(DQ )})
    (C {<echo>} {(DQ <'All files will now be copied to your hard disk. This may take a while.'>)})
    (C {<echo>} {(DQ )})
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<mount>} {<'/dev/'> ($ Id.VSub_DollarName '$usr')} {<'/mnt'>}]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Pipeline
          children: [
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<cd>} {<'/usr'>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Exit exit>
                          arg_word: {<1>}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:list)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_Backtick '`'>
                                  child: 
                                    (command.Pipeline
                                      children: [(C {<ls>}) (C {<fgrep>} {<-v>} {<install>})]
                                      negated: F
                                    )
                                )
                              )
                            }
                          spids: [3019]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: d
                      iter_words: [{($ Id.VSub_DollarName '$list')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<cpdir>} {<-v>} {($ Id.VSub_DollarName '$d')} 
                              {<'/mnt/'> ($ Id.VSub_DollarName '$d')}
                            )
                          ]
                        )
                    )
                  ]
                )
            )
            (C {<progressbar>} {(DQ ($ Id.VSub_DollarName '$USRFILES'))})
          ]
          negated: F
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$usr')}]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<mount>} {<'/dev/'> ($ Id.VSub_DollarName '$root')} {<'/mnt'>}]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Pipeline
          children: [
            (C {<cpdir>} {<-vx>} {<'/'>} {<'/mnt'>})
            (C {<progressbar>} {(DQ ($ Id.VSub_DollarName '$ROOTFILES'))})
          ]
          negated: F
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (C {<cp>} {<'/mnt/etc/motd.install'>} {<'/mnt/etc/motd'>})
    (C {<rm>} {<'/mnt/var/log'>})
    (C {<ln>} {<-s>} {<'/usr/log'>} {<'/mnt/var/log'>})
    (command.Simple
      words: [{<rm>} {<'/mnt/etc/issue'>} {<'/mnt/CD'>} {<'/mnt/.'> <Id.Lit_Star '*'>}]
      redirects: [(redir op:<Id.Redir_Great '2>'> loc:(redir_loc.Fd fd:2) arg:{<'/dev/null'>})]
      do_fork: T
    )
    (command.Simple
      words: [
        {<echo>}
        {
          (DQ <'# Poor man\'s File System Table.\n'> <'\n'> <'root=/dev/'> 
            ($ Id.VSub_DollarName '$root') <'\n'> <'usr=/dev/'> ($ Id.VSub_DollarName '$usr') <'\n'> ($ Id.VSub_DollarName '$fshome')
          )
        }
      ]
      redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/mnt/etc/fstab'>})]
      do_fork: T
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$keymap'))})
        (C {<cp>} {<-p>} {(DQ <'/usr/lib/keymaps/'> ($ Id.VSub_DollarName '$keymap') <.map>)} 
          {<'/mnt/etc/keymap'>}
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$root')}]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<mount>} {<'/dev/'> ($ Id.VSub_DollarName '$usr')} {<'/mnt'>}]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [
            {<installboot>}
            {<-d>}
            {<'/dev/'> ($ Id.VSub_DollarName '$root')}
            {<'/usr/mdec/bootblock'>}
            {<'/boot/boot'>}
          ]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<edparams>} {<'/dev/'> ($ Id.VSub_DollarName '$root')} 
          {
            (DQ <'rootdev='> ($ Id.VSub_DollarName '$root') <'; ramimagedev='> 
              ($ Id.VSub_DollarName '$root') 
              <
'; minix(1,Start MINIX 3) { image=/boot/image_big; boot; }; newminix(2,Start Custom MINIX 3) { unset image; boot }; main() { echo By default, MINIX 3 will automatically load in 3 seconds.; echo Press ESC to enter the monitor for special configuration.; trap 3000 boot; menu; }; save'
              >
            )
          }
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:pfile)
          op: assign_op.Equal
          rhs: {(DQ <'/mnt/src/tools/fdbootparams'>)}
          spids: [3287]
        )
      ]
    )
    (command.Simple
      words: [
        {<echo>}
        {
          (DQ <'rootdev='> ($ Id.VSub_DollarName '$root') <'; ramimagedev='> 
            ($ Id.VSub_DollarName '$root') <'; save'>
          )
        }
      ]
      redirects: [
        (redir
          op: <Id.Redir_Great '>'>
          loc: (redir_loc.Fd fd:1)
          arg: {($ Id.VSub_DollarName '$pfile')}
        )
      ]
      do_fork: T
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:cddrive)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  child: 
                    (command.Pipeline
                      children: [
                        (C {<mount>})
                        (C {<grep>} {<usr>})
                        (C {<awk>} {(SQ <'{ print $1 }'>)})
                        (C {<sed>} {(SQ <'s/p.*//'>)})
                      ]
                      negated: F
                    )
                )
              )
            }
          spids: [3308]
        )
      ]
    )
    (command.Simple
      words: [{<echo>} {(DQ <'cddrive='> ($ Id.VSub_DollarName '$cddrive'))}]
      redirects: [
        (redir op:<Id.Redir_DGreat '>>'> loc:(redir_loc.Fd fd:1) arg:{<'/mnt/etc/rc.package'>})
      ]
      do_fork: T
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:bios)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  child: 
                    (command.Pipeline
                      children: [
                        (C {<echo>} {($ Id.VSub_DollarName '$primary')})
                        (C {<sed>} {<-e>} {(SQ <'s/d./dX/g'>)} {<-e>} {(SQ <'s/c.//g'>)})
                      ]
                      negated: F
                    )
                )
              )
            }
          spids: [3351]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {(DQ ($ Id.VSub_DollarName '$auto'))} 
                  {<Id.Lit_Equals '='>} {(DQ <r>)} {<Id.Lit_RBracket ']'>}
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          words: [{<mount>} {<'/dev/'> ($ Id.VSub_DollarName '$home')} {<'/home'>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '2>'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  action: [
                    (command.ForEach
                      iter_name: u
                      iter_words: [{<bin>} {<ast>}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:h)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (C {<eval>} {<echo>} {(DQ <'~'> ($ Id.VSub_DollarName '$u'))})
                                      )
                                    }
                                  spids: [3427]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [(C {<mkdir>} {($ Id.VSub_DollarName '$h')})]
                                    )
                                  action: [
                                    (C {<echo>} 
                                      {
                                        (DQ <' * Creating home directory for '> 
                                          ($ Id.VSub_DollarName '$u') <' in '> ($ Id.VSub_DollarName '$h')
                                        )
                                      }
                                    )
                                    (C {<cpdir>} {<'/usr/ast'>} {($ Id.VSub_DollarName '$h')})
                                    (C {<chown>} {<-R>} 
                                      {($ Id.VSub_DollarName '$u') <Id.Lit_Colon ':'> <operator>} {($ Id.VSub_DollarName '$h')}
                                    )
                                  ]
                                  spids: [3442 3449]
                                )
                              ]
                              else_action: [
                                (C {<echo>} {(DQ <' * Couldn\'t create '> ($ Id.VSub_DollarName '$h'))})
                              ]
                            )
                          ]
                        )
                    )
                    (C {<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$home')})
                  ]
                  spids: [3399 3412]
                )
              ]
            )
          ]
          spids: [3379 3397]
        )
      ]
    )
    (C {<echo>} {(DQ <'Saving random data..'>)})
    (C {<dd>} {<Id.Lit_VarLike 'if='> <'/dev/random'>} {<Id.Lit_VarLike 'of='> <'/mnt/adm/random.dat'>} 
      {<Id.Lit_VarLike 'bs='> <1024>} {<Id.Lit_VarLike 'count='> <1>}
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$usr')}]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (C {<echo>} {(DQ )})
    (C {<echo>} {(DQ <' --- Step 8: Select your Ethernet chip ---------------------------------'>)})
    (C {<echo>} {(DQ )})
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<mount>} {<'/dev/'> ($ Id.VSub_DollarName '$root')} {<'/mnt'>}]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<mount>} {<'/dev/'> ($ Id.VSub_DollarName '$usr')} {<'/mnt/usr'>}]
          redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<'/bin/netconf'>} {<-p>} {<'/mnt'>})
        (C {<echo>} {<FAILED>} {<TO>} {<CONFIGURE>} {<NETWORK>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$usr')})
        (C {<echo>} {<Unmounted>} {($ Id.VSub_DollarName '$usr')})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<umount>} {<'/dev/'> ($ Id.VSub_DollarName '$root')})
        (C {<echo>} {<Unmounted>} {($ Id.VSub_DollarName '$root')})
      ]
    )
    (C {<echo>} 
      {
        (DQ <'\n'> <'Please type \'shutdown\' to exit MINIX 3 and enter the boot monitor. At\n'> 
          <'the boot monitor prompt, type \'boot '> ($ Id.VSub_DollarName '$bios') <'\', where X is the bios drive\n'> 
          <'number of the drive you installed on, to try your new MINIX system.\n'> ($ Id.VSub_DollarName '$biosdrivename') <'\n'> <'\n'> 
          <'This ends the MINIX 3 setup script.  After booting your newly set up system,\n'> <'you can run the test suites as indicated in the setup manual.  You also \n'> 
          <'may want to take care of local configuration, such as securing your system\n'> <'with a password.  Please consult the usage manual for more information. \n'> <'\n'>
        )
      }
    )
  ]
)