From 5db6bbeec9c4e0505e2f4fa383d2ea6cbf8fa025 Mon Sep 17 00:00:00 2001
From: TuDatTr <tran.tuan-dat@mailbox.org>
Date: Fri, 22 May 2020 03:01:50 +0200
Subject: [PATCH] Finished cleanup

---
 .gitmodules                            |    6 -
 README.md                              |   18 +-
 README.org                             |  100 --
 config/.Xdefaults                      |   39 +
 config/.Xresources                     |   36 -
 config/.config/ranger/commands.py      |   48 -
 config/.config/ranger/commands_full.py | 1741 ------------------------
 config/.config/ranger/scope.sh         |  216 ---
 config/.gtk-bookmarks                  |    1 -
 config/.gtkrc-2.0                      |   18 -
 config/.local/share/ranger/bookmarks   |    2 +-
 config/.scripts/i3lock.py              |    2 +-
 config/.scripts/spotify-play.cpp       |   93 --
 config/.scripts/spotify-play.out       |  Bin 39648 -> 0 bytes
 config/.scripts/spotify-play.py        |   47 -
 vim/.vim/.VimballRecord                |    1 -
 vim/.vim/spell/de.utf-8.add            | 1600 +++++++++++-----------
 vim/.vim/templates/writeup.md          |   12 -
 18 files changed, 852 insertions(+), 3128 deletions(-)
 delete mode 100644 .gitmodules
 delete mode 100644 README.org
 delete mode 100644 config/.Xresources
 delete mode 100644 config/.config/ranger/commands.py
 delete mode 100644 config/.config/ranger/commands_full.py
 delete mode 100755 config/.config/ranger/scope.sh
 delete mode 100644 config/.gtk-bookmarks
 delete mode 100644 config/.gtkrc-2.0
 delete mode 100644 config/.scripts/spotify-play.cpp
 delete mode 100755 config/.scripts/spotify-play.out
 delete mode 100755 config/.scripts/spotify-play.py
 delete mode 100644 vim/.vim/.VimballRecord
 delete mode 100644 vim/.vim/templates/writeup.md

diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index c6c44e3..0000000
--- a/.gitmodules
+++ /dev/null
@@ -1,6 +0,0 @@
-[submodule "vim/.vim/pack/plugins/start/vim-go"]
-	path = vim/.vim/pack/plugins/start/vim-go
-	url = https://github.com/fatih/vim-go/
-[submodule "vim/.vim/plugin/vim/.vim/plugged/vim-polyglot"]
-	path = vim/.vim/plugin/vim/.vim/plugged/vim-polyglot
-	url = https://github.com/sheerun/vim-polyglot
diff --git a/README.md b/README.md
index f541adb..73af8af 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,21 @@ Main tools I am currently using are:
 
 ## Getting started
 
-Todo (along with cleanup)
+To make full use of the dotfiles we need to install the following packages via pacman:
+
+`pacman -Syu zsh gvim byobu conky firefox rxvt-unicode dunst highlight i3-gaps neofetch ranger rofi`
+
+And the following packages from the AUR:
+`yay -S cava polybar`
+
+### zsh setup
+
+```sh
+chsh -s /bin/zsh
+sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"
+cp -r /usr/share/zsh-theme-powerlevel9k $HOME/.oh-my-zsh/themes/powerlevel9k
+rm -rf $HOME/.*bash* # optional, but removes all bash related stuff from the home directory
+```
 
 ### Font setup
 
@@ -42,4 +56,4 @@ stow config
 
 ## License
 
-This project is license under the GPL-3.0 License - see LICENSE file for details.
+This project is licensed under the GPL-3.0 License - see LICENSE file for details.
diff --git a/README.org b/README.org
deleted file mode 100644
index 21026d6..0000000
--- a/README.org
+++ /dev/null
@@ -1,100 +0,0 @@
-* dotfiles ┐【￣～￣】┌
-These are my personal dotfiles.
-I'm using:
- - [[https://www.gnu.org/software/emacs/][GNU Emacs]]
- - [[https://www.gnu.org/software/stow][GNU stow]]
- - [[https://github.com/Airblader/i3][i3-gaps]]
- - [[https://github.com/jaagr/polybar][Polybar]]
- - [[https://github.com/nana-4/materia-theme][Materia Theme]]
- - [[http://zsh.sourceforge.net][zsh]]
-
-** TODOS:
-
- 1) Making an own [[https://github.com/brndnmtthws/conky/wiki/Configuraion-Settings][conky]], conky_maia-like
-
-** Getting Started
-*** Prerequisites
-**** Pacman Install
-***** System
-      - lightdm
-****** Terminal 
-       - zsh
-       - termite
-***** Essentials
-      - nyancat
-      - stow
-      - git
-      - python-pip
-      - xsel
-      - rofi
-***** Lifestyle
-      - emacs
-      - texlive-most
-      - evince
-      - scrot
-      - aspell-en
-***** Pretty stuff (i.e. ricing, pretty cli-apps)
-      - cmus
-      - lxappearance
-      - conky
-      - arc-icon-theme
-****** oh-my-zsh
-       - powerline-fonts
-       - awesome-terminal-fonts
-       - zsh-theme-powerlevel9k
-
-**** Yaourt Install
-***** System
-      - lightdm-mini-greeter
-      - i3-gaps (Moved into the official Arch community repo)
-      - i3lock-color
-***** Essentials
-      - polybar
-***** Pretty stuff (i.e. ricing, pretty cli-apps)
-      - cava
-      - materia-theme
-      - neofetch
-*** Setting up zsh
-#+BEGIN_SRC sh
-chsh -s /bin/zsh
-sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"  # Downloading/Installing oh-my-zsh
-cp -r /usr/share/zsh-theme-powerlevel9k ~/.oh-my-zsh/themes/powerlevel9k  # copying powerlevel9k-theme to the desired directory
-rm -rf ~/.*bash* # remove bash related files from your home directory.. don't do it if you wanna keep using bash with this user
-#+END_SRC
-
-*** Setting up Emacs
-I tried to make this as easy as possible. All packages should be installed automatically.
-Config file is =.emacs.d/config.org=
-*** Font setup
-Stolen from [[https://github.com/powerline/fonts][here]].
-#+BEGIN_SRC sh
-git clone https://github.com/powerline/fonts.git --depth=1
-# install
-cd fonts
-./install.sh
-# clean-up a bit
-cd ..
-rm -rf fonts
-#+END_SRC
-
-*** "Installing" the dotfiles.
-Take a look at already existing files and delete them if necessary.
-#+BEGIN_SRC sh
-git clone https://github.com/TuDatTr/dotfiles .dotfiles && cd .dotfiles
-stow emacs
-stow zsh
-stow config
-sudo ln -s ~/.scripts/pipes.sh /usr/local/bin/pipes
-#+END_SRC
-
-
-* Author
- - Tuan-Dat Tran - [[https://github.com/tudattr/][TuDatTr]]
-
-* License
-This project is license under the GPL-3.0 License - see LICENSE file for details.
-
-* Acknowledgements
- - [[https://www.reddit.com/r/unixporn/][unixporn - the home for *NIX customisation!]]
- - [[https://uigradients.com][uiGradients - Beautiful colored gradients]]
- - [[http://terminal.sexy/][terminal.sexy - Terminal Color Scheme Designer]]
diff --git a/config/.Xdefaults b/config/.Xdefaults
index 3e8c914..67c25be 100644
--- a/config/.Xdefaults
+++ b/config/.Xdefaults
@@ -24,3 +24,42 @@ urxvt*blurRadius: 15
 ! Xft
 Xft.dpi: 92
 Xft.antialias: 1
+
+! Color
+*.foreground:   #98abb2
+*.background:   #181b28
+*.cursorColor:  #ffffff
+
+! black
+*.color0:       #161925
+*.color8:       #0c0e14
+
+! red
+*.color1:       #e84f4f
+*.color9:       #d23d3d
+
+! green
+*.color2:       #00ffaf
+*.color10:      #237885
+
+! yellow
+*.color3:       #ffbb24
+*.color11:      #f8ec09
+
+! blue
+*.color4:       #007fff
+*.color12:      #00c4ff
+
+! magenta
+*.color5:       #8c00fd
+*.color13:      #cd00df
+
+! cyan
+*.color6:       #00e8b7
+*.color14:      #00d3a7
+
+! white
+*.color7:       #98abb2
+*.color15:      #c0bfbc
+
+
diff --git a/config/.Xresources b/config/.Xresources
deleted file mode 100644
index 8634f9f..0000000
--- a/config/.Xresources
+++ /dev/null
@@ -1,36 +0,0 @@
-! Color
-*.foreground:   #98abb2
-*.background:   #181b28
-*.cursorColor:  #ffffff
-
-! black
-*.color0:       #161925
-*.color8:       #0c0e14
-
-! red
-*.color1:       #e84f4f
-*.color9:       #d23d3d
-
-! green
-*.color2:       #00ffaf
-*.color10:      #237885
-
-! yellow
-*.color3:       #ffbb24
-*.color11:      #f8ec09
-
-! blue
-*.color4:       #007fff
-*.color12:      #00c4ff
-
-! magenta
-*.color5:       #8c00fd
-*.color13:      #cd00df
-
-! cyan
-*.color6:       #00e8b7
-*.color14:      #00d3a7
-
-! white
-*.color7:       #98abb2
-*.color15:      #c0bfbc
diff --git a/config/.config/ranger/commands.py b/config/.config/ranger/commands.py
deleted file mode 100644
index eac4567..0000000
--- a/config/.config/ranger/commands.py
+++ /dev/null
@@ -1,48 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-
-import os
-
-from ranger.api.commands import Command
-
-class my_edit(Command):
-    # The so-called doc-string of the class will be visible in the built-in
-    # help that is accessible by typing "?c" inside ranger.
-    """:my_edit <filename>
-
-    A sample command for demonstration purposes that opens a file in an editor.
-    """
-
-    # The execute method is called when you run this command in ranger.
-    def execute(self):
-        # self.arg(1) is the first (space-separated) argument to the function.
-        # This way you can write ":my_edit somefilename<ENTER>".
-        if self.arg(1):
-            # self.rest(1) contains self.arg(1) and everything that follows
-            target_filename = self.rest(1)
-        else:
-            # self.fm is a ranger.core.filemanager.FileManager object and gives
-            # you access to internals of ranger.
-            # self.fm.thisfile is a ranger.container.file.File object and is a
-            # reference to the currently selected file.
-            target_filename = self.fm.thisfile.path
-
-        # This is a generic function to print text in ranger.
-        self.fm.notify("Let's edit the file " + target_filename + "!")
-
-        # Using bad=True in fm.notify allows you to print error messages:
-        if not os.path.exists(target_filename):
-            self.fm.notify("The given file does not exist!", bad=True)
-            return
-
-        # This executes a function from ranger.core.acitons, a module with a
-        # variety of subroutines that can help you construct commands.
-        # Check out the source, or run "pydoc ranger.core.actions" for a list.
-        self.fm.edit_file(target_filename)
-
-    # The tab method is called when you press tab, and should return a list of
-    # suggestions that the user will tab through.
-    # tabnum is 1 for <TAB> and -1 for <S-TAB> by default
-    def tab(self, tabnum):
-        # This is a generic tab-completion function that iterates through the
-        # content of the current directory.
-        return self._tab_directory_content()
diff --git a/config/.config/ranger/commands_full.py b/config/.config/ranger/commands_full.py
deleted file mode 100644
index f67be14..0000000
--- a/config/.config/ranger/commands_full.py
+++ /dev/null
@@ -1,1741 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-
-from collections import deque
-import os
-import re
-
-from ranger.api.commands import Command
-
-
-class alias(Command):
-    """:alias <newcommand> <oldcommand>
-
-    Copies the oldcommand as newcommand.
-    """
-
-    context = 'browser'
-    resolve_macros = False
-
-    def execute(self):
-        if not self.arg(1) or not self.arg(2):
-            self.fm.notify('Syntax: alias <newcommand> <oldcommand>', bad=True)
-            return
-
-        self.fm.commands.alias(self.arg(1), self.rest(2))
-
-
-class echo(Command):
-    """:echo <text>
-
-    Display the text in the statusbar.
-    """
-
-    def execute(self):
-        self.fm.notify(self.rest(1))
-
-
-class cd(Command):
-    """:cd [-r] <path>
-
-    The cd command changes the directory.
-    If the path is a file, selects that file.
-    The command 'cd -' is equivalent to typing ``.
-    Using the option "-r" will get you to the real path.
-    """
-
-    def execute(self):
-        if self.arg(1) == '-r':
-            self.shift()
-            destination = os.path.realpath(self.rest(1))
-            if os.path.isfile(destination):
-                self.fm.select_file(destination)
-                return
-        else:
-            destination = self.rest(1)
-
-        if not destination:
-            destination = '~'
-
-        if destination == '-':
-            self.fm.enter_bookmark('`')
-        else:
-            self.fm.cd(destination)
-
-    def _tab_args(self):
-        # dest must be rest because path could contain spaces
-        if self.arg(1) == '-r':
-            start = self.start(2)
-            dest = self.rest(2)
-        else:
-            start = self.start(1)
-            dest = self.rest(1)
-
-        if dest:
-            head, tail = os.path.split(os.path.expanduser(dest))
-            if head:
-                dest_exp = os.path.join(os.path.normpath(head), tail)
-            else:
-                dest_exp = tail
-        else:
-            dest_exp = ''
-        return (start, dest_exp, os.path.join(self.fm.thisdir.path, dest_exp),
-                dest.endswith(os.path.sep))
-
-    @staticmethod
-    def _tab_paths(dest, dest_abs, ends_with_sep):
-        if not dest:
-            try:
-                return next(os.walk(dest_abs))[1], dest_abs
-            except (OSError, StopIteration):
-                return [], ''
-
-        if ends_with_sep:
-            try:
-                return [os.path.join(dest, path) for path in next(os.walk(dest_abs))[1]], ''
-            except (OSError, StopIteration):
-                return [], ''
-
-        return None, None
-
-    def _tab_match(self, path_user, path_file):
-        if self.fm.settings.cd_tab_case == 'insensitive':
-            path_user = path_user.lower()
-            path_file = path_file.lower()
-        elif self.fm.settings.cd_tab_case == 'smart' and path_user.islower():
-            path_file = path_file.lower()
-        return path_file.startswith(path_user)
-
-    def _tab_normal(self, dest, dest_abs):
-        dest_dir = os.path.dirname(dest)
-        dest_base = os.path.basename(dest)
-
-        try:
-            dirnames = next(os.walk(os.path.dirname(dest_abs)))[1]
-        except (OSError, StopIteration):
-            return [], ''
-
-        return [os.path.join(dest_dir, d) for d in dirnames if self._tab_match(dest_base, d)], ''
-
-    def _tab_fuzzy_match(self, basepath, tokens):
-        """ Find directories matching tokens recursively """
-        if not tokens:
-            tokens = ['']
-        paths = [basepath]
-        while True:
-            token = tokens.pop()
-            matches = []
-            for path in paths:
-                try:
-                    directories = next(os.walk(path))[1]
-                except (OSError, StopIteration):
-                    continue
-                matches += [os.path.join(path, d) for d in directories
-                            if self._tab_match(token, d)]
-            if not tokens or not matches:
-                return matches
-            paths = matches
-
-        return None
-
-    def _tab_fuzzy(self, dest, dest_abs):
-        tokens = []
-        basepath = dest_abs
-        while True:
-            basepath_old = basepath
-            basepath, token = os.path.split(basepath)
-            if basepath == basepath_old:
-                break
-            if os.path.isdir(basepath_old) and not token.startswith('.'):
-                basepath = basepath_old
-                break
-            tokens.append(token)
-
-        paths = self._tab_fuzzy_match(basepath, tokens)
-        if not os.path.isabs(dest):
-            paths_rel = basepath
-            paths = [os.path.relpath(path, paths_rel) for path in paths]
-        else:
-            paths_rel = ''
-        return paths, paths_rel
-
-    def tab(self, tabnum):
-        from os.path import sep
-
-        start, dest, dest_abs, ends_with_sep = self._tab_args()
-
-        paths, paths_rel = self._tab_paths(dest, dest_abs, ends_with_sep)
-        if paths is None:
-            if self.fm.settings.cd_tab_fuzzy:
-                paths, paths_rel = self._tab_fuzzy(dest, dest_abs)
-            else:
-                paths, paths_rel = self._tab_normal(dest, dest_abs)
-
-        paths.sort()
-
-        if self.fm.settings.cd_bookmarks:
-            paths[0:0] = [
-                os.path.relpath(v.path, paths_rel) if paths_rel else v.path
-                for v in self.fm.bookmarks.dct.values() for path in paths
-                if v.path.startswith(os.path.join(paths_rel, path) + sep)
-            ]
-
-        if not paths:
-            return None
-        if len(paths) == 1:
-            return start + paths[0] + sep
-        return [start + dirname for dirname in paths]
-
-
-class chain(Command):
-    """:chain <command1>; <command2>; ...
-
-    Calls multiple commands at once, separated by semicolons.
-    """
-
-    def execute(self):
-        if not self.rest(1).strip():
-            self.fm.notify('Syntax: chain <command1>; <command2>; ...', bad=True)
-            return
-        for command in [s.strip() for s in self.rest(1).split(";")]:
-            self.fm.execute_console(command)
-
-
-class shell(Command):
-    escape_macros_for_shell = True
-
-    def execute(self):
-        if self.arg(1) and self.arg(1)[0] == '-':
-            flags = self.arg(1)[1:]
-            command = self.rest(2)
-        else:
-            flags = ''
-            command = self.rest(1)
-
-        if command:
-            self.fm.execute_command(command, flags=flags)
-
-    def tab(self, tabnum):
-        from ranger.ext.get_executables import get_executables
-        if self.arg(1) and self.arg(1)[0] == '-':
-            command = self.rest(2)
-        else:
-            command = self.rest(1)
-        start = self.line[0:len(self.line) - len(command)]
-
-        try:
-            position_of_last_space = command.rindex(" ")
-        except ValueError:
-            return (start + program + ' ' for program
-                    in get_executables() if program.startswith(command))
-        if position_of_last_space == len(command) - 1:
-            selection = self.fm.thistab.get_selection()
-            if len(selection) == 1:
-                return self.line + selection[0].shell_escaped_basename + ' '
-            return self.line + '%s '
-
-        before_word, start_of_word = self.line.rsplit(' ', 1)
-        return (before_word + ' ' + file.shell_escaped_basename
-                for file in self.fm.thisdir.files or []
-                if file.shell_escaped_basename.startswith(start_of_word))
-
-
-class open_with(Command):
-
-    def execute(self):
-        app, flags, mode = self._get_app_flags_mode(self.rest(1))
-        self.fm.execute_file(
-            files=[f for f in self.fm.thistab.get_selection()],
-            app=app,
-            flags=flags,
-            mode=mode)
-
-    def tab(self, tabnum):
-        return self._tab_through_executables()
-
-    def _get_app_flags_mode(self, string):  # pylint: disable=too-many-branches,too-many-statements
-        """Extracts the application, flags and mode from a string.
-
-        examples:
-        "mplayer f 1" => ("mplayer", "f", 1)
-        "atool 4" => ("atool", "", 4)
-        "p" => ("", "p", 0)
-        "" => None
-        """
-
-        app = ''
-        flags = ''
-        mode = 0
-        split = string.split()
-
-        if len(split) == 1:
-            part = split[0]
-            if self._is_app(part):
-                app = part
-            elif self._is_flags(part):
-                flags = part
-            elif self._is_mode(part):
-                mode = part
-
-        elif len(split) == 2:
-            part0 = split[0]
-            part1 = split[1]
-
-            if self._is_app(part0):
-                app = part0
-                if self._is_flags(part1):
-                    flags = part1
-                elif self._is_mode(part1):
-                    mode = part1
-            elif self._is_flags(part0):
-                flags = part0
-                if self._is_mode(part1):
-                    mode = part1
-            elif self._is_mode(part0):
-                mode = part0
-                if self._is_flags(part1):
-                    flags = part1
-
-        elif len(split) >= 3:
-            part0 = split[0]
-            part1 = split[1]
-            part2 = split[2]
-
-            if self._is_app(part0):
-                app = part0
-                if self._is_flags(part1):
-                    flags = part1
-                    if self._is_mode(part2):
-                        mode = part2
-                elif self._is_mode(part1):
-                    mode = part1
-                    if self._is_flags(part2):
-                        flags = part2
-            elif self._is_flags(part0):
-                flags = part0
-                if self._is_mode(part1):
-                    mode = part1
-            elif self._is_mode(part0):
-                mode = part0
-                if self._is_flags(part1):
-                    flags = part1
-
-        return app, flags, int(mode)
-
-    def _is_app(self, arg):
-        return not self._is_flags(arg) and not arg.isdigit()
-
-    @staticmethod
-    def _is_flags(arg):
-        from ranger.core.runner import ALLOWED_FLAGS
-        return all(x in ALLOWED_FLAGS for x in arg)
-
-    @staticmethod
-    def _is_mode(arg):
-        return all(x in '0123456789' for x in arg)
-
-
-class set_(Command):
-    """:set <option name>=<python expression>
-
-    Gives an option a new value.
-
-    Use `:set <option>!` to toggle or cycle it, e.g. `:set flush_input!`
-    """
-    name = 'set'  # don't override the builtin set class
-
-    def execute(self):
-        name = self.arg(1)
-        name, value, _, toggle = self.parse_setting_line_v2()
-        if toggle:
-            self.fm.toggle_option(name)
-        else:
-            self.fm.set_option_from_string(name, value)
-
-    def tab(self, tabnum):  # pylint: disable=too-many-return-statements
-        from ranger.gui.colorscheme import get_all_colorschemes
-        name, value, name_done = self.parse_setting_line()
-        settings = self.fm.settings
-        if not name:
-            return sorted(self.firstpart + setting for setting in settings)
-        if not value and not name_done:
-            return sorted(self.firstpart + setting for setting in settings
-                          if setting.startswith(name))
-        if not value:
-            value_completers = {
-                "colorscheme":
-                # Cycle through colorschemes when name, but no value is specified
-                lambda: sorted(self.firstpart + colorscheme for colorscheme
-                               in get_all_colorschemes(self.fm)),
-
-                "column_ratios":
-                lambda: self.firstpart + ",".join(map(str, settings[name])),
-            }
-
-            def default_value_completer():
-                return self.firstpart + str(settings[name])
-
-            return value_completers.get(name, default_value_completer)()
-        if bool in settings.types_of(name):
-            if 'true'.startswith(value.lower()):
-                return self.firstpart + 'True'
-            if 'false'.startswith(value.lower()):
-                return self.firstpart + 'False'
-        # Tab complete colorscheme values if incomplete value is present
-        if name == "colorscheme":
-            return sorted(self.firstpart + colorscheme for colorscheme
-                          in get_all_colorschemes(self.fm) if colorscheme.startswith(value))
-        return None
-
-
-class setlocal(set_):
-    """:setlocal path=<regular expression> <option name>=<python expression>
-
-    Gives an option a new value.
-    """
-    PATH_RE_DQUOTED = re.compile(r'^setlocal\s+path="(.*?)"')
-    PATH_RE_SQUOTED = re.compile(r"^setlocal\s+path='(.*?)'")
-    PATH_RE_UNQUOTED = re.compile(r'^path=(.*?)$')
-
-    def _re_shift(self, match):
-        if not match:
-            return None
-        path = os.path.expanduser(match.group(1))
-        for _ in range(len(path.split())):
-            self.shift()
-        return path
-
-    def execute(self):
-        path = self._re_shift(self.PATH_RE_DQUOTED.match(self.line))
-        if path is None:
-            path = self._re_shift(self.PATH_RE_SQUOTED.match(self.line))
-        if path is None:
-            path = self._re_shift(self.PATH_RE_UNQUOTED.match(self.arg(1)))
-        if path is None and self.fm.thisdir:
-            path = self.fm.thisdir.path
-        if not path:
-            return
-
-        name, value, _ = self.parse_setting_line()
-        self.fm.set_option_from_string(name, value, localpath=path)
-
-
-class setintag(set_):
-    """:setintag <tag or tags> <option name>=<option value>
-
-    Sets an option for directories that are tagged with a specific tag.
-    """
-
-    def execute(self):
-        tags = self.arg(1)
-        self.shift()
-        name, value, _ = self.parse_setting_line()
-        self.fm.set_option_from_string(name, value, tags=tags)
-
-
-class default_linemode(Command):
-
-    def execute(self):
-        from ranger.container.fsobject import FileSystemObject
-
-        if len(self.args) < 2:
-            self.fm.notify(
-                "Usage: default_linemode [path=<regexp> | tag=<tag(s)>] <linemode>", bad=True)
-
-        # Extract options like "path=..." or "tag=..." from the command line
-        arg1 = self.arg(1)
-        method = "always"
-        argument = None
-        if arg1.startswith("path="):
-            method = "path"
-            argument = re.compile(arg1[5:])
-            self.shift()
-        elif arg1.startswith("tag="):
-            method = "tag"
-            argument = arg1[4:]
-            self.shift()
-
-        # Extract and validate the line mode from the command line
-        lmode = self.rest(1)
-        if lmode not in FileSystemObject.linemode_dict:
-            self.fm.notify(
-                "Invalid linemode: %s; should be %s" % (
-                    lmode, "/".join(FileSystemObject.linemode_dict)),
-                bad=True,
-            )
-
-        # Add the prepared entry to the fm.default_linemodes
-        entry = [method, argument, lmode]
-        self.fm.default_linemodes.appendleft(entry)
-
-        # Redraw the columns
-        if self.fm.ui.browser:
-            for col in self.fm.ui.browser.columns:
-                col.need_redraw = True
-
-    def tab(self, tabnum):
-        return (self.arg(0) + " " + lmode
-                for lmode in self.fm.thisfile.linemode_dict.keys()
-                if lmode.startswith(self.arg(1)))
-
-
-class quit(Command):  # pylint: disable=redefined-builtin
-    """:quit
-
-    Closes the current tab, if there's only one tab.
-    Otherwise quits if there are no tasks in progress.
-    """
-    def _exit_no_work(self):
-        if self.fm.loader.has_work():
-            self.fm.notify('Not quitting: Tasks in progress: Use `quit!` to force quit')
-        else:
-            self.fm.exit()
-
-    def execute(self):
-        if len(self.fm.tabs) >= 2:
-            self.fm.tab_close()
-        else:
-            self._exit_no_work()
-
-
-class quit_bang(Command):
-    """:quit!
-
-    Closes the current tab, if there's only one tab.
-    Otherwise force quits immediately.
-    """
-    name = 'quit!'
-    allow_abbrev = False
-
-    def execute(self):
-        if len(self.fm.tabs) >= 2:
-            self.fm.tab_close()
-        else:
-            self.fm.exit()
-
-
-class quitall(Command):
-    """:quitall
-
-    Quits if there are no tasks in progress.
-    """
-    def _exit_no_work(self):
-        if self.fm.loader.has_work():
-            self.fm.notify('Not quitting: Tasks in progress: Use `quitall!` to force quit')
-        else:
-            self.fm.exit()
-
-    def execute(self):
-        self._exit_no_work()
-
-
-class quitall_bang(Command):
-    """:quitall!
-
-    Force quits immediately.
-    """
-    name = 'quitall!'
-    allow_abbrev = False
-
-    def execute(self):
-        self.fm.exit()
-
-
-class terminal(Command):
-    """:terminal
-
-    Spawns an "x-terminal-emulator" starting in the current directory.
-    """
-
-    def execute(self):
-        from ranger.ext.get_executables import get_term
-        self.fm.run(get_term(), flags='f')
-
-
-class delete(Command):
-    """:delete
-
-    Tries to delete the selection or the files passed in arguments (if any).
-    The arguments use a shell-like escaping.
-
-    "Selection" is defined as all the "marked files" (by default, you
-    can mark files with space or v). If there are no marked files,
-    use the "current file" (where the cursor is)
-
-    When attempting to delete non-empty directories or multiple
-    marked files, it will require a confirmation.
-    """
-
-    allow_abbrev = False
-    escape_macros_for_shell = True
-
-    def execute(self):
-        import shlex
-        from functools import partial
-
-        def is_directory_with_files(path):
-            return os.path.isdir(path) and not os.path.islink(path) and len(os.listdir(path)) > 0
-
-        if self.rest(1):
-            files = shlex.split(self.rest(1))
-            many_files = (len(files) > 1 or is_directory_with_files(files[0]))
-        else:
-            cwd = self.fm.thisdir
-            tfile = self.fm.thisfile
-            if not cwd or not tfile:
-                self.fm.notify("Error: no file selected for deletion!", bad=True)
-                return
-
-            # relative_path used for a user-friendly output in the confirmation.
-            files = [f.relative_path for f in self.fm.thistab.get_selection()]
-            many_files = (cwd.marked_items or is_directory_with_files(tfile.path))
-
-        confirm = self.fm.settings.confirm_on_delete
-        if confirm != 'never' and (confirm != 'multiple' or many_files):
-            self.fm.ui.console.ask(
-                "Confirm deletion of: %s (y/N)" % ', '.join(files),
-                partial(self._question_callback, files),
-                ('n', 'N', 'y', 'Y'),
-            )
-        else:
-            # no need for a confirmation, just delete
-            self.fm.delete(files)
-
-    def tab(self, tabnum):
-        return self._tab_directory_content()
-
-    def _question_callback(self, files, answer):
-        if answer == 'y' or answer == 'Y':
-            self.fm.delete(files)
-
-
-class jump_non(Command):
-    """:jump_non [-FLAGS...]
-
-    Jumps to first non-directory if highlighted file is a directory and vice versa.
-
-    Flags:
-     -r    Jump in reverse order
-     -w    Wrap around if reaching end of filelist
-    """
-    def __init__(self, *args, **kwargs):
-        super(jump_non, self).__init__(*args, **kwargs)
-
-        flags, _ = self.parse_flags()
-        self._flag_reverse = 'r' in flags
-        self._flag_wrap = 'w' in flags
-
-    @staticmethod
-    def _non(fobj, is_directory):
-        return fobj.is_directory if not is_directory else not fobj.is_directory
-
-    def execute(self):
-        tfile = self.fm.thisfile
-        passed = False
-        found_before = None
-        found_after = None
-        for fobj in self.fm.thisdir.files[::-1] if self._flag_reverse else self.fm.thisdir.files:
-            if fobj.path == tfile.path:
-                passed = True
-                continue
-
-            if passed:
-                if self._non(fobj, tfile.is_directory):
-                    found_after = fobj.path
-                    break
-            elif not found_before and self._non(fobj, tfile.is_directory):
-                found_before = fobj.path
-
-        if found_after:
-            self.fm.select_file(found_after)
-        elif self._flag_wrap and found_before:
-            self.fm.select_file(found_before)
-
-
-class mark_tag(Command):
-    """:mark_tag [<tags>]
-
-    Mark all tags that are tagged with either of the given tags.
-    When leaving out the tag argument, all tagged files are marked.
-    """
-    do_mark = True
-
-    def execute(self):
-        cwd = self.fm.thisdir
-        tags = self.rest(1).replace(" ", "")
-        if not self.fm.tags or not cwd.files:
-            return
-        for fileobj in cwd.files:
-            try:
-                tag = self.fm.tags.tags[fileobj.realpath]
-            except KeyError:
-                continue
-            if not tags or tag in tags:
-                cwd.mark_item(fileobj, val=self.do_mark)
-        self.fm.ui.status.need_redraw = True
-        self.fm.ui.need_redraw = True
-
-
-class console(Command):
-    """:console <command>
-
-    Open the console with the given command.
-    """
-
-    def execute(self):
-        position = None
-        if self.arg(1)[0:2] == '-p':
-            try:
-                position = int(self.arg(1)[2:])
-            except ValueError:
-                pass
-            else:
-                self.shift()
-        self.fm.open_console(self.rest(1), position=position)
-
-
-class load_copy_buffer(Command):
-    """:load_copy_buffer
-
-    Load the copy buffer from datadir/copy_buffer
-    """
-    copy_buffer_filename = 'copy_buffer'
-
-    def execute(self):
-        import sys
-        from ranger.container.file import File
-        from os.path import exists
-        fname = self.fm.datapath(self.copy_buffer_filename)
-        unreadable = IOError if sys.version_info[0] < 3 else OSError
-        try:
-            fobj = open(fname, 'r')
-        except unreadable:
-            return self.fm.notify(
-                "Cannot open %s" % (fname or self.copy_buffer_filename), bad=True)
-
-        self.fm.copy_buffer = set(File(g)
-                                  for g in fobj.read().split("\n") if exists(g))
-        fobj.close()
-        self.fm.ui.redraw_main_column()
-        return None
-
-
-class save_copy_buffer(Command):
-    """:save_copy_buffer
-
-    Save the copy buffer to datadir/copy_buffer
-    """
-    copy_buffer_filename = 'copy_buffer'
-
-    def execute(self):
-        import sys
-        fname = None
-        fname = self.fm.datapath(self.copy_buffer_filename)
-        unwritable = IOError if sys.version_info[0] < 3 else OSError
-        try:
-            fobj = open(fname, 'w')
-        except unwritable:
-            return self.fm.notify("Cannot open %s" %
-                                  (fname or self.copy_buffer_filename), bad=True)
-        fobj.write("\n".join(fobj.path for fobj in self.fm.copy_buffer))
-        fobj.close()
-        return None
-
-
-class unmark_tag(mark_tag):
-    """:unmark_tag [<tags>]
-
-    Unmark all tags that are tagged with either of the given tags.
-    When leaving out the tag argument, all tagged files are unmarked.
-    """
-    do_mark = False
-
-
-class mkdir(Command):
-    """:mkdir <dirname>
-
-    Creates a directory with the name <dirname>.
-    """
-
-    def execute(self):
-        from os.path import join, expanduser, lexists
-        from os import makedirs
-
-        dirname = join(self.fm.thisdir.path, expanduser(self.rest(1)))
-        if not lexists(dirname):
-            makedirs(dirname)
-        else:
-            self.fm.notify("file/directory exists!", bad=True)
-
-    def tab(self, tabnum):
-        return self._tab_directory_content()
-
-
-class touch(Command):
-    """:touch <fname>
-
-    Creates a file with the name <fname>.
-    """
-
-    def execute(self):
-        from os.path import join, expanduser, lexists
-
-        fname = join(self.fm.thisdir.path, expanduser(self.rest(1)))
-        if not lexists(fname):
-            open(fname, 'a').close()
-        else:
-            self.fm.notify("file/directory exists!", bad=True)
-
-    def tab(self, tabnum):
-        return self._tab_directory_content()
-
-
-class edit(Command):
-    """:edit <filename>
-
-    Opens the specified file in vim
-    """
-
-    def execute(self):
-        if not self.arg(1):
-            self.fm.edit_file(self.fm.thisfile.path)
-        else:
-            self.fm.edit_file(self.rest(1))
-
-    def tab(self, tabnum):
-        return self._tab_directory_content()
-
-
-class eval_(Command):
-    """:eval [-q] <python code>
-
-    Evaluates the python code.
-    `fm' is a reference to the FM instance.
-    To display text, use the function `p'.
-
-    Examples:
-    :eval fm
-    :eval len(fm.directories)
-    :eval p("Hello World!")
-    """
-    name = 'eval'
-    resolve_macros = False
-
-    def execute(self):
-        # The import is needed so eval() can access the ranger module
-        import ranger  # NOQA pylint: disable=unused-import,unused-variable
-        if self.arg(1) == '-q':
-            code = self.rest(2)
-            quiet = True
-        else:
-            code = self.rest(1)
-            quiet = False
-        global cmd, fm, p, quantifier  # pylint: disable=invalid-name,global-variable-undefined
-        fm = self.fm
-        cmd = self.fm.execute_console
-        p = fm.notify
-        quantifier = self.quantifier
-        try:
-            try:
-                result = eval(code)  # pylint: disable=eval-used
-            except SyntaxError:
-                exec(code)  # pylint: disable=exec-used
-            else:
-                if result and not quiet:
-                    p(result)
-        except Exception as err:  # pylint: disable=broad-except
-            fm.notify("The error `%s` was caused by evaluating the "
-                      "following code: `%s`" % (err, code), bad=True)
-
-
-class rename(Command):
-    """:rename <newname>
-
-    Changes the name of the currently highlighted file to <newname>
-    """
-
-    def execute(self):
-        from ranger.container.file import File
-        from os import access
-
-        new_name = self.rest(1)
-
-        if not new_name:
-            return self.fm.notify('Syntax: rename <newname>', bad=True)
-
-        if new_name == self.fm.thisfile.relative_path:
-            return None
-
-        if access(new_name, os.F_OK):
-            return self.fm.notify("Can't rename: file already exists!", bad=True)
-
-        if self.fm.rename(self.fm.thisfile, new_name):
-            file_new = File(new_name)
-            self.fm.bookmarks.update_path(self.fm.thisfile.path, file_new)
-            self.fm.tags.update_path(self.fm.thisfile.path, file_new.path)
-            self.fm.thisdir.pointed_obj = file_new
-            self.fm.thisfile = file_new
-
-        return None
-
-    def tab(self, tabnum):
-        return self._tab_directory_content()
-
-
-class rename_append(Command):
-    """:rename_append [-FLAGS...]
-
-    Opens the console with ":rename <current file>" with the cursor positioned
-    before the file extension.
-
-    Flags:
-     -a    Position before all extensions
-     -r    Remove everything before extensions
-    """
-    def __init__(self, *args, **kwargs):
-        super(rename_append, self).__init__(*args, **kwargs)
-
-        flags, _ = self.parse_flags()
-        self._flag_ext_all = 'a' in flags
-        self._flag_remove = 'r' in flags
-
-    def execute(self):
-        from ranger import MACRO_DELIMITER, MACRO_DELIMITER_ESC
-
-        tfile = self.fm.thisfile
-        relpath = tfile.relative_path.replace(MACRO_DELIMITER, MACRO_DELIMITER_ESC)
-        basename = tfile.basename.replace(MACRO_DELIMITER, MACRO_DELIMITER_ESC)
-
-        if basename.find('.') <= 0:
-            self.fm.open_console('rename ' + relpath)
-            return
-
-        if self._flag_ext_all:
-            pos_ext = re.search(r'[^.]+', basename).end(0)
-        else:
-            pos_ext = basename.rindex('.')
-        pos = len(relpath) - len(basename) + pos_ext
-
-        if self._flag_remove:
-            relpath = relpath[:-len(basename)] + basename[pos_ext:]
-            pos -= pos_ext
-
-        self.fm.open_console('rename ' + relpath, position=(7 + pos))
-
-
-class chmod(Command):
-    """:chmod <octal number>
-
-    Sets the permissions of the selection to the octal number.
-
-    The octal number is between 0 and 777. The digits specify the
-    permissions for the user, the group and others.
-
-    A 1 permits execution, a 2 permits writing, a 4 permits reading.
-    Add those numbers to combine them. So a 7 permits everything.
-    """
-
-    def execute(self):
-        mode_str = self.rest(1)
-        if not mode_str:
-            if not self.quantifier:
-                self.fm.notify("Syntax: chmod <octal number>", bad=True)
-                return
-            mode_str = str(self.quantifier)
-
-        try:
-            mode = int(mode_str, 8)
-            if mode < 0 or mode > 0o777:
-                raise ValueError
-        except ValueError:
-            self.fm.notify("Need an octal number between 0 and 777!", bad=True)
-            return
-
-        for fobj in self.fm.thistab.get_selection():
-            try:
-                os.chmod(fobj.path, mode)
-            except OSError as ex:
-                self.fm.notify(ex)
-
-        # reloading directory.  maybe its better to reload the selected
-        # files only.
-        self.fm.thisdir.content_outdated = True
-
-
-class bulkrename(Command):
-    """:bulkrename
-
-    This command opens a list of selected files in an external editor.
-    After you edit and save the file, it will generate a shell script
-    which does bulk renaming according to the changes you did in the file.
-
-    This shell script is opened in an editor for you to review.
-    After you close it, it will be executed.
-    """
-
-    def execute(self):  # pylint: disable=too-many-locals,too-many-statements
-        import sys
-        import tempfile
-        from ranger.container.file import File
-        from ranger.ext.shell_escape import shell_escape as esc
-        py3 = sys.version_info[0] >= 3
-
-        # Create and edit the file list
-        filenames = [f.relative_path for f in self.fm.thistab.get_selection()]
-        listfile = tempfile.NamedTemporaryFile(delete=False)
-        listpath = listfile.name
-
-        if py3:
-            listfile.write("\n".join(filenames).encode("utf-8"))
-        else:
-            listfile.write("\n".join(filenames))
-        listfile.close()
-        self.fm.execute_file([File(listpath)], app='editor')
-        listfile = open(listpath, 'r')
-        new_filenames = listfile.read().split("\n")
-        listfile.close()
-        os.unlink(listpath)
-        if all(a == b for a, b in zip(filenames, new_filenames)):
-            self.fm.notify("No renaming to be done!")
-            return
-
-        # Generate script
-        cmdfile = tempfile.NamedTemporaryFile()
-        script_lines = []
-        script_lines.append("# This file will be executed when you close the editor.\n")
-        script_lines.append("# Please double-check everything, clear the file to abort.\n")
-        script_lines.extend("mv -vi -- %s %s\n" % (esc(old), esc(new))
-                            for old, new in zip(filenames, new_filenames) if old != new)
-        script_content = "".join(script_lines)
-        if py3:
-            cmdfile.write(script_content.encode("utf-8"))
-        else:
-            cmdfile.write(script_content)
-        cmdfile.flush()
-
-        # Open the script and let the user review it, then check if the script
-        # was modified by the user
-        self.fm.execute_file([File(cmdfile.name)], app='editor')
-        cmdfile.seek(0)
-        script_was_edited = (script_content != cmdfile.read())
-
-        # Do the renaming
-        self.fm.run(['/bin/sh', cmdfile.name], flags='w')
-        cmdfile.close()
-
-        # Retag the files, but only if the script wasn't changed during review,
-        # because only then we know which are the source and destination files.
-        if not script_was_edited:
-            tags_changed = False
-            for old, new in zip(filenames, new_filenames):
-                if old != new:
-                    oldpath = self.fm.thisdir.path + '/' + old
-                    newpath = self.fm.thisdir.path + '/' + new
-                    if oldpath in self.fm.tags:
-                        old_tag = self.fm.tags.tags[oldpath]
-                        self.fm.tags.remove(oldpath)
-                        self.fm.tags.tags[newpath] = old_tag
-                        tags_changed = True
-            if tags_changed:
-                self.fm.tags.dump()
-        else:
-            fm.notify("files have not been retagged")
-
-
-class relink(Command):
-    """:relink <newpath>
-
-    Changes the linked path of the currently highlighted symlink to <newpath>
-    """
-
-    def execute(self):
-        new_path = self.rest(1)
-        tfile = self.fm.thisfile
-
-        if not new_path:
-            return self.fm.notify('Syntax: relink <newpath>', bad=True)
-
-        if not tfile.is_link:
-            return self.fm.notify('%s is not a symlink!' % tfile.relative_path, bad=True)
-
-        if new_path == os.readlink(tfile.path):
-            return None
-
-        try:
-            os.remove(tfile.path)
-            os.symlink(new_path, tfile.path)
-        except OSError as err:
-            self.fm.notify(err)
-
-        self.fm.reset()
-        self.fm.thisdir.pointed_obj = tfile
-        self.fm.thisfile = tfile
-
-        return None
-
-    def tab(self, tabnum):
-        if not self.rest(1):
-            return self.line + os.readlink(self.fm.thisfile.path)
-        return self._tab_directory_content()
-
-
-class help_(Command):
-    """:help
-
-    Display ranger's manual page.
-    """
-    name = 'help'
-
-    def execute(self):
-        def callback(answer):
-            if answer == "q":
-                return
-            elif answer == "m":
-                self.fm.display_help()
-            elif answer == "c":
-                self.fm.dump_commands()
-            elif answer == "k":
-                self.fm.dump_keybindings()
-            elif answer == "s":
-                self.fm.dump_settings()
-
-        self.fm.ui.console.ask(
-            "View [m]an page, [k]ey bindings, [c]ommands or [s]ettings? (press q to abort)",
-            callback,
-            list("mqkcs")
-        )
-
-
-class copymap(Command):
-    """:copymap <keys> <newkeys1> [<newkeys2>...]
-
-    Copies a "browser" keybinding from <keys> to <newkeys>
-    """
-    context = 'browser'
-
-    def execute(self):
-        if not self.arg(1) or not self.arg(2):
-            return self.fm.notify("Not enough arguments", bad=True)
-
-        for arg in self.args[2:]:
-            self.fm.ui.keymaps.copy(self.context, self.arg(1), arg)
-
-        return None
-
-
-class copypmap(copymap):
-    """:copypmap <keys> <newkeys1> [<newkeys2>...]
-
-    Copies a "pager" keybinding from <keys> to <newkeys>
-    """
-    context = 'pager'
-
-
-class copycmap(copymap):
-    """:copycmap <keys> <newkeys1> [<newkeys2>...]
-
-    Copies a "console" keybinding from <keys> to <newkeys>
-    """
-    context = 'console'
-
-
-class copytmap(copymap):
-    """:copycmap <keys> <newkeys1> [<newkeys2>...]
-
-    Copies a "taskview" keybinding from <keys> to <newkeys>
-    """
-    context = 'taskview'
-
-
-class unmap(Command):
-    """:unmap <keys> [<keys2>, ...]
-
-    Remove the given "browser" mappings
-    """
-    context = 'browser'
-
-    def execute(self):
-        for arg in self.args[1:]:
-            self.fm.ui.keymaps.unbind(self.context, arg)
-
-
-class cunmap(unmap):
-    """:cunmap <keys> [<keys2>, ...]
-
-    Remove the given "console" mappings
-    """
-    context = 'browser'
-
-
-class punmap(unmap):
-    """:punmap <keys> [<keys2>, ...]
-
-    Remove the given "pager" mappings
-    """
-    context = 'pager'
-
-
-class tunmap(unmap):
-    """:tunmap <keys> [<keys2>, ...]
-
-    Remove the given "taskview" mappings
-    """
-    context = 'taskview'
-
-
-class map_(Command):
-    """:map <keysequence> <command>
-
-    Maps a command to a keysequence in the "browser" context.
-
-    Example:
-    map j move down
-    map J move down 10
-    """
-    name = 'map'
-    context = 'browser'
-    resolve_macros = False
-
-    def execute(self):
-        if not self.arg(1) or not self.arg(2):
-            self.fm.notify("Syntax: {0} <keysequence> <command>".format(self.get_name()), bad=True)
-            return
-
-        self.fm.ui.keymaps.bind(self.context, self.arg(1), self.rest(2))
-
-
-class cmap(map_):
-    """:cmap <keysequence> <command>
-
-    Maps a command to a keysequence in the "console" context.
-
-    Example:
-    cmap <ESC> console_close
-    cmap <C-x> console_type test
-    """
-    context = 'console'
-
-
-class tmap(map_):
-    """:tmap <keysequence> <command>
-
-    Maps a command to a keysequence in the "taskview" context.
-    """
-    context = 'taskview'
-
-
-class pmap(map_):
-    """:pmap <keysequence> <command>
-
-    Maps a command to a keysequence in the "pager" context.
-    """
-    context = 'pager'
-
-
-class scout(Command):
-    """:scout [-FLAGS...] <pattern>
-
-    Swiss army knife command for searching, traveling and filtering files.
-
-    Flags:
-     -a    Automatically open a file on unambiguous match
-     -e    Open the selected file when pressing enter
-     -f    Filter files that match the current search pattern
-     -g    Interpret pattern as a glob pattern
-     -i    Ignore the letter case of the files
-     -k    Keep the console open when changing a directory with the command
-     -l    Letter skipping; e.g. allow "rdme" to match the file "readme"
-     -m    Mark the matching files after pressing enter
-     -M    Unmark the matching files after pressing enter
-     -p    Permanent filter: hide non-matching files after pressing enter
-     -r    Interpret pattern as a regular expression pattern
-     -s    Smart case; like -i unless pattern contains upper case letters
-     -t    Apply filter and search pattern as you type
-     -v    Inverts the match
-
-    Multiple flags can be combined.  For example, ":scout -gpt" would create
-    a :filter-like command using globbing.
-    """
-    # pylint: disable=bad-whitespace
-    AUTO_OPEN     = 'a'
-    OPEN_ON_ENTER = 'e'
-    FILTER        = 'f'
-    SM_GLOB       = 'g'
-    IGNORE_CASE   = 'i'
-    KEEP_OPEN     = 'k'
-    SM_LETTERSKIP = 'l'
-    MARK          = 'm'
-    UNMARK        = 'M'
-    PERM_FILTER   = 'p'
-    SM_REGEX      = 'r'
-    SMART_CASE    = 's'
-    AS_YOU_TYPE   = 't'
-    INVERT        = 'v'
-    # pylint: enable=bad-whitespace
-
-    def __init__(self, *args, **kwargs):
-        super(scout, self).__init__(*args, **kwargs)
-        self._regex = None
-        self.flags, self.pattern = self.parse_flags()
-
-    def execute(self):  # pylint: disable=too-many-branches
-        thisdir = self.fm.thisdir
-        flags = self.flags
-        pattern = self.pattern
-        regex = self._build_regex()
-        count = self._count(move=True)
-
-        self.fm.thistab.last_search = regex
-        self.fm.set_search_method(order="search")
-
-        if (self.MARK in flags or self.UNMARK in flags) and thisdir.files:
-            value = flags.find(self.MARK) > flags.find(self.UNMARK)
-            if self.FILTER in flags:
-                for fobj in thisdir.files:
-                    thisdir.mark_item(fobj, value)
-            else:
-                for fobj in thisdir.files:
-                    if regex.search(fobj.relative_path):
-                        thisdir.mark_item(fobj, value)
-
-        if self.PERM_FILTER in flags:
-            thisdir.filter = regex if pattern else None
-
-        # clean up:
-        self.cancel()
-
-        if self.OPEN_ON_ENTER in flags or \
-                (self.AUTO_OPEN in flags and count == 1):
-            if pattern == '..':
-                self.fm.cd(pattern)
-            else:
-                self.fm.move(right=1)
-                if self.quickly_executed:
-                    self.fm.block_input(0.5)
-
-        if self.KEEP_OPEN in flags and thisdir != self.fm.thisdir:
-            # reopen the console:
-            if not pattern:
-                self.fm.open_console(self.line)
-            else:
-                self.fm.open_console(self.line[0:-len(pattern)])
-
-        if self.quickly_executed and thisdir != self.fm.thisdir and pattern != "..":
-            self.fm.block_input(0.5)
-
-    def cancel(self):
-        self.fm.thisdir.temporary_filter = None
-        self.fm.thisdir.refilter()
-
-    def quick(self):
-        asyoutype = self.AS_YOU_TYPE in self.flags
-        if self.FILTER in self.flags:
-            self.fm.thisdir.temporary_filter = self._build_regex()
-        if self.PERM_FILTER in self.flags and asyoutype:
-            self.fm.thisdir.filter = self._build_regex()
-        if self.FILTER in self.flags or self.PERM_FILTER in self.flags:
-            self.fm.thisdir.refilter()
-        if self._count(move=asyoutype) == 1 and self.AUTO_OPEN in self.flags:
-            return True
-        return False
-
-    def tab(self, tabnum):
-        self._count(move=True, offset=tabnum)
-
-    def _build_regex(self):
-        if self._regex is not None:
-            return self._regex
-
-        frmat = "%s"
-        flags = self.flags
-        pattern = self.pattern
-
-        if pattern == ".":
-            return re.compile("")
-
-        # Handle carets at start and dollar signs at end separately
-        if pattern.startswith('^'):
-            pattern = pattern[1:]
-            frmat = "^" + frmat
-        if pattern.endswith('$'):
-            pattern = pattern[:-1]
-            frmat += "$"
-
-        # Apply one of the search methods
-        if self.SM_REGEX in flags:
-            regex = pattern
-        elif self.SM_GLOB in flags:
-            regex = re.escape(pattern).replace("\\*", ".*").replace("\\?", ".")
-        elif self.SM_LETTERSKIP in flags:
-            regex = ".*".join(re.escape(c) for c in pattern)
-        else:
-            regex = re.escape(pattern)
-
-        regex = frmat % regex
-
-        # Invert regular expression if necessary
-        if self.INVERT in flags:
-            regex = "^(?:(?!%s).)*$" % regex
-
-        # Compile Regular Expression
-        # pylint: disable=no-member
-        options = re.UNICODE
-        if self.IGNORE_CASE in flags or self.SMART_CASE in flags and \
-                pattern.islower():
-            options |= re.IGNORECASE
-        # pylint: enable=no-member
-        try:
-            self._regex = re.compile(regex, options)
-        except re.error:
-            self._regex = re.compile("")
-        return self._regex
-
-    def _count(self, move=False, offset=0):
-        count = 0
-        cwd = self.fm.thisdir
-        pattern = self.pattern
-
-        if not pattern or not cwd.files:
-            return 0
-        if pattern == '.':
-            return 0
-        if pattern == '..':
-            return 1
-
-        deq = deque(cwd.files)
-        deq.rotate(-cwd.pointer - offset)
-        i = offset
-        regex = self._build_regex()
-        for fsobj in deq:
-            if regex.search(fsobj.relative_path):
-                count += 1
-                if move and count == 1:
-                    cwd.move(to=(cwd.pointer + i) % len(cwd.files))
-                    self.fm.thisfile = cwd.pointed_obj
-            if count > 1:
-                return count
-            i += 1
-
-        return count == 1
-
-
-class narrow(Command):
-    """
-    :narrow
-
-    Show only the files selected right now. If no files are selected,
-    disable narrowing.
-    """
-    def execute(self):
-        if self.fm.thisdir.marked_items:
-            selection = [f.basename for f in self.fm.thistab.get_selection()]
-            self.fm.thisdir.narrow_filter = selection
-        else:
-            self.fm.thisdir.narrow_filter = None
-        self.fm.thisdir.refilter()
-
-
-class filter_inode_type(Command):
-    """
-    :filter_inode_type [dfl]
-
-    Displays only the files of specified inode type. Parameters
-    can be combined.
-
-        d display directories
-        f display files
-        l display links
-    """
-
-    def execute(self):
-        if not self.arg(1):
-            self.fm.thisdir.inode_type_filter = ""
-        else:
-            self.fm.thisdir.inode_type_filter = self.arg(1)
-        self.fm.thisdir.refilter()
-
-
-class filter_stack(Command):
-    """
-    :filter_stack ...
-
-    Manages the filter stack.
-
-        filter_stack add FILTER_TYPE ARGS...
-        filter_stack pop
-        filter_stack decompose
-        filter_stack rotate [N=1]
-        filter_stack clear
-        filter_stack show
-    """
-    def execute(self):
-        from ranger.core.filter_stack import SIMPLE_FILTERS, FILTER_COMBINATORS
-
-        subcommand = self.arg(1)
-
-        if subcommand == "add":
-            try:
-                self.fm.thisdir.filter_stack.append(
-                    SIMPLE_FILTERS[self.arg(2)](self.rest(3))
-                )
-            except KeyError:
-                FILTER_COMBINATORS[self.arg(2)](self.fm.thisdir.filter_stack)
-        elif subcommand == "pop":
-            self.fm.thisdir.filter_stack.pop()
-        elif subcommand == "decompose":
-            inner_filters = self.fm.thisdir.filter_stack.pop().decompose()
-            if inner_filters:
-                self.fm.thisdir.filter_stack.extend(inner_filters)
-        elif subcommand == "clear":
-            self.fm.thisdir.filter_stack = []
-        elif subcommand == "rotate":
-            rotate_by = int(self.arg(2) or 1)
-            self.fm.thisdir.filter_stack = (
-                self.fm.thisdir.filter_stack[-rotate_by:]
-                + self.fm.thisdir.filter_stack[:-rotate_by]
-            )
-        elif subcommand == "show":
-            stack = list(map(str, self.fm.thisdir.filter_stack))
-            pager = self.fm.ui.open_pager()
-            pager.set_source(["Filter stack: "] + stack)
-            pager.move(to=100, percentage=True)
-            return
-        else:
-            self.fm.notify(
-                "Unknown subcommand: {}".format(subcommand),
-                bad=True
-            )
-            return
-
-        self.fm.thisdir.refilter()
-
-
-class grep(Command):
-    """:grep <string>
-
-    Looks for a string in all marked files or directories
-    """
-
-    def execute(self):
-        if self.rest(1):
-            action = ['grep', '--line-number']
-            action.extend(['-e', self.rest(1), '-r'])
-            action.extend(f.path for f in self.fm.thistab.get_selection())
-            self.fm.execute_command(action, flags='p')
-
-
-class flat(Command):
-    """
-    :flat <level>
-
-    Flattens the directory view up to the specified level.
-
-        -1 fully flattened
-         0 remove flattened view
-    """
-
-    def execute(self):
-        try:
-            level_str = self.rest(1)
-            level = int(level_str)
-        except ValueError:
-            level = self.quantifier
-        if level is None:
-            self.fm.notify("Syntax: flat <level>", bad=True)
-            return
-        if level < -1:
-            self.fm.notify("Need an integer number (-1, 0, 1, ...)", bad=True)
-        self.fm.thisdir.unload()
-        self.fm.thisdir.flat = level
-        self.fm.thisdir.load_content()
-
-
-
-class stage(Command):
-    """
-    :stage
-
-    Stage selected files for the corresponding version control system
-    """
-
-    def execute(self):
-        from ranger.ext.vcs import VcsError
-
-        if self.fm.thisdir.vcs and self.fm.thisdir.vcs.track:
-            filelist = [f.path for f in self.fm.thistab.get_selection()]
-            try:
-                self.fm.thisdir.vcs.action_add(filelist)
-            except VcsError as ex:
-                self.fm.notify('Unable to stage files: {0}'.format(ex))
-            self.fm.ui.vcsthread.process(self.fm.thisdir)
-        else:
-            self.fm.notify('Unable to stage files: Not in repository')
-
-
-class unstage(Command):
-    """
-    :unstage
-
-    Unstage selected files for the corresponding version control system
-    """
-
-    def execute(self):
-        from ranger.ext.vcs import VcsError
-
-        if self.fm.thisdir.vcs and self.fm.thisdir.vcs.track:
-            filelist = [f.path for f in self.fm.thistab.get_selection()]
-            try:
-                self.fm.thisdir.vcs.action_reset(filelist)
-            except VcsError as ex:
-                self.fm.notify('Unable to unstage files: {0}'.format(ex))
-            self.fm.ui.vcsthread.process(self.fm.thisdir)
-        else:
-            self.fm.notify('Unable to unstage files: Not in repository')
-
-
-
-class prompt_metadata(Command):
-    """
-    :prompt_metadata <key1> [<key2> [<key3> ...]]
-
-    Prompt the user to input metadata for multiple keys in a row.
-    """
-
-    _command_name = "meta"
-    _console_chain = None
-
-    def execute(self):
-        prompt_metadata._console_chain = self.args[1:]
-        self._process_command_stack()
-
-    def _process_command_stack(self):
-        if prompt_metadata._console_chain:
-            key = prompt_metadata._console_chain.pop()
-            self._fill_console(key)
-        else:
-            for col in self.fm.ui.browser.columns:
-                col.need_redraw = True
-
-    def _fill_console(self, key):
-        metadata = self.fm.metadata.get_metadata(self.fm.thisfile.path)
-        if key in metadata and metadata[key]:
-            existing_value = metadata[key]
-        else:
-            existing_value = ""
-        text = "%s %s %s" % (self._command_name, key, existing_value)
-        self.fm.open_console(text, position=len(text))
-
-
-class meta(prompt_metadata):
-    """
-    :meta <key> [<value>]
-
-    Change metadata of a file.  Deletes the key if value is empty.
-    """
-
-    def execute(self):
-        key = self.arg(1)
-        update_dict = dict()
-        update_dict[key] = self.rest(2)
-        selection = self.fm.thistab.get_selection()
-        for fobj in selection:
-            self.fm.metadata.set_metadata(fobj.path, update_dict)
-        self._process_command_stack()
-
-    def tab(self, tabnum):
-        key = self.arg(1)
-        metadata = self.fm.metadata.get_metadata(self.fm.thisfile.path)
-        if key in metadata and metadata[key]:
-            return [" ".join([self.arg(0), self.arg(1), metadata[key]])]
-        return [self.arg(0) + " " + k for k in sorted(metadata)
-                if k.startswith(self.arg(1))]
-
-
-class linemode(default_linemode):
-    """
-    :linemode <mode>
-
-    Change what is displayed as a filename.
-
-    - "mode" may be any of the defined linemodes (see: ranger.core.linemode).
-      "normal" is mapped to "filename".
-    """
-
-    def execute(self):
-        mode = self.arg(1)
-
-        if mode == "normal":
-            from ranger.core.linemode import DEFAULT_LINEMODE
-            mode = DEFAULT_LINEMODE
-
-        if mode not in self.fm.thisfile.linemode_dict:
-            self.fm.notify("Unhandled linemode: `%s'" % mode, bad=True)
-            return
-
-        self.fm.thisdir.set_linemode_of_children(mode)
-
-        # Ask the browsercolumns to redraw
-        for col in self.fm.ui.browser.columns:
-            col.need_redraw = True
-
-
-class yank(Command):
-    """:yank [name|dir|path]
-
-    Copies the file's name (default), directory or path into both the primary X
-    selection and the clipboard.
-    """
-
-    modes = {
-        '': 'basename',
-        'name_without_extension': 'basename_without_extension',
-        'name': 'basename',
-        'dir': 'dirname',
-        'path': 'path',
-    }
-
-    def execute(self):
-        import subprocess
-
-        def clipboards():
-            from ranger.ext.get_executables import get_executables
-            clipboard_managers = {
-                'xclip': [
-                    ['xclip'],
-                    ['xclip', '-selection', 'clipboard'],
-                ],
-                'xsel': [
-                    ['xsel'],
-                    ['xsel', '-b'],
-                ],
-                'pbcopy': [
-                    ['pbcopy'],
-                ],
-            }
-            ordered_managers = ['pbcopy', 'xclip', 'xsel']
-            executables = get_executables()
-            for manager in ordered_managers:
-                if manager in executables:
-                    return clipboard_managers[manager]
-            return []
-
-        clipboard_commands = clipboards()
-
-        mode = self.modes[self.arg(1)]
-        selection = self.get_selection_attr(mode)
-
-        new_clipboard_contents = "\n".join(selection)
-        for command in clipboard_commands:
-            process = subprocess.Popen(command, universal_newlines=True,
-                                       stdin=subprocess.PIPE)
-            process.communicate(input=new_clipboard_contents)
-
-    def get_selection_attr(self, attr):
-        return [getattr(item, attr) for item in
-                self.fm.thistab.get_selection()]
-
-    def tab(self, tabnum):
-        return (
-            self.start(1) + mode for mode
-            in sorted(self.modes.keys())
-            if mode
-        )
diff --git a/config/.config/ranger/scope.sh b/config/.config/ranger/scope.sh
deleted file mode 100755
index 13a25b4..0000000
--- a/config/.config/ranger/scope.sh
+++ /dev/null
@@ -1,216 +0,0 @@
-#!/usr/bin/env bash
-
-set -o noclobber -o noglob -o nounset -o pipefail
-IFS=$'\n'
-
-# If the option `use_preview_script` is set to `true`,
-# then this script will be called and its output will be displayed in ranger.
-# ANSI color codes are supported.
-# STDIN is disabled, so interactive scripts won't work properly
-
-# This script is considered a configuration file and must be updated manually.
-# It will be left untouched if you upgrade ranger.
-
-# Meanings of exit codes:
-# code | meaning    | action of ranger
-# -----+------------+-------------------------------------------
-# 0    | success    | Display stdout as preview
-# 1    | no preview | Display no preview at all
-# 2    | plain text | Display the plain content of the file
-# 3    | fix width  | Don't reload when width changes
-# 4    | fix height | Don't reload when height changes
-# 5    | fix both   | Don't ever reload
-# 6    | image      | Display the image `$IMAGE_CACHE_PATH` points to as an image preview
-# 7    | image      | Display the file directly as an image
-
-# Script arguments
-FILE_PATH="${1}"         # Full path of the highlighted file
-PV_WIDTH="${2}"          # Width of the preview pane (number of fitting characters)
-PV_HEIGHT="${3}"         # Height of the preview pane (number of fitting characters)
-IMAGE_CACHE_PATH="${4}"  # Full path that should be used to cache image preview
-PV_IMAGE_ENABLED="${5}"  # 'True' if image previews are enabled, 'False' otherwise.
-
-FILE_EXTENSION="${FILE_PATH##*.}"
-FILE_EXTENSION_LOWER=$(echo ${FILE_EXTENSION} | tr '[:upper:]' '[:lower:]')
-
-# Settings
-HIGHLIGHT_SIZE_MAX=262143  # 256KiB
-HIGHLIGHT_TABWIDTH=8
-HIGHLIGHT_STYLE='pablo'
-PYGMENTIZE_STYLE='autumn'
-
-
-handle_extension() {
-    case "${FILE_EXTENSION_LOWER}" in
-        # Archive
-        a|ace|alz|arc|arj|bz|bz2|cab|cpio|deb|gz|jar|lha|lz|lzh|lzma|lzo|\
-        rpm|rz|t7z|tar|tbz|tbz2|tgz|tlz|txz|tZ|tzo|war|xpi|xz|Z|zip)
-            atool --list -- "${FILE_PATH}" && exit 5
-            bsdtar --list --file "${FILE_PATH}" && exit 5
-            exit 1;;
-        rar)
-            # Avoid password prompt by providing empty password
-            unrar lt -p- -- "${FILE_PATH}" && exit 5
-            exit 1;;
-        7z)
-            # Avoid password prompt by providing empty password
-            7z l -p -- "${FILE_PATH}" && exit 5
-            exit 1;;
-
-        # PDF
-        pdf)
-            # Preview as text conversion
-            pdftotext -l 10 -nopgbrk -q -- "${FILE_PATH}" - | fmt -w ${PV_WIDTH} && exit 5
-            mutool draw -F txt -i -- "${FILE_PATH}" 1-10 | fmt -w ${PV_WIDTH} && exit 5
-            exiftool "${FILE_PATH}" && exit 5
-            exit 1;;
-
-        # BitTorrent
-        torrent)
-            transmission-show -- "${FILE_PATH}" && exit 5
-            exit 1;;
-
-        # OpenDocument
-        odt|ods|odp|sxw)
-            # Preview as text conversion
-            odt2txt "${FILE_PATH}" && exit 5
-            exit 1;;
-
-        # HTML
-        htm|html|xhtml)
-            # Preview as text conversion
-            w3m -dump "${FILE_PATH}" && exit 5
-            lynx -dump -- "${FILE_PATH}" && exit 5
-            elinks -dump "${FILE_PATH}" && exit 5
-            ;; # Continue with next handler on failure
-    esac
-}
-
-handle_image() {
-    local mimetype="${1}"
-    case "${mimetype}" in
-        # SVG
-        # image/svg+xml)
-        #     convert "${FILE_PATH}" "${IMAGE_CACHE_PATH}" && exit 6
-        #     exit 1;;
-
-        # Image
-        image/*)
-            local orientation
-            orientation="$( identify -format '%[EXIF:Orientation]\n' -- "${FILE_PATH}" )"
-            # If orientation data is present and the image actually
-            # needs rotating ("1" means no rotation)...
-            if [[ -n "$orientation" && "$orientation" != 1 ]]; then
-                # ...auto-rotate the image according to the EXIF data.
-                convert -- "${FILE_PATH}" -auto-orient "${IMAGE_CACHE_PATH}" && exit 6
-            fi
-
-            # `w3mimgdisplay` will be called for all images (unless overriden as above),
-            # but might fail for unsupported types.
-            exit 7;;
-
-        # Video
-        # video/*)
-        #     # Thumbnail
-        #     ffmpegthumbnailer -i "${FILE_PATH}" -o "${IMAGE_CACHE_PATH}" -s 0 && exit 6
-        #     exit 1;;
-        # PDF
-        # application/pdf)
-        #     pdftoppm -f 1 -l 1 \
-        #              -scale-to-x 1920 \
-        #              -scale-to-y -1 \
-        #              -singlefile \
-        #              -jpeg -tiffcompression jpeg \
-        #              -- "${FILE_PATH}" "${IMAGE_CACHE_PATH%.*}" \
-        #         && exit 6 || exit 1;;
-
-        # Preview archives using the first image inside.
-        # (Very useful for comic book collections for example.)
-        # application/zip|application/x-rar|application/x-7z-compressed|\
-        #     application/x-xz|application/x-bzip2|application/x-gzip|application/x-tar)
-        #     local fn=""; local fe=""
-        #     local zip=""; local rar=""; local tar=""; local bsd=""
-        #     case "${mimetype}" in
-        #         application/zip) zip=1 ;;
-        #         application/x-rar) rar=1 ;;
-        #         application/x-7z-compressed) ;;
-        #         *) tar=1 ;;
-        #     esac
-        #     { [ "$tar" ] && fn=$(tar --list --file "${FILE_PATH}"); } || \
-        #     { fn=$(bsdtar --list --file "${FILE_PATH}") && bsd=1 && tar=""; } || \
-        #     { [ "$rar" ] && fn=$(unrar lb -p- -- "${FILE_PATH}"); } || \
-        #     { [ "$zip" ] && fn=$(zipinfo -1 -- "${FILE_PATH}"); } || return
-        #
-        #     fn=$(echo "$fn" | python -c "import sys; import mimetypes as m; \
-        #             [ print(l, end='') for l in sys.stdin if \
-        #               (m.guess_type(l[:-1])[0] or '').startswith('image/') ]" |\
-        #         sort -V | head -n 1)
-        #     [ "$fn" = "" ] && return
-        #     [ "$bsd" ] && fn=$(printf '%b' "$fn")
-        #
-        #     [ "$tar" ] && tar --extract --to-stdout \
-        #         --file "${FILE_PATH}" -- "$fn" > "${IMAGE_CACHE_PATH}" && exit 6
-        #     fe=$(echo -n "$fn" | sed 's/[][*?\]/\\\0/g')
-        #     [ "$bsd" ] && bsdtar --extract --to-stdout \
-        #         --file "${FILE_PATH}" -- "$fe" > "${IMAGE_CACHE_PATH}" && exit 6
-        #     [ "$bsd" ] || [ "$tar" ] && rm -- "${IMAGE_CACHE_PATH}"
-        #     [ "$rar" ] && unrar p -p- -inul -- "${FILE_PATH}" "$fn" > \
-        #         "${IMAGE_CACHE_PATH}" && exit 6
-        #     [ "$zip" ] && unzip -pP "" -- "${FILE_PATH}" "$fe" > \
-        #         "${IMAGE_CACHE_PATH}" && exit 6
-        #     [ "$rar" ] || [ "$zip" ] && rm -- "${IMAGE_CACHE_PATH}"
-        #     ;;
-    esac
-}
-
-handle_mime() {
-    local mimetype="${1}"
-    case "${mimetype}" in
-        # Text
-        text/* | */xml)
-            # Syntax highlight
-            if [[ "$( stat --printf='%s' -- "${FILE_PATH}" )" -gt "${HIGHLIGHT_SIZE_MAX}" ]]; then
-                exit 2
-            fi
-            if [[ "$( tput colors )" -ge 256 ]]; then
-                local pygmentize_format='terminal256'
-                local highlight_format='xterm256'
-            else
-                local pygmentize_format='terminal'
-                local highlight_format='ansi'
-            fi
-            highlight --replace-tabs="${HIGHLIGHT_TABWIDTH}" --out-format="${highlight_format}" \
-                --style="${HIGHLIGHT_STYLE}" --force -- "${FILE_PATH}" && exit 5
-            # pygmentize -f "${pygmentize_format}" -O "style=${PYGMENTIZE_STYLE}" -- "${FILE_PATH}" && exit 5
-            exit 2;;
-
-        # Image
-        image/*)
-            # Preview as text conversion
-            # img2txt --gamma=0.6 --width="${PV_WIDTH}" -- "${FILE_PATH}" && exit 4
-            exiftool "${FILE_PATH}" && exit 5
-            exit 1;;
-
-        # Video and audio
-        video/* | audio/*)
-            mediainfo "${FILE_PATH}" && exit 5
-            exiftool "${FILE_PATH}" && exit 5
-            exit 1;;
-    esac
-}
-
-handle_fallback() {
-    echo '----- File Type Classification -----' && file --dereference --brief -- "${FILE_PATH}" && exit 5
-    exit 1
-}
-
-
-MIMETYPE="$( file --dereference --brief --mime-type -- "${FILE_PATH}" )"
-if [[ "${PV_IMAGE_ENABLED}" == 'True' ]]; then
-    handle_image "${MIMETYPE}"
-fi
-handle_extension
-handle_mime "${MIMETYPE}"
-handle_fallback
-
-exit 1
diff --git a/config/.gtk-bookmarks b/config/.gtk-bookmarks
deleted file mode 100644
index 96227c0..0000000
--- a/config/.gtk-bookmarks
+++ /dev/null
@@ -1 +0,0 @@
-file:///home/tuan/.nextcloud/
diff --git a/config/.gtkrc-2.0 b/config/.gtkrc-2.0
deleted file mode 100644
index 536e5d1..0000000
--- a/config/.gtkrc-2.0
+++ /dev/null
@@ -1,18 +0,0 @@
-# DO NOT EDIT! This file will be overwritten by LXAppearance.
-# Any customization should be done in ~/.gtkrc-2.0.mine instead.
-
-include "/home/tuan/.gtkrc-2.0.mine"
-gtk-theme-name="Sweet"
-gtk-icon-theme-name="Arc"
-gtk-font-name="Hack Nerd Font Mono Regular 9"
-gtk-cursor-theme-name="Adwaita"
-gtk-cursor-theme-size=0
-gtk-toolbar-style=GTK_TOOLBAR_ICONS
-gtk-toolbar-icon-size=GTK_ICON_SIZE_LARGE_TOOLBAR
-gtk-button-images=0
-gtk-menu-images=0
-gtk-enable-event-sounds=1
-gtk-enable-input-feedback-sounds=1
-gtk-xft-antialias=1
-gtk-xft-hinting=1
-gtk-xft-hintstyle="hintmedium"
diff --git a/config/.local/share/ranger/bookmarks b/config/.local/share/ranger/bookmarks
index ce7f741..2ad7086 100644
--- a/config/.local/share/ranger/bookmarks
+++ b/config/.local/share/ranger/bookmarks
@@ -9,5 +9,5 @@ t:/home/tuan/Templates
 w:/home/tuan/workspace_l/Projects
 k:/home/tuan/Documents/CTF/TryHackMe/VulnUniversity
 q:/home/tuan/.nextcloud/Quick Drop
-':/home/tuan/.dotfiles/config/.config/ranger
+':/home/tuan/.local/share/ranger
 e:/home/tuan/Documents/CTF/TryHackMe/Ice/2_Recon
diff --git a/config/.scripts/i3lock.py b/config/.scripts/i3lock.py
index 73c6088..3c41ea6 100755
--- a/config/.scripts/i3lock.py
+++ b/config/.scripts/i3lock.py
@@ -191,4 +191,4 @@ if __name__ == '__main__':
         screenshot()
         pixelate()
         lock()
-        log(start_time)
+        # log(start_time)
diff --git a/config/.scripts/spotify-play.cpp b/config/.scripts/spotify-play.cpp
deleted file mode 100644
index bfed409..0000000
--- a/config/.scripts/spotify-play.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/*  ______  _________ _______  _______  _        _______ _________ _______  _______  _______ 
- * (  __  \ \__   __/(  ____ \(  ____ \( \      (  ___  )\__   __/(       )(  ____ \(  ____ )
- * | (  \  )   ) (   | (    \/| (    \/| (      | (   ) |   ) (   | () () || (    \/| (    )|
- * | |   ) |   | |   | (_____ | |      | |      | (___) |   | |   | || || || (__    | (____)|
- * | |   | |   | |   (_____  )| |      | |      |  ___  |   | |   | |(_)| ||  __)   |     __)
- * | |   ) |   | |         ) || |      | |      | (   ) |   | |   | |   | || (      | (\ (   
- * | (__/  )___) (___/\____) || (____/\| (____/\| )   ( |___) (___| )   ( || (____/\| ) \ \__
- * (______/ \_______/\_______)(_______/(_______/|/     \|\_______/|/     \|(_______/|/   \__/
- * 
- * 
- * THIS IS GARBAGE CODE AND I KNOW IT. 
- * I KNOW ABSOLUTLY NOTHING ABOUT C++ AND JUST FRANKENSTEINED
- * A BUNCH OF CODE SAMPLES, USING MY PYTHON CODE AS A TEMPLATE.
- */
-
-#include <sys/types.h>
-#include <unistd.h>
-#include <pwd.h>
-#include <dirent.h>
-#include <errno.h>
-#include <vector>
-#include <string>
-#include <fstream>
-#include <iostream>
-
-using namespace std;
-
-int getdir(string dir, vector<string> &files){
-  DIR *dp;
-  struct dirent *dirp;
-  if((dp = opendir(dir.c_str())) == NULL){
-    cout << "Error(" << errno << ") opening " << dir << endl;
-    return errno;
-  }
-
-  while ((dirp = readdir(dp)) != NULL){
-    files.push_back(string(dirp->d_name));
-  }
-  closedir(dp);
-  return 0;
-}
-
-string getfile(string file_path){
-  ifstream inFile;
-  string file_content;
-  inFile.open(file_path);
-  if(!inFile){
-    return "";
-  }
-  inFile >> file_content;
-  return file_content;
-}
-
-bool spotify_running(){
-  string dir = string("/proc/");
-  vector<string> processes = vector<string>();
-  getdir(dir, processes);
-  string proc_name = string("");
-  for (unsigned int i = 0; i < procs.size(); i++){
-    proc_name = dir + procs[i] + "/cmdline";
-    if(getfile(proc_name).find(string("/usr/bin/spotify")) != string::npos){
-      return true;
-    }
-  }
-  return false;
-}
-
-int main(){
-  //
-  struct passwd *pw = getpwuid(getuid());
-  const char *homedir = pw->pw_dir;
-  int state = -1;
-  int playstate = 0;
-  string playstate_file = "";
-  playstate_file += homedir + string("/.scripts/playstate");
-  while (spotify_running()){
-    usleep(100000);
-    // cout << spotify_running() << endl;
-    playstate = stoi(getfile(playstate_file));
-    if(playstate != state){
-      state = playstate;
-      if (state == 0){
-	cout << "" << endl;
-	system("playerctl pause");
-      }
-      else if (state == 1){
-	cout << "" << endl;
-	system("playerctl play");
-      }
-    }
-  }
-  cout << endl;
-}
diff --git a/config/.scripts/spotify-play.out b/config/.scripts/spotify-play.out
deleted file mode 100755
index 21aa910c5965d3d88bebbdd1bea5d718b57f0ea1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 39648
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

diff --git a/config/.scripts/spotify-play.py b/config/.scripts/spotify-play.py
deleted file mode 100755
index 48ad62e..0000000
--- a/config/.scripts/spotify-play.py
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/usr/bin/python
-import subprocess
-import time
-import os
-
-
-def find_proc(proc_name):
-    this_proc = "pythonspotify-play.py"
-    proc_path = '/proc'
-    proc = next(os.walk('{}/'.format(proc_path)))[1]
-    for process in proc:
-        cmdline_path = '{}/{}/cmdline'.format(proc_path,process)
-        try:
-            with open(cmdline_path, 'r') as cmd:
-                proc_content = cmd.readline()
-                if (proc_name in proc_content):
-                    return True
-        except FileNotFoundError:
-            pass
-    return False
-
-
-def spotify_running():
-    return find_proc('/usr/bin/spotify')
-
-
-def main():
-    state = -1
-    home = os.path.expanduser("~")
-    while spotify_running():
-        with open(home + '/.scripts/playstate', 'r') as f:
-            try:
-                file_state = int(f.readline().strip('\n'))
-            except ValueError:
-                pass
-        if state != file_state:
-            state = file_state
-            if state == 0:
-                print("")
-                subprocess.run(["playerctl","pause"])
-            elif state == 1:
-                print("")
-                subprocess.run(["playerctl","play"])
-        time.sleep(0.1)
-        
-if __name__ == '__main__':
-    main()
diff --git a/vim/.vim/.VimballRecord b/vim/.vim/.VimballRecord
deleted file mode 100644
index 0253393..0000000
--- a/vim/.vim/.VimballRecord
+++ /dev/null
@@ -1 +0,0 @@
-Colorizer.vmb: call delete('/home/tuan/.vim/plugin/ColorizerPlugin.vim')|call delete('/home/tuan/.vim/doc/Colorizer.txt')|call delete('/home/tuan/.vim/autoload/Colorizer.vim')
diff --git a/vim/.vim/spell/de.utf-8.add b/vim/.vim/spell/de.utf-8.add
index e8fd785..fc00579 100644
--- a/vim/.vim/spell/de.utf-8.add
+++ b/vim/.vim/spell/de.utf-8.add
@@ -1,856 +1,846 @@
-FSR
-Marecel
-Zutter
-FSK
-Karbe
-ICB
-tabbing
-Fotoboxen
-Datenschutzgrundverordnung
-DSGVO
-Freiverzehrkarte
-Busse
-StuPa
-Docs
-Busticket
-Studierendenwerk
-Softgetränke
-Water
-Science
-Micha
-Katha
-Komedia
-Tuan
-Planungstreffen
-FSRs
-Medizintechik
-Gästeliste
-VVK
-Tagesordnugnspunkte
-BEGINNING
-EDITABLE
-Dat
-Hilal
-FSE
-Bektas
-Abdallah
-Murad
-Waltmann
-Prochazka
-Dömckes
-Hasselhuhn
-Fachschaftsräte
-presFSR
-Schlittenhardt
-Bärserker
-Jöran
-Terminfindung
-Smartboard
-#VS
-VV
-Studierendenparlament
-#elbstbewirtschaftlung
-Ipek
-Nedzhati
-QVK
-Hochschulpolitik
-Selbstbewirtschaftung
-ESE
-Orientierungswoche
-Tutorenprogramm
-Bookstacks
-Erstifahrt
-Erstis
-Kundennummer
-Stauder
-Fachschaftenkonferenz
-Görges
-Studierendenschaft
-Weihnachts
-Orientierungswochen
-Flunkyballturnier
-Schützenbahn
-Einschreibezahlen
-Neustudierende
-myUDE
-App
-Fahrradreperaturstation
-Stottrop
-Rahmenordnungen
-Quartalstreffen
-Schneegaß
-Merch
-Gästelistenplatz
-Quartalstreffens
-Studienrelevantes
-Wahlauschusses
-Beckerpape
-Wahlauschuss
-Sitzungsdisziplin
-Sitzungsordnung
-Disziplinator
-Sitzungskodex
-Schlüsselrecht
-HG
-Schlüsselentzug
-Gästelistenplätzen
-Prozessdokumentation
-Bookstack
-testweise
-Prochazkas
-SME
-Zulassungssystem
-Masterstudiengangssystems
-Echtle
-white
-Whiteboard
-LUDIs
-Lern
-anderer
-Diskussionszentren
-Easteregg
-prüfungsfähig
-KN1
-Ratsarbeit
-HoPo
-absFSR
-anwHelper
-presGuest
-presBear
-O
-Herrn
-KKC
-T01
-#m
-#m
-Fahrscheinkontrolle
-gegendert
-#ertiefungsbereic
-Vertiefungsbereich
-Vertiefungsbereiche
-Rathgeb
-Smartboards
-Beamerfläche
-Fachschaftsratssitzung
-Whatsapp
-fsr
-nanoengineering
-Übungsblatt
-a
-b
-c
-d
-rechtslinear
-linkslinear
-Produktionsregeln
-Produktionsregel
-nichtterminalsymbole
-Eingabewort
-Überführungsfunktionen
-Bandalphabets
-Leistungszeitraum
-Rechnungs
-Campusse
-Inf
-Raumzugang
-SNE
-Bittners
-Bachelorstudiengang
-prüfungsunfähig
-Berichtspunkte
-Neuwirth
-Sellerbeck
-Vennemann
-Qualitätsverbesserungskomission
-Seier
-presHelper
-Cansu
-Akyüz
-Startzustand
-gefeba
-Anwendungsentwickler
-Studierendenberatung
-Fachschaftsrat
-Infrastrukturreferats
-Fachschaftsrates
-GitLab
-TS3
-Hauptverantwortlicher
-Erstsemestereinführung
-Deligierter
-Qualitätsverbesserungskommission
-Rektoratsgesprächen
-Musikpark
-Studienalltag
-zeitbeschränkt
-bandbeschränkt
-e
-n
-t
-z1
-z2
-z3
-LSB
-Ursprungsstelle
-OwnCloud
-Programmierungvorlesung
-Lastenfahrräder
-#eilnahmergebühren
-Betriebsysteme
-Rechnerstrukturen
-Wirtschaftsinformatiker
-Kimmeskamp
-Montoringprogramm
-Studierendenparlementssitzung
-Papierpakete
-Druckerpapier
-Erstitüten
-unbenotet
-unbenoteten
-Creditpunkte
-außeinanderzusetzen
-Teilnahmegebühren
-Fachschaftsraum
-Ambient
-Lights
-Buildcount
-Stoppanweisung
-IF
-SKIP
-GOTO
-THEN
-GOTOSTART
-M1
-M2
-x
-Schleifenbeginn
-Schleifenende
-f
-w
-l
-y
-mod
-Z
-Bsp
-k
-j
-i
-Studienbeiratssitzung
-erp4students
-Rektoratssitzung
-Gleichstellungsbeauftragten
-Masterstudiengang
-Modulhandbuch
-reverse
-pdf
-source
-Koczian
-Abdifitah
-Studienbeirat
-Medienschrank
-Teambildende
-Professorengespräche
-Hygienedienst
-Gegenstandsverzeichnisses
-Gegenstandsverzeichnis
-#affemschinen
-Kaffemaschinen
-Snippets
 #
-Vorverarbeitungsfunktion
-Mohamed
-Mech
-Instagram
-Postvorlage
-textbasierte
-Posts
-sponsored
-Gleistellungsbeauftragte
-ZIM
-Evaluierungskomissionen
-Fakultätsratssitzung
-Evaluierungskomission
-schonmal
-vorgeglüht
-Bauingeneurwesen
-klingonischer
-Helferantrag
-Fürstimmen
-Entschuldigungsstatus
-Konteneröffnung
-Werbeposter
-Beitragsvorlage
-h
-vorfomuliert
-Programmier
-Stritzel
-Moodle
+#a
+a
+A2
+Abdallah
+Abdifitah
+absFSR
 #achschaftbezahlten
-Davi
-#oche
-Ersti
-Busanbindung
-Dogs
-spreadshirt
-Bauingeneurswesen
-#ergleisweis
-vergleisweise
-Einwurfschlitz
-Fachschaftsrathelfer
-Sitzungstermin
-Vorlesungsbeginn
-Sitzungstermine
-Putzdienstes
-Tischmülleimer
-Fachschafts
-Lernraumes
-Dechenstraße
-Gladbeck
-s
-DBMS
-wegklicken
-Personalkarten
-Aufderlandwehr
-Bittner
-Filipp
-Dolshanski
-Philip
-Josie
-Frese
-Grei
-Hetkämper
-Hülsmann
-Komnick
-Lampret
-Ploog
-Reistorff
-Haefs
-Smets
-Thiemann
-Tsafos
-Aylin
-Wollatz
-Frederik
-Myriam
-Weinz
-Röttges
-Janzik
+Active
+Adomas
+#affemschinen
+Ahlemann
+AirSniff
+Akduell
+Akyüz
+Alanah
 Aledia
-Security
-Andert
 Aline
+Almeida
+Ambient
+Ambilights
+Ambrosius
+anderer
+Andert
+Anil
+#ansponderschloss
+Anwendungsentwickler
+Anwendungsntwicklung
+anwHelper
+App
+Ashef
 Aslan
-Ömer
+ASP
+AStAs
+asyncio
 Athanasiadis
-Christos
-Phish
-NanoEngineering
+Aufderlandwehr
+außeinanderzusetzen
+Außenaktivitäten
+auswertung
+Aylin
+#b
+b
+B1
+Bachelorarbeit
+Bachelorarbeitsnote
+Bachelorstudiengang
+Bakir
+Banas
+Bandalphabets
+bandbeschränkt
 Bangel
+Bärserker
 Bathon
+Batuhan
+Bauingeneurwesen
 Baumert
+Beamerfläche
+Beckerpape
+BEGINNING
+Beitragsvorlage
+Bektas
 Bereska
+Berichtspunkte
 Bernemann
+Berufungskomission
+Beschaffungsantrag
+Besetzungskommmission
 Bestgen
+besuch
+Betriebsysteme
+Beyer
 Biebeck
+Bildungsaspekt
+Bittner
+Bittners
 Bojahr
-Schagen
-ISE
+Bookstack
+Bookstacks
+boolean
+Bootstrap
 Boscheck
 Boßeler
+Boxes
+Brauerreitour
+Brinda
 Brökelschen
 Bruns
+Bsp
+Buciunes
 Buddenbohm
+Buildcount
 Bulavintseva
+Buono
 Burczyk
+Burgmann
+Busanbindung
 Bushran
-Shashi
-Valeriya
+Busse
+Busticket
+c
+C2
+Campusse
+Campussen
+Cansu
+CaSchü
+Ceyda
+Challenges
+chart
+Christos
+Cirriculum
+cloud
+Concurrency
+Correct
+Credit
+Creditpunkte
+CSS
+CTF
+d
+Darleen
+Dat
+Datenbankmanagementsystem
+Datenbanktabelle
+Datenschutzgrundverordnung
+Davi
+david
+DBMS
+Debian
+Dechenstraße
+Deckenhalterung
+Deligierter
+Desktopanwendungen
 Dette
+Deutschtest
 Dewert
+Diskussionszentren
+Disziplinator
 Dittler
-Thuy
-Trang
+docker
+Docs
+Dogan
+Dogs
+Dolshanski
+Dömckes
+Dorit
+Dreizehnlindenhalle
+dringstens
+Drittveranstaltungen
+Druckerpapier
+DSGVO
+due
+durchzuplanen
+e
+Easteregg
+Echtle
+edge
+EDITABLE
+eduroam
+eduroams
+Eikemper
+#eilnahmergebühren
+Eingabewort
+Einschreibezahlen
+Einwurfschlitz
+Eirich
+#eitereführen
+#elbstbewirtschaftlung
+Elif
+emacs
+Entschuldigungsstatus
 Erdmann
+#ergleisweis
+erp4students
+Ersatzschlüssel
+Ersti
+Erstifahrt
+Erstis
+Erstitüten
+Erstsemestereinführung
+Erstsemesterfahrt
+Erstsemster
+Erstsemstern
 Ertas
+#ertiefungsbereic
+ESE
+Essensflatrate
+Evaluierungskomission
+Evaluierungskomissionen
+Excel
+Exmatrikulierung
+exterene
+f
+fachchaftsnahe
+Fachschaftenkonferenz
+Fachschafts
+Fachschaftsrat
+Fachschaftsräte
+Fachschaftsrates
+Fachschaftsrathelfer
+Fachschaftsratsmitglied
+Fachschaftsratsmitglieder
+Fachschaftsratssitzung
+Fachschaftsraum
+Fachschaftsraums
+Fachschaftstreffen
+Fachschaftsveranstaltungen
+Fachschaftsvollversammlung
+Fahrradreperaturstation
+Fahrscheinkontrolle
+Fakultätsratssitzung
+Fakultätszusammenlegung
+false
 Fanke
-Batuhan
-Zhou
+Filipp
+Finanzreferat
+flag
+Flunkyballturnier
+Folke
+Formating
+formatting
+Forms
+Fotoboxen
+Framework
+Frameworks
+Frederik
+Freefloating
+Freiverzehrkarte
+Fremdbibliotheken
+Frese
+Freundel
+Fritsch
+fse
+FSE
+FSK
+FSKs
+fsr
+FSR
+FSRs
+FSVV
+Funkenberg
+Fürstimmen
+FZS
+Gamenight
+Gästeliste
+Gästelistenplatz
+Gästelistenplätzen
+Gebäudemanagement
+Gebäudemanagements
+Gebäudezugang
+gefeba
+gegendert
+Gegenstandsverzeichnis
+Gegenstandsverzeichnisses
+Geochaching
+Gesundheitsbelehrung
+Gesundheitsbelehrungen
+Geurtz
+Giebeler
+Git
+GitLab
+Gladbeck
+Glaspavillion
+Gleichstellungsbeauftragten
+Gleistellungsbeauftragte
+Goedicke
+Golenia
+GoogleCTF
+Gördes
+Görgens
+Görges
+GOTO
+GOTOSTART
+Grei
+Gremienmails
+Gremienplätze
+Gremienwahlen
+Gremzo
+Grinewitschus
+Gritzner
+Günes
+h
+Häckner
+Haefs
+Hallekamp
 Han
-Zhang
+Hardening
+Hartnagel
+Hasselhuhn
+Hauptcampus
+Hauptverantwortlicher
+Heckschen
+Heghmanns
+Heitmann
+Helferantrag
+Henscheid
+Herbrich
+Herrn
+Heßeling
+Hesselmann
+Hetkämper
+Hetmank
+Hetzel
+Heyermann
+HG
+HHJ
+HHP
+Hilal
+Hißmann
+Hochschulpolitik
+Högden
+Hondar
+hopo
+HoPo
+Horlemann
+Hoßfeld
+How2Rat
+Hülsmann
+Hülzevoort
+Hygienedienst
+Hyperthreading
+i
+ICB
+if
+IF
+#igitalisierung
+Immel
+Inf
+info
+Inforeferat
+Infragistics
+Infrastrukturreferats
+Ingrun
+Instagram
+IoT
+Ipek
+Isabell
+ISE
+Isidorovic
+itemize
+j
+Janke
+Janzik
+Jarno
+Jeske
 Jessie
-Wurzalla
-Waasmann
-Ullrich
-Turman
-Triquart
+Jian
+Joey
+Johannimloh
+Jöran
+Josie
+Juniorprofessorenevaluierungskomissionen
+Jurij
+Justizariat
+k
+Kaczmarek
+Kaffemaschinen
+Kaldewey
+Kalkowsky
+Kampmann
+Kandidaturaufstellung
+Kara
+Karas
+Karbe
+Kassenprüferin
+Katha
+Kelm
+Kimmeskamp
+KKC
+Klausurbeaufsichtigung
+Klausurrunde
+Kleingruppen
+klingonischer
+Klinikmensa
+KN1
+Koczian
+Kolfenbach
+Komedia
+Komnick
+Konteneröffnung
+Kontowski
+Kopka
+krankheitsbedingt
+Kretzschmar
+Kristof
+Kulturanteil
+Kundennummer
+l
+Ladezeiten
+Lampret
+Landeslehrendenpreis
+#lankboxes
+Lärmquellekatalog
+LaSoWi
+Lastenfahrräder
+Latza
+Lehnert
+Lehramter
+Lehramtlern
+Lehramtsstudierende
+Lehramtsstudierenden
+Lehramtsstudierender
+Lehramtsstudierenenden
+Lehrauslastung
+Lehrräume
+Leistungszeitraum
+Lern
+Lerngruppen
+Lernnacht
+Lernnächte
+Lernraum
+Lernraumes
+Lights
+linkslinear
+LINQ
+Lipfert
+Ljubisav
+Löppenberg
+LSB
+Lückenjans
+LuDi
+LuDI
+LuDis
+LUDIs
+#m
+M1
+M2
+Mahngelder
+Manske
+Manthey
+Marecel
+Maruan
+Masterstudiengang
+Masterstudiengangssystems
+Masterzulassungen
+Mech
+Medienschrank
+MediTech
+Medizintechik
+Meilan
+Meisner
+Mensastammtisch
+Merch
+Mettbach
+Micha
+Michèle
+Michen
+Microcontroller
+Miera
+Mikulicz
+Miltner
+mit
+mitbeworben
+mitüberprüft
+mktitle
+mod
+Modulhandbuch
+Mohamed
+Mölders
+Mommertz
+Monsees
+Montoringprogramm
+Moodle
+Moreno
+Mrzyk
+Multicores
+Multithreading
+Murad
+Muschalik
+Musebrink
+Museumsbesuch
+Musikpark
+MVC
+Myriam
+myUDE
+n
+Nachtermin
+Nachterminklausuren
+nanoengineering
+NanoEngineering
+Nashed
+Nebenläufiger
+Necker
+Nedzhati
+Nendrup
+Networking
+Neustudierende
+Neustudierenden
+Neuwirth
+Nextbike
+ng2
+Nguyen
+nichtterminalsymbole
+night
+Nikolaos
+Ninian
+Nohman
+Nuevo
+Nutzungsregeln
+O
+#oche
+of
+Oktoberwochenende
+Olligs
+Ömer
+optimalerweise
+Oracle
+Orhan
+Orientierungswoche
+Orientierungswochen
+#orran
+Ortabas
+#osh
 Ostasienwissenschaften
+Ostkamp
+OwnCloud
+Özlem
+p1
+p2
+paassen
+Paaßen
+PACKAGES
+Pannhausen
+Papierpakete
+pdf
+Personalkarten
+Personenbeförderungsschein
+Pflichtterminen
+Philip
+Phish
+picoCTF
+PicoCTF
+Pinar
+Planungstreffen
+Plewa
+Ploog
+Podday
+Points
+Poos
+Pöss
+Posts
+Postvorlage
+Powerpoint
+presBear
+presFSR
+presGuest
+presHelper
+print
+Prochazka
+Prochazkas
+Produktionsregel
+Produktionsregeln
+Professorengespräche
+Profiling
+Programmier
+Programmierclub
+Programmierungvorlesung
+Proxmox
+Prozessdokumentation
+Prüfungsamt
+Prüfungsauschüsse
+prüfungsfähig
+Prüfungsleistung
+prüfungsunfähig
+Pseudonymisierung
+Pseudonymklausur
+Putzdienstes
+Pytlik
+q
+q1
+q2
+q3
+Qualitätsverbesserungskomission
+Qualitätsverbesserungskommission
+Qualitätsverbesserungskonferenz
+Qualitätsverbesserungsmittel
+Quartalstreffen
+Quartalstreffens
+Quittungsnummern
+QVK
+Rachul
+Rademaker
+Rahmatullah
+Rahmenordnungen
+Rathgeb
+Rathofer
+Ratnere
+Ratsarbeit
+Ratsvorstellung
+Ratswahl
+Rauls
+Raumplan
+Raumzugang
+Rechnerstrukturen
+Rechnungs
+rechtslinear
+Regularia
+Reinigungskosten
+Reisebusse
+Reistorff
+Rektoratsgesprächen
+Rektoratssitzung
+Requests
+reverse
+Riemk
+Riesner
+Robeck
+Rößing
+Röttges
+#rschritten
+Rümeysa
+s
+#S
+Salhi
+Samir
+Samsung
+Sarina
+Sauerbrei
+Schagen
+Scheiermann
+Scheiler
+Schendel
+Schendzielorz
+Scheychon
+Scheyon
+Schlautmann
+Schleifenbeginn
+Schleifenende
+Schlittenhardt
+Schlottmann
+Schlung
+Schlüsselanhänger
+Schlüsselentzug
+Schlüsselrecht
+Schmiedtchen
+Schneegaß
+Schnupperuni
+schonmal
+Schönrath
+Schülerpraktikum
+Schulungstermine
+Schuppert
+Schützenbahn
+Science
+Scraping
+scripting
+Scripting
+SCSS
+Security
+Seier
+selbstbewirtschaftet
+Selbstbewirtschaftung
+Sellerbeck
+Senatsleute
+Senatswahlen
+SEP
+Serververwaltung
+Sever
+Shashi
+shell
+SHORTCUTS
+Sicherheits
+Sicherheitschallenegs
+Sicking
+Siegmann
+Sitzungsdisziplin
+Sitzungskodex
+Sitzungsordnung
+Sitzungstermin
+Sitzungstermine
+SKIP
+Skubski
+SM
+Smartboard
+Smartboards
+SME
+Smets
+SNE
+Snippets
+Softgetränke
+SommerUni
+source
+SoWi
+sponsored
+Sprachverwendung
+spreadshirt
+Spyrou
+SS20
+SSL
+Startzustand
+Statusm0n
+Stauder
+Sterzing
+Stoppanweisung
+Stottrop
+Stritzel
+Studienalltag
+Studienbeirat
+Studienbeirates
+Studienbeirats
+Studienbeiratssitzung
+Studienrelevantes
+Studierendenberatung
+Studierendenparlament
+Studierendenparlementssitzung
+Studierendenschaft
+Studierendenwerk
+Studiumverlaufsplan
+StuPa
 Südholt
+SVN
 Sygulla
+Systemadministration
+t
+T01
+tabbing
+Tagesordnugnspunkte
+Teambildende
+Teilnahmebeitrag
+Teilnahmegebühren
 Tekaat
 Tellbüscher
 Tepper
 Terdin
 Teriete
+Terminfindung
+testweise
 Tetos
+textbasierte
+Textnachricht
+THEN
+Thiele
+Thiemann
 Thom
+Thuy
+Tinoco
+Tischmülleimer
+To
 Todenhöfer
 Tonkel
-Anil
-Vivien
-Nikolaos
-Darleen
-Plewa
-Rachul
-Rahmatullah
-Ashef
-Rathofer
-Ratnere
-Rauls
-Riemk
-Riesner
-Robeck
-Sauerbrei
-Scheiermann
-Scheiler
-Schendzielorz
-Schlottmann
-Schlung
-Dorit
-Sicking
-Ninian
-Schmiedtchen
-Schönrath
-Schuppert
-Spyrou
-Sterzing
-Hartnagel
-Heckschen
-Henscheid
-Herbrich
-Heßeling
-Hetzel
-Heyermann
-Hißmann
-Högden
-Hondar
-Jurij
-Hülzevoort
-Wirtschaftspädagogik
-Immel
-Isidorovic
-Ljubisav
-Joey
-Janke
-Jeske
-Jeske
-Michèle
-Kaczmarek
-Karas
-Kelm
-Kolfenbach
-Kontowski
-Kretzschmar
-Latza
-Latza
-Lipfert
-Löppenberg
-Manske
-Mettbach
-Michen
-Mölders
-Monsees
-Moreno
-Murad
-Muschalik
-Musebrink
-Nashed
-Necker
-Nendrup
-Nguyen
-Olligs
-Olligs
-Ortabas
-Ostkamp
-Elif
-Ceyda
-Samir
-Ingrun
-Freundel
-Fritsch
-Funkenberg
-Geurtz
-Giebeler
-Golenia
-Görgens
-Grinewitschus
-Gritzner
-Häckner
-Hallekamp
-Kaldewey
-Jian
-To
-Pöss
-Sever
-Buono
-Zöller
-Kopka
 Trampnau
-Gremzo
-Vorjohann
-Gördes
-Mrzyk
-Beyer
-Pytlik
-Kara
-Pinar
-Isabell
-Manthey
-Buciunes
-Adomas
-Schlautmann
-Heitmann
-Kristof
-WirtschaftsIng
-Banas
-Jarno
-Sarina
-Wronna
-Mommertz
-Hesselmann
-Kalkowsky
-SoWi
-Scheyon
-LaSoWi
-Wißmann
-Horlemann
-Podday
-Mikulicz
-Tinoco
-Zirger
-Veseljak
-Johannimloh
-Heghmanns
-Folke
-Günes
-Miltner
-Dogan
-Eirich
-Lückenjans
-Maruan
-Salhi
-Rößing
-MediTech
-Burgmann
-Ambrosius
-Siegmann
-Almeida
-Pannhausen
-Thiele
-Wegenaer
-Kampmann
-Scheychon
-Nuevo
-Vierheilig
-Meilan
-Nohman
-Bakir
-Alanah
-WiWi
-Voteller
-Datenbankmanagementsystem
+Trang
 Transaktionsmanagement
-Datenbanktabelle
-behebung
-widerprüchliche
-Programmierclub
-Concurrency
-Kleingruppen
-Zentralübung
-Paaßen
-david
-paassen
-due
-edge
-cloud
-Multithreading
-Multicores
-Hyperthreading
-Ersatzschlüssel
-Vertrauenskasse
-Meisner
-Goedicke
-Vollzugriff
-Senatsleute
+Transponderschloss
+Triquart
+TS3
+Tsafos
+Tuan
+Turman
+Tutorenprogramm
+TypeScript
+Ü2
+Überführungsfunktionen
+Übungsblatt
+Ullrich
+unbenotet
+unbenoteten
+Ungleichverteilung
+Unipolitik
+#urchzufuHren
+Ursprungsstelle
+Utz
+Valeriya
+VCS
+Vennemann
+verarbeitung
+vergleisweise
 Versorgungsbudget
-Beschaffungsantrag
+Vertiefungsbereich
+Vertiefungsbereiche
+Vertrauenskasse
+Veseljak
+Vierheilig
+vim
+Visio
+Vivien
+Vollzugriff
+vorfomuliert
+vorgeglüht
+Vorjohann
+Vorlesungsbeginn
+Vorterminen
+Vorverarbeitungsfunktion
+Voteller
+#VS
+VV
+VVK
+w
+Waas
+Waasmann
+Wahlauschuss
+Wahlauschusses
+Wahlmodalitäten
+Waltmann
+Water
+Webentwicklung
+Wegenaer
+wegklicken
+Weihnachts
+Weinz
+Werbeposter
+Whatsapp
+while
+white
+Whiteboard
+Whiteboards
+widerprüchliche
+WinForms
+Wirtschaftsinformatik
+Wirtschaftsinformatiker
+WirtschaftsIng
+Wirtschaftspädagogik
+Wißmann
+WiWi
+Wolfssee
+Wollatz
+Workload
+Wronna
+WS21
+Wunschtag
+Wurzalla
+x
+y
+Yilmaz
+Z
+z1
+z2
+z3
 Zahlungsbereitschaft
 Zahlungshinweis
-Fakultätszusammenlegung
-exterene
-CaSchü
-Klinikmensa
-Juniorprofessorenevaluierungskomissionen
-Lärmquellekatalog
-Fachschaftsratsmitglieder
-Fachschaftsveranstaltungen
-Drittveranstaltungen
-FZS
-besuch
-Nebenläufiger
-print
-while
-q2
-q1
-q
-Ü2
-PACKAGES
-Correct
-Formating
-#lankboxes
-Boxes
-mktitle
-formatting
-SHORTCUTS
-p1
-p2
-boolean
-flag
-false
-if
-q3
-Excel
-Powerpoint
-zweitsprachig
-C2
-Schülerpraktikum
-Cirriculum
-of
-VCS
-Mahngelder
-Gebäudemanagement
-Gebäudemanagements
-Forms
-CSS
-TypeScript
-Bootstrap
-SCSS
-Infragistics
-Framework
-ASP
-LINQ
-Webentwicklung
-ng2
-chart
-asyncio
-Serververwaltung
-Oracle
-Anwendungsntwicklung
-Debian
-Scripting
-Active
-Benutzerverwalung
-Proxmox
-Hardening
-Git
-SVN
-MVC
-CTF
-Challenges
-Sicherheits
-PicoCTF
-GoogleCTF
-picoCTF
-B1
-Microcontroller
-Sicherheitschallenegs
-Visio
-Sprachverwendung
-A2
-verarbeitung
-WinForms
-Scraping
-auswertung
-Lernnacht
-Pseudonymklausur
-SommerUni
-Nutzungsregeln
-Akduell
-Besetzungskommmission
-Mensastammtisch
-Wolfssee
-Nextbike
-Freefloating
-Hetmank
-Fachschaftsratsmitglied
-Studienbeirats
-Qualitätsverbesserungskonferenz
-Studienbeirates
-How2Rat
-Gamenight
-mit
-#urchzufuHren
-Pseudonymisierung
-eduroams
-eduroam
-SSL
-Schnupperuni
-fachchaftsnahe
-Zulassungsgrenze
-Justizariat
-Bachelorarbeit
-mitüberprüft
-Bachelorarbeitsnote
-Masterzulassungen
-Klausurbeaufsichtigung
-mitbeworben
-Glaspavillion
-Reinigungskosten
-Inforeferat
-Zugangskarten
+zeitbeschränkt
+Zentralübung
+Zhang
+Zhou
+ZIM
+Zirger
+Zöller
 Zugangsgenehmigung
-Gebäudezugang
-Waas
-Qualitätsverbesserungsmittel
-Whiteboards
-Lehrräume
-Landeslehrendenpreis
-#ansponderschloss
-LuDi
-Geochaching
-Außenaktivitäten
-Bildungsaspekt
-Brauerreitour
-durchzuplanen
-Gesundheitsbelehrung
-Oktoberwochenende
-info
-fse
-Exmatrikulierung
-itemize
-Utz
-Ungleichverteilung
-Transponderschloss
-Lerngruppen
-Fachschaftsraums
-Nachtermin
-Vorterminen
-Essensflatrate
-Textnachricht
-Reisebusse
-Museumsbesuch
-Dreizehnlindenhalle
-Ahlemann
-Kulturanteil
-Personenbeförderungsschein
-optimalerweise
-Samsung
-Quittungsnummern
-Raumplan
-Prüfungsamt
-Nachterminklausuren
-Senatswahlen
-Kandidaturaufstellung
-Gremienmails
-hopo
-Neustudierenden
-Ratsvorstellung
-Statusm0n
-SS20
-WS21
-Deutschtest
-Lehrauslastung
-night
-Deckenhalterung
-SM
-Ratswahl
-HHP
-HHJ
-Fachschaftstreffen
-Erstsemesterfahrt
-#osh
-Profiling
-Klausurrunde
-Lehramtlern
-Gremienwahlen
-Gesundheitsbelehrungen
-Wunschtag
-FSKs
+Zugangskarten
+Zulassungsgrenze
 Zulassungskriterien
-Ladezeiten
-Lernraum
-Prüfungsleistung
-Lehramter
-Fremdbibliotheken
-Studiumverlaufsplan
-Lehramtsstudierenden
-Workload
-Pflichtterminen
-Zweitfächer
-Lehramtsstudierende
-SEP
-Points
-Credit
-Wirtschaftsinformatik
-Schlüsselanhänger
-Teilnahmebeitrag
-selbstbewirtschaftet
-Finanzreferat
-dringstens
-Schulungstermine
-Unipolitik
-Rademaker
-Özlem
-Yilmaz
-Rümeysa
-Orhan
-AStAs
-Brinda
-Prüfungsauschüsse
-LuDI
-Berufungskomission
-Hoßfeld
-Systemadministration
-Gremienplätze
-#rschritten
-#
-#
-#a
-#S
-#b
-Regularia
-Wahlmodalitäten
-Fachschaftsvollversammlung
-LuDis
 Zulassungsordnung
-Networking
-#eitereführen
-#orran
-Miera
-Lernnächte
-Erstsemstern
-Schendel
-Ambilights
-Lehramtsstudierenenden
-Erstsemster
-Skubski
-Eikemper
-krankheitsbedingt
-Lehramtsstudierender
-Lehnert
-Kassenprüferin
-FSVV
+Zulassungssystem
 Zusammlegung
-#igitalisierung
-Hauptcampus
-Campussen
-Desktopanwendungen
-Requests
-IoT
-emacs
-vim
-docker
-shell
-scripting
-Frameworks
-AirSniff
-Poos
+Zutter
+Zweitfächer
+zweitsprachig
diff --git a/vim/.vim/templates/writeup.md b/vim/.vim/templates/writeup.md
deleted file mode 100644
index 5cdbe0b..0000000
--- a/vim/.vim/templates/writeup.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# 
-
-**Category:** 
-**Points:** 
-
-## Challenge
->
-
-## Solution
-
-### Flag
-``