(CommandList
  children: [
    (FuncDef
      name: _ImageMagick
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {($ VSub_Name "$prev")}
              arms: [
                (case_arm
                  pat_list: [{(-channel)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Red Green Blue Opacity Matte Cyan\n"> 
                                                  <"                Magenta Yellow Black">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [25 42]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [22]
                        )
                      ]
                      spids: [22]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [18 19 52 -1]
                )
                (case_arm
                  pat_list: [{(-colormap)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} {(SQ <"shared private">)} {(--)} 
                                              {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [62 78]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [59]
                        )
                      ]
                      spids: [59]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [55 56 88 -1]
                )
                (case_arm
                  pat_list: [{(-colorspace)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"GRAY OHTA RGB Transparent XYZ YCbCr YIQ\n"> 
                                                  <"                YPbPr YUV CMYK">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [98 115]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [95]
                        )
                      ]
                      spids: [95]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [91 92 125 -1]
                )
                (case_arm
                  pat_list: [{(-compose)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Over In Out Atop Xor Plus Minus Add\n"> 
                                                  <
"                Subtract Difference Multiply Bumpmap Copy CopyRed CopyGreen\n"
                                                  > <"                CopyBlue CopyOpacity">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [135 153]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [132]
                        )
                      ]
                      spids: [132]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [128 129 163 -1]
                )
                (case_arm
                  pat_list: [{(-compress)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"None BZip Fax Group4 JPEG Lossless LZW\n"> 
                                                  <"                RLE Zip">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [173 190]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [170]
                        )
                      ]
                      spids: [170]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [166 167 200 -1]
                )
                (case_arm
                  pat_list: [{(-dispose)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {(SQ <"Undefined None Background Previous">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [210 228]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [207]
                        )
                      ]
                      spids: [207]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [203 204 238 -1]
                )
                (case_arm
                  pat_list: [{(-encoding)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"AdobeCustom AdobeExpert AdobeStandard\n"> 
                                                  <
"                AppleRoman BIG5 GB2312 Latin2 None SJIScode Symbol Unicode\n"
                                                  > <"                Wansung">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [248 266]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [245]
                        )
                      ]
                      spids: [245]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [241 242 276 -1]
                )
                (case_arm
                  pat_list: [{(-endian)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} {(SQ <"MSB LSB">)} {(--)} 
                                              {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [286 302]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [283]
                        )
                      ]
                      spids: [283]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [279 280 312 -1]
                )
                (case_arm
                  pat_list: [{(-filter)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Point Box Triangle Hermite Hanning\n"> 
                                                  <
"                Hamming Blackman Gaussian Quadratic Cubic Catrom Mitchell\n"
                                                  > <"                Lanczos Bessel Sinc">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [322 340]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [319]
                        )
                      ]
                      spids: [319]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [315 316 350 -1]
                )
                (case_arm
                  pat_list: [{(-format)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (DQ 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {(convert)} {(-list)} {(format)})
                                                              (C {(awk)} 
                                                                {
                                                                  (SQ 
                                                                    <
"/ [r-][w-][+-] / { sub(\"[*]$\",\"\",$1); print tolower($1) }"
                                                                    >
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [367 385]
                                                  )
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [360 396]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [357]
                        )
                      ]
                      spids: [357]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [353 354 406 -1]
                )
                (case_arm
                  pat_list: [{(-gravity)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Northwest North NorthEast West Center\n"> 
                                                  <
"                East SouthWest South SouthEast"
                                                  >
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [416 433]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [413]
                        )
                      ]
                      spids: [413]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [409 410 443 -1]
                )
                (case_arm
                  pat_list: [{(-intent)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Absolute Perceptual Relative\n"> 
                                                  <"                Saturation">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [453 470]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [450]
                        )
                      ]
                      spids: [450]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [446 447 480 -1]
                )
                (case_arm
                  pat_list: [{(-interlace)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} {(SQ <"None Line Plane Partition">)} 
                                              {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [490 506]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [487]
                        )
                      ]
                      spids: [487]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [483 484 516 -1]
                )
                (case_arm
                  pat_list: [{(-limit)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} {(SQ <"Disk File Map Memory">)} {(--)} 
                                              {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [526 542]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [523]
                        )
                      ]
                      spids: [523]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [519 520 552 -1]
                )
                (case_arm
                  pat_list: [{(-list)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Delegate Format Magic Module Resource\n"> 
                                                  <"                Type">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [562 579]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [559]
                        )
                      ]
                      spids: [559]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [555 556 589 -1]
                )
                (case_arm
                  pat_list: [{(-map)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {(SQ <"best default gray red green blue">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [599 617]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [596]
                        )
                      ]
                      spids: [596]
                    )
                    (C {(_filedir)})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [592 593 630 -1]
                )
                (case_arm
                  pat_list: [{(-noise)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Uniform Gaussian Multiplicative\n"> 
                                                  <"                Impulse Laplacian Poisson">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [640 657]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [637]
                        )
                      ]
                      spids: [637]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [633 634 667 -1]
                )
                (case_arm
                  pat_list: [{(-preview)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Rotate Shear Roll Hue Saturation\n"> 
                                                  <
"                Brightness Gamma Spiff Dull Grayscale Quantize Despeckle\n"
                                                  > <"                ReduceNoise AddNoise Sharpen Blur Treshold EdgeDetect Spread\n"> 
                                                  <
"                Shade Raise Segment Solarize Swirl Implode Wave OilPaint\n"
                                                  > <"                CharcoalDrawing JPEG">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [677 697]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [674]
                        )
                      ]
                      spids: [674]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [670 671 707 -1]
                )
                (case_arm
                  pat_list: [{(-mask)} {(-profile)} {(-texture)} {(-tile)} {(-write)}]
                  action: [
                    (C {(_filedir)})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [710 719 730 -1]
                )
                (case_arm
                  pat_list: [{(-type)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Bilevel Grayscale Palette PaletteMatte\n"> 
                                                  <
"                TrueColor TrueColorMatte ColorSeparation ColorSeparationlMatte\n"
                                                  > <"                Optimize">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [740 758]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [737]
                        )
                      ]
                      spids: [737]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [733 734 768 -1]
                )
                (case_arm
                  pat_list: [{(-units)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"Undefined PixelsPerInch\n"> 
                                                  <"                PixelsPerCentimeter">
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [778 795]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [775]
                        )
                      ]
                      spids: [775]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [771 772 805 -1]
                )
                (case_arm
                  pat_list: [{(-virtual-pixel)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} {(SQ <"Constant Edge mirror tile">)} 
                                              {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [815 831]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [812]
                        )
                      ]
                      spids: [812]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [808 809 841 -1]
                )
                (case_arm
                  pat_list: [{(-visual)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <"StaticGray GrayScale StaticColor\n"> 
                                                  <
"                PseudoColor TrueColor DirectColor defaut visualid"
                                                  >
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [851 870]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [848]
                        )
                      ]
                      spids: [848]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [844 845 880 -1]
                )
              ]
              spids: [11 15 883]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [8]
        )
      spids: [4 7]
    )
    (AndOr
      children: [
        (FuncDef
          name: _convert
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[903])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[905])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[907])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[909])
                  ]
                  spids: [901]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [950 966]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [947]
                            )
                          ]
                          spids: [947]
                        )
                      ]
                      spids: [-1 944]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ 
                                                      <
"+adjoin +append +compress +contrast +debug\n"
                                                      > <"            +dither +endian +gamma +label +map +mask +matte +negate +noise\n"> 
                                                      <"            +page +raise +render +write">
                                                    )
                                                  } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [993 1011]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [990]
                            )
                          ]
                          spids: [990]
                        )
                      ]
                      spids: [971 987]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [1016 1022]
                )
              ]
              spids: [898]
            )
          spids: [894 897]
        )
        (C {(complete)} {(-F)} {(_convert)} {(convert)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _mogrify
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1046])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1048])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1050])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1052])
                  ]
                  spids: [1044]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1093 1109]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1090]
                            )
                          ]
                          spids: [1090]
                        )
                      ]
                      spids: [-1 1087]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ 
                                                      <
"+compress +contrast +debug +dither +endian\n"
                                                      > <"            +gamma +label +map +mask +matte +negate +page +raise">
                                                    )
                                                  } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1136 1153]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1133]
                            )
                          ]
                          spids: [1133]
                        )
                      ]
                      spids: [1114 1130]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [1158 1164]
                )
              ]
              spids: [1041]
            )
          spids: [1037 1040]
        )
        (C {(complete)} {(-F)} {(_mogrify)} {(mogrify)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _display
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1188])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1190])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1192])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1194])
                  ]
                  spids: [1186]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1235 1251]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1232]
                            )
                          ]
                          spids: [1232]
                        )
                      ]
                      spids: [-1 1229]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ 
                                                      <
"+compress +contrast +debug +dither +endian\n"
                                                      > <"            +gamma +label +map +matte +negate +page +raise +write">
                                                    )
                                                  } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1278 1295]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1275]
                            )
                          ]
                          spids: [1275]
                        )
                      ]
                      spids: [1256 1272]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [1300 1306]
                )
              ]
              spids: [1183]
            )
          spids: [1179 1182]
        )
        (C {(complete)} {(-F)} {(_display)} {(display)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _animate
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1330])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1332])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1334])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1336])
                  ]
                  spids: [1328]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1377 1393]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1374]
                            )
                          ]
                          spids: [1374]
                        )
                      ]
                      spids: [-1 1371]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"+debug +dither +gamma +map +matte">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1420 1438]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1417]
                            )
                          ]
                          spids: [1417]
                        )
                      ]
                      spids: [1398 1414]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [1443 1449]
                )
              ]
              spids: [1325]
            )
          spids: [1321 1324]
        )
        (C {(complete)} {(-F)} {(_animate)} {(animate)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _identify
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1473])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1475])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1477])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1479])
                  ]
                  spids: [1471]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1520 1536]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1517]
                            )
                          ]
                          spids: [1517]
                        )
                      ]
                      spids: [-1 1514]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <"+debug">)} {(--)} 
                                                  {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1563 1579]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1560]
                            )
                          ]
                          spids: [1560]
                        )
                      ]
                      spids: [1541 1557]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [1584 1590]
                )
              ]
              spids: [1468]
            )
          spids: [1464 1467]
        )
        (C {(complete)} {(-F)} {(_identify)} {(identify)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _montage
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1614])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1616])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1618])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1620])
                  ]
                  spids: [1612]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1661 1677]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1658]
                            )
                          ]
                          spids: [1658]
                        )
                      ]
                      spids: [-1 1655]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ 
                                                      <
"+adjoin +compress +debug +dither +endian\n"
                                                      > <"            +gamma +label +matte +page">
                                                    )
                                                  } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1704 1721]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1701]
                            )
                          ]
                          spids: [1701]
                        )
                      ]
                      spids: [1682 1698]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [1726 1732]
                )
              ]
              spids: [1609]
            )
          spids: [1605 1608]
        )
        (C {(complete)} {(-F)} {(_montage)} {(montage)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _composite
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1756])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1758])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1760])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1762])
                  ]
                  spids: [1754]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1803 1819]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1800]
                            )
                          ]
                          spids: [1800]
                        )
                      ]
                      spids: [-1 1797]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <"+compress +debug +dither +endian +label\n"> 
                                                      <"            +matte +negate +page +write">
                                                    )
                                                  } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1846 1863]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1843]
                            )
                          ]
                          spids: [1843]
                        )
                      ]
                      spids: [1824 1840]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [1868 1874]
                )
              ]
              spids: [1751]
            )
          spids: [1747 1750]
        )
        (C {(complete)} {(-F)} {(_composite)} {(composite)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _compare
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1898])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1900])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1902])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1904])
                  ]
                  spids: [1896]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1945 1961]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1942]
                            )
                          ]
                          spids: [1942]
                        )
                      ]
                      spids: [-1 1939]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <"+debug">)} {(--)} 
                                                  {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1988 2004]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1985]
                            )
                          ]
                          spids: [1985]
                        )
                      ]
                      spids: [1966 1982]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [2009 2015]
                )
              ]
              spids: [1893]
            )
          spids: [1889 1892]
        )
        (C {(complete)} {(-F)} {(_compare)} {(compare)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _conjure
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[2039])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[2041])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[2043])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[2045])
                  ]
                  spids: [2037]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [2086 2102]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2083]
                            )
                          ]
                          spids: [2083]
                        )
                      ]
                      spids: [-1 2080]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <"+debug">)} {(--)} 
                                                  {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [2129 2145]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2126]
                            )
                          ]
                          spids: [2126]
                        )
                      ]
                      spids: [2107 2123]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [2150 2156]
                )
              ]
              spids: [2034]
            )
          spids: [2030 2033]
        )
        (C {(complete)} {(-F)} {(_conjure)} {(conjure)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _import
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[2180])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[2182])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[2184])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[2186])
                  ]
                  spids: [2178]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [2227 2243]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2224]
                            )
                          ]
                          spids: [2224]
                        )
                      ]
                      spids: [-1 2221]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <"+debug">)} {(--)} 
                                                  {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [2270 2286]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2267]
                            )
                          ]
                          spids: [2267]
                        )
                      ]
                      spids: [2248 2264]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [2291 2297]
                )
              ]
              spids: [2175]
            )
          spids: [2171 2174]
        )
        (C {(complete)} {(-F)} {(_import)} {(import)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _stream
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[2321])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[2323])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[2325])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[2327])
                  ]
                  spids: [2319]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [(C {(_ImageMagick)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DAmp
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(-) (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <"$( _parse_help \"$1\" -help )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [2368 2384]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2365]
                            )
                          ]
                          spids: [2365]
                        )
                      ]
                      spids: [-1 2362]
                    )
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name "$cur"))}
                                  right: {(Lit_Other "+") (Lit_Other "*")}
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <"+debug">)} {(--)} 
                                                  {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [2411 2427]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2408]
                            )
                          ]
                          spids: [2408]
                        )
                      ]
                      spids: [2389 2405]
                    )
                  ]
                  else_action: [(C {(_filedir)})]
                  spids: [2432 2438]
                )
              ]
              spids: [2316]
            )
          spids: [2312 2315]
        )
        (C {(complete)} {(-F)} {(_stream)} {(stream)})
      ]
      op_id: Op_DAmp
    )
  ]
)