arc-completion.bash

_arc() {
  COMPREPLY=()

  local i args opts items candidates

  local cur prev words cword
  _get_comp_words_by_ref -n "\"'><=;|&(:" cur prev words cword

  local need_space="1"
  local IFS=$' \t\n'

  if [[ ${cword} == 1 ]] ; then
    if [[ ${cur} == -* ]] ;  then
      COMPREPLY+=( $(compgen -W '-h --help -v --version --svnrevision' -- ${cur}) )
    else
      COMPREPLY+=( $(compgen -W ' mount unmount sync init  add clean cp encrypt mergetool mv reset rm stash copy-info  blame praise describe diff difftool ls-files log reflog merge-base root show status  branch checkout cherry-pick commit rebase revert tag  fetch pr pull push  fsck archive export gc  config dump gen-key info ls-tree rev-parse token internal prefetch-files repair-command list-commands user-info  --update --has-update --set-channel --is-launcher --remove-unused-versions' -- ${cur}) )
    fi
  else
    case "${words[1]}" in
      'mount')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --server -p --port --ssl --log --json-trace --pull-server --pull-port --pull-ssl --arcanum-url -r --repository -b --branch --local -m --mount -F --foreground -D --debug --allow-root --allow-other --no-threads --no-auto-unmount -S --store --frozen --read-only --no-auto-cache -o --vfs-version --inode-cache-size --overlay-rocks-block-cache-size --fuse-threads --fuse-timeout --skip-overlay-convertion --no-aggressive-delete --object-store --path-filter -C --cache-size --fetch-trees --monitoring-port --yav-token-via-ssh --ssh-tokens --no-ssh-tokens --disable-mount-manager -l --list' -- ${cur}) )
        else
          case ${prev} in
            '--server')
              ;;
            '-p'|'--port')
              ;;
            '--ssl')
              ;;
            '--log')
              ;;
            '--json-trace')
              ;;
            '--pull-server')
              ;;
            '--pull-port')
              ;;
            '--pull-ssl')
              ;;
            '--arcanum-url')
              ;;
            '-r'|'--repository')
              ;;
            '-b'|'--branch')
              ;;
            '-m'|'--mount')
              ;;
            '-S'|'--store')
              ;;
            '-o')
              ;;
            '--vfs-version')
              ;;
            '--inode-cache-size')
              ;;
            '--overlay-rocks-block-cache-size')
              ;;
            '--fuse-threads')
              ;;
            '--fuse-timeout')
              ;;
            '--object-store')
              ;;
            '--path-filter')
              ;;
            '-C'|'--cache-size')
              ;;
            '--fetch-trees')
              ;;
            '--monitoring-port')
              ;;
            '--disable-mount-manager')
              ;;
            *)
              args=0
              opts='@(--server|-p|--port|--ssl|--log|--json-trace|--pull-server|--pull-port|--pull-ssl|--arcanum-url|-r|--repository|-b|--branch|-m|--mount|-S|--store|-o|--vfs-version|--inode-cache-size|--overlay-rocks-block-cache-size|--fuse-threads|--fuse-timeout|--object-store|--path-filter|-C|--cache-size|--fetch-trees|--monitoring-port|--disable-mount-manager)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'unmount'|'umount')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --forget -l --list' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'sync'|'wave-stash')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W 'start follow stop status update' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'start'|'begin')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -u --include-untracked --wave-branch -f --foreground --force-wave -n --interval -r --remote-follow --force-follow' -- ${cur}) )
              else
                case ${prev} in
                  '--wave-branch')
                    ;;
                  '-n'|'--interval')
                    ;;
                  '-r'|'--remote-follow')
                    ;;
                  *)
                    args=0
                    opts='@(--wave-branch|-n|--interval|-r|--remote-follow)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'follow')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -n --interval -f --foreground --force --wait-wave -r --remote' -- ${cur}) )
              else
                case ${prev} in
                  '-n'|'--interval')
                    ;;
                  '--wait-wave')
                    ;;
                  '-r'|'--remote')
                    ;;
                  *)
                    args=0
                    opts='@(-n|--interval|--wait-wave|-r|--remote)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'stop'|'finish')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -f --force --no-wait -r --remote' -- ${cur}) )
              else
                case ${prev} in
                  '-r'|'--remote')
                    ;;
                  *)
                    args=0
                    opts='@(-r|--remote)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'status'|'st')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --json -r --remote' -- ${cur}) )
              else
                case ${prev} in
                  '-r'|'--remote')
                    ;;
                  *)
                    args=0
                    opts='@(-r|--remote)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'update'|'up')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -r --wait-remote' -- ${cur}) )
              else
                case ${prev} in
                  '-r'|'--wait-remote')
                    ;;
                  *)
                    args=0
                    opts='@(-r|--wait-remote)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'init')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -s --server -p --port --ssl -r --repository --bare --object-store' -- ${cur}) )
        else
          case ${prev} in
            '-s'|'--server')
              ;;
            '-p'|'--port')
              ;;
            '--ssl')
              ;;
            '-r'|'--repository')
              ;;
            '--object-store')
              ;;
            *)
              args=0
              opts='@(-s|--server|-p|--port|--ssl|-r|--repository|--object-store)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'add')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -A --all -n --dry-run -f --force -p --patch -u --update -v --verbose --ignore-removal --chmod' -- ${cur}) )
        else
          case ${prev} in
            '--chmod')
              ;;
            *)
              args=0
              opts='@(--chmod)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'clean')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet -n --dry-run -d -x -X' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'cp')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -f --force -r --cached' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
                1)
                  ;;
                2)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'encrypt')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'mergetool')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -t --tool --tool-help -y --no-prompt' -- ${cur}) )
        else
          case ${prev} in
            '-t'|'--tool')
              ;;
            *)
              args=0
              opts='@(-t|--tool)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'mv')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -f --force -k --cached' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'reset')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --hard --mixed -q --quiet --soft -f --force' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  IFS=$'\n'
                  COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
                  IFS=$' \t\n'
                  IFS=$'\n'
                  items=( $(${words[@]} ---CUSTOM-COMPLETION--- RemoteBranch "${cword}" "" "" 2> /dev/null) )
                  candidates=$(compgen -W "${items[*]:1}" -- "$cur")
                  COMPREPLY+=( $candidates )
                  [[ $candidates == *"${items[1]}" ]] && need_space=""
                  IFS=$' \t\n'
                  ;;
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'rm')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -n --dry-run -q --quiet --cached -r -f --force --ignore-unmatch' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'stash')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W ' apply branch clear drop list pop push show' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'apply')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet --index' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'branch')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                      1)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'clear')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      *)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'drop')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'list')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision --json -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      *)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'pop')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet --index' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'push')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet -k --keep-index -u --include-untracked -a --all -m --message --no-cleanup' -- ${cur}) )
              else
                case ${prev} in
                  '-m'|'--message')
                    ;;
                  *)
                    args=0
                    opts='@(-m|--message)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'show')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -U --unified --name-only --name-status --svn --git --json' -- ${cur}) )
              else
                case ${prev} in
                  '-U'|'--unified')
                    ;;
                  *)
                    args=0
                    opts='@(-U|--unified)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'copy-info'|'history')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W 'set remove' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'set')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                      1)
                        ;;
                      2)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'remove')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'blame')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -r --revisions -s --json -w' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
                1)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'praise')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -r --revisions -s --json -w' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
                1)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'describe')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --all --long --first-parent --exact-match --match --exclude --always --dirty --candidates --svn' -- ${cur}) )
        else
          case ${prev} in
            '--match')
              ;;
            '--exclude')
              ;;
            '--dirty')
              ;;
            '--candidates')
              ;;
            *)
              args=0
              opts='@(--match|--exclude|--dirty|--candidates)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'diff')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -U --unified --cached --staged --name-only --name-status --resolve-moves --svn --git --stat --json -R --reverse' -- ${cur}) )
        else
          case ${prev} in
            '-U'|'--unified')
              ;;
            '--resolve-moves')
              ;;
            *)
              args=0
              opts='@(-U|--unified|--resolve-moves)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'difftool')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -t --tool --tool-help -y --no-prompt' -- ${cur}) )
        else
          case ${prev} in
            '-t'|'--tool')
              ;;
            *)
              args=0
              opts='@(-t|--tool)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'ls-files')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -c --cached -d --deleted -m --modified -o --others' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'log')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -n --max-count --oneline --json --no-walk --stat --author --grep --graph --no-decorate -S --search --after --before --name-only --name-status -p --patch -U --unified --resolve-moves --attrs --format --pretty' -- ${cur}) )
        else
          case ${prev} in
            '-n'|'--max-count')
              ;;
            '--author')
              ;;
            '--grep')
              ;;
            '-S'|'--search')
              ;;
            '--after')
              ;;
            '--before')
              ;;
            '-U'|'--unified')
              ;;
            '--format')
              ;;
            '--pretty')
              ;;
            *)
              args=0
              opts='@(-n|--max-count|--author|--grep|-S|--search|--after|--before|-U|--unified|--format|--pretty)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'reflog')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W ' show expire delete exists' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'show')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -n --max-count --stat --author --grep --no-decorate --after --before' -- ${cur}) )
              else
                case ${prev} in
                  '-n'|'--max-count')
                    ;;
                  '--author')
                    ;;
                  '--grep')
                    ;;
                  '--after')
                    ;;
                  '--before')
                    ;;
                  *)
                    args=0
                    opts='@(-n|--max-count|--author|--grep|--after|--before)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'expire')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --expire --updateref --rewrite -n --dry-run -v --verbose' -- ${cur}) )
              else
                case ${prev} in
                  '--expire')
                    ;;
                  *)
                    args=0
                    opts='@(--expire)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      *)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'delete')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --updateref --rewrite -n --dry-run -v --verbose' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      *)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'exists')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'merge-base')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet --leftmost --force-local --json' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
                1)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'root')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --from-cwd' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
              esac
              ;;
          esac
        fi
        ;;
      'show')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet -U --unified --name-only --name-status --oneline --no-decorate --resolve-moves --svn --git --stat --json --attrs' -- ${cur}) )
        else
          case ${prev} in
            '-U'|'--unified')
              ;;
            '--resolve-moves')
              ;;
            *)
              args=0
              opts='@(-U|--unified|--resolve-moves)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'status'|'st')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -b --branch -s --short --json -u --ignored --no-ahead-behind --no-sync-status' -- ${cur}) )
        else
          case ${prev} in
            '-u')
              ;;
            *)
              args=0
              opts='@(-u)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'branch'|'br')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -v --verbose -q --quiet -u --set-upstream-to --unset-upstream -a --all -m --move -M -d --delete -D -l --list -f --force --merged --points-at --json --desc' -- ${cur}) )
        else
          case ${prev} in
            '-u'|'--set-upstream-to')
              IFS=$'\n'
              items=( $(${words[@]} ---CUSTOM-COMPLETION--- RemoteBranch "${cword}" "" "" 2> /dev/null) )
              candidates=$(compgen -W "${items[*]:1}" -- "$cur")
              COMPREPLY+=( $candidates )
              [[ $candidates == *"${items[1]}" ]] && need_space=""
              IFS=$' \t\n'
              ;;
            '--merged')
              ;;
            '--points-at')
              ;;
            '--desc')
              ;;
            *)
              args=0
              opts='@(-u|--set-upstream-to|--merged|--points-at|--desc)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  IFS=$'\n'
                  COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
                  IFS=$' \t\n'
                  ;;
                1)
                  IFS=$'\n'
                  COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
                  IFS=$' \t\n'
                  IFS=$'\n'
                  items=( $(${words[@]} ---CUSTOM-COMPLETION--- RemoteBranch "${cword}" "" "" 2> /dev/null) )
                  candidates=$(compgen -W "${items[*]:1}" -- "$cur")
                  COMPREPLY+=( $candidates )
                  [[ $candidates == *"${items[1]}" ]] && need_space=""
                  IFS=$' \t\n'
                  ;;
                *)
                  IFS=$'\n'
                  COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
                  IFS=$' \t\n'
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'checkout'|'co')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -b -f --force -q --quiet --no-track' -- ${cur}) )
        else
          case ${prev} in
            '-b')
              ;;
            *)
              args=0
              opts='@(-b)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  IFS=$'\n'
                  COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
                  IFS=$' \t\n'
                  IFS=$'\n'
                  items=( $(${words[@]} ---CUSTOM-COMPLETION--- RemoteBranch "${cword}" "" "" 2> /dev/null) )
                  candidates=$(compgen -W "${items[*]:1}" -- "$cur")
                  COMPREPLY+=( $candidates )
                  [[ $candidates == *"${items[1]}" ]] && need_space=""
                  IFS=$' \t\n'
                  ;;
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'cherry-pick')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet -e --edit -m --mainline -X -x --allow-empty-message --abort --continue --skip --allow-empty -f --force' -- ${cur}) )
        else
          case ${prev} in
            '-m'|'--mainline')
              ;;
            '-X')
              ;;
            *)
              args=0
              opts='@(-m|--mainline|-X)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'commit'|'ci')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -F --file -m --message --squash --fixup -a --all --dry-run --allow-empty-message -e --edit --amend --no-edit -n --no-verify --skip-hook -f --force --reset-author' -- ${cur}) )
        else
          case ${prev} in
            '-F'|'--file')
              ;;
            '-m'|'--message')
              ;;
            '--squash')
              ;;
            '--fixup')
              ;;
            '--skip-hook')
              ;;
            *)
              args=0
              opts='@(-F|--file|-m|--message|--squash|--fixup|--skip-hook)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'rebase')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet -X --onto --abort --continue --skip --sequence-path -i --interactive --autosquash --empty -f --force' -- ${cur}) )
        else
          case ${prev} in
            '-X')
              ;;
            '--onto')
              IFS=$'\n'
              COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
              IFS=$' \t\n'
              IFS=$'\n'
              items=( $(${words[@]} ---CUSTOM-COMPLETION--- RemoteBranch "${cword}" "" "" 2> /dev/null) )
              candidates=$(compgen -W "${items[*]:1}" -- "$cur")
              COMPREPLY+=( $candidates )
              [[ $candidates == *"${items[1]}" ]] && need_space=""
              IFS=$' \t\n'
              ;;
            '--sequence-path')
              ;;
            '--empty')
              ;;
            *)
              args=0
              opts='@(-X|--onto|--sequence-path|--empty)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  IFS=$'\n'
                  COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
                  IFS=$' \t\n'
                  IFS=$'\n'
                  items=( $(${words[@]} ---CUSTOM-COMPLETION--- RemoteBranch "${cword}" "" "" 2> /dev/null) )
                  candidates=$(compgen -W "${items[*]:1}" -- "$cur")
                  COMPREPLY+=( $candidates )
                  [[ $candidates == *"${items[1]}" ]] && need_space=""
                  IFS=$' \t\n'
                  ;;
                1)
                  IFS=$'\n'
                  COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
                  IFS=$' \t\n'
                  IFS=$'\n'
                  items=( $(${words[@]} ---CUSTOM-COMPLETION--- RemoteBranch "${cword}" "" "" 2> /dev/null) )
                  candidates=$(compgen -W "${items[*]:1}" -- "$cur")
                  COMPREPLY+=( $candidates )
                  [[ $candidates == *"${items[1]}" ]] && need_space=""
                  IFS=$' \t\n'
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'revert')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet --no-edit -e --edit -m --mainline -X --abort --continue --skip --allow-empty -f --force' -- ${cur}) )
        else
          case ${prev} in
            '-m'|'--mainline')
              ;;
            '-X')
              ;;
            *)
              args=0
              opts='@(-m|--mainline|-X)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'tag')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -l --list -d --delete --points-at' -- ${cur}) )
        else
          case ${prev} in
            '-d'|'--delete')
              ;;
            '--points-at')
              ;;
            *)
              args=0
              opts='@(-d|--delete|--points-at)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
                1)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'fetch')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --all --verbose' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'pr')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W 'checkout create discard list status view' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'checkout'|'co')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet -f --force -i --iteration -p --published' -- ${cur}) )
              else
                case ${prev} in
                  '-i'|'--iteration')
                    ;;
                  *)
                    args=0
                    opts='@(-i|--iteration)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'create'|'c')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet -F --file -m --message -e --edit --no-edit --no-commits --to -f --force --follow -A --auto -M --merge --publish -T --tests --shipit --push --keep-branch' -- ${cur}) )
              else
                case ${prev} in
                  '-F'|'--file')
                    ;;
                  '-m'|'--message')
                    ;;
                  '--to')
                    ;;
                  '--push')
                    ;;
                  *)
                    args=0
                    opts='@(-F|--file|-m|--message|--to|--push)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'discard')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --id' -- ${cur}) )
              else
                case ${prev} in
                  '--id')
                    ;;
                  *)
                    args=0
                    opts='@(--id)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'list')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -i --in -o --out --all -d --draft --no-draft -A --author -R --reviewer -S --status --owner --subscriber --ticket --label --shipper -l --limit --as --sort --asc --desc --json' -- ${cur}) )
              else
                case ${prev} in
                  '-A'|'--author')
                    ;;
                  '-R'|'--reviewer')
                    ;;
                  '-S'|'--status')
                    ;;
                  '--owner')
                    ;;
                  '--subscriber')
                    ;;
                  '--ticket')
                    ;;
                  '--label')
                    ;;
                  '--shipper')
                    ;;
                  '-l'|'--limit')
                    ;;
                  '--as')
                    ;;
                  '--sort')
                    ;;
                  *)
                    args=0
                    opts='@(-A|--author|-R|--reviewer|-S|--status|--owner|--subscriber|--ticket|--label|--shipper|-l|--limit|--as|--sort)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'status'|'st')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -b --branch -s --short --json --follow' -- ${cur}) )
              else
                case ${prev} in
                  '-b'|'--branch')
                    ;;
                  *)
                    args=0
                    opts='@(-b|--branch)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'view')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --id -b --branch' -- ${cur}) )
              else
                case ${prev} in
                  '--id')
                    ;;
                  '-b'|'--branch')
                    ;;
                  *)
                    args=0
                    opts='@(--id|-b|--branch)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'pull')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet --all -f --force --ff-only -r --rebase' -- ${cur}) )
        else
          case ${prev} in
            '-r'|'--rebase')
              ;;
            *)
              args=0
              opts='@(-r|--rebase)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  IFS=$'\n'
                  COMPREPLY+=( $(compgen -W "$(${words[@]} ---CUSTOM-COMPLETION--- LocalBranch "${cword}" "" "" 2> /dev/null)" -- ${cur}) )
                  IFS=$' \t\n'
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'push')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -q --quiet -d --delete -u --set-upstream --all -f --force' -- ${cur}) )
        else
          case ${prev} in
            '-d'|'--delete')
              ;;
            '-u'|'--set-upstream')
              ;;
            *)
              args=0
              opts='@(-d|--delete|-u|--set-upstream)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'fsck')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W 'objects overlay' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'objects')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      *)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'overlay')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision --log -v --verbose --no-progress --load-objects -n --dry-run -y --no-prompt' -- ${cur}) )
              else
                case ${prev} in
                  '--log')
                    ;;
                  *)
                    args=0
                    opts='@(--log)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'archive')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -o --output -l --list -v --verbose --format' -- ${cur}) )
        else
          case ${prev} in
            '-o'|'--output')
              ;;
            '--format')
              ;;
            *)
              args=0
              opts='@(-o|--output|--format)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'export')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -v --verbose --to' -- ${cur}) )
        else
          case ${prev} in
            '--to')
              ;;
            *)
              args=0
              opts='@(--to)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'gc')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -n --dry-run' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
              esac
              ;;
          esac
        fi
        ;;
      'config')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -l --list --unset --remove-section --name-only --file' -- ${cur}) )
        else
          case ${prev} in
            '--file')
              ;;
            *)
              args=0
              opts='@(--file)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
                1)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'dump')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W 'changelist changeset debug trees-diff entry has-changes merge-base object object-db pr pulld-pr rev-graph stage svn-rev vfs' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'changelist')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --print-flat --print-resolved --print-diff --print-json --print-zipatch --print-tree-aware --dump-zipatch --svn-mode --no-move-detect --trunk-svn-path --resolve-copy-while-merge' -- ${cur}) )
              else
                case ${prev} in
                  '--dump-zipatch')
                    ;;
                  '--trunk-svn-path')
                    ;;
                  *)
                    args=0
                    opts='@(--dump-zipatch|--trunk-svn-path)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                      1)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'changeset')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                      1)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'debug')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -b --bundle -c --changed -o --output --debug-commit --no-sample' -- ${cur}) )
              else
                case ${prev} in
                  '-o'|'--output')
                    ;;
                  *)
                    args=0
                    opts='@(-o|--output)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'trees-diff')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --path' -- ${cur}) )
              else
                case ${prev} in
                  '--path')
                    ;;
                  *)
                    args=0
                    opts='@(--path)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                      1)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'entry')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help -r --ref --cached' -- ${cur}) )
              else
                case ${prev} in
                  '-r'|'--ref')
                    ;;
                  *)
                    args=0
                    opts='@(-r|--ref)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'has-changes')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      *)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'merge-base')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision --force-local --leftmost --load-from-dump --compare-to -h --help' -- ${cur}) )
              else
                case ${prev} in
                  '--load-from-dump')
                    ;;
                  '--compare-to')
                    ;;
                  *)
                    args=0
                    opts='@(--load-from-dump|--compare-to)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                      1)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'object')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'object-db')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --info --to-disk-store --from-disk-store --object-stats --clean' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'pr')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'pulld-pr')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --id -b --branch' -- ${cur}) )
              else
                case ${prev} in
                  '--id')
                    ;;
                  '-b'|'--branch')
                    ;;
                  *)
                    args=0
                    opts='@(--id|-b|--branch)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'rev-graph')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --trunk-only -n --max-count --load-from --make-commit' -- ${cur}) )
              else
                case ${prev} in
                  '-n'|'--max-count')
                    ;;
                  '--load-from')
                    ;;
                  *)
                    args=0
                    opts='@(-n|--max-count|--load-from)'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'stage')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --json' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'svn-rev')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'vfs')
              if [[ ${cword} == 3 ]] ; then
                if [[ ${cur} == -* ]] ;  then
                  COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
                else
                  COMPREPLY+=( $(compgen -W 'overlay metrics inode' -- ${cur}) )
                fi
              else
                case "${words[3]}" in
                  'overlay')
                    if [[ ${cur} == -* ]] ;  then
                      COMPREPLY+=( $(compgen -W '--svnrevision -h --help -S --store --all --no-traverse-parents --no-dentries --no-xattrs -v --verbose' -- ${cur}) )
                    else
                      case ${prev} in
                        '-S'|'--store')
                          ;;
                        *)
                          args=0
                          opts='@(-S|--store)'
                          for (( i=4; i < cword; i++ )); do
                            if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                              (( args++ ))
                            fi
                          done

                          case ${args} in
                            *)
                              ;;
                          esac
                          ;;
                      esac
                    fi
                    ;;
                  'metrics')
                    if [[ ${cur} == -* ]] ;  then
                      COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
                    else
                      case ${prev} in
                        *)
                          args=0
                          opts='@()'
                          for (( i=4; i < cword; i++ )); do
                            if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                              (( args++ ))
                            fi
                          done

                          case ${args} in
                          esac
                          ;;
                      esac
                    fi
                    ;;
                  'inode')
                    if [[ ${cur} == -* ]] ;  then
                      COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
                    else
                      case ${prev} in
                        *)
                          args=0
                          opts='@()'
                          for (( i=4; i < cword; i++ )); do
                            if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                              (( args++ ))
                            fi
                          done

                          case ${args} in
                            *)
                              ;;
                          esac
                          ;;
                      esac
                    fi
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'gen-key')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
              esac
              ;;
          esac
        fi
        ;;
      'info')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --json' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
              esac
              ;;
          esac
        fi
        ;;
      'ls-tree')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help -d -r -t --name-only --full-name --json --traverse-blobrefs' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                0)
                  ;;
                1)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'rev-parse')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --sq --sq-quote --not --default --quiet --arc-dir --is-inside-arc-dir --is-inside-work-tree --is-bare-repository --is-local-repository --show-prefix --show-toplevel' -- ${cur}) )
        else
          case ${prev} in
            '--default')
              ;;
            *)
              args=0
              opts='@(--default)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'token')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W ' store show' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'store')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help --ask' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
            'show')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                    esac
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'internal')
        if [[ ${cword} == 2 ]] ; then
          if [[ ${cur} == -* ]] ;  then
            COMPREPLY+=( $(compgen -W '-h --help' -- ${cur}) )
          else
            COMPREPLY+=( $(compgen -W 'change-filter arcadia-rules' -- ${cur}) )
          fi
        else
          case "${words[2]}" in
            'change-filter')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      *)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
            'arcadia-rules')
              if [[ ${cur} == -* ]] ;  then
                COMPREPLY+=( $(compgen -W '--svnrevision -h --help' -- ${cur}) )
              else
                case ${prev} in
                  *)
                    args=0
                    opts='@()'
                    for (( i=3; i < cword; i++ )); do
                      if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                        (( args++ ))
                      fi
                    done

                    case ${args} in
                      0)
                        ;;
                    esac
                    ;;
                esac
              fi
              ;;
          esac
        fi
        ;;
      'prefetch-files')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --remote-branches --local-branches --commit --ignore-not-found --best-effort --quiet --rpc-timeout --no-blobs' -- ${cur}) )
        else
          case ${prev} in
            '--commit')
              ;;
            '--rpc-timeout')
              ;;
            *)
              args=0
              opts='@(--commit|--rpc-timeout)'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      'repair-command')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '-h --help --svnrevision' -- ${cur}) )
        fi
        ;;
      'list-commands')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '-h --help --svnrevision' -- ${cur}) )
        fi
        ;;
      'user-info')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '--svnrevision -h --help --update --json' -- ${cur}) )
        else
          case ${prev} in
            *)
              args=0
              opts='@()'
              for (( i=2; i < cword; i++ )); do
                if [[ ${words[i]} != -* && ${words[i-1]} != $opts ]]; then
                  (( args++ ))
                fi
              done

              case ${args} in
                *)
                  ;;
              esac
              ;;
          esac
        fi
        ;;
      '--update')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '-h --help --svnrevision' -- ${cur}) )
        fi
        ;;
      '--has-update')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '-h --help --svnrevision' -- ${cur}) )
        fi
        ;;
      '--set-channel')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '-h --help --svnrevision' -- ${cur}) )
        fi
        ;;
      '--is-launcher')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '-h --help --svnrevision' -- ${cur}) )
        fi
        ;;
      '--remove-unused-versions')
        if [[ ${cur} == -* ]] ;  then
          COMPREPLY+=( $(compgen -W '-h --help --svnrevision' -- ${cur}) )
        fi
        ;;
    esac
  fi


  __ltrim_colon_completions "$cur"

  IFS=$'\n'
  if [ ${#COMPREPLY[@]} -ne 0 ]; then
    if [[ -z $need_space ]]; then
      COMPREPLY=( $(printf "%q\n" "${COMPREPLY[@]}") )
    else
      COMPREPLY=( $(printf "%q \n" "${COMPREPLY[@]}") )
    fi
  fi

  return 0
}

complete -o nospace -o default -F _arc arc