(CommandList
  children: [
    (Sentence child:(C {(set)} {(-eo)} {(pipefail)}) terminator:<Op_Semi ";">)
    (AndOr
      children: [(DBracket expr:(WordTest w:{($ VSub_Name "$DOKKU_TRACE")})) (C {(set)} {(-x)})]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:MOVES)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {(ABLE)}
                  {(ABNORMA)}
                  {(AGAIN)}
                  {(AIREXPL)}
                  {(ANG)}
                  {(ANGER)}
                  {(ASAIL)}
                  {(ATTACK)}
                  {(AURORA)}
                  {(AWL)}
                  {(BAN)}
                  {(BAND)}
                  {(BARE)}
                  {(BEAT)}
                  {(BEATED)}
                  {(BELLY)}
                  {(BIND)}
                  {(BITE)}
                  {(BLOC)}
                  {(BLOOD)}
                  {(BODY)}
                  {(BOOK)}
                  {(BREATH)}
                  {(BUMP)}
                  {(CAST)}
                  {(CHAM)}
                  {(CLAMP)}
                  {(CLAP)}
                  {(CLAW)}
                  {(CLEAR)}
                  {(CLI)}
                  {(CLIP)}
                  {(CLOUD)}
                  {(CONTRO)}
                  {(CONVY)}
                  {(COOLHIT)}
                  {(CRASH)}
                  {(CRY)}
                  {(CUT)}
                  {(DESCRI)}
                  {(D-FIGHT)}
                  {(DIG)}
                  {(DITCH)}
                  {(DIV)}
                  {(DOZ)}
                  {(DRE)}
                  {(DUL)}
                  {(DU-PIN)}
                  {(DYE)}
                  {(EARTH)}
                  {(EDU)}
                  {(EG-BOMB)}
                  {(EGG)}
                  {(ELEGY)}
                  {(ELE-HIT)}
                  {(EMBODY)}
                  {(EMPLI)}
                  {(ENGL)}
                  {(ERUPT)}
                  {(EVENS)}
                  {(EXPLOR)}
                  {(EYES)}
                  {(FALL)}
                  {(FAST)}
                  {(F-CAR)}
                  {(F-DANCE)}
                  {(FEARS)}
                  {(F-FIGHT)}
                  {(FIGHT)}
                  {(FIR)}
                  {(FIRE)}
                  {(FIREHIT)}
                  {(FLAME)}
                  {(FLAP)}
                  {(FLASH)}
                  {(FLEW)}
                  {(FORCE)}
                  {(FRA)}
                  {(FREEZE)}
                  {(FROG)}
                  {(G-BIRD)}
                  {(GENKISS)}
                  {(GIFT)}
                  {(G-KISS)}
                  {(G-MOUSE)}
                  {(GRADE)}
                  {(GROW)}
                  {(HAMMER)}
                  {(HARD)}
                  {(HAT)}
                  {(HATE)}
                  {(H-BOMB)}
                  {(HELL-R)}
                  {(HEMP)}
                  {(HINT)}
                  {(HIT)}
                  {(HU)}
                  {(HUNT)}
                  {(HYPNOSI)}
                  {(INHA)}
                  {(IRO)}
                  {(IRONBAR)}
                  {(IR-WING)}
                  {(J-GUN)}
                  {(KEE)}
                  {(KICK)}
                  {(KNIF)}
                  {(KNIFE)}
                  {(KNOCK)}
                  {(LEVEL)}
                  {(LIGH)}
                  {(LIGHHIT)}
                  {(LIGHT)}
                  {(LIVE)}
                  {(L-WALL)}
                  {(MAD)}
                  {(MAJUS)}
                  {(MEL)}
                  {(MELO)}
                  {(MESS)}
                  {(MILK)}
                  {(MIMI)}
                  {(MISS)}
                  {(MIXING)}
                  {(MOVE)}
                  {(MUD)}
                  {(NI-BED)}
                  {(NOISY)}
                  {(NOONLI)}
                  {(NULL)}
                  {(N-WAVE)}
                  {(PAT)}
                  {(PEACE)}
                  {(PIN)}
                  {(PLAN)}
                  {(PLANE)}
                  {(POIS)}
                  {(POL)}
                  {(POWDE)}
                  {(POWE)}
                  {(POWER)}
                  {(PRIZE)}
                  {(PROTECT)}
                  {(PROUD)}
                  {(RAGE)}
                  {(RECOR)}
                  {(REFLAC)}
                  {(REFREC)}
                  {(REGR)}
                  {(RELIV)}
                  {(RENEW)}
                  {(R-FIGHT)}
                  {(RING)}
                  {(RKICK)}
                  {(ROCK)}
                  {(ROUND)}
                  {(RUS)}
                  {(RUSH)}
                  {(SAND)}
                  {(SAW)}
                  {(SCISSOR)}
                  {(SCRA)}
                  {(SCRIPT)}
                  {(SEEN)}
                  {(SERVER)}
                  {(SHADOW)}
                  {(SHELL)}
                  {(SHINE)}
                  {(SHO)}
                  {(SIGHT)}
                  {(SIN)}
                  {(SMALL)}
                  {(SMELT)}
                  {(SMOK)}
                  {(SNAKE)}
                  {(SNO)}
                  {(SNOW)}
                  {(SOU)}
                  {(SO-WAVE)}
                  {(SPAR)}
                  {(SPEC)}
                  {(SPID)}
                  {(S-PIN)}
                  {(SPRA)}
                  {(STAM)}
                  {(STARE)}
                  {(STEA)}
                  {(STONE)}
                  {(STORM)}
                  {(STRU)}
                  {(STRUG)}
                  {(STUDEN)}
                  {(SUBS)}
                  {(SUCID)}
                  {(SUN-LIG)}
                  {(SUNRIS)}
                  {(SUPLY)}
                  {(S-WAVE)}
                  {(TAILS)}
                  {(TANGL)}
                  {(TASTE)}
                  {(TELLI)}
                  {(THANK)}
                  {(TONKICK)}
                  {(TOOTH)}
                  {(TORL)}
                  {(TRAIN)}
                  {(TRIKICK)}
                  {(TUNGE)}
                  {(VOLT)}
                  {(WA-GUN)}
                  {(WATCH)}
                  {(WAVE)}
                  {(W-BOMB)}
                  {(WFALL)}
                  {(WFING)}
                  {(WHIP)}
                  {(WHIRL)}
                  {(WIND)}
                  {(WOLF)}
                  {(WOOD)}
                  {(WOR)}
                  {(YUJA)}
                ]
              )
            }
          spids: [23]
        )
      ]
      spids: [23]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:NAMES)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {(SEED)}
                  {(GRASS)}
                  {(FLOWE)}
                  {(SHAD)}
                  {(CABR)}
                  {(SNAKE)}
                  {(GOLD)}
                  {(COW)}
                  {(GUIKI)}
                  {(PEDAL)}
                  {(DELAN)}
                  {(B-FLY)}
                  {(BIDE)}
                  {(KEYU)}
                  {(FORK)}
                  {(LAP)}
                  {(PIGE)}
                  {(PIJIA)}
                  {(CAML)}
                  {(LAT)}
                  {(BIRD)}
                  {(BABOO)}
                  {(VIV)}
                  {(ABOKE)}
                  {(PIKAQ)}
                  {(RYE)}
                  {(SAN)}
                  {(BREAD)}
                  {(LIDEL)}
                  {(LIDE)}
                  {(PIP)}
                  {(PIKEX)}
                  {(ROK)}
                  {(JUGEN)}
                  {(PUD)}
                  {(BUDE)}
                  {(ZHIB)}
                  {(GELU)}
                  {(GRAS)}
                  {(FLOW)}
                  {(LAFUL)}
                  {(ATH)}
                  {(BALA)}
                  {(CORN)}
                  {(MOLUF)}
                  {(DESP)}
                  {(DAKED)}
                  {(MIMI)}
                  {(BOLUX)}
                  {(KODA)}
                  {(GELUD)}
                  {(MONK)}
                  {(SUMOY)}
                  {(GEDI)}
                  {(WENDI)}
                  {(NILEM)}
                  {(NILE)}
                  {(NILEC)}
                  {(KEZI)}
                  {(YONGL)}
                  {(HUDE)}
                  {(WANLI)}
                  {(GELI)}
                  {(GUAIL)}
                  {(MADAQ)}
                  {(WUCI)}
                  {(WUCI)}
                  {(MUJEF)}
                  {(JELLY)}
                  {(SICIB)}
                  {(GELU)}
                  {(NELUO)}
                  {(BOLI)}
                  {(JIALE)}
                  {(YED)}
                  {(YEDE)}
                  {(CLO)}
                  {(SCARE)}
                  {(AOCO)}
                  {(DEDE)}
                  {(DEDEI)}
                  {(BAWU)}
                  {(JIUG)}
                  {(BADEB)}
                  {(BADEB)}
                  {(HOLE)}
                  {(BALUX)}
                  {(GES)}
                  {(FANT)}
                  {(QUAR)}
                  {(YIHE)}
                  {(SWAB)}
                  {(SLIPP)}
                  {(CLU)}
                  {(DEPOS)}
                  {(BILIY)}
                  {(YUANO)}
                  {(SOME)}
                  {(NO)}
                  {(YELA)}
                  {(EMPT)}
                  {(ZECUN)}
                  {(XIAHE)}
                  {(BOLEL)}
                  {(DEJI)}
                  {(MACID)}
                  {(XIHON)}
                  {(XITO)}
                  {(LUCK)}
                  {(MENJI)}
                  {(GELU)}
                  {(DECI)}
                  {(XIDE)}
                  {(DASAJ)}
                  {(DONGN)}
                  {(RICUL)}
                  {(MINXI)}
                  {(BALIY)}
                  {(ZENDA)}
                  {(LUZEL)}
                  {(HELE5)}
                  {(0FENB)}
                  {(KAIL)}
                  {(JIAND)}
                  {(CARP)}
                  {(JINDE)}
                  {(LAPU)}
                  {(MUDE)}
                  {(YIFU)}
                  {(LINLI)}
                  {(SANDI)}
                  {(HUSI)}
                  {(JINC)}
                  {(OUMU)}
                  {(OUMUX)}
                  {(CAP)}
                  {(KUIZA)}
                  {(PUD)}
                  {(TIAO)}
                  {(FRMAN)}
                  {(CLAU)}
                  {(SPARK)}
                  {(DRAGO)}
                  {(BOLIU)}
                  {(GUAIL)}
                  {(MIYOU)}
                  {(MIY)}
                  {(QIAOK)}
                  {(BEIL)}
                  {(MUKEI)}
                  {(RIDED)}
                  {(MADAM)}
                  {(BAGEP)}
                  {(CROC)}
                  {(ALIGE)}
                  {(OUDAL)}
                  {(OUD)}
                  {(DADA)}
                  {(HEHE)}
                  {(YEDEA)}
                  {(NUXI)}
                  {(NUXIN)}
                  {(ROUY)}
                  {(ALIAD)}
                  {(STICK)}
                  {(QIANG)}
                  {(LAAND)}
                  {(PIQI)}
                  {(PI)}
                  {(PUPI)}
                  {(DEKE)}
                  {(DEKEJ)}
                  {(NADI)}
                  {(NADIO)}
                  {(MALI)}
                  {(PEA)}
                  {(ELECT)}
                  {(FLOWE)}
                  {(MAL)}
                  {(MALI)}
                  {(HUSHU)}
                  {(NILEE)}
                  {(YUZI)}
                  {(POPOZ)}
                  {(DUZI)}
                  {(HEBA)}
                  {(XIAN)}
                  {(SHAN)}
                  {(YEYEA)}
                  {(WUY)}
                  {(LUO)}
                  {(KEFE)}
                  {(HULA)}
                  {(CROW)}
                  {(YADEH)}
                  {(MOW)}
                  {(ANNAN)}
                  {(SUONI)}
                  {(KYLI)}
                  {(HULU)}
                  {(HUDEL)}
                  {(YEHE)}
                  {(GULAE)}
                  {(YEHE)}
                  {(BLU)}
                  {(GELAN)}
                  {(BOAT)}
                  {(NIP)}
                  {(POIT)}
                  {(HELAK)}
                  {(XINL)}
                  {(BEAR)}
                  {(LINB)}
                  {(MAGEH)}
                  {(MAGEJ)}
                  {(WULI)}
                  {(YIDE)}
                  {(RIVE)}
                  {(FISH)}
                  {(AOGU)}
                  {(DELIE)}
                  {(MANTE)}
                  {(KONMU)}
                  {(DELU)}
                  {(HELU)}
                  {(HUAN)}
                  {(HUMA)}
                  {(DONGF)}
                  {(JINCA)}
                  {(HEDE)}
                  {(DEFU)}
                  {(LIBY)}
                  {(JIAPA)}
                  {(MEJI)}
                  {(HELE)}
                  {(BUHU)}
                  {(MILK)}
                  {(HABI)}
                  {(THUN)}
                  {(GARD)}
                  {(DON)}
                  {(YANGQ)}
                  {(SANAQ)}
                  {(BANQ)}
                  {(LUJ)}
                  {(PHIX)}
                  {(SIEI)}
                  {(EGG)}
                ]
              )
            }
          spids: [472]
        )
      ]
      spids: [472]
    )
    (FuncDef
      name: random_number
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (DBracket
                  expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Number "$1"))})
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:RANGE)
                      op: Equal
                      rhs: {(DQ ($ VSub_Number "$1"))}
                      spids: [991]
                    )
                  ]
                  spids: [991]
                )
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Name "$RANGE"))})
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:number)
                          op: Equal
                          rhs: {($ VSub_Name "$RANDOM")}
                          spids: [1013]
                        )
                      ]
                      spids: [1013]
                    )
                    (C {(let)} {(DQ ("number %= ") ($ VSub_Name "$RANGE"))})
                  ]
                  spids: [-1 1010]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:number)
                      op: Equal
                      rhs: {($ VSub_Name "$RANDOM")}
                      spids: [1028]
                    )
                  ]
                  spids: [1028]
                )
              ]
              spids: [1025 1032]
            )
            (C {(echo)} {($ VSub_Name "$number")})
          ]
          spids: [976]
        )
      spids: [972 975]
    )
    (FuncDef
      name: random_name
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NUM1)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(random_number)} 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name MOVES>
                                    prefix_op: VSub_Pound
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [1053 1059]
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1050 1060]
                      )
                    }
                  spids: [1049]
                )
              ]
              spids: [1049]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NUM2)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(random_number)} 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name MOVES>
                                    prefix_op: VSub_Pound
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [1067 1073]
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1064 1074]
                      )
                    }
                  spids: [1063]
                )
              ]
              spids: [1063]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NUM3)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(random_number)} 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name NAMES>
                                    prefix_op: VSub_Pound
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [1081 1087]
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1078 1088]
                      )
                    }
                  spids: [1077]
                )
              ]
              spids: [1077]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:UPPER_APPNAME)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name MOVES>
                          bracket_op: (ArrayIndex expr:(ArithWord w:{(${ VSub_Name NUM1)}))
                          spids: [1094 1101]
                        ) (-) 
                        (BracedVarSub
                          token: <VSub_Name MOVES>
                          bracket_op: (ArrayIndex expr:(ArithWord w:{(${ VSub_Name NUM2)}))
                          spids: [1103 1110]
                        ) (-) 
                        (BracedVarSub
                          token: <VSub_Name NAMES>
                          bracket_op: (ArrayIndex expr:(ArithWord w:{(${ VSub_Name NUM3)}))
                          spids: [1112 1119]
                        )
                      )
                    }
                  spids: [1092]
                )
              ]
              spids: [1092]
            )
            (AndOr
              children: [
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_EqualTilde
                      left: {(DQ ($ VSub_Name "$BASH_VERSION"))}
                      right: {(4.) (Lit_Other "*")}
                    )
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:lower_appname)
                      op: Equal
                      rhs: 
                        {
                          (BracedVarSub
                            token: <VSub_Name UPPER_APPNAME>
                            suffix_op: (StringUnary op_id:VOp1_DComma arg_word:{})
                            spids: [1140 1143]
                          )
                        }
                      spids: [1139]
                    )
                  ]
                  spids: [1139]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (DBracket
                  expr: (BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$lower_appname"))})
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:lower_appname)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (C {(echo)} {(DQ ($ VSub_Name "$UPPER_APPNAME"))})
                                      (C {(tr)} {(SQ <"[:upper:]">)} {(SQ <"[:lower:]">)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1159 1177]
                          )
                        }
                      spids: [1158]
                    )
                  ]
                  spids: [1158]
                )
              ]
              op_id: Op_DAmp
            )
            (C {(echo)} {(DQ ($ VSub_Name "$lower_appname"))})
          ]
          spids: [1046]
        )
      spids: [1042 1045]
    )
    (FuncDef
      name: client_help_msg
      body: 
        (BraceGroup
          children: [
            (C {(echo)} 
              {
                (DQ ("==> Configure the DOKKU_HOST environment variable or run ") ($ VSub_Number "$0") 
                  (" from a repository with a git remote named dokku")
                )
              }
            )
            (C {(echo)} {(DQ ("--> i.e. git remote add dokku dokku@<dokku-host>:<app-name>"))})
            (C {(exit)} {(20)})
          ]
          spids: [1193]
        )
      spids: [1189 1192]
    )
    (FuncDef
      name: is_git_repo
      body: 
        (BraceGroup
          children: [
            (Sentence child:(C {(git)} {(rev-parse)}) terminator:<Op_Amp "&">)
            (SimpleCommand
              redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[1234])]
            )
          ]
          spids: [1226]
        )
      spids: [1222 1225]
    )
    (FuncDef
      name: has_dokku_remote
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [(C {(git)} {(remote)} {(show)}) (C {(grep)} {(dokku)})]
              negated: False
            )
          ]
          spids: [1244]
        )
      spids: [1240 1243]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (DBracket expr:(BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$DOKKU_HOST")}))
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_d child:{(.git)})
                            )
                            (SimpleCommand
                              words: [{(git)} {(rev-parse)} {(--git-dir)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(/dev/null)}
                                  spids: [1294]
                                )
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [1298]
                                )
                              ]
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:DOKKU_HOST)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (AndOr
                                        children: [
                                          (Pipeline
                                            children: [
                                              (SimpleCommand
                                                words: [{(git)} {(remote)} {(-v)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: 2
                                                    arg_word: {(/dev/null)}
                                                    spids: [1313]
                                                  )
                                                ]
                                              )
                                              (C {(grep)} {(-Ei)} {(DQ ("^dokku"))})
                                              (C {(head)} {(-n)} {(1)})
                                              (C {(cut)} {(-f1)} {(-d) (SQ <" ">)})
                                              (C {(cut)} {(-f2)} {(-d)} {(SQ <"@">)})
                                              (SimpleCommand
                                                words: [{(cut)} {(-f1)} {(-d) (SQ <":">)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: 2
                                                    arg_word: {(/dev/null)}
                                                    spids: [1368]
                                                  )
                                                ]
                                              )
                                            ]
                                            negated: False
                                          )
                                          (C {(true)})
                                        ]
                                        op_id: Op_DPipe
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1306 1374]
                              )
                            }
                          spids: [1305]
                        )
                      ]
                      spids: [1305]
                    )
                  ]
                  spids: [-1 1302]
                )
              ]
              else_action: [(C {(client_help_msg)})]
              spids: [1377 1383]
            )
          ]
          spids: [-1 1273]
        )
      ]
      spids: [-1 1385]
    )
    (C {(export)} 
      {(Lit_VarLike "DOKKU_PORT=") 
        (BracedVarSub
          token: <VSub_Name DOKKU_PORT>
          suffix_op: (StringUnary op_id:VTest_ColonEquals arg_word:{(22)})
          spids: [1391 1395]
        )
      }
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (LogicalNot
                      child: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$DOKKU_HOST")})
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (FuncDef
              name: _dokku
              body: 
                (BraceGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:appname)
                          op: Equal
                          rhs: {(DQ )}
                          spids: [1421]
                        )
                      ]
                      spids: [1421]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (DBracket
                                      expr: (BoolUnary op_id:BoolUnary_d child:{(.git)})
                                    )
                                    (SimpleCommand
                                      words: [{(git)} {(rev-parse)} {(--git-dir)}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [1444]
                                        )
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 2
                                          arg_word: {(1)}
                                          spids: [1448]
                                        )
                                      ]
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(set)} {(Lit_Other "+") (e)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:appname)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (SimpleCommand
                                                    words: [{(git)} {(remote)} {(-v)}]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [1469]
                                                      )
                                                    ]
                                                  )
                                                  (C {(grep)} {(-Ei)} 
                                                    {(DQ ("dokku@") ($ VSub_Name "$DOKKU_HOST"))}
                                                  )
                                                  (C {(head)} {(-n)} {(1)})
                                                  (C {(cut)} {(-f2)} {(-d) (SQ <"@">)})
                                                  (C {(cut)} {(-f1)} {(-d) (SQ <" ">)})
                                                  (SimpleCommand
                                                    words: [{(cut)} {(-f2)} {(-d) (SQ <":">)}]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [1524]
                                                      )
                                                    ]
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1462 1526]
                                      )
                                    }
                                  spids: [1461]
                                )
                              ]
                              spids: [1461]
                            )
                            (C {(set)} {(-e)})
                          ]
                          spids: [-1 1452]
                        )
                      ]
                      else_action: [(C {(echo)} {(DQ ("This is not a git repository"))})]
                      spids: [1534 1544]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(apps) (Lit_Other ":") (create)}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolUnary
                                              op_id: BoolUnary_z
                                              child: {(DQ ($ VSub_Number "$2"))}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:appname)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [(C {(random_name)})]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [1580 1582]
                                              )
                                            }
                                          spids: [1579]
                                        )
                                      ]
                                      spids: [1579]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:counter)
                                          op: Equal
                                          rhs: {(0)}
                                          spids: [1585]
                                        )
                                      ]
                                      spids: [1585]
                                    )
                                    (While
                                      cond: [
                                        (Sentence
                                          child: 
                                            (Pipeline
                                              children: [
                                                (SimpleCommand
                                                  words: [
                                                    {(ssh)}
                                                    {(-p)}
                                                    {(DQ ($ VSub_Name "$DOKKU_PORT"))}
                                                    {(DQ ("dokku@") ($ VSub_Name "$DOKKU_HOST"))}
                                                    {(apps)}
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: 2
                                                      arg_word: {(/dev/null)}
                                                      spids: [1606]
                                                    )
                                                  ]
                                                )
                                                (C {(grep)} {(-q)} {(DQ ($ VSub_Name "$appname"))})
                                              ]
                                              negated: False
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      body: 
                                        (DoGroup
                                          children: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (DBracket
                                                          expr: 
                                                            (BoolBinary
                                                              op_id: BoolBinary_ge
                                                              left: {($ VSub_Name "$counter")}
                                                              right: {(100)}
                                                            )
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
"Error: could not reasonably generate a new app name. try cleaning up some apps..."
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(ssh)} {(-p)} {(DQ ($ VSub_Name "$DOKKU_PORT"))} 
                                                      {(DQ ("dokku@") ($ VSub_Name "$DOKKU_HOST"))} {(apps)}
                                                    )
                                                    (C {(exit)} {(1)})
                                                  ]
                                                  spids: [-1 1635]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:appname)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [(C {(random_name)})]
                                                              )
                                                            left_token: <Left_CommandSub "$(">
                                                            spids: [1670 1672]
                                                          )
                                                        }
                                                      spids: [1669]
                                                    )
                                                  ]
                                                  spids: [1669]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:counter)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (ArithSubPart
                                                            anode: 
                                                              (ArithBinary
                                                                op_id: Arith_Plus
                                                                left: (ArithVarRef name:counter)
                                                                right: (ArithWord w:{(Lit_Digits 1)})
                                                              )
                                                            spids: [1676 1681]
                                                          )
                                                        }
                                                      spids: [1675]
                                                    )
                                                  ]
                                                  spids: [1675]
                                                )
                                              ]
                                              spids: [1666 1684]
                                            )
                                          ]
                                          spids: [1619 1687]
                                        )
                                    )
                                  ]
                                  spids: [-1 1576]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:appname)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Number "$2"))}
                                      spids: [1693]
                                    )
                                  ]
                                  spids: [1693]
                                )
                              ]
                              spids: [1690 1699]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(git)} {(remote)} {(add)} {(dokku)} 
                                          {
                                            (DQ ("dokku@") ($ VSub_Name "$DOKKU_HOST") (":") 
                                              ($ VSub_Name "$appname")
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(echo)} 
                                      {
                                        (DQ ("-----> Dokku remote added at ") 
                                          ($ VSub_Name "$DOKKU_HOST")
                                        )
                                      }
                                    )
                                    (C {(echo)} 
                                      {(DQ ("-----> Application name is ") ($ VSub_Name "$appname"))}
                                    )
                                  ]
                                  spids: [-1 1720]
                                )
                              ]
                              else_action: [
                                (C {(echo)} 
                                  {
                                    (DQ 
                                      (
"!      Dokku remote not added! Do you already have a dokku remote?"
                                      )
                                    )
                                  }
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                )
                              ]
                              spids: [1739 1752]
                            )
                          ]
                          spids: [1557 1560 1755 -1]
                        )
                        (case_arm
                          pat_list: [{(apps) (Lit_Other ":") (destroy)}]
                          action: [
                            (AndOr
                              children: [
                                (C {(is_git_repo)})
                                (AndOr
                                  children: [
                                    (C {(has_dokku_remote)})
                                    (C {(git)} {(remote)} {(remove)} {(dokku)})
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [1758 1761 1781 -1]
                        )
                      ]
                      spids: [1548 1554 1784]
                    )
                    (AndOr
                      children: [
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_At "$@"))})
                        )
                        (AndOr
                          children: [
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Name "$appname"))})
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:app_arg)
                                  op: Equal
                                  rhs: {(DQ ("--app ") ($ VSub_Name "$appname"))}
                                  spids: [1812]
                                )
                              ]
                              spids: [1812]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (C {(ssh)} {(-o)} {(Lit_VarLike "LogLevel=") (QUIET)} {(-p)} 
                      {($ VSub_Name "$DOKKU_PORT")} {(-t)} {(dokku) (Lit_Other "@") ($ VSub_Name "$DOKKU_HOST")} {(--)} {($ VSub_Name "$app_arg")} 
                      {($ VSub_At "$@")}
                    )
                  ]
                  spids: [1418]
                )
              spids: [1414 1417]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Number "$0"))}
                                  right: {(DQ (dokku))}
                                )
                            )
                            (AndOr
                              children: [
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(DQ ($ VSub_Number "$0"))}
                                      right: {(Lit_Other "*") (dokku_client.sh)}
                                    )
                                )
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(DQ ($ VSub_Number "$0"))}
                                      right: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [(C {(which)} {(dokku)})]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [1896 1900]
                                          )
                                        }
                                    )
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(_dokku)} {(DQ ($ VSub_At "$@"))}) (C {(exit)} {($ VSub_QMark "$?")})]
                  spids: [-1 1905]
                )
              ]
              spids: [-1 1920]
            )
          ]
          spids: [-1 1411]
        )
      ]
      else_action: [(C {(client_help_msg)})]
      spids: [1922 1927]
    )
  ]
)