Massive change to the structure of the tree.

2025-03-10 23:59:38 +01:00 · 2025-03-10 23:59:38 +01:00 · c71934ed3b
commit c71934ed3b
parent 2fc5f7a514
137 changed files with 51 additions and 266 deletions
--- a/_saved/_suckless/dmenu/LICENSE
+++ b/_saved/_suckless/dmenu/LICENSE
@ -0,0 +1,30 @@
+MIT/X Consortium License
+
+© 2006-2019 Anselm R Garbe <anselm@garbe.ca>
+© 2006-2008 Sander van Dijk <a.h.vandijk@gmail.com>
+© 2006-2007 Michał Janeczek <janeczek@gmail.com>
+© 2007 Kris Maglione <jg@suckless.org>
+© 2009 Gottox <gottox@s01.de>
+© 2009 Markus Schnalke <meillo@marmaro.de>
+© 2009 Evan Gates <evan.gates@gmail.com>
+© 2010-2012 Connor Lane Smith <cls@lubutu.com>
+© 2014-2022 Hiltjo Posthuma <hiltjo@codemadness.org>
+© 2015-2019 Quentin Rameau <quinq@fifth.space>
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/_saved/_suckless/dmenu/Makefile
+++ b/_saved/_suckless/dmenu/Makefile
@ -0,0 +1,64 @@
+# dmenu - dynamic menu
+# See LICENSE file for copyright and license details.
+
+include config.mk
+
+SRC = drw.c dmenu.c stest.c util.c
+OBJ = $(SRC:.c=.o)
+
+all: options dmenu stest
+
+options:
+	@echo dmenu build options:
+	@echo "CFLAGS   = $(CFLAGS)"
+	@echo "LDFLAGS  = $(LDFLAGS)"
+	@echo "CC       = $(CC)"
+
+.c.o:
+	$(CC) -c $(CFLAGS) $<
+
+config.h:
+	cp config.def.h $@
+
+$(OBJ): arg.h config.h config.mk drw.h
+
+dmenu: dmenu.o drw.o util.o
+	$(CC) -o $@ dmenu.o drw.o util.o $(LDFLAGS)
+
+stest: stest.o
+	$(CC) -o $@ stest.o $(LDFLAGS)
+
+clean:
+	rm -f dmenu stest $(OBJ) dmenu-$(VERSION).tar.gz
+
+dist: clean
+	mkdir -p dmenu-$(VERSION)
+	cp LICENSE Makefile README arg.h config.def.h config.mk dmenu.1\
+		drw.h util.h dmenu_path dmenu_run stest.1 $(SRC)\
+		dmenu-$(VERSION)
+	tar -cf dmenu-$(VERSION).tar dmenu-$(VERSION)
+	gzip dmenu-$(VERSION).tar
+	rm -rf dmenu-$(VERSION)
+
+install: all
+	mkdir -p $(DESTDIR)$(PREFIX)/bin
+	cp -f dmenu dmenu_path dmenu_run stest $(DESTDIR)$(PREFIX)/bin
+	chmod 755 $(DESTDIR)$(PREFIX)/bin/dmenu
+	chmod 755 $(DESTDIR)$(PREFIX)/bin/dmenu_path
+	chmod 755 $(DESTDIR)$(PREFIX)/bin/dmenu_run
+	chmod 755 $(DESTDIR)$(PREFIX)/bin/stest
+	mkdir -p $(DESTDIR)$(MANPREFIX)/man1
+	sed "s/VERSION/$(VERSION)/g" < dmenu.1 > $(DESTDIR)$(MANPREFIX)/man1/dmenu.1
+	sed "s/VERSION/$(VERSION)/g" < stest.1 > $(DESTDIR)$(MANPREFIX)/man1/stest.1
+	chmod 644 $(DESTDIR)$(MANPREFIX)/man1/dmenu.1
+	chmod 644 $(DESTDIR)$(MANPREFIX)/man1/stest.1
+
+uninstall:
+	rm -f $(DESTDIR)$(PREFIX)/bin/dmenu\
+		$(DESTDIR)$(PREFIX)/bin/dmenu_path\
+		$(DESTDIR)$(PREFIX)/bin/dmenu_run\
+		$(DESTDIR)$(PREFIX)/bin/stest\
+		$(DESTDIR)$(MANPREFIX)/man1/dmenu.1\
+		$(DESTDIR)$(MANPREFIX)/man1/stest.1
+
+.PHONY: all options clean dist install uninstall
--- a/_saved/_suckless/dmenu/README.md
+++ b/_saved/_suckless/dmenu/README.md
@ -0,0 +1,25 @@
+# ftpd's dmenu build
+
+## Patches applied
+
+These patches from suckless.org were applied from the newest versions, in order:
+
+1. `dmenu-border-20201112-1a13d04.diff`
+1. `dmenu-center-20200111-8cd37e1.diff`
+
+## Fix color emoji
+
+Delete the following from drw.c:
+
+    /* Do not allow using color fonts. This is a workaround for a BadLength
+     * error from Xft with color glyphs. Modelled on the Xterm workaround. See
+     * https://bugzilla.redhat.com/show_bug.cgi?id=1498269
+     * https://lists.suckless.org/dev/1701/30932.html
+     * https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=916349
+     * and lots more all over the internet.
+     */
+    FcBool iscol;
+    if(FcPatternGetBool(xfont->pattern, FC_COLOR, 0, &iscol) == FcResultMatch && iscol) {
+    	XftFontClose(drw->dpy, xfont);
+    	return NULL;
+    }
--- a/_saved/_suckless/dmenu/arg.h
+++ b/_saved/_suckless/dmenu/arg.h
@ -0,0 +1,49 @@
+/*
+ * Copy me if you can.
+ * by 20h
+ */
+
+#ifndef ARG_H__
+#define ARG_H__
+
+extern char *argv0;
+
+/* use main(int argc, char *argv[]) */
+#define ARGBEGIN	for (argv0 = *argv, argv++, argc--;\
+					argv[0] && argv[0][0] == '-'\
+					&& argv[0][1];\
+					argc--, argv++) {\
+				char argc_;\
+				char **argv_;\
+				int brk_;\
+				if (argv[0][1] == '-' && argv[0][2] == '\0') {\
+					argv++;\
+					argc--;\
+					break;\
+				}\
+				for (brk_ = 0, argv[0]++, argv_ = argv;\
+						argv[0][0] && !brk_;\
+						argv[0]++) {\
+					if (argv_ != argv)\
+						break;\
+					argc_ = argv[0][0];\
+					switch (argc_)
+
+#define ARGEND			}\
+			}
+
+#define ARGC()		argc_
+
+#define EARGF(x)	((argv[0][1] == '\0' && argv[1] == NULL)?\
+				((x), abort(), (char *)0) :\
+				(brk_ = 1, (argv[0][1] != '\0')?\
+					(&argv[0][1]) :\
+					(argc--, argv++, argv[0])))
+
+#define ARGF()		((argv[0][1] == '\0' && argv[1] == NULL)?\
+				(char *)0 :\
+				(brk_ = 1, (argv[0][1] != '\0')?\
+					(&argv[0][1]) :\
+					(argc--, argv++, argv[0])))
+
+#endif
--- a/_saved/_suckless/dmenu/config.def.h
+++ b/_saved/_suckless/dmenu/config.def.h
@ -0,0 +1,28 @@
+/* See LICENSE file for copyright and license details. */
+/* Default settings; can be overriden by command line. */
+
+static int topbar = 1;                      /* -b  option; if 0, dmenu appears at bottom     */
+static int centered = 0;                    /* -c option; centers dmenu on screen */
+static int min_width = 500;                    /* minimum width when centered */
+/* -fn option overrides fonts[0]; default X11 font or font set */
+static const char *fonts[] = {
+	"monospace:size=10"
+};
+static const char *prompt      = NULL;      /* -p  option; prompt to the left of input field */
+static const char *colors[SchemeLast][2] = {
+	/*     fg         bg       */
+	[SchemeNorm] = { "#bbbbbb", "#222222" },
+	[SchemeSel] = { "#eeeeee", "#005577" },
+	[SchemeOut] = { "#000000", "#00ffff" },
+};
+/* -l option; if nonzero, dmenu uses vertical list with given number of lines */
+static unsigned int lines      = 0;
+
+/*
+ * Characters not considered part of a word while deleting words
+ * for example: " /?\"&[]"
+ */
+static const char worddelimiters[] = " ";
+
+/* Size of the window border */
+static unsigned int border_width = 0;
--- a/_saved/_suckless/dmenu/config.h
+++ b/_saved/_suckless/dmenu/config.h
@ -0,0 +1,29 @@
+/* See LICENSE file for copyright and license details. */
+/* Default settings; can be overriden by command line. */
+
+static int topbar = 1;                      /* -b  option; if 0, dmenu appears at bottom     */
+static int centered = 0;                    /* -c option; centers dmenu on screen */
+static int min_width = 500;                    /* minimum width when centered */
+/* -fn option overrides fonts[0]; default X11 font or font set */
+static const char *fonts[] = {
+  "RobotoMono Nerd Font:style=Medium:size=10",
+  "Noto Color Emoji:style=Regular:size=12",
+};
+static const char *prompt      = NULL;      /* -p  option; prompt to the left of input field */
+static const char *colors[SchemeLast][2] = {
+  /*               fg         bg       */
+  [SchemeNorm] = { "#c7c7c7", "#272822" },
+  [SchemeSel] =  { "#e6e1cf", "#005577" },
+  [SchemeOut] =  { "#000000", "#005577" },
+};
+/* -l option; if nonzero, dmenu uses vertical list with given number of lines */
+static unsigned int lines      = 0;
+
+/*
+ * Characters not considered part of a word while deleting words
+ * for example: " /?\"&[]"
+ */
+static const char worddelimiters[] = " ";
+
+/* Size of the window border */
+static unsigned int border_width = 5;
--- a/_saved/_suckless/dmenu/config.mk
+++ b/_saved/_suckless/dmenu/config.mk
@ -0,0 +1,32 @@
+# dmenu version
+VERSION = 5.2
+
+# paths
+PREFIX = /usr/local
+MANPREFIX = $(PREFIX)/share/man
+
+X11INC = /usr/X11R6/include
+X11LIB = /usr/X11R6/lib
+
+# Xinerama, comment if you don't want it
+# XINERAMALIBS  = -lXinerama
+# XINERAMAFLAGS = -DXINERAMA
+
+# freetype
+FREETYPELIBS = -lfontconfig -lXft
+FREETYPEINC = /usr/include/freetype2
+# OpenBSD (uncomment)
+#FREETYPEINC = $(X11INC)/freetype2
+#MANPREFIX = ${PREFIX}/man
+
+# includes and libs
+INCS = -I$(X11INC) -I$(FREETYPEINC)
+LIBS = -L$(X11LIB) -lX11 $(XINERAMALIBS) $(FREETYPELIBS)
+
+# flags
+CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 -D_POSIX_C_SOURCE=200809L -DVERSION=\"$(VERSION)\" $(XINERAMAFLAGS)
+CFLAGS   = -std=c99 -pedantic -Wall -Os $(INCS) $(CPPFLAGS)
+LDFLAGS  = $(LIBS)
+
+# compiler and linker
+CC = cc
--- a/_saved/_suckless/dmenu/dmenu.1
+++ b/_saved/_suckless/dmenu/dmenu.1
@ -0,0 +1,197 @@
+.TH DMENU 1 dmenu\-VERSION
+.SH NAME
+dmenu \- dynamic menu
+.SH SYNOPSIS
+.B dmenu
+.RB [ \-bfiv ]
+.RB [ \-l
+.IR lines ]
+.RB [ \-m
+.IR monitor ]
+.RB [ \-p
+.IR prompt ]
+.RB [ \-fn
+.IR font ]
+.RB [ \-nb
+.IR color ]
+.RB [ \-nf
+.IR color ]
+.RB [ \-sb
+.IR color ]
+.RB [ \-sf
+.IR color ]
+.RB [ \-w
+.IR windowid ]
+.P
+.BR dmenu_run " ..."
+.SH DESCRIPTION
+.B dmenu
+is a dynamic menu for X, which reads a list of newline\-separated items from
+stdin.  When the user selects an item and presses Return, their choice is printed
+to stdout and dmenu terminates.  Entering text will narrow the items to those
+matching the tokens in the input.
+.P
+.B dmenu_run
+is a script used by
+.IR dwm (1)
+which lists programs in the user's $PATH and runs the result in their $SHELL.
+.SH OPTIONS
+.TP
+.B \-b
+dmenu appears at the bottom of the screen.
+.TP
+.B \-c
+dmenu appears centered on the screen.
+.TP
+.B \-f
+dmenu grabs the keyboard before reading stdin if not reading from a tty. This
+is faster, but will lock up X until stdin reaches end\-of\-file.
+.TP
+.B \-i
+dmenu matches menu items case insensitively.
+.TP
+.BI \-l " lines"
+dmenu lists items vertically, with the given number of lines.
+.TP
+.BI \-m " monitor"
+dmenu is displayed on the monitor number supplied. Monitor numbers are starting
+from 0.
+.TP
+.BI \-p " prompt"
+defines the prompt to be displayed to the left of the input field.
+.TP
+.BI \-fn " font"
+defines the font or font set used.
+.TP
+.BI \-nb " color"
+defines the normal background color.
+.IR #RGB ,
+.IR #RRGGBB ,
+and X color names are supported.
+.TP
+.BI \-nf " color"
+defines the normal foreground color.
+.TP
+.BI \-sb " color"
+defines the selected background color.
+.TP
+.BI \-sf " color"
+defines the selected foreground color.
+.TP
+.B \-v
+prints version information to stdout, then exits.
+.TP
+.BI \-w " windowid"
+embed into windowid.
+.SH USAGE
+dmenu is completely controlled by the keyboard.  Items are selected using the
+arrow keys, page up, page down, home, and end.
+.TP
+.B Tab
+Copy the selected item to the input field.
+.TP
+.B Return
+Confirm selection.  Prints the selected item to stdout and exits, returning
+success.
+.TP
+.B Ctrl-Return
+Confirm selection.  Prints the selected item to stdout and continues.
+.TP
+.B Shift\-Return
+Confirm input.  Prints the input text to stdout and exits, returning success.
+.TP
+.B Escape
+Exit without selecting an item, returning failure.
+.TP
+.B Ctrl-Left
+Move cursor to the start of the current word
+.TP
+.B Ctrl-Right
+Move cursor to the end of the current word
+.TP
+.B C\-a
+Home
+.TP
+.B C\-b
+Left
+.TP
+.B C\-c
+Escape
+.TP
+.B C\-d
+Delete
+.TP
+.B C\-e
+End
+.TP
+.B C\-f
+Right
+.TP
+.B C\-g
+Escape
+.TP
+.B C\-h
+Backspace
+.TP
+.B C\-i
+Tab
+.TP
+.B C\-j
+Return
+.TP
+.B C\-J
+Shift-Return
+.TP
+.B C\-k
+Delete line right
+.TP
+.B C\-m
+Return
+.TP
+.B C\-M
+Shift-Return
+.TP
+.B C\-n
+Down
+.TP
+.B C\-p
+Up
+.TP
+.B C\-u
+Delete line left
+.TP
+.B C\-w
+Delete word left
+.TP
+.B C\-y
+Paste from primary X selection
+.TP
+.B C\-Y
+Paste from X clipboard
+.TP
+.B M\-b
+Move cursor to the start of the current word
+.TP
+.B M\-f
+Move cursor to the end of the current word
+.TP
+.B M\-g
+Home
+.TP
+.B M\-G
+End
+.TP
+.B M\-h
+Up
+.TP
+.B M\-j
+Page down
+.TP
+.B M\-k
+Page up
+.TP
+.B M\-l
+Down
+.SH SEE ALSO
+.IR dwm (1),
+.IR stest (1)
--- a/_saved/_suckless/dmenu/dmenu.c
+++ b/_saved/_suckless/dmenu/dmenu.c
@ -0,0 +1,823 @@
+/* See LICENSE file for copyright and license details. */
+#include <ctype.h>
+#include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/Xutil.h>
+#ifdef XINERAMA
+#include <X11/extensions/Xinerama.h>
+#endif
+#include <X11/Xft/Xft.h>
+
+#include "drw.h"
+#include "util.h"
+
+/* macros */
+#define INTERSECT(x,y,w,h,r)  (MAX(0, MIN((x)+(w),(r).x_org+(r).width)  - MAX((x),(r).x_org)) \
+                             * MAX(0, MIN((y)+(h),(r).y_org+(r).height) - MAX((y),(r).y_org)))
+#define LENGTH(X)             (sizeof X / sizeof X[0])
+#define TEXTW(X)              (drw_fontset_getwidth(drw, (X)) + lrpad)
+
+/* enums */
+enum { SchemeNorm, SchemeSel, SchemeOut, SchemeLast }; /* color schemes */
+
+struct item {
+	char *text;
+	struct item *left, *right;
+	int out;
+};
+
+static char text[BUFSIZ] = "";
+static char *embed;
+static int bh, mw, mh;
+static int inputw = 0, promptw;
+static int lrpad; /* sum of left and right padding */
+static size_t cursor;
+static struct item *items = NULL;
+static struct item *matches, *matchend;
+static struct item *prev, *curr, *next, *sel;
+static int mon = -1, screen;
+
+static Atom clip, utf8;
+static Display *dpy;
+static Window root, parentwin, win;
+static XIC xic;
+
+static Drw *drw;
+static Clr *scheme[SchemeLast];
+
+#include "config.h"
+
+static int (*fstrncmp)(const char *, const char *, size_t) = strncmp;
+static char *(*fstrstr)(const char *, const char *) = strstr;
+
+static unsigned int
+textw_clamp(const char *str, unsigned int n)
+{
+	unsigned int w = drw_fontset_getwidth_clamp(drw, str, n) + lrpad;
+	return MIN(w, n);
+}
+
+static void
+appenditem(struct item *item, struct item **list, struct item **last)
+{
+	if (*last)
+		(*last)->right = item;
+	else
+		*list = item;
+
+	item->left = *last;
+	item->right = NULL;
+	*last = item;
+}
+
+static void
+calcoffsets(void)
+{
+	int i, n;
+
+	if (lines > 0)
+		n = lines * bh;
+	else
+		n = mw - (promptw + inputw + TEXTW("<") + TEXTW(">"));
+	/* calculate which items will begin the next page and previous page */
+	for (i = 0, next = curr; next; next = next->right)
+		if ((i += (lines > 0) ? bh : textw_clamp(next->text, n)) > n)
+			break;
+	for (i = 0, prev = curr; prev && prev->left; prev = prev->left)
+		if ((i += (lines > 0) ? bh : textw_clamp(prev->left->text, n)) > n)
+			break;
+}
+
+static int
+max_textw(void)
+{
+	int len = 0;
+	for (struct item *item = items; item && item->text; item++)
+		len = MAX(TEXTW(item->text), len);
+	return len;
+}
+
+static void
+cleanup(void)
+{
+	size_t i;
+
+	XUngrabKey(dpy, AnyKey, AnyModifier, root);
+	for (i = 0; i < SchemeLast; i++)
+		free(scheme[i]);
+	for (i = 0; items && items[i].text; ++i)
+		free(items[i].text);
+	free(items);
+	drw_free(drw);
+	XSync(dpy, False);
+	XCloseDisplay(dpy);
+}
+
+static char *
+cistrstr(const char *h, const char *n)
+{
+	size_t i;
+
+	if (!n[0])
+		return (char *)h;
+
+	for (; *h; ++h) {
+		for (i = 0; n[i] && tolower((unsigned char)n[i]) ==
+		            tolower((unsigned char)h[i]); ++i)
+			;
+		if (n[i] == '\0')
+			return (char *)h;
+	}
+	return NULL;
+}
+
+static int
+drawitem(struct item *item, int x, int y, int w)
+{
+	if (item == sel)
+		drw_setscheme(drw, scheme[SchemeSel]);
+	else if (item->out)
+		drw_setscheme(drw, scheme[SchemeOut]);
+	else
+		drw_setscheme(drw, scheme[SchemeNorm]);
+
+	return drw_text(drw, x, y, w, bh, lrpad / 2, item->text, 0);
+}
+
+static void
+drawmenu(void)
+{
+	unsigned int curpos;
+	struct item *item;
+	int x = 0, y = 0, w;
+
+	drw_setscheme(drw, scheme[SchemeNorm]);
+	drw_rect(drw, 0, 0, mw, mh, 1, 1);
+
+	if (prompt && *prompt) {
+		drw_setscheme(drw, scheme[SchemeSel]);
+		x = drw_text(drw, x, 0, promptw, bh, lrpad / 2, prompt, 0);
+	}
+	/* draw input field */
+	w = (lines > 0 || !matches) ? mw - x : inputw;
+	drw_setscheme(drw, scheme[SchemeNorm]);
+	drw_text(drw, x, 0, w, bh, lrpad / 2, text, 0);
+
+	curpos = TEXTW(text) - TEXTW(&text[cursor]);
+	if ((curpos += lrpad / 2 - 1) < w) {
+		drw_setscheme(drw, scheme[SchemeNorm]);
+		drw_rect(drw, x + curpos, 2, 2, bh - 4, 1, 0);
+	}
+
+	if (lines > 0) {
+		/* draw vertical list */
+		for (item = curr; item != next; item = item->right)
+			drawitem(item, x, y += bh, mw - x);
+	} else if (matches) {
+		/* draw horizontal list */
+		x += inputw;
+		w = TEXTW("<");
+		if (curr->left) {
+			drw_setscheme(drw, scheme[SchemeNorm]);
+			drw_text(drw, x, 0, w, bh, lrpad / 2, "<", 0);
+		}
+		x += w;
+		for (item = curr; item != next; item = item->right)
+			x = drawitem(item, x, 0, textw_clamp(item->text, mw - x - TEXTW(">")));
+		if (next) {
+			w = TEXTW(">");
+			drw_setscheme(drw, scheme[SchemeNorm]);
+			drw_text(drw, mw - w, 0, w, bh, lrpad / 2, ">", 0);
+		}
+	}
+	drw_map(drw, win, 0, 0, mw, mh);
+}
+
+static void
+grabfocus(void)
+{
+	struct timespec ts = { .tv_sec = 0, .tv_nsec = 10000000  };
+	Window focuswin;
+	int i, revertwin;
+
+	for (i = 0; i < 100; ++i) {
+		XGetInputFocus(dpy, &focuswin, &revertwin);
+		if (focuswin == win)
+			return;
+		XSetInputFocus(dpy, win, RevertToParent, CurrentTime);
+		nanosleep(&ts, NULL);
+	}
+	die("cannot grab focus");
+}
+
+static void
+grabkeyboard(void)
+{
+	struct timespec ts = { .tv_sec = 0, .tv_nsec = 1000000  };
+	int i;
+
+	if (embed)
+		return;
+	/* try to grab keyboard, we may have to wait for another process to ungrab */
+	for (i = 0; i < 1000; i++) {
+		if (XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync,
+		                  GrabModeAsync, CurrentTime) == GrabSuccess)
+			return;
+		nanosleep(&ts, NULL);
+	}
+	die("cannot grab keyboard");
+}
+
+static void
+match(void)
+{
+	static char **tokv = NULL;
+	static int tokn = 0;
+
+	char buf[sizeof text], *s;
+	int i, tokc = 0;
+	size_t len, textsize;
+	struct item *item, *lprefix, *lsubstr, *prefixend, *substrend;
+
+	strcpy(buf, text);
+	/* separate input text into tokens to be matched individually */
+	for (s = strtok(buf, " "); s; tokv[tokc - 1] = s, s = strtok(NULL, " "))
+		if (++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv)))
+			die("cannot realloc %zu bytes:", tokn * sizeof *tokv);
+	len = tokc ? strlen(tokv[0]) : 0;
+
+	matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL;
+	textsize = strlen(text) + 1;
+	for (item = items; item && item->text; item++) {
+		for (i = 0; i < tokc; i++)
+			if (!fstrstr(item->text, tokv[i]))
+				break;
+		if (i != tokc) /* not all tokens match */
+			continue;
+		/* exact matches go first, then prefixes, then substrings */
+		if (!tokc || !fstrncmp(text, item->text, textsize))
+			appenditem(item, &matches, &matchend);
+		else if (!fstrncmp(tokv[0], item->text, len))
+			appenditem(item, &lprefix, &prefixend);
+		else
+			appenditem(item, &lsubstr, &substrend);
+	}
+	if (lprefix) {
+		if (matches) {
+			matchend->right = lprefix;
+			lprefix->left = matchend;
+		} else
+			matches = lprefix;
+		matchend = prefixend;
+	}
+	if (lsubstr) {
+		if (matches) {
+			matchend->right = lsubstr;
+			lsubstr->left = matchend;
+		} else
+			matches = lsubstr;
+		matchend = substrend;
+	}
+	curr = sel = matches;
+	calcoffsets();
+}
+
+static void
+insert(const char *str, ssize_t n)
+{
+	if (strlen(text) + n > sizeof text - 1)
+		return;
+	/* move existing text out of the way, insert new text, and update cursor */
+	memmove(&text[cursor + n], &text[cursor], sizeof text - cursor - MAX(n, 0));
+	if (n > 0)
+		memcpy(&text[cursor], str, n);
+	cursor += n;
+	match();
+}
+
+static size_t
+nextrune(int inc)
+{
+	ssize_t n;
+
+	/* return location of next utf8 rune in the given direction (+1 or -1) */
+	for (n = cursor + inc; n + inc >= 0 && (text[n] & 0xc0) == 0x80; n += inc)
+		;
+	return n;
+}
+
+static void
+movewordedge(int dir)
+{
+	if (dir < 0) { /* move cursor to the start of the word*/
+		while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)]))
+			cursor = nextrune(-1);
+		while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)]))
+			cursor = nextrune(-1);
+	} else { /* move cursor to the end of the word */
+		while (text[cursor] && strchr(worddelimiters, text[cursor]))
+			cursor = nextrune(+1);
+		while (text[cursor] && !strchr(worddelimiters, text[cursor]))
+			cursor = nextrune(+1);
+	}
+}
+
+static void
+keypress(XKeyEvent *ev)
+{
+	char buf[32];
+	int len;
+	KeySym ksym;
+	Status status;
+
+	len = XmbLookupString(xic, ev, buf, sizeof buf, &ksym, &status);
+	switch (status) {
+	default: /* XLookupNone, XBufferOverflow */
+		return;
+	case XLookupChars:
+		goto insert;
+	case XLookupKeySym:
+	case XLookupBoth:
+		break;
+	}
+
+	if (ev->state & ControlMask) {
+		switch(ksym) {
+		case XK_a: ksym = XK_Home;      break;
+		case XK_b: ksym = XK_Left;      break;
+		case XK_c: ksym = XK_Escape;    break;
+		case XK_d: ksym = XK_Delete;    break;
+		case XK_e: ksym = XK_End;       break;
+		case XK_f: ksym = XK_Right;     break;
+		case XK_g: ksym = XK_Escape;    break;
+		case XK_h: ksym = XK_BackSpace; break;
+		case XK_i: ksym = XK_Tab;       break;
+		case XK_j: /* fallthrough */
+		case XK_J: /* fallthrough */
+		case XK_m: /* fallthrough */
+		case XK_M: ksym = XK_Return; ev->state &= ~ControlMask; break;
+		case XK_n: ksym = XK_Down;      break;
+		case XK_p: ksym = XK_Up;        break;
+
+		case XK_k: /* delete right */
+			text[cursor] = '\0';
+			match();
+			break;
+		case XK_u: /* delete left */
+			insert(NULL, 0 - cursor);
+			break;
+		case XK_w: /* delete word */
+			while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)]))
+				insert(NULL, nextrune(-1) - cursor);
+			while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)]))
+				insert(NULL, nextrune(-1) - cursor);
+			break;
+		case XK_y: /* paste selection */
+		case XK_Y:
+			XConvertSelection(dpy, (ev->state & ShiftMask) ? clip : XA_PRIMARY,
+			                  utf8, utf8, win, CurrentTime);
+			return;
+		case XK_Left:
+		case XK_KP_Left:
+			movewordedge(-1);
+			goto draw;
+		case XK_Right:
+		case XK_KP_Right:
+			movewordedge(+1);
+			goto draw;
+		case XK_Return:
+		case XK_KP_Enter:
+			break;
+		case XK_bracketleft:
+			cleanup();
+			exit(1);
+		default:
+			return;
+		}
+	} else if (ev->state & Mod1Mask) {
+		switch(ksym) {
+		case XK_b:
+			movewordedge(-1);
+			goto draw;
+		case XK_f:
+			movewordedge(+1);
+			goto draw;
+		case XK_g: ksym = XK_Home;  break;
+		case XK_G: ksym = XK_End;   break;
+		case XK_h: ksym = XK_Up;    break;
+		case XK_j: ksym = XK_Next;  break;
+		case XK_k: ksym = XK_Prior; break;
+		case XK_l: ksym = XK_Down;  break;
+		default:
+			return;
+		}
+	}
+
+	switch(ksym) {
+	default:
+insert:
+		if (!iscntrl((unsigned char)*buf))
+			insert(buf, len);
+		break;
+	case XK_Delete:
+	case XK_KP_Delete:
+		if (text[cursor] == '\0')
+			return;
+		cursor = nextrune(+1);
+		/* fallthrough */
+	case XK_BackSpace:
+		if (cursor == 0)
+			return;
+		insert(NULL, nextrune(-1) - cursor);
+		break;
+	case XK_End:
+	case XK_KP_End:
+		if (text[cursor] != '\0') {
+			cursor = strlen(text);
+			break;
+		}
+		if (next) {
+			/* jump to end of list and position items in reverse */
+			curr = matchend;
+			calcoffsets();
+			curr = prev;
+			calcoffsets();
+			while (next && (curr = curr->right))
+				calcoffsets();
+		}
+		sel = matchend;
+		break;
+	case XK_Escape:
+		cleanup();
+		exit(1);
+	case XK_Home:
+	case XK_KP_Home:
+		if (sel == matches) {
+			cursor = 0;
+			break;
+		}
+		sel = curr = matches;
+		calcoffsets();
+		break;
+	case XK_Left:
+	case XK_KP_Left:
+		if (cursor > 0 && (!sel || !sel->left || lines > 0)) {
+			cursor = nextrune(-1);
+			break;
+		}
+		if (lines > 0)
+			return;
+		/* fallthrough */
+	case XK_Up:
+	case XK_KP_Up:
+		if (sel && sel->left && (sel = sel->left)->right == curr) {
+			curr = prev;
+			calcoffsets();
+		}
+		break;
+	case XK_Next:
+	case XK_KP_Next:
+		if (!next)
+			return;
+		sel = curr = next;
+		calcoffsets();
+		break;
+	case XK_Prior:
+	case XK_KP_Prior:
+		if (!prev)
+			return;
+		sel = curr = prev;
+		calcoffsets();
+		break;
+	case XK_Return:
+	case XK_KP_Enter:
+		puts((sel && !(ev->state & ShiftMask)) ? sel->text : text);
+		if (!(ev->state & ControlMask)) {
+			cleanup();
+			exit(0);
+		}
+		if (sel)
+			sel->out = 1;
+		break;
+	case XK_Right:
+	case XK_KP_Right:
+		if (text[cursor] != '\0') {
+			cursor = nextrune(+1);
+			break;
+		}
+		if (lines > 0)
+			return;
+		/* fallthrough */
+	case XK_Down:
+	case XK_KP_Down:
+		if (sel && sel->right && (sel = sel->right) == next) {
+			curr = next;
+			calcoffsets();
+		}
+		break;
+	case XK_Tab:
+		if (!sel)
+			return;
+		cursor = strnlen(sel->text, sizeof text - 1);
+		memcpy(text, sel->text, cursor);
+		text[cursor] = '\0';
+		match();
+		break;
+	}
+
+draw:
+	drawmenu();
+}
+
+static void
+paste(void)
+{
+	char *p, *q;
+	int di;
+	unsigned long dl;
+	Atom da;
+
+	/* we have been given the current selection, now insert it into input */
+	if (XGetWindowProperty(dpy, win, utf8, 0, (sizeof text / 4) + 1, False,
+	                   utf8, &da, &di, &dl, &dl, (unsigned char **)&p)
+	    == Success && p) {
+		insert(p, (q = strchr(p, '\n')) ? q - p : (ssize_t)strlen(p));
+		XFree(p);
+	}
+	drawmenu();
+}
+
+static void
+readstdin(void)
+{
+	char *line = NULL;
+	size_t i, junk, size = 0;
+	ssize_t len;
+
+	/* read each line from stdin and add it to the item list */
+	for (i = 0; (len = getline(&line, &junk, stdin)) != -1; i++, line = NULL) {
+		if (i + 1 >= size / sizeof *items)
+			if (!(items = realloc(items, (size += BUFSIZ))))
+				die("cannot realloc %zu bytes:", size);
+		if (line[len - 1] == '\n')
+			line[len - 1] = '\0';
+		items[i].text = line;
+		items[i].out = 0;
+	}
+	if (items)
+		items[i].text = NULL;
+	lines = MIN(lines, i);
+}
+
+static void
+run(void)
+{
+	XEvent ev;
+
+	while (!XNextEvent(dpy, &ev)) {
+		if (XFilterEvent(&ev, win))
+			continue;
+		switch(ev.type) {
+		case DestroyNotify:
+			if (ev.xdestroywindow.window != win)
+				break;
+			cleanup();
+			exit(1);
+		case Expose:
+			if (ev.xexpose.count == 0)
+				drw_map(drw, win, 0, 0, mw, mh);
+			break;
+		case FocusIn:
+			/* regrab focus from parent window */
+			if (ev.xfocus.window != win)
+				grabfocus();
+			break;
+		case KeyPress:
+			keypress(&ev.xkey);
+			break;
+		case SelectionNotify:
+			if (ev.xselection.property == utf8)
+				paste();
+			break;
+		case VisibilityNotify:
+			if (ev.xvisibility.state != VisibilityUnobscured)
+				XRaiseWindow(dpy, win);
+			break;
+		}
+	}
+}
+
+static void
+setup(void)
+{
+	int x, y, i, j;
+	unsigned int du;
+	XSetWindowAttributes swa;
+	XIM xim;
+	Window w, dw, *dws;
+	XWindowAttributes wa;
+	XClassHint ch = {"dmenu", "dmenu"};
+#ifdef XINERAMA
+	XineramaScreenInfo *info;
+	Window pw;
+	int a, di, n, area = 0;
+#endif
+	/* init appearance */
+	for (j = 0; j < SchemeLast; j++)
+		scheme[j] = drw_scm_create(drw, colors[j], 2);
+
+	clip = XInternAtom(dpy, "CLIPBOARD",   False);
+	utf8 = XInternAtom(dpy, "UTF8_STRING", False);
+
+	/* calculate menu geometry */
+	bh = drw->fonts->h + 2;
+	lines = MAX(lines, 0);
+	mh = (lines + 1) * bh;
+	promptw = (prompt && *prompt) ? TEXTW(prompt) - lrpad / 4 : 0;
+#ifdef XINERAMA
+	i = 0;
+	if (parentwin == root && (info = XineramaQueryScreens(dpy, &n))) {
+		XGetInputFocus(dpy, &w, &di);
+		if (mon >= 0 && mon < n)
+			i = mon;
+		else if (w != root && w != PointerRoot && w != None) {
+			/* find top-level window containing current input focus */
+			do {
+				if (XQueryTree(dpy, (pw = w), &dw, &w, &dws, &du) && dws)
+					XFree(dws);
+			} while (w != root && w != pw);
+			/* find xinerama screen with which the window intersects most */
+			if (XGetWindowAttributes(dpy, pw, &wa))
+				for (j = 0; j < n; j++)
+					if ((a = INTERSECT(wa.x, wa.y, wa.width, wa.height, info[j])) > area) {
+						area = a;
+						i = j;
+					}
+		}
+		/* no focused window is on screen, so use pointer location instead */
+		if (mon < 0 && !area && XQueryPointer(dpy, root, &dw, &dw, &x, &y, &di, &di, &du))
+			for (i = 0; i < n; i++)
+				if (INTERSECT(x, y, 1, 1, info[i]) != 0)
+					break;
+
+		if (centered) {
+			mw = MIN(MAX(max_textw() + promptw, min_width), info[i].width);
+			x = info[i].x_org + ((info[i].width  - mw) / 2);
+			y = info[i].y_org + ((info[i].height - mh) / 2);
+		} else {
+			x = info[i].x_org;
+			y = info[i].y_org + (topbar ? 0 : info[i].height - mh);
+			mw = info[i].width;
+		}
+
+		XFree(info);
+	} else
+#endif
+	{
+		if (!XGetWindowAttributes(dpy, parentwin, &wa))
+			die("could not get embedding window attributes: 0x%lx",
+			    parentwin);
+		x = 0;
+		y = topbar ? 0 : wa.height - mh;
+		mw = wa.width;
+
+		if (centered) {
+			mw = MIN(MAX(max_textw() + promptw, min_width), wa.width);
+			x = (wa.width  - mw) / 2;
+			y = (wa.height - mh) / 2;
+		} else {
+			x = 0;
+			y = topbar ? 0 : wa.height - mh;
+			mw = wa.width;
+		}
+	}
+	inputw = mw / 3; /* input width: ~33% of monitor width */
+	match();
+
+	/* create menu window */
+	swa.override_redirect = True;
+	swa.background_pixel = scheme[SchemeNorm][ColBg].pixel;
+	swa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask;
+	win = XCreateWindow(dpy, parentwin, x, y - (topbar ? 0 : border_width * 2), mw - border_width * 2, mh, border_width,
+	                    CopyFromParent, CopyFromParent, CopyFromParent,
+	                    CWOverrideRedirect | CWBackPixel | CWEventMask, &swa);
+	if (border_width)
+		XSetWindowBorder(dpy, win, scheme[SchemeSel][ColBg].pixel);
+	XSetClassHint(dpy, win, &ch);
+
+
+	/* input methods */
+	if ((xim = XOpenIM(dpy, NULL, NULL, NULL)) == NULL)
+		die("XOpenIM failed: could not open input device");
+
+	xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
+	                XNClientWindow, win, XNFocusWindow, win, NULL);
+
+	XMapRaised(dpy, win);
+	if (embed) {
+		XSelectInput(dpy, parentwin, FocusChangeMask | SubstructureNotifyMask);
+		if (XQueryTree(dpy, parentwin, &dw, &w, &dws, &du) && dws) {
+			for (i = 0; i < du && dws[i] != win; ++i)
+				XSelectInput(dpy, dws[i], FocusChangeMask);
+			XFree(dws);
+		}
+		grabfocus();
+	}
+	drw_resize(drw, mw, mh);
+	drawmenu();
+}
+
+static void
+usage(void)
+{
+	die("usage: dmenu [-bfiv] [-l lines] [-p prompt] [-fn font] [-m monitor]\n"
+	    "             [-nb color] [-nf color] [-sb color] [-sf color] [-w windowid]");
+}
+
+int
+main(int argc, char *argv[])
+{
+	XWindowAttributes wa;
+	int i, fast = 0;
+
+	for (i = 1; i < argc; i++)
+		/* these options take no arguments */
+		if (!strcmp(argv[i], "-v")) {      /* prints version information */
+			puts("dmenu-"VERSION);
+			exit(0);
+		} else if (!strcmp(argv[i], "-b")) /* appears at the bottom of the screen */
+			topbar = 0;
+		else if (!strcmp(argv[i], "-f"))   /* grabs keyboard before reading stdin */
+			fast = 1;
+		else if (!strcmp(argv[i], "-c"))   /* centers dmenu on screen */
+			centered = 1;
+		else if (!strcmp(argv[i], "-i")) { /* case-insensitive item matching */
+			fstrncmp = strncasecmp;
+			fstrstr = cistrstr;
+		} else if (i + 1 == argc)
+			usage();
+		/* these options take one argument */
+		else if (!strcmp(argv[i], "-l"))   /* number of lines in vertical list */
+			lines = atoi(argv[++i]);
+		else if (!strcmp(argv[i], "-m"))
+			mon = atoi(argv[++i]);
+		else if (!strcmp(argv[i], "-p"))   /* adds prompt to left of input field */
+			prompt = argv[++i];
+		else if (!strcmp(argv[i], "-fn"))  /* font or font set */
+			fonts[0] = argv[++i];
+		else if (!strcmp(argv[i], "-nb"))  /* normal background color */
+			colors[SchemeNorm][ColBg] = argv[++i];
+		else if (!strcmp(argv[i], "-nf"))  /* normal foreground color */
+			colors[SchemeNorm][ColFg] = argv[++i];
+		else if (!strcmp(argv[i], "-sb"))  /* selected background color */
+			colors[SchemeSel][ColBg] = argv[++i];
+		else if (!strcmp(argv[i], "-sf"))  /* selected foreground color */
+			colors[SchemeSel][ColFg] = argv[++i];
+		else if (!strcmp(argv[i], "-w"))   /* embedding window id */
+			embed = argv[++i];
+		else if (!strcmp(argv[i], "-bw"))
+			border_width = atoi(argv[++i]); /* border width */
+		else
+			usage();
+
+	if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
+		fputs("warning: no locale support\n", stderr);
+	if (!(dpy = XOpenDisplay(NULL)))
+		die("cannot open display");
+	screen = DefaultScreen(dpy);
+	root = RootWindow(dpy, screen);
+	if (!embed || !(parentwin = strtol(embed, NULL, 0)))
+		parentwin = root;
+	if (!XGetWindowAttributes(dpy, parentwin, &wa))
+		die("could not get embedding window attributes: 0x%lx",
+		    parentwin);
+	drw = drw_create(dpy, screen, root, wa.width, wa.height);
+	if (!drw_fontset_create(drw, fonts, LENGTH(fonts)))
+		die("no fonts could be loaded.");
+	lrpad = drw->fonts->h;
+
+#ifdef __OpenBSD__
+	if (pledge("stdio rpath", NULL) == -1)
+		die("pledge");
+#endif
+
+	if (fast && !isatty(0)) {
+		grabkeyboard();
+		readstdin();
+	} else {
+		readstdin();
+		grabkeyboard();
+	}
+	setup();
+	run();
+
+	return 1; /* unreachable */
+}
--- a/_saved/_suckless/dmenu/dmenu_path
+++ b/_saved/_suckless/dmenu/dmenu_path
@ -0,0 +1,13 @@
+#!/bin/sh
+
+cachedir="${XDG_CACHE_HOME:-"$HOME/.cache"}"
+cache="$cachedir/dmenu_run"
+
+[ ! -e "$cachedir" ] && mkdir -p "$cachedir"
+
+IFS=:
+if stest -dqr -n "$cache" $PATH; then
+	stest -flx $PATH | sort -u | tee "$cache"
+else
+	cat "$cache"
+fi
--- a/_saved/_suckless/dmenu/dmenu_run
+++ b/_saved/_suckless/dmenu/dmenu_run
@ -0,0 +1,2 @@
+#!/bin/sh
+dmenu_path | dmenu "$@" | ${SHELL:-"/bin/sh"} &
--- a/_saved/_suckless/dmenu/drw.c
+++ b/_saved/_suckless/dmenu/drw.c
@ -0,0 +1,450 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <X11/Xlib.h>
+#include <X11/Xft/Xft.h>
+
+#include "drw.h"
+#include "util.h"
+
+#define UTF_INVALID 0xFFFD
+#define UTF_SIZ     4
+
+static const unsigned char utfbyte[UTF_SIZ + 1] = {0x80,    0, 0xC0, 0xE0, 0xF0};
+static const unsigned char utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
+static const long utfmin[UTF_SIZ + 1] = {       0,    0,  0x80,  0x800,  0x10000};
+static const long utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
+
+static long
+utf8decodebyte(const char c, size_t *i)
+{
+	for (*i = 0; *i < (UTF_SIZ + 1); ++(*i))
+		if (((unsigned char)c & utfmask[*i]) == utfbyte[*i])
+			return (unsigned char)c & ~utfmask[*i];
+	return 0;
+}
+
+static size_t
+utf8validate(long *u, size_t i)
+{
+	if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
+		*u = UTF_INVALID;
+	for (i = 1; *u > utfmax[i]; ++i)
+		;
+	return i;
+}
+
+static size_t
+utf8decode(const char *c, long *u, size_t clen)
+{
+	size_t i, j, len, type;
+	long udecoded;
+
+	*u = UTF_INVALID;
+	if (!clen)
+		return 0;
+	udecoded = utf8decodebyte(c[0], &len);
+	if (!BETWEEN(len, 1, UTF_SIZ))
+		return 1;
+	for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
+		udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
+		if (type)
+			return j;
+	}
+	if (j < len)
+		return 0;
+	*u = udecoded;
+	utf8validate(u, len);
+
+	return len;
+}
+
+Drw *
+drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h)
+{
+	Drw *drw = ecalloc(1, sizeof(Drw));
+
+	drw->dpy = dpy;
+	drw->screen = screen;
+	drw->root = root;
+	drw->w = w;
+	drw->h = h;
+	drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen));
+	drw->gc = XCreateGC(dpy, root, 0, NULL);
+	XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);
+
+	return drw;
+}
+
+void
+drw_resize(Drw *drw, unsigned int w, unsigned int h)
+{
+	if (!drw)
+		return;
+
+	drw->w = w;
+	drw->h = h;
+	if (drw->drawable)
+		XFreePixmap(drw->dpy, drw->drawable);
+	drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen));
+}
+
+void
+drw_free(Drw *drw)
+{
+	XFreePixmap(drw->dpy, drw->drawable);
+	XFreeGC(drw->dpy, drw->gc);
+	drw_fontset_free(drw->fonts);
+	free(drw);
+}
+
+/* This function is an implementation detail. Library users should use
+ * drw_fontset_create instead.
+ */
+static Fnt *
+xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern)
+{
+	Fnt *font;
+	XftFont *xfont = NULL;
+	FcPattern *pattern = NULL;
+
+	if (fontname) {
+		/* Using the pattern found at font->xfont->pattern does not yield the
+		 * same substitution results as using the pattern returned by
+		 * FcNameParse; using the latter results in the desired fallback
+		 * behaviour whereas the former just results in missing-character
+		 * rectangles being drawn, at least with some fonts. */
+		if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) {
+			fprintf(stderr, "error, cannot load font from name: '%s'\n", fontname);
+			return NULL;
+		}
+		if (!(pattern = FcNameParse((FcChar8 *) fontname))) {
+			fprintf(stderr, "error, cannot parse font name to pattern: '%s'\n", fontname);
+			XftFontClose(drw->dpy, xfont);
+			return NULL;
+		}
+	} else if (fontpattern) {
+		if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) {
+			fprintf(stderr, "error, cannot load font from pattern.\n");
+			return NULL;
+		}
+	} else {
+		die("no font specified.");
+	}
+
+	font = ecalloc(1, sizeof(Fnt));
+	font->xfont = xfont;
+	font->pattern = pattern;
+	font->h = xfont->ascent + xfont->descent;
+	font->dpy = drw->dpy;
+
+	return font;
+}
+
+static void
+xfont_free(Fnt *font)
+{
+	if (!font)
+		return;
+	if (font->pattern)
+		FcPatternDestroy(font->pattern);
+	XftFontClose(font->dpy, font->xfont);
+	free(font);
+}
+
+Fnt*
+drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount)
+{
+	Fnt *cur, *ret = NULL;
+	size_t i;
+
+	if (!drw || !fonts)
+		return NULL;
+
+	for (i = 1; i <= fontcount; i++) {
+		if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) {
+			cur->next = ret;
+			ret = cur;
+		}
+	}
+	return (drw->fonts = ret);
+}
+
+void
+drw_fontset_free(Fnt *font)
+{
+	if (font) {
+		drw_fontset_free(font->next);
+		xfont_free(font);
+	}
+}
+
+void
+drw_clr_create(Drw *drw, Clr *dest, const char *clrname)
+{
+	if (!drw || !dest || !clrname)
+		return;
+
+	if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen),
+	                       DefaultColormap(drw->dpy, drw->screen),
+	                       clrname, dest))
+		die("error, cannot allocate color '%s'", clrname);
+}
+
+/* Wrapper to create color schemes. The caller has to call free(3) on the
+ * returned color scheme when done using it. */
+Clr *
+drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
+{
+	size_t i;
+	Clr *ret;
+
+	/* need at least two colors for a scheme */
+	if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor))))
+		return NULL;
+
+	for (i = 0; i < clrcount; i++)
+		drw_clr_create(drw, &ret[i], clrnames[i]);
+	return ret;
+}
+
+void
+drw_setfontset(Drw *drw, Fnt *set)
+{
+	if (drw)
+		drw->fonts = set;
+}
+
+void
+drw_setscheme(Drw *drw, Clr *scm)
+{
+	if (drw)
+		drw->scheme = scm;
+}
+
+void
+drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert)
+{
+	if (!drw || !drw->scheme)
+		return;
+	XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel);
+	if (filled)
+		XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
+	else
+		XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1);
+}
+
+int
+drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert)
+{
+	int i, ty, ellipsis_x = 0;
+	unsigned int tmpw, ew, ellipsis_w = 0, ellipsis_len;
+	XftDraw *d = NULL;
+	Fnt *usedfont, *curfont, *nextfont;
+	int utf8strlen, utf8charlen, render = x || y || w || h;
+	long utf8codepoint = 0;
+	const char *utf8str;
+	FcCharSet *fccharset;
+	FcPattern *fcpattern;
+	FcPattern *match;
+	XftResult result;
+	int charexists = 0, overflow = 0;
+	/* keep track of a couple codepoints for which we have no match. */
+	enum { nomatches_len = 64 };
+	static struct { long codepoint[nomatches_len]; unsigned int idx; } nomatches;
+	static unsigned int ellipsis_width = 0;
+
+	if (!drw || (render && (!drw->scheme || !w)) || !text || !drw->fonts)
+		return 0;
+
+	if (!render) {
+		w = invert ? invert : ~invert;
+	} else {
+		XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel);
+		XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
+		d = XftDrawCreate(drw->dpy, drw->drawable,
+		                  DefaultVisual(drw->dpy, drw->screen),
+		                  DefaultColormap(drw->dpy, drw->screen));
+		x += lpad;
+		w -= lpad;
+	}
+
+	usedfont = drw->fonts;
+	if (!ellipsis_width && render)
+		ellipsis_width = drw_fontset_getwidth(drw, "...");
+	while (1) {
+		ew = ellipsis_len = utf8strlen = 0;
+		utf8str = text;
+		nextfont = NULL;
+		while (*text) {
+			utf8charlen = utf8decode(text, &utf8codepoint, UTF_SIZ);
+			for (curfont = drw->fonts; curfont; curfont = curfont->next) {
+				charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint);
+				if (charexists) {
+					drw_font_getexts(curfont, text, utf8charlen, &tmpw, NULL);
+					if (ew + ellipsis_width <= w) {
+						/* keep track where the ellipsis still fits */
+						ellipsis_x = x + ew;
+						ellipsis_w = w - ew;
+						ellipsis_len = utf8strlen;
+					}
+
+					if (ew + tmpw > w) {
+						overflow = 1;
+						/* called from drw_fontset_getwidth_clamp():
+						 * it wants the width AFTER the overflow
+						 */
+						if (!render)
+							x += tmpw;
+						else
+							utf8strlen = ellipsis_len;
+					} else if (curfont == usedfont) {
+						utf8strlen += utf8charlen;
+						text += utf8charlen;
+						ew += tmpw;
+					} else {
+						nextfont = curfont;
+					}
+					break;
+				}
+			}
+
+			if (overflow || !charexists || nextfont)
+				break;
+			else
+				charexists = 0;
+		}
+
+		if (utf8strlen) {
+			if (render) {
+				ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent;
+				XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg],
+				                  usedfont->xfont, x, ty, (XftChar8 *)utf8str, utf8strlen);
+			}
+			x += ew;
+			w -= ew;
+		}
+		if (render && overflow)
+			drw_text(drw, ellipsis_x, y, ellipsis_w, h, 0, "...", invert);
+
+		if (!*text || overflow) {
+			break;
+		} else if (nextfont) {
+			charexists = 0;
+			usedfont = nextfont;
+		} else {
+			/* Regardless of whether or not a fallback font is found, the
+			 * character must be drawn. */
+			charexists = 1;
+
+			for (i = 0; i < nomatches_len; ++i) {
+				/* avoid calling XftFontMatch if we know we won't find a match */
+				if (utf8codepoint == nomatches.codepoint[i])
+					goto no_match;
+			}
+
+			fccharset = FcCharSetCreate();
+			FcCharSetAddChar(fccharset, utf8codepoint);
+
+			if (!drw->fonts->pattern) {
+				/* Refer to the comment in xfont_create for more information. */
+				die("the first font in the cache must be loaded from a font string.");
+			}
+
+			fcpattern = FcPatternDuplicate(drw->fonts->pattern);
+			FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset);
+			FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue);
+
+			FcConfigSubstitute(NULL, fcpattern, FcMatchPattern);
+			FcDefaultSubstitute(fcpattern);
+			match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result);
+
+			FcCharSetDestroy(fccharset);
+			FcPatternDestroy(fcpattern);
+
+			if (match) {
+				usedfont = xfont_create(drw, NULL, match);
+				if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) {
+					for (curfont = drw->fonts; curfont->next; curfont = curfont->next)
+						; /* NOP */
+					curfont->next = usedfont;
+				} else {
+					xfont_free(usedfont);
+					nomatches.codepoint[++nomatches.idx % nomatches_len] = utf8codepoint;
+no_match:
+					usedfont = drw->fonts;
+				}
+			}
+		}
+	}
+	if (d)
+		XftDrawDestroy(d);
+
+	return x + (render ? w : 0);
+}
+
+void
+drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h)
+{
+	if (!drw)
+		return;
+
+	XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y);
+	XSync(drw->dpy, False);
+}
+
+unsigned int
+drw_fontset_getwidth(Drw *drw, const char *text)
+{
+	if (!drw || !drw->fonts || !text)
+		return 0;
+	return drw_text(drw, 0, 0, 0, 0, 0, text, 0);
+}
+
+unsigned int
+drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n)
+{
+	unsigned int tmp = 0;
+	if (drw && drw->fonts && text && n)
+		tmp = drw_text(drw, 0, 0, 0, 0, 0, text, n);
+	return MIN(n, tmp);
+}
+
+void
+drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h)
+{
+	XGlyphInfo ext;
+
+	if (!font || !text)
+		return;
+
+	XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext);
+	if (w)
+		*w = ext.xOff;
+	if (h)
+		*h = font->h;
+}
+
+Cur *
+drw_cur_create(Drw *drw, int shape)
+{
+	Cur *cur;
+
+	if (!drw || !(cur = ecalloc(1, sizeof(Cur))))
+		return NULL;
+
+	cur->cursor = XCreateFontCursor(drw->dpy, shape);
+
+	return cur;
+}
+
+void
+drw_cur_free(Drw *drw, Cur *cursor)
+{
+	if (!cursor)
+		return;
+
+	XFreeCursor(drw->dpy, cursor->cursor);
+	free(cursor);
+}
--- a/_saved/_suckless/dmenu/drw.h
+++ b/_saved/_suckless/dmenu/drw.h
@ -0,0 +1,58 @@
+/* See LICENSE file for copyright and license details. */
+
+typedef struct {
+	Cursor cursor;
+} Cur;
+
+typedef struct Fnt {
+	Display *dpy;
+	unsigned int h;
+	XftFont *xfont;
+	FcPattern *pattern;
+	struct Fnt *next;
+} Fnt;
+
+enum { ColFg, ColBg }; /* Clr scheme index */
+typedef XftColor Clr;
+
+typedef struct {
+	unsigned int w, h;
+	Display *dpy;
+	int screen;
+	Window root;
+	Drawable drawable;
+	GC gc;
+	Clr *scheme;
+	Fnt *fonts;
+} Drw;
+
+/* Drawable abstraction */
+Drw *drw_create(Display *dpy, int screen, Window win, unsigned int w, unsigned int h);
+void drw_resize(Drw *drw, unsigned int w, unsigned int h);
+void drw_free(Drw *drw);
+
+/* Fnt abstraction */
+Fnt *drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount);
+void drw_fontset_free(Fnt* set);
+unsigned int drw_fontset_getwidth(Drw *drw, const char *text);
+unsigned int drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n);
+void drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h);
+
+/* Colorscheme abstraction */
+void drw_clr_create(Drw *drw, Clr *dest, const char *clrname);
+Clr *drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount);
+
+/* Cursor abstraction */
+Cur *drw_cur_create(Drw *drw, int shape);
+void drw_cur_free(Drw *drw, Cur *cursor);
+
+/* Drawing context manipulation */
+void drw_setfontset(Drw *drw, Fnt *set);
+void drw_setscheme(Drw *drw, Clr *scm);
+
+/* Drawing functions */
+void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert);
+int drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert);
+
+/* Map functions */
+void drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h);
--- a/_saved/_suckless/dmenu/stest.1
+++ b/_saved/_suckless/dmenu/stest.1
@ -0,0 +1,90 @@
+.TH STEST 1 dmenu\-VERSION
+.SH NAME
+stest \- filter a list of files by properties
+.SH SYNOPSIS
+.B stest
+.RB [ -abcdefghlpqrsuwx ]
+.RB [ -n
+.IR file ]
+.RB [ -o
+.IR file ]
+.RI [ file ...]
+.SH DESCRIPTION
+.B stest
+takes a list of files and filters by the files' properties, analogous to
+.IR test (1).
+Files which pass all tests are printed to stdout. If no files are given, stest
+reads files from stdin.
+.SH OPTIONS
+.TP
+.B \-a
+Test hidden files.
+.TP
+.B \-b
+Test that files are block specials.
+.TP
+.B \-c
+Test that files are character specials.
+.TP
+.B \-d
+Test that files are directories.
+.TP
+.B \-e
+Test that files exist.
+.TP
+.B \-f
+Test that files are regular files.
+.TP
+.B \-g
+Test that files have their set-group-ID flag set.
+.TP
+.B \-h
+Test that files are symbolic links.
+.TP
+.B \-l
+Test the contents of a directory given as an argument.
+.TP
+.BI \-n " file"
+Test that files are newer than
+.IR file .
+.TP
+.BI \-o " file"
+Test that files are older than
+.IR file .
+.TP
+.B \-p
+Test that files are named pipes.
+.TP
+.B \-q
+No files are printed, only the exit status is returned.
+.TP
+.B \-r
+Test that files are readable.
+.TP
+.B \-s
+Test that files are not empty.
+.TP
+.B \-u
+Test that files have their set-user-ID flag set.
+.TP
+.B \-v
+Invert the sense of tests, only failing files pass.
+.TP
+.B \-w
+Test that files are writable.
+.TP
+.B \-x
+Test that files are executable.
+.SH EXIT STATUS
+.TP
+.B 0
+At least one file passed all tests.
+.TP
+.B 1
+No files passed all tests.
+.TP
+.B 2
+An error occurred.
+.SH SEE ALSO
+.IR dmenu (1),
+.IR test (1)
--- a/_saved/_suckless/dmenu/stest.c
+++ b/_saved/_suckless/dmenu/stest.c
@ -0,0 +1,109 @@
+/* See LICENSE file for copyright and license details. */
+#include <sys/stat.h>
+
+#include <dirent.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "arg.h"
+char *argv0;
+
+#define FLAG(x)  (flag[(x)-'a'])
+
+static void test(const char *, const char *);
+static void usage(void);
+
+static int match = 0;
+static int flag[26];
+static struct stat old, new;
+
+static void
+test(const char *path, const char *name)
+{
+	struct stat st, ln;
+
+	if ((!stat(path, &st) && (FLAG('a') || name[0] != '.')        /* hidden files      */
+	&& (!FLAG('b') || S_ISBLK(st.st_mode))                        /* block special     */
+	&& (!FLAG('c') || S_ISCHR(st.st_mode))                        /* character special */
+	&& (!FLAG('d') || S_ISDIR(st.st_mode))                        /* directory         */
+	&& (!FLAG('e') || access(path, F_OK) == 0)                    /* exists            */
+	&& (!FLAG('f') || S_ISREG(st.st_mode))                        /* regular file      */
+	&& (!FLAG('g') || st.st_mode & S_ISGID)                       /* set-group-id flag */
+	&& (!FLAG('h') || (!lstat(path, &ln) && S_ISLNK(ln.st_mode))) /* symbolic link     */
+	&& (!FLAG('n') || st.st_mtime > new.st_mtime)                 /* newer than file   */
+	&& (!FLAG('o') || st.st_mtime < old.st_mtime)                 /* older than file   */
+	&& (!FLAG('p') || S_ISFIFO(st.st_mode))                       /* named pipe        */
+	&& (!FLAG('r') || access(path, R_OK) == 0)                    /* readable          */
+	&& (!FLAG('s') || st.st_size > 0)                             /* not empty         */
+	&& (!FLAG('u') || st.st_mode & S_ISUID)                       /* set-user-id flag  */
+	&& (!FLAG('w') || access(path, W_OK) == 0)                    /* writable          */
+	&& (!FLAG('x') || access(path, X_OK) == 0)) != FLAG('v')) {   /* executable        */
+		if (FLAG('q'))
+			exit(0);
+		match = 1;
+		puts(name);
+	}
+}
+
+static void
+usage(void)
+{
+	fprintf(stderr, "usage: %s [-abcdefghlpqrsuvwx] "
+	        "[-n file] [-o file] [file...]\n", argv0);
+	exit(2); /* like test(1) return > 1 on error */
+}
+
+int
+main(int argc, char *argv[])
+{
+	struct dirent *d;
+	char path[PATH_MAX], *line = NULL, *file;
+	size_t linesiz = 0;
+	ssize_t n;
+	DIR *dir;
+	int r;
+
+	ARGBEGIN {
+	case 'n': /* newer than file */
+	case 'o': /* older than file */
+		file = EARGF(usage());
+		if (!(FLAG(ARGC()) = !stat(file, (ARGC() == 'n' ? &new : &old))))
+			perror(file);
+		break;
+	default:
+		/* miscellaneous operators */
+		if (strchr("abcdefghlpqrsuvwx", ARGC()))
+			FLAG(ARGC()) = 1;
+		else
+			usage(); /* unknown flag */
+	} ARGEND;
+
+	if (!argc) {
+		/* read list from stdin */
+		while ((n = getline(&line, &linesiz, stdin)) > 0) {
+			if (line[n - 1] == '\n')
+				line[n - 1] = '\0';
+			test(line, line);
+		}
+		free(line);
+	} else {
+		for (; argc; argc--, argv++) {
+			if (FLAG('l') && (dir = opendir(*argv))) {
+				/* test directory contents */
+				while ((d = readdir(dir))) {
+					r = snprintf(path, sizeof path, "%s/%s",
+					             *argv, d->d_name);
+					if (r >= 0 && (size_t)r < sizeof path)
+						test(path, d->d_name);
+				}
+				closedir(dir);
+			} else {
+				test(*argv, *argv);
+			}
+		}
+	}
+	return match ? 0 : 1;
+}
--- a/_saved/_suckless/dmenu/util.c
+++ b/_saved/_suckless/dmenu/util.c
@ -0,0 +1,36 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "util.h"
+
+void
+die(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+
+	if (fmt[0] && fmt[strlen(fmt)-1] == ':') {
+		fputc(' ', stderr);
+		perror(NULL);
+	} else {
+		fputc('\n', stderr);
+	}
+
+	exit(1);
+}
+
+void *
+ecalloc(size_t nmemb, size_t size)
+{
+	void *p;
+
+	if (!(p = calloc(nmemb, size)))
+		die("calloc:");
+	return p;
+}
--- a/_saved/_suckless/dmenu/util.h
+++ b/_saved/_suckless/dmenu/util.h
@ -0,0 +1,8 @@
+/* See LICENSE file for copyright and license details. */
+
+#define MAX(A, B)               ((A) > (B) ? (A) : (B))
+#define MIN(A, B)               ((A) < (B) ? (A) : (B))
+#define BETWEEN(X, A, B)        ((A) <= (X) && (X) <= (B))
+
+void die(const char *fmt, ...);
+void *ecalloc(size_t nmemb, size_t size);
--- a/_saved/_suckless/dwm/LICENSE
+++ b/_saved/_suckless/dwm/LICENSE
@ -0,0 +1,38 @@
+MIT/X Consortium License
+
+© 2006-2019 Anselm R Garbe <anselm@garbe.ca>
+© 2006-2009 Jukka Salmi <jukka at salmi dot ch>
+© 2006-2007 Sander van Dijk <a dot h dot vandijk at gmail dot com>
+© 2007-2011 Peter Hartlich <sgkkr at hartlich dot com>
+© 2007-2009 Szabolcs Nagy <nszabolcs at gmail dot com>
+© 2007-2009 Christof Musik <christof at sendfax dot de>
+© 2007-2009 Premysl Hruby <dfenze at gmail dot com>
+© 2007-2008 Enno Gottox Boland <gottox at s01 dot de>
+© 2008 Martin Hurton <martin dot hurton at gmail dot com>
+© 2008 Neale Pickett <neale dot woozle dot org>
+© 2009 Mate Nagy <mnagy at port70 dot net>
+© 2010-2016 Hiltjo Posthuma <hiltjo@codemadness.org>
+© 2010-2012 Connor Lane Smith <cls@lubutu.com>
+© 2011 Christoph Lohmann <20h@r-36.net>
+© 2015-2016 Quentin Rameau <quinq@fifth.space>
+© 2015-2016 Eric Pruitt <eric.pruitt@gmail.com>
+© 2016-2017 Markus Teich <markus.teich@stusta.mhn.de>
+© 2020-2022 Chris Down <chris@chrisdown.name>
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/_saved/_suckless/dwm/Makefile
+++ b/_saved/_suckless/dwm/Makefile
@ -0,0 +1,51 @@
+# dwm - dynamic window manager
+# See LICENSE file for copyright and license details.
+
+include config.mk
+
+SRC = drw.c dwm.c util.c
+OBJ = ${SRC:.c=.o}
+
+all: options dwm
+
+options:
+	@echo dwm build options:
+	@echo "CFLAGS   = ${CFLAGS}"
+	@echo "LDFLAGS  = ${LDFLAGS}"
+	@echo "CC       = ${CC}"
+
+.c.o:
+	${CC} -c ${CFLAGS} $<
+
+${OBJ}: config.h config.mk
+
+config.h:
+	cp config.def.h $@
+
+dwm: ${OBJ}
+	${CC} -o $@ ${OBJ} ${LDFLAGS}
+
+clean:
+	rm -f dwm ${OBJ} dwm-${VERSION}.tar.gz
+
+dist: clean
+	mkdir -p dwm-${VERSION}
+	cp -R LICENSE Makefile README config.def.h config.mk\
+		dwm.1 drw.h util.h ${SRC} dwm.png transient.c dwm-${VERSION}
+	tar -cf dwm-${VERSION}.tar dwm-${VERSION}
+	gzip dwm-${VERSION}.tar
+	rm -rf dwm-${VERSION}
+
+install: all
+	mkdir -p ${DESTDIR}${PREFIX}/bin
+	cp -f dwm ${DESTDIR}${PREFIX}/bin
+	chmod 755 ${DESTDIR}${PREFIX}/bin/dwm
+	mkdir -p ${DESTDIR}${MANPREFIX}/man1
+	sed "s/VERSION/${VERSION}/g" < dwm.1 > ${DESTDIR}${MANPREFIX}/man1/dwm.1
+	chmod 644 ${DESTDIR}${MANPREFIX}/man1/dwm.1
+
+uninstall:
+	rm -f ${DESTDIR}${PREFIX}/bin/dwm\
+		${DESTDIR}${MANPREFIX}/man1/dwm.1
+
+.PHONY: all options clean dist install uninstall
--- a/_saved/_suckless/dwm/README.md
+++ b/_saved/_suckless/dwm/README.md
@ -0,0 +1,64 @@
+# ftpd's dwm build
+
+## Patches applied
+
+These patches from suckless.org were applied from the newest versions, in order:
+
+1. `dwm-status2d-systray-6.3.diff`
+1. `dwm-restartsig-20180523-6.2.diff`
+1. `dwm-preserveonrestart (local, see _patches/)`
+1. `dwm-notitle-6.2.diff`
+1. `dwm-attachbelow-6.2.diff`
+1. `dwm-vanitygaps-6.2.diff (version providing multiple new layouts)`
+1. `dwm-swallow-20201211-61bb8b2.diff`
+1. `dwm-scratchpads-20200414-728d397b.diff`
+1. `dwm-alwayscenter-20200625-f04cac6.diff`
+1. `dwm-tagschemes-1.0.diff` (local, see _patches/ - use `git apply`)
+
+**note**: lot of manual work was involved, these won't apply easily on top of the others.
+
+## Fix color emoji
+
+Delete the following from drw.c:
+
+    /* Do not allow using color fonts. This is a workaround for a BadLength
+     * error from Xft with color glyphs. Modelled on the Xterm workaround. See
+     * https://bugzilla.redhat.com/show_bug.cgi?id=1498269
+     * https://lists.suckless.org/dev/1701/30932.html
+     * https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=916349
+     * and lots more all over the internet.
+     */
+    FcBool iscol;
+    if(FcPatternGetBool(xfont->pattern, FC_COLOR, 0, &iscol) == FcResultMatch && iscol) {
+    	XftFontClose(drw->dpy, xfont);
+    	return NULL;
+    }
+
+## Fix compile warnings
+
+Delete the following from dwm.c:
+
+    int boxs = drw->fonts->h / 9;
+    int boxw = drw->fonts->h / 6 + 2;
+
+Change in dwm.c:
+
+    fscanf(f, "%*u %*s %*c %u", &v);
+
+to:
+
+    if (fscanf(f, "%*u %*s %*c %u", &v));
+
+If dmenu will be configured separately, remove from dwm.c:
+
+    if (arg->v == dmenucmd)
+      dmenumon[0] = '0' + selmon->num;
+
+and from config.def.h/config.h:
+
+    static const char dmenufont[]       = "monospace:size=10";
+
+    /* commands */
+    static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn() */
+    static const char *dmenucmd[] = { "dmenu_run", "-m", dmenumon, "-fn", dmenufont, "-nb", col_gray1, "-nf", col_gray3, "-sb", col_cyan, "-sf", col_gray4, NULL };
+    static const char *termcmd[]  = { "st", NULL };
--- a/_saved/_suckless/dwm/_patches/dwm-preserveonrestart-6.3.diff
+++ b/_saved/_suckless/dwm/_patches/dwm-preserveonrestart-6.3.diff
@ -0,0 +1,114 @@
+From 713fa8650f5a20006451ebcccf57a4512e83bae8 Mon Sep 17 00:00:00 2001
+From: Arda Atci <arda@phytech.io>
+Date: Wed, 18 May 2022 17:23:16 +0300
+Subject: [PATCH] preserve clients on old tags when renewing dwm
+
+---
+ dwm.c | 38 +++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 37 insertions(+), 1 deletion(-)
+
+diff --git a/dwm.c b/dwm.c
+index a96f33c..a12e0bd 100644
+--- a/dwm.c
+++ b/dwm.c
+@@ -62,7 +62,7 @@ enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */
+ enum { SchemeNorm, SchemeSel }; /* color schemes */
+ enum { NetSupported, NetWMName, NetWMState, NetWMCheck,
+        NetWMFullscreen, NetActiveWindow, NetWMWindowType,
+-       NetWMWindowTypeDialog, NetClientList, NetLast }; /* EWMH atoms */
+       NetWMWindowTypeDialog, NetClientList, NetClientInfo, NetLast }; /* EWMH atoms */
+ enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */
+ enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
+        ClkClientWin, ClkRootWin, ClkLast }; /* clicks */
+@@ -198,6 +198,7 @@ static void scan(void);
+ static int sendevent(Client *c, Atom proto);
+ static void sendmon(Client *c, Monitor *m);
+ static void setclientstate(Client *c, long state);
+static void setclienttagprop(Client *c);
+ static void setfocus(Client *c);
+ static void setfullscreen(Client *c, int fullscreen);
+ static void setlayout(const Arg *arg);
+@@ -1060,6 +1061,26 @@ manage(Window w, XWindowAttributes *wa)
+ 	updatewindowtype(c);
+ 	updatesizehints(c);
+ 	updatewmhints(c);
+	{
+		int format;
+		unsigned long *data, n, extra;
+		Monitor *m;
+		Atom atom;
+		if (XGetWindowProperty(dpy, c->win, netatom[NetClientInfo], 0L, 2L, False, XA_CARDINAL,
+				&atom, &format, &n, &extra, (unsigned char **)&data) == Success && n == 2) {
+			c->tags = *data;
+			for (m = mons; m; m = m->next) {
+				if (m->num == *(data+1)) {
+					c->mon = m;
+					break;
+				}
+			}
+		}
+		if (n > 0)
+			XFree(data);
+	}
+	setclienttagprop(c);
+
+ 	XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);
+ 	grabbuttons(c, 0);
+ 	if (!c->isfloating)
+@@ -1423,6 +1444,7 @@ sendmon(Client *c, Monitor *m)
+ 	c->tags = m->tagset[m->seltags]; /* assign tags of target monitor */
+ 	attach(c);
+ 	attachstack(c);
+	setclienttagprop(c);
+ 	focus(NULL);
+ 	arrange(NULL);
+ }
+@@ -1566,6 +1588,7 @@ setup(void)
+ 	netatom[NetWMWindowType] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False);
+ 	netatom[NetWMWindowTypeDialog] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_DIALOG", False);
+ 	netatom[NetClientList] = XInternAtom(dpy, "_NET_CLIENT_LIST", False);
+	netatom[NetClientInfo] = XInternAtom(dpy, "_NET_CLIENT_INFO", False);
+ 	/* init cursors */
+ 	cursor[CurNormal] = drw_cur_create(drw, XC_left_ptr);
+ 	cursor[CurResize] = drw_cur_create(drw, XC_sizing);
+@@ -1589,6 +1612,7 @@ setup(void)
+ 	XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,
+ 		PropModeReplace, (unsigned char *) netatom, NetLast);
+ 	XDeleteProperty(dpy, root, netatom[NetClientList]);
+	XDeleteProperty(dpy, root, netatom[NetClientInfo]);
+ 	/* select events */
+ 	wa.cursor = cursor[CurNormal]->cursor;
+ 	wa.event_mask = SubstructureRedirectMask|SubstructureNotifyMask
+@@ -1656,11 +1680,22 @@ spawn(const Arg *arg)
+ 	}
+ }
+ 
+void
+setclienttagprop(Client *c)
+{
+	long data[] = { (long) c->tags, (long) c->mon->num };
+	XChangeProperty(dpy, c->win, netatom[NetClientInfo], XA_CARDINAL, 32,
+			PropModeReplace, (unsigned char *) data, 2);
+}
+
+ void
+ tag(const Arg *arg)
+ {
+	Client *c;
+ 	if (selmon->sel && arg->ui & TAGMASK) {
+		c = selmon->sel;
+ 		selmon->sel->tags = arg->ui & TAGMASK;
+		setclienttagprop(c);
+ 		focus(NULL);
+ 		arrange(selmon);
+ 	}
+@@ -1735,6 +1770,7 @@ toggletag(const Arg *arg)
+ 	newtags = selmon->sel->tags ^ (arg->ui & TAGMASK);
+ 	if (newtags) {
+ 		selmon->sel->tags = newtags;
+		setclienttagprop(selmon->sel);
+ 		focus(NULL);
+ 		arrange(selmon);
+ 	}
+-- 
+2.36.1
--- a/_saved/_suckless/dwm/_patches/dwm-tagschemes-1.0.diff
+++ b/_saved/_suckless/dwm/_patches/dwm-tagschemes-1.0.diff
@ -0,0 +1,68 @@
+diff --git a/config.def.h b/config.def.h
+index 3a60ca7..5979f05 100644
+--- a/config.def.h
+++ b/config.def.h
+@@ -17,16 +17,24 @@ static const int showsystray        = 1;     /* 0 means no systray */
+ static const int showbar            = 1;     /* 0 means no bar */
+ static const int topbar             = 1;     /* 0 means bottom bar */
+ static const char *fonts[]          = { "monospace:size=10" };
+-static const char col_gray1[]       = "#222222";
+-static const char col_gray2[]       = "#444444";
+-static const char col_gray3[]       = "#bbbbbb";
+-static const char col_gray4[]       = "#eeeeee";
+-static const char col_cyan[]        = "#005577";
+-static const char *colors[][3]      = {
+-  /*                fg         bg         border   */
+-  [SchemeNorm]  = { col_gray3, col_gray1, col_gray2 },
+-  [SchemeSel]   = { col_gray4, col_cyan,  col_cyan  },
+-  [SchemeEmpty] = { col_empty, col_gray1, col_gray2 },
+static const char col_fg[]          = "#ffffff";
+static const char col_bg[]          = "#272822";
+static const char col_bd[]          = "#272822";
+static const char col_fg_empty[]    = "#404040";
+static const char col_fg_layout[]   = "#909090";
+static const char col_fg_urgent[]   = "#ffffff";
+static const char col_bg_urgent[]   = "#770000";
+static const char col_bd_urgent[]   = "#770000";
+static const char col_fg_sel[]      = "#ffffff";
+static const char col_bg_sel[]      = "#005577";
+static const char col_bd_sel[]      = "#ffffff";
+static const char *colors[][3] = {
+  /*                 fg             bg             border   */
+  [SchemeNorm]   = { col_fg,        col_bg,        col_bd },
+  [SchemeSel]    = { col_fg_sel,    col_bg_sel,    col_bd_sel },
+  [SchemeEmpty]  = { col_fg_empty,  col_bg,        col_bd },
+  [SchemeLayout] = { col_fg_layout, col_bg,        col_bd },
+  [SchemeUrgent] = { col_fg_urgent, col_bg_urgent, col_bd_urgent },
+ };
+ 
+ typedef struct {
+diff --git a/dwm.c b/dwm.c
+index 8a200d5..626eab3 100644
+--- a/dwm.c
+++ b/dwm.c
+@@ -81,7 +81,7 @@
+ 
+ /* enums */
+ enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */
+-enum { SchemeNorm, SchemeSel }; /* color schemes */
+enum { SchemeNorm, SchemeSel, SchemeEmpty, SchemeLayout, SchemeUrgent }; /* color schemes */
+ enum { NetSupported, NetWMName, NetWMState, NetWMCheck,
+   NetSystemTray, NetSystemTrayOP, NetSystemTrayOrientation, NetSystemTrayOrientationHorz,
+   NetWMFullscreen, NetActiveWindow, NetWMWindowType,
+@@ -1029,12 +1029,12 @@ drawbar(Monitor *m)
+   x = 0;
+   for (i = 0; i < LENGTH(tags); i++) {
+     w = TEXTW(tags[i]);
+-    drw_setscheme(drw, scheme[m->tagset[m->seltags] & 1 << i ? SchemeSel : SchemeNorm]);
+-    drw_text(drw, x, 0, w, bh, lrpad / 2, tags[i], urg & 1 << i);
+    drw_setscheme(drw, scheme[m->tagset[m->seltags] & 1 << i ? SchemeSel : urg & 1 << i ? SchemeUrgent : occ & 1 << i ? SchemeNorm : SchemeEmpty ]);
+    drw_text(drw, x, 0, w, bh, lrpad / 2, tags[i], 0);
+     x += w;
+   }
+   w = blw = TEXTW(m->ltsymbol);
+-  drw_setscheme(drw, scheme[SchemeNorm]);
+  drw_setscheme(drw, scheme[SchemeLayout]);
+   x = drw_text(drw, x, 0, w, bh, lrpad / 2, m->ltsymbol, 0);
+ 
+   if ((w = m->ww - tw - stw - x) > bh) {
--- a/_saved/_suckless/dwm/config.def.h
+++ b/_saved/_suckless/dwm/config.def.h
@ -0,0 +1,176 @@
+/* See LICENSE file for copyright and license details. */
+
+/* appearance */
+static const unsigned int borderpx  = 1;        /* border pixel of windows */
+static const unsigned int snap      = 32;       /* snap pixel */
+static const unsigned int gappih    = 20;       /* horiz inner gap between windows */
+static const unsigned int gappiv    = 10;       /* vert inner gap between windows */
+static const unsigned int gappoh    = 10;       /* horiz outer gap between windows and screen edge */
+static const unsigned int gappov    = 30;       /* vert outer gap between windows and screen edge */
+static       int smartgaps          = 0;        /* 1 means no outer gap when there is only one window */
+static const int swallowfloating    = 0;        /* 1 means swallow floating windows by default */
+static const unsigned int systraypinning = 0;   /* 0: sloppy systray follows selected monitor, >0: pin systray to monitor X */
+static const unsigned int systrayonleft = 0;   	/* 0: systray in the right corner, >0: systray on left of status text */
+static const unsigned int systrayspacing = 2;   /* systray spacing */
+static const int systraypinningfailfirst = 1;   /* 1: if pinning fails, display systray on the first monitor, False: display systray on the last monitor*/
+static const int showsystray        = 1;     /* 0 means no systray */
+static const int showbar            = 1;     /* 0 means no bar */
+static const int topbar             = 1;     /* 0 means bottom bar */
+static const char *fonts[]          = { "monospace:size=10" };
+static const char col_gray1[]       = "#222222";
+static const char col_gray2[]       = "#444444";
+static const char col_gray3[]       = "#bbbbbb";
+static const char col_gray4[]       = "#eeeeee";
+static const char col_cyan[]        = "#005577";
+static const char *colors[][3]      = {
+  /*                fg         bg         border   */
+  [SchemeNorm]  = { col_gray3, col_gray1, col_gray2 },
+  [SchemeSel]   = { col_gray4, col_cyan,  col_cyan  },
+  [SchemeEmpty] = { col_empty, col_gray1, col_gray2 },
+};
+
+typedef struct {
+  const char *name;
+  const void *cmd;
+} Sp;
+const char *spcmd1[] = {"st", "-n", "spterm", "-g", "120x34", NULL };
+const char *spcmd2[] = {"st", "-n", "spfm", "-g", "144x41", "-e", "ranger", NULL };
+const char *spcmd3[] = {"keepassxc", NULL };
+static Sp scratchpads[] = {
+  /* name          cmd  */
+  {"spterm",      spcmd1},
+  {"spranger",    spcmd2},
+  {"keepassxc",   spcmd3},
+};
+
+/* tagging */
+static const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };
+
+static const Rule rules[] = {
+  /* xprop(1):
+   *	WM_CLASS(STRING) = instance, class
+   *	WM_NAME(STRING) = title
+   */
+  /* class     instance  title           tags mask  isfloating  isterminal  noswallow  monitor */
+  { "Gimp",    NULL,     NULL,           0,         1,          0,           0,        -1 },
+  { "Firefox", NULL,     NULL,           1 << 8,    0,          0,          -1,        -1 },
+  { "St",      NULL,     NULL,           0,         0,          1,           0,        -1 },
+  { NULL,      NULL,     "Event Tester", 0,         0,          0,           1,        -1 }, /* xev */
+  { NULL,		  "spterm",		NULL,		SPTAG(0),		1,			 -1 },
+  { NULL,		  "spfm",		NULL,		SPTAG(1),		1,			 -1 },
+  { NULL,		  "keepassxc",	NULL,		SPTAG(2),		0,			 -1 },
+};
+
+/* layout(s) */
+static const float mfact     = 0.55; /* factor of master area size [0.05..0.95] */
+static const int nmaster     = 1;    /* number of clients in master area */
+static const int resizehints = 1;    /* 1 means respect size hints in tiled resizals */
+static const int attachbelow = 1;    /* 1 means attach after the currently active window */
+static const int lockfullscreen = 1; /* 1 will force focus on the fullscreen window */
+
+#define FORCE_VSPLIT 1  /* nrowgrid layout: force two clients to always split vertically */
+#include "vanitygaps.c"
+
+static const Layout layouts[] = {
+  /* symbol     arrange function */
+  { "[]=",      tile },    /* first entry is default */
+  { "[M]",      monocle },
+  { "[@]",      spiral },
+  { "[\\]",     dwindle },
+  { "H[]",      deck },
+  { "TTT",      bstack },
+  { "===",      bstackhoriz },
+  { "HHH",      grid },
+  { "###",      nrowgrid },
+  { "---",      horizgrid },
+  { ":::",      gaplessgrid },
+  { "|M|",      centeredmaster },
+  { ">M>",      centeredfloatingmaster },
+  { "><>",      NULL },    /* no layout function means floating behavior */
+  { NULL,       NULL },
+};
+
+/* key definitions */
+#define MODKEY Mod1Mask
+#define TAGKEYS(KEY,TAG) \
+{ MODKEY,                       KEY,      view,           {.ui = 1 << TAG} }, \
+{ MODKEY|ControlMask,           KEY,      toggleview,     {.ui = 1 << TAG} }, \
+{ MODKEY|ShiftMask,             KEY,      tag,            {.ui = 1 << TAG} }, \
+{ MODKEY|ControlMask|ShiftMask, KEY,      toggletag,      {.ui = 1 << TAG} },
+
+/* helper for spawning shell commands in the pre dwm-5.0 fashion */
+#define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }
+
+static Key keys[] = {
+  /* modifier                     key        function        argument */
+  { MODKEY,                       XK_p,      spawn,          {.v = dmenucmd } },
+  { MODKEY|ShiftMask,             XK_Return, spawn,          {.v = termcmd } },
+  { MODKEY,                       XK_b,      togglebar,      {0} },
+  { MODKEY,                       XK_j,      focusstack,     {.i = +1 } },
+  { MODKEY,                       XK_k,      focusstack,     {.i = -1 } },
+  { MODKEY,                       XK_i,      incnmaster,     {.i = +1 } },
+  { MODKEY,                       XK_d,      incnmaster,     {.i = -1 } },
+  { MODKEY,                       XK_h,      setmfact,       {.f = -0.05} },
+  { MODKEY,                       XK_l,      setmfact,       {.f = +0.05} },
+  { MODKEY,                       XK_Return, zoom,           {0} },
+  { MODKEY|Mod4Mask,              XK_u,      incrgaps,       {.i = +1 } },
+  { MODKEY|Mod4Mask|ShiftMask,    XK_u,      incrgaps,       {.i = -1 } },
+  { MODKEY|Mod4Mask,              XK_i,      incrigaps,      {.i = +1 } },
+  { MODKEY|Mod4Mask|ShiftMask,    XK_i,      incrigaps,      {.i = -1 } },
+  { MODKEY|Mod4Mask,              XK_o,      incrogaps,      {.i = +1 } },
+  { MODKEY|Mod4Mask|ShiftMask,    XK_o,      incrogaps,      {.i = -1 } },
+  { MODKEY|Mod4Mask,              XK_6,      incrihgaps,     {.i = +1 } },
+  { MODKEY|Mod4Mask|ShiftMask,    XK_6,      incrihgaps,     {.i = -1 } },
+  { MODKEY|Mod4Mask,              XK_7,      incrivgaps,     {.i = +1 } },
+  { MODKEY|Mod4Mask|ShiftMask,    XK_7,      incrivgaps,     {.i = -1 } },
+  { MODKEY|Mod4Mask,              XK_8,      incrohgaps,     {.i = +1 } },
+  { MODKEY|Mod4Mask|ShiftMask,    XK_8,      incrohgaps,     {.i = -1 } },
+  { MODKEY|Mod4Mask,              XK_9,      incrovgaps,     {.i = +1 } },
+  { MODKEY|Mod4Mask|ShiftMask,    XK_9,      incrovgaps,     {.i = -1 } },
+  { MODKEY|Mod4Mask,              XK_0,      togglegaps,     {0} },
+  { MODKEY|Mod4Mask|ShiftMask,    XK_0,      defaultgaps,    {0} },
+  { MODKEY,                       XK_Tab,    view,           {0} },
+  { MODKEY|ShiftMask,             XK_c,      killclient,     {0} },
+  { MODKEY,                       XK_t,      setlayout,      {.v = &layouts[0]} },
+  { MODKEY,                       XK_f,      setlayout,      {.v = &layouts[1]} },
+  { MODKEY,                       XK_m,      setlayout,      {.v = &layouts[2]} },
+  { MODKEY,                       XK_space,  setlayout,      {0} },
+  { MODKEY|ShiftMask,             XK_space,  togglefloating, {0} },
+  { MODKEY,                       XK_0,      view,           {.ui = ~0 } },
+  { MODKEY|ShiftMask,             XK_0,      tag,            {.ui = ~0 } },
+  { MODKEY,                       XK_comma,  focusmon,       {.i = -1 } },
+  { MODKEY,                       XK_period, focusmon,       {.i = +1 } },
+  { MODKEY|ShiftMask,             XK_comma,  tagmon,         {.i = -1 } },
+  { MODKEY|ShiftMask,             XK_period, tagmon,         {.i = +1 } },
+  { MODKEY,            			XK_y,  	   togglescratch,  {.ui = 0 } },
+  { MODKEY,            			XK_u,	   togglescratch,  {.ui = 1 } },
+  { MODKEY,            			XK_x,	   togglescratch,  {.ui = 2 } },
+  TAGKEYS(                        XK_1,                      0)
+    TAGKEYS(                        XK_2,                      1)
+    TAGKEYS(                        XK_3,                      2)
+    TAGKEYS(                        XK_4,                      3)
+    TAGKEYS(                        XK_5,                      4)
+    TAGKEYS(                        XK_6,                      5)
+    TAGKEYS(                        XK_7,                      6)
+    TAGKEYS(                        XK_8,                      7)
+    TAGKEYS(                        XK_9,                      8)
+    { MODKEY|ShiftMask,             XK_q,      quit,           {0} },
+    { MODKEY|ControlMask|ShiftMask, XK_q,      quit,           {1} }, 
+};
+
+/* button definitions */
+/* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
+static Button buttons[] = {
+  /* click                event mask      button          function        argument */
+  { ClkTagBar,            MODKEY,         Button1,        tag,            {0} },
+  { ClkTagBar,            MODKEY,         Button3,        toggletag,      {0} },
+  { ClkStatusText,        0,              Button2,        spawn,          {.v = termcmd } },
+  { ClkClientWin,         MODKEY,         Button1,        movemouse,      {0} },
+  { ClkClientWin,         MODKEY,         Button2,        togglefloating, {0} },
+  { ClkClientWin,         MODKEY,         Button1,        resizemouse,    {0} },
+  { ClkTagBar,            0,              Button1,        view,           {0} },
+  { ClkTagBar,            0,              Button3,        toggleview,     {0} },
+  { ClkTagBar,            MODKEY,         Button1,        tag,            {0} },
+  { ClkTagBar,            MODKEY,         Button3,        toggletag,      {0} },
+};
+
--- a/_saved/_suckless/dwm/config.h
+++ b/_saved/_suckless/dwm/config.h
@ -0,0 +1,205 @@
+/* See LICENSE file for copyright and license details. */
+
+/* appearance */
+static const unsigned int borderpx  = 5;        /* border pixel of windows */
+static const unsigned int snap      = 32;       /* snap pixel */
+static const unsigned int gappih    = 10;       /* horiz inner gap between windows */
+static const unsigned int gappiv    = 10;       /* vert inner gap between windows */
+static const unsigned int gappoh    = 10;       /* horiz outer gap between windows and screen edge */
+static const unsigned int gappov    = 10;       /* vert outer gap between windows and screen edge */
+static       int smartgaps          = 0;        /* 1 means no outer gap when there is only one window */
+static const int swallowfloating    = 1;        /* 1 means swallow floating windows by default */
+static const unsigned int systraypinning = 0;   /* 0: sloppy systray follows selected monitor, >0: pin systray to monitor X */
+static const unsigned int systrayonleft  = 0;   	/* 0: systray in the right corner, >0: systray on left of status text */
+static const unsigned int systrayspacing = 2;   /* systray spacing */
+static const int systraypinningfailfirst = 1;   /* 1: if pinning fails, display systray on the first monitor, False: display systray on the last monitor*/
+static const int showsystray        = 1;         /* 0 means no systray */
+static const int showbar            = 1;        /* 0 means no bar */
+static const int topbar             = 1;        /* 0 means bottom bar */
+static const char *fonts[]          = { "RobotoMono Nerd Font:style=Medium:pixelsize=13" };
+static const char col_fg[]          = "#ffffff";
+static const char col_bg[]          = "#272822";
+static const char col_bd[]          = "#272822";
+static const char col_fg_empty[]    = "#404040";
+static const char col_fg_layout[]   = "#909090";
+static const char col_fg_urgent[]   = "#ffffff";
+static const char col_bg_urgent[]   = "#770000";
+static const char col_bd_urgent[]   = "#770000";
+static const char col_fg_sel[]      = "#ffffff";
+static const char col_bg_sel[]      = "#005577";
+static const char col_bd_sel[]      = "#ffffff";
+static const char *colors[][3] = {
+  /*                 fg             bg             border   */
+  [SchemeNorm]   = { col_fg,        col_bg,        col_bd },
+  [SchemeSel]    = { col_fg_sel,    col_bg_sel,    col_bd_sel },
+  [SchemeEmpty]  = { col_fg_empty,  col_bg,        col_bd },
+  [SchemeLayout] = { col_fg_layout, col_bg,        col_bd },
+  [SchemeUrgent] = { col_fg_urgent, col_bg_urgent, col_bd_urgent },
+};
+
+typedef struct {
+  const char *name;
+  const void *cmd;
+} Sp;
+const char *spcmd1[] = {"st", "-n", "spterm", "-g", "120x34", NULL };
+const char *spcmd2[] = {"st", "-n", "spwork", "-g", "120x34", NULL };
+static Sp scratchpads[] = {
+  /* name    cmd  */
+  {"spterm", spcmd1},
+  {"spwork", spcmd2},
+};
+
+/* tagging */
+static const char *tags[] = {"\uf292", "\uf738", "\uf70d", "\uf7aa", "\uf120", "\uf120", "\ufc58", "\uf9b0", "\uf296", "\uf2bb"};
+
+static const Rule rules[] = {
+  /* xprop(1):
+   *	WM_CLASS(STRING) = instance, class
+   *	WM_NAME(STRING) = title
+   */
+  /* class                          instance      title               tags mask  isfloating  isterminal   noswallow  monitor */
+  { NULL,                           NULL,         "st",               0,         0,          1,           0,        -1 },
+  { "firefox",                      NULL,         NULL,               2,         0,          0,           1,        -1 },
+  { "Ferdi",                        NULL,         NULL,               1 << 2,    0,          0,           0,        -1 },
+  { "Slack",                        NULL,         NULL,               1 << 7,    0,          0,           0,        -1 },
+  { "workfx",                       NULL,         NULL,               1 << 9,    0,          0,           1,        -1 },
+  { NULL,                           NULL,         "Event Tester",     0,         0,          0,           1,        -1 }, /* xev */
+  { NULL,                           "mutt",       NULL,               1 << 3,    0,          1,           1,        -1 },
+  { NULL,                           "spterm",     NULL,               SPTAG(0),  1,          1,           0,        -1 },
+  { NULL,                           "spwork",     NULL,               SPTAG(1),  1,          1,           0,        -1 },
+};
+
+/* layout(s) */
+static const float mfact     = 0.55; /* factor of master area size [0.05..0.95] */
+static const int nmaster     = 1;    /* number of clients in master area */
+static const int resizehints = 1;    /* 1 means respect size hints in tiled resizals */
+static const int attachbelow = 1;    /* 1 means attach after the currently active window */
+static const int lockfullscreen = 1; /* 1 will force focus on the fullscreen window */
+
+#define FORCE_VSPLIT 1  /* nrowgrid layout: force two clients to always split vertically */
+#include "vanitygaps.c"
+
+static const Layout layouts[] = {
+  /* symbol     arrange function */
+  { "[]=",      tile },    /* first entry is default */
+  { "><>",      NULL },    /* no layout function means floating behavior */
+  { "[M]",      monocle },
+  { "TTT",      bstack },
+  { "===",      bstackhoriz },
+  { "[@]",      spiral },
+  { "[\\]",     dwindle },
+  { "H[]",      deck },
+  { "HHH",      grid },
+  { "###",      nrowgrid },
+  { "---",      horizgrid },
+  { ":::",      gaplessgrid },
+  { "|M|",      centeredmaster },
+  { ">M>",      centeredfloatingmaster },
+  { NULL,       NULL },
+};
+
+/* key definitions */
+#define MODKEY Mod4Mask
+#define SHTKEY (Mod4Mask|ShiftMask)
+#define CTRKEY (Mod4Mask|ControlMask)
+#define ALLKEY (Mod4Mask|ShiftMask|ControlMask)
+#define TAGKEYS(KEY,TAG) \
+{ MODKEY,                       KEY,      view,           {.ui = 1 << TAG} }, \
+{ MODKEY|ControlMask,           KEY,      toggleview,     {.ui = 1 << TAG} }, \
+{ MODKEY|ShiftMask,             KEY,      tag,            {.ui = 1 << TAG} }, \
+{ MODKEY|ControlMask|ShiftMask, KEY,      toggletag,      {.ui = 1 << TAG} },
+
+/* helper for spawning shell commands in the pre dwm-5.0 fashion */
+#define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }
+
+#include <X11/XF86keysym.h>
+
+static Key keys[] = {
+  /* modifier    key          function        argument */
+  TAGKEYS(       XK_1,                        0)
+    TAGKEYS(       XK_2,                        1)
+    TAGKEYS(       XK_3,                        2)
+    TAGKEYS(       XK_4,                        3)
+    TAGKEYS(       XK_5,                        4)
+    TAGKEYS(       XK_6,                        5)
+    TAGKEYS(       XK_7,                        6)
+    TAGKEYS(       XK_8,                        7)
+    TAGKEYS(       XK_9,                        8)
+    TAGKEYS(       XK_0,                        9)
+    /* apps n'shit */
+    { MODKEY,      XK_Return,   spawn,          SHCMD("BROWSER=firefox st") },
+    { SHTKEY,      XK_Return,   spawn,          SHCMD("BROWSER=workfx st -n work") },
+    { MODKEY,      XK_space,    spawn,          SHCMD("dmenu_run -c -i -l 20") },
+    { MODKEY,      XK_i,        spawn,          SHCMD("scrot -f -s 'scrot_%Y-%m-%d_%H-%M-%S_%s.png'") },
+    { SHTKEY,      XK_i,        spawn,          SHCMD("scrot 'scrot_%Y-%m-%d_%H-%M-%S_%s.png'") },
+    { MODKEY,      XK_m,        spawn,          SHCMD("pgrep -x neomutt > /dev/null || BROWSER=firefox st -n mutt -e neomutt") },
+    //{ MODKEY,      XK_m,        spawn,          SHCMD("mbsync -c /f/.config/mutt/mbsyncrc -a") },
+    { MODKEY,      XK_q,        killclient,     {0} },
+    { MODKEY,      XK_e,        togglescratch,  {.ui = 0 } },
+    { SHTKEY,      XK_e,        togglescratch,  {.ui = 1 } },
+    /* service controls */
+    { CTRKEY,      XK_a,        spawn,          SHCMD("dmenu-audio") },
+    { CTRKEY,      XK_b,        spawn,          SHCMD("dmenu-bluetooth") },
+    { CTRKEY,      XK_d,        spawn,          SHCMD("dmenu-display") },
+    { CTRKEY,      XK_e,        spawn,          SHCMD("dmenu-emoji") },
+    /* window controls */
+    { SHTKEY,      XK_m,        zoom,           {0} },
+    { SHTKEY,      XK_h,        setmfact,       {.f = -0.05} },
+    { SHTKEY,      XK_l,        setmfact,       {.f = +0.05} },
+    { SHTKEY,      XK_j,        focusstack,     {.i = -1 } },
+    { SHTKEY,      XK_k,        focusstack,     {.i = 11 } },
+    { SHTKEY,      XK_f,        togglefloating, {0} },
+    { SHTKEY,      XK_equal,    incnmaster,     {.i = +1 } },
+    { SHTKEY,      XK_minus,    incnmaster,     {.i = -1 } },
+    /* main dwm controls */
+    { ALLKEY,      XK_B,        togglebar,      {0} },
+    { ALLKEY,      XK_t,        setlayout,      {.v = &layouts[0]} },
+    { ALLKEY,      XK_f,        setlayout,      {.v = &layouts[1]} },
+    { ALLKEY,      XK_m,        setlayout,      {.v = &layouts[2]} },
+    { ALLKEY,      XK_b,        setlayout,      {.v = &layouts[3]} },
+    { ALLKEY,      XK_h,        setlayout,      {.v = &layouts[4]} },
+    { ALLKEY,      XK_l,        spawn,          SHCMD("slock") },
+    { ALLKEY,      XK_r,        quit,           {1} },
+    { ALLKEY,      XK_q,        quit,           {0} },
+    /* multimedia keys */
+    { 0, XF86XK_AudioMute,          spawn,  SHCMD("pactl set-sink-mute @DEFAULT_SINK@ toggle; kill -46 $(pidof dwmblocks)") },
+    { 0, XF86XK_AudioMicMute,       spawn,  SHCMD("sb-vol-in micmute") },
+    { 0, XF86XK_AudioRaiseVolume,   spawn,  SHCMD("pactl set-sink-volume @DEFAULT_SINK@ +5%; kill -46 $(pidof dwmblocks)") },
+    { 0, XF86XK_AudioLowerVolume,   spawn,  SHCMD("pactl set-sink-volume @DEFAULT_SINK@ -5%; kill -46 $(pidof dwmblocks)") },
+    { 0, XF86XK_MonBrightnessDown,  spawn,  SHCMD("xbacklight -dec 10") },
+    { 0, XF86XK_MonBrightnessUp,    spawn,  SHCMD("xbacklight -inc 10") },
+    /* only to avoid warnings */
+    { MODKEY|Mod1Mask,              XK_comma,    focusmon,       {.i = -1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_comma,    tagmon,         {.i = -1 } },
+    { MODKEY|Mod1Mask,              XK_period,   focusmon,       {.i = +1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_period,   tagmon,         {.i = +1 } },
+    { MODKEY|Mod1Mask,              XK_u,        incrgaps,       {.i = +1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_u,        incrgaps,       {.i = -1 } },
+    { MODKEY|Mod1Mask,              XK_i,        incrigaps,      {.i = +1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_i,        incrigaps,      {.i = -1 } },
+    { MODKEY|Mod1Mask,              XK_o,        incrogaps,      {.i = +1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_o,        incrogaps,      {.i = -1 } },
+    { MODKEY|Mod1Mask,              XK_6,        incrihgaps,     {.i = +1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_6,        incrihgaps,     {.i = -1 } },
+    { MODKEY|Mod1Mask,              XK_7,        incrivgaps,     {.i = +1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_7,        incrivgaps,     {.i = -1 } },
+    { MODKEY|Mod1Mask,              XK_8,        incrohgaps,     {.i = +1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_8,        incrohgaps,     {.i = -1 } },
+    { MODKEY|Mod1Mask,              XK_9,        incrovgaps,     {.i = +1 } },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_9,        incrovgaps,     {.i = -1 } },
+    { MODKEY|Mod1Mask,              XK_0,        togglegaps,     {0} },
+    { MODKEY|Mod1Mask|ShiftMask,    XK_0,        defaultgaps,    {0} },
+};
+
+/* button definitions */
+/* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
+static Button buttons[] = {
+  /* click                event mask      button          function        argument */
+  { ClkTagBar,            0,              Button1,        view,           {0} },
+  { ClkTagBar,            0,              Button3,        toggleview,     {0} },
+  { ClkLtSymbol,          0,              Button1,        setlayout,      {0} },
+  { ClkClientWin,         MODKEY,         Button1,        movemouse,      {0} },
+  { ClkClientWin,         MODKEY,         Button2,        togglefloating, {0} },
+  { ClkClientWin,         MODKEY,         Button3,        resizemouse,    {0} },
+};
+
--- a/_saved/_suckless/dwm/config.mk
+++ b/_saved/_suckless/dwm/config.mk
@ -0,0 +1,41 @@
+# dwm version
+VERSION = 6.3
+
+# Customize below to fit your system
+
+# paths
+PREFIX = /usr/local
+MANPREFIX = ${PREFIX}/share/man
+
+X11INC = /usr/X11R6/include
+X11LIB = /usr/X11R6/lib
+
+# Xinerama, comment if you don't want it
+XINERAMALIBS  = -lXinerama
+XINERAMAFLAGS = -DXINERAMA
+
+# freetype
+FREETYPELIBS = -lfontconfig -lXft
+FREETYPEINC = /usr/include/freetype2
+# OpenBSD (uncomment)
+#FREETYPEINC = ${X11INC}/freetype2
+#MANPREFIX = ${PREFIX}/man
+#KVMLIB = -lkvm
+
+# includes and libs
+INCS = -I${X11INC} -I${FREETYPEINC}
+LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS}
+LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} -lX11-xcb -lxcb -lxcb-res ${KVMLIB}
+
+# flags
+CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_POSIX_C_SOURCE=200809L -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS}
+#CFLAGS   = -g -std=c99 -pedantic -Wall -O0 ${INCS} ${CPPFLAGS}
+CFLAGS   = -std=c99 -pedantic -Wall -Wno-deprecated-declarations -Os ${INCS} ${CPPFLAGS}
+LDFLAGS  = ${LIBS}
+
+# Solaris
+#CFLAGS = -fast ${INCS} -DVERSION=\"${VERSION}\"
+#LDFLAGS = ${LIBS}
+
+# compiler and linker
+CC = cc
--- a/_saved/_suckless/dwm/drw.c
+++ b/_saved/_suckless/dwm/drw.c
@ -0,0 +1,451 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <X11/Xlib.h>
+#include <X11/Xft/Xft.h>
+
+#include "drw.h"
+#include "util.h"
+
+#define UTF_INVALID 0xFFFD
+#define UTF_SIZ     4
+
+static const unsigned char utfbyte[UTF_SIZ + 1] = {0x80,    0, 0xC0, 0xE0, 0xF0};
+static const unsigned char utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
+static const long utfmin[UTF_SIZ + 1] = {       0,    0,  0x80,  0x800,  0x10000};
+static const long utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
+
+  static long
+utf8decodebyte(const char c, size_t *i)
+{
+  for (*i = 0; *i < (UTF_SIZ + 1); ++(*i))
+    if (((unsigned char)c & utfmask[*i]) == utfbyte[*i])
+      return (unsigned char)c & ~utfmask[*i];
+  return 0;
+}
+
+  static size_t
+utf8validate(long *u, size_t i)
+{
+  if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
+    *u = UTF_INVALID;
+  for (i = 1; *u > utfmax[i]; ++i)
+    ;
+  return i;
+}
+
+  static size_t
+utf8decode(const char *c, long *u, size_t clen)
+{
+  size_t i, j, len, type;
+  long udecoded;
+
+  *u = UTF_INVALID;
+  if (!clen)
+    return 0;
+  udecoded = utf8decodebyte(c[0], &len);
+  if (!BETWEEN(len, 1, UTF_SIZ))
+    return 1;
+  for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
+    udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
+    if (type)
+      return j;
+  }
+  if (j < len)
+    return 0;
+  *u = udecoded;
+  utf8validate(u, len);
+
+  return len;
+}
+
+  Drw *
+drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h)
+{
+  Drw *drw = ecalloc(1, sizeof(Drw));
+
+  drw->dpy = dpy;
+  drw->screen = screen;
+  drw->root = root;
+  drw->w = w;
+  drw->h = h;
+  drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen));
+  drw->gc = XCreateGC(dpy, root, 0, NULL);
+  XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);
+
+  return drw;
+}
+
+  void
+drw_resize(Drw *drw, unsigned int w, unsigned int h)
+{
+  if (!drw)
+    return;
+
+  drw->w = w;
+  drw->h = h;
+  if (drw->drawable)
+    XFreePixmap(drw->dpy, drw->drawable);
+  drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen));
+}
+
+  void
+drw_free(Drw *drw)
+{
+  XFreePixmap(drw->dpy, drw->drawable);
+  XFreeGC(drw->dpy, drw->gc);
+  drw_fontset_free(drw->fonts);
+  free(drw);
+}
+
+/* This function is an implementation detail. Library users should use
+ * drw_fontset_create instead.
+ */
+  static Fnt *
+xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern)
+{
+  Fnt *font;
+  XftFont *xfont = NULL;
+  FcPattern *pattern = NULL;
+
+  if (fontname) {
+    /* Using the pattern found at font->xfont->pattern does not yield the
+     * same substitution results as using the pattern returned by
+     * FcNameParse; using the latter results in the desired fallback
+     * behaviour whereas the former just results in missing-character
+     * rectangles being drawn, at least with some fonts. */
+    if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) {
+      fprintf(stderr, "error, cannot load font from name: '%s'\n", fontname);
+      return NULL;
+    }
+    if (!(pattern = FcNameParse((FcChar8 *) fontname))) {
+      fprintf(stderr, "error, cannot parse font name to pattern: '%s'\n", fontname);
+      XftFontClose(drw->dpy, xfont);
+      return NULL;
+    }
+  } else if (fontpattern) {
+    if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) {
+      fprintf(stderr, "error, cannot load font from pattern.\n");
+      return NULL;
+    }
+  } else {
+    die("no font specified.");
+  }
+
+  font = ecalloc(1, sizeof(Fnt));
+  font->xfont = xfont;
+  font->pattern = pattern;
+  font->h = xfont->ascent + xfont->descent;
+  font->dpy = drw->dpy;
+
+  return font;
+}
+
+  static void
+xfont_free(Fnt *font)
+{
+  if (!font)
+    return;
+  if (font->pattern)
+    FcPatternDestroy(font->pattern);
+  XftFontClose(font->dpy, font->xfont);
+  free(font);
+}
+
+  Fnt*
+drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount)
+{
+  Fnt *cur, *ret = NULL;
+  size_t i;
+
+  if (!drw || !fonts)
+    return NULL;
+
+  for (i = 1; i <= fontcount; i++) {
+    if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) {
+      cur->next = ret;
+      ret = cur;
+    }
+  }
+  return (drw->fonts = ret);
+}
+
+  void
+drw_fontset_free(Fnt *font)
+{
+  if (font) {
+    drw_fontset_free(font->next);
+    xfont_free(font);
+  }
+}
+
+  void
+drw_clr_create(Drw *drw, Clr *dest, const char *clrname)
+{
+  if (!drw || !dest || !clrname)
+    return;
+
+  if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen),
+        DefaultColormap(drw->dpy, drw->screen),
+        clrname, dest))
+    die("error, cannot allocate color '%s'", clrname);
+}
+
+/* Wrapper to create color schemes. The caller has to call free(3) on the
+ * returned color scheme when done using it. */
+  Clr *
+drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
+{
+  size_t i;
+  Clr *ret;
+
+  /* need at least two colors for a scheme */
+  if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor))))
+    return NULL;
+
+  for (i = 0; i < clrcount; i++)
+    drw_clr_create(drw, &ret[i], clrnames[i]);
+  return ret;
+}
+
+  void
+drw_setfontset(Drw *drw, Fnt *set)
+{
+  if (drw)
+    drw->fonts = set;
+}
+
+  void
+drw_setscheme(Drw *drw, Clr *scm)
+{
+  if (drw)
+    drw->scheme = scm;
+}
+
+  void
+drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert)
+{
+  if (!drw || !drw->scheme)
+    return;
+  XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel);
+  if (filled)
+    XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
+  else
+    XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1);
+}
+
+  int
+drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert)
+{
+  int i, ty, ellipsis_x = 0;
+  unsigned int tmpw, ew, ellipsis_w = 0, ellipsis_len;
+  XftDraw *d = NULL;
+  Fnt *usedfont, *curfont, *nextfont;
+  int utf8strlen, utf8charlen, render = x || y || w || h;
+  long utf8codepoint = 0;
+  const char *utf8str;
+  FcCharSet *fccharset;
+  FcPattern *fcpattern;
+  FcPattern *match;
+  XftResult result;
+  int charexists = 0, overflow = 0;
+  /* keep track of a couple codepoints for which we have no match. */
+  enum { nomatches_len = 64 };
+  static struct { long codepoint[nomatches_len]; unsigned int idx; } nomatches;
+  static unsigned int ellipsis_width = 0;
+
+  if (!drw || (render && (!drw->scheme || !w)) || !text || !drw->fonts)
+    return 0;
+
+  if (!render) {
+    w = invert ? invert : ~invert;
+  } else {
+    XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel);
+    XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
+    d = XftDrawCreate(drw->dpy, drw->drawable,
+        DefaultVisual(drw->dpy, drw->screen),
+        DefaultColormap(drw->dpy, drw->screen));
+    x += lpad;
+    w -= lpad;
+  }
+
+  usedfont = drw->fonts;
+  if (!ellipsis_width && render)
+    ellipsis_width = drw_fontset_getwidth(drw, "...");
+  while (1) {
+    ew = ellipsis_len = utf8strlen = 0;
+    utf8str = text;
+    nextfont = NULL;
+    while (*text) {
+      utf8charlen = utf8decode(text, &utf8codepoint, UTF_SIZ);
+      for (curfont = drw->fonts; curfont; curfont = curfont->next) {
+        charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint);
+        if (charexists) {
+          drw_font_getexts(curfont, text, utf8charlen, &tmpw, NULL);
+          if (ew + ellipsis_width <= w) {
+            /* keep track where the ellipsis still fits */
+            ellipsis_x = x + ew;
+            ellipsis_w = w - ew;
+            ellipsis_len = utf8strlen;
+          }
+
+          if (ew + tmpw > w) {
+            overflow = 1;
+            /* called from drw_fontset_getwidth_clamp():
+             * it wants the width AFTER the overflow
+             */
+            if (!render)
+              x += tmpw;
+            else
+              utf8strlen = ellipsis_len;
+          } else if (curfont == usedfont) {
+            utf8strlen += utf8charlen;
+            text += utf8charlen;
+            ew += tmpw;
+          } else {
+            nextfont = curfont;
+          }
+          break;
+        }
+      }
+
+      if (overflow || !charexists || nextfont)
+        break;
+      else
+        charexists = 0;
+    }
+
+    if (utf8strlen) {
+      if (render) {
+        ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent;
+        XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg],
+            usedfont->xfont, x, ty, (XftChar8 *)utf8str, utf8strlen);
+      }
+      x += ew;
+      w -= ew;
+    }
+    if (render && overflow)
+      drw_text(drw, ellipsis_x, y, ellipsis_w, h, 0, "...", invert);
+
+    if (!*text || overflow) {
+      break;
+    } else if (nextfont) {
+      charexists = 0;
+      usedfont = nextfont;
+    } else {
+      /* Regardless of whether or not a fallback font is found, the
+       * character must be drawn. */
+      charexists = 1;
+
+      for (i = 0; i < nomatches_len; ++i) {
+        /* avoid calling XftFontMatch if we know we won't find a match */
+        if (utf8codepoint == nomatches.codepoint[i])
+          goto no_match;
+      }
+
+      fccharset = FcCharSetCreate();
+      FcCharSetAddChar(fccharset, utf8codepoint);
+
+      if (!drw->fonts->pattern) {
+        /* Refer to the comment in xfont_create for more information. */
+        die("the first font in the cache must be loaded from a font string.");
+      }
+
+      fcpattern = FcPatternDuplicate(drw->fonts->pattern);
+      FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset);
+      FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue);
+      FcPatternAddBool(fcpattern, FC_COLOR, FcFalse);
+
+      FcConfigSubstitute(NULL, fcpattern, FcMatchPattern);
+      FcDefaultSubstitute(fcpattern);
+      match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result);
+
+      FcCharSetDestroy(fccharset);
+      FcPatternDestroy(fcpattern);
+
+      if (match) {
+        usedfont = xfont_create(drw, NULL, match);
+        if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) {
+          for (curfont = drw->fonts; curfont->next; curfont = curfont->next)
+            ; /* NOP */
+          curfont->next = usedfont;
+        } else {
+          xfont_free(usedfont);
+          nomatches.codepoint[++nomatches.idx % nomatches_len] = utf8codepoint;
+no_match:
+          usedfont = drw->fonts;
+        }
+      }
+    }
+  }
+  if (d)
+    XftDrawDestroy(d);
+
+  return x + (render ? w : 0);
+}
+
+  void
+drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h)
+{
+  if (!drw)
+    return;
+
+  XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y);
+  XSync(drw->dpy, False);
+}
+
+  unsigned int
+drw_fontset_getwidth(Drw *drw, const char *text)
+{
+  if (!drw || !drw->fonts || !text)
+    return 0;
+  return drw_text(drw, 0, 0, 0, 0, 0, text, 0);
+}
+
+  unsigned int
+drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n)
+{
+  unsigned int tmp = 0;
+  if (drw && drw->fonts && text && n)
+    tmp = drw_text(drw, 0, 0, 0, 0, 0, text, n);
+  return MIN(n, tmp);
+}
+
+  void
+drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h)
+{
+  XGlyphInfo ext;
+
+  if (!font || !text)
+    return;
+
+  XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext);
+  if (w)
+    *w = ext.xOff;
+  if (h)
+    *h = font->h;
+}
+
+  Cur *
+drw_cur_create(Drw *drw, int shape)
+{
+  Cur *cur;
+
+  if (!drw || !(cur = ecalloc(1, sizeof(Cur))))
+    return NULL;
+
+  cur->cursor = XCreateFontCursor(drw->dpy, shape);
+
+  return cur;
+}
+
+  void
+drw_cur_free(Drw *drw, Cur *cursor)
+{
+  if (!cursor)
+    return;
+
+  XFreeCursor(drw->dpy, cursor->cursor);
+  free(cursor);
+}
--- a/_saved/_suckless/dwm/drw.h
+++ b/_saved/_suckless/dwm/drw.h
@ -0,0 +1,58 @@
+/* See LICENSE file for copyright and license details. */
+
+typedef struct {
+  Cursor cursor;
+} Cur;
+
+typedef struct Fnt {
+  Display *dpy;
+  unsigned int h;
+  XftFont *xfont;
+  FcPattern *pattern;
+  struct Fnt *next;
+} Fnt;
+
+enum { ColFg, ColBg, ColBorder }; /* Clr scheme index */
+typedef XftColor Clr;
+
+typedef struct {
+  unsigned int w, h;
+  Display *dpy;
+  int screen;
+  Window root;
+  Drawable drawable;
+  GC gc;
+  Clr *scheme;
+  Fnt *fonts;
+} Drw;
+
+/* Drawable abstraction */
+Drw *drw_create(Display *dpy, int screen, Window win, unsigned int w, unsigned int h);
+void drw_resize(Drw *drw, unsigned int w, unsigned int h);
+void drw_free(Drw *drw);
+
+/* Fnt abstraction */
+Fnt *drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount);
+void drw_fontset_free(Fnt* set);
+unsigned int drw_fontset_getwidth(Drw *drw, const char *text);
+unsigned int drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n);
+void drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h);
+
+/* Colorscheme abstraction */
+void drw_clr_create(Drw *drw, Clr *dest, const char *clrname);
+Clr *drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount);
+
+/* Cursor abstraction */
+Cur *drw_cur_create(Drw *drw, int shape);
+void drw_cur_free(Drw *drw, Cur *cursor);
+
+/* Drawing context manipulation */
+void drw_setfontset(Drw *drw, Fnt *set);
+void drw_setscheme(Drw *drw, Clr *scm);
+
+/* Drawing functions */
+void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert);
+int drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert);
+
+/* Map functions */
+void drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h);
--- a/_saved/_suckless/dwm/dwm.1
+++ b/_saved/_suckless/dwm/dwm.1
@ -0,0 +1,189 @@
+.TH DWM 1 dwm\-VERSION
+.SH NAME
+dwm \- dynamic window manager
+.SH SYNOPSIS
+.B dwm
+.RB [ \-v ]
+.SH DESCRIPTION
+dwm is a dynamic window manager for X. It manages windows in tiled, monocle
+and floating layouts. Either layout can be applied dynamically, optimising the
+environment for the application in use and the task performed.
+.P
+In tiled layouts windows are managed in a master and stacking area. The master
+area on the left contains one window by default, and the stacking area on the
+right contains all other windows. The number of master area windows can be
+adjusted from zero to an arbitrary number. In monocle layout all windows are
+maximised to the screen size. In floating layout windows can be resized and
+moved freely. Dialog windows are always managed floating, regardless of the
+layout applied.
+.P
+Windows are grouped by tags. Each window can be tagged with one or multiple
+tags. Selecting certain tags displays all windows with these tags.
+.P
+Each screen contains a small status bar which displays all available tags, the
+layout, the title of the focused window, and the text read from the root window
+name property, if the screen is focused. A floating window is indicated with an
+empty square and a maximised floating window is indicated with a filled square
+before the windows title.  The selected tags are indicated with a different
+color. The tags of the focused window are indicated with a filled square in the
+top left corner.  The tags which are applied to one or more windows are
+indicated with an empty square in the top left corner.
+.P
+The attach below patch makes newly spawned windows attach after the currently
+selected window
+.P
+dwm draws a small border around windows to indicate the focus state.
+.SH OPTIONS
+.TP
+.B \-v
+prints version information to stderr, then exits.
+.SH USAGE
+.SS Status bar
+.TP
+.B X root window name
+is read and displayed in the status text area. It can be set with the
+.BR xsetroot (1)
+command.
+.TP
+.B Button1
+click on a tag label to display all windows with that tag, click on the layout
+label toggles between tiled and floating layout.
+.TP
+.B Button3
+click on a tag label adds/removes all windows with that tag to/from the view.
+.TP
+.B Mod1\-Button1
+click on a tag label applies that tag to the focused window.
+.TP
+.B Mod1\-Button3
+click on a tag label adds/removes that tag to/from the focused window.
+.SS Keyboard commands
+.TP
+.B Mod1\-Shift\-Return
+Start
+.BR st(1).
+.TP
+.B Mod1\-p
+Spawn
+.BR dmenu(1)
+for launching other programs.
+.TP
+.B Mod1\-,
+Focus previous screen, if any.
+.TP
+.B Mod1\-.
+Focus next screen, if any.
+.TP
+.B Mod1\-Shift\-,
+Send focused window to previous screen, if any.
+.TP
+.B Mod1\-Shift\-.
+Send focused window to next screen, if any.
+.TP
+.B Mod1\-b
+Toggles bar on and off.
+.TP
+.B Mod1\-t
+Sets tiled layout.
+.TP
+.B Mod1\-f
+Sets floating layout.
+.TP
+.B Mod1\-m
+Sets monocle layout.
+.TP
+.B Mod1\-space
+Toggles between current and previous layout.
+.TP
+.B Mod1\-j
+Focus next window.
+.TP
+.B Mod1\-k
+Focus previous window.
+.TP
+.B Mod1\-i
+Increase number of windows in master area.
+.TP
+.B Mod1\-d
+Decrease number of windows in master area.
+.TP
+.B Mod1\-l
+Increase master area size.
+.TP
+.B Mod1\-h
+Decrease master area size.
+.TP
+.B Mod1\-Return
+Zooms/cycles focused window to/from master area (tiled layouts only).
+.TP
+.B Mod1\-Shift\-c
+Close focused window.
+.TP
+.B Mod1\-Shift\-space
+Toggle focused window between tiled and floating state.
+.TP
+.B Mod1\-Tab
+Toggles to the previously selected tags.
+.TP
+.B Mod1\-Shift\-[1..n]
+Apply nth tag to focused window.
+.TP
+.B Mod1\-Shift\-0
+Apply all tags to focused window.
+.TP
+.B Mod1\-Control\-Shift\-[1..n]
+Add/remove nth tag to/from focused window.
+.TP
+.B Mod1\-[1..n]
+View all windows with nth tag.
+.TP
+.B Mod1\-0
+View all windows with any tag.
+.TP
+.B Mod1\-Control\-[1..n]
+Add/remove all windows with nth tag to/from the view.
+.TP
+.B Mod1\-Shift\-q
+Quit dwm.
+.TP
+.B Mod1\-Control\-Shift\-q
+Restart dwm.
+.SS Mouse commands
+.TP
+.B Mod1\-Button1
+Move focused window while dragging. Tiled windows will be toggled to the floating state.
+.TP
+.B Mod1\-Button2
+Toggles focused window between floating and tiled state.
+.TP
+.B Mod1\-Button3
+Resize focused window while dragging. Tiled windows will be toggled to the floating state.
+.SH CUSTOMIZATION
+dwm is customized by creating a custom config.h and (re)compiling the source
+code. This keeps it fast, secure and simple.
+.SH SIGNALS
+.TP
+.B SIGHUP - 1
+Restart the dwm process.
+.TP
+.B SIGTERM - 15
+Cleanly terminate the dwm process.
+.SH SEE ALSO
+.BR dmenu (1),
+.BR st (1)
+.SH ISSUES
+Java applications which use the XToolkit/XAWT backend may draw grey windows
+only. The XToolkit/XAWT backend breaks ICCCM-compliance in recent JDK 1.5 and early
+JDK 1.6 versions, because it assumes a reparenting window manager. Possible workarounds
+are using JDK 1.4 (which doesn't contain the XToolkit/XAWT backend) or setting the
+environment variable
+.BR AWT_TOOLKIT=MToolkit
+(to use the older Motif backend instead) or running
+.B xprop -root -f _NET_WM_NAME 32a -set _NET_WM_NAME LG3D
+or
+.B wmname LG3D
+(to pretend that a non-reparenting window manager is running that the
+XToolkit/XAWT backend can recognize) or when using OpenJDK setting the environment variable
+.BR _JAVA_AWT_WM_NONREPARENTING=1 .
+.SH BUGS
+Send all bug reports with a patch to hackers@suckless.org.
--- a/_saved/_suckless/dwm/dwm.c
+++ b/_saved/_suckless/dwm/dwm.c
--- a/_saved/_suckless/dwm/transient.c
+++ b/_saved/_suckless/dwm/transient.c
@ -0,0 +1,42 @@
+/* cc transient.c -o transient -lX11 */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+int main(void) {
+  Display *d;
+  Window r, f, t = None;
+  XSizeHints h;
+  XEvent e;
+
+  d = XOpenDisplay(NULL);
+  if (!d)
+    exit(1);
+  r = DefaultRootWindow(d);
+
+  f = XCreateSimpleWindow(d, r, 100, 100, 400, 400, 0, 0, 0);
+  h.min_width = h.max_width = h.min_height = h.max_height = 400;
+  h.flags = PMinSize | PMaxSize;
+  XSetWMNormalHints(d, f, &h);
+  XStoreName(d, f, "floating");
+  XMapWindow(d, f);
+
+  XSelectInput(d, f, ExposureMask);
+  while (1) {
+    XNextEvent(d, &e);
+
+    if (t == None) {
+      sleep(5);
+      t = XCreateSimpleWindow(d, r, 50, 50, 100, 100, 0, 0, 0);
+      XSetTransientForHint(d, t, f);
+      XStoreName(d, t, "transient");
+      XMapWindow(d, t);
+      XSelectInput(d, t, ExposureMask);
+    }
+  }
+
+  XCloseDisplay(d);
+  exit(0);
+}
--- a/_saved/_suckless/dwm/util.c
+++ b/_saved/_suckless/dwm/util.c
@ -0,0 +1,35 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "util.h"
+
+  void *
+ecalloc(size_t nmemb, size_t size)
+{
+  void *p;
+
+  if (!(p = calloc(nmemb, size)))
+    die("calloc:");
+  return p;
+}
+
+void
+die(const char *fmt, ...) {
+  va_list ap;
+
+  va_start(ap, fmt);
+  vfprintf(stderr, fmt, ap);
+  va_end(ap);
+
+  if (fmt[0] && fmt[strlen(fmt)-1] == ':') {
+    fputc(' ', stderr);
+    perror(NULL);
+  } else {
+    fputc('\n', stderr);
+  }
+
+  exit(1);
+}
--- a/_saved/_suckless/dwm/util.h
+++ b/_saved/_suckless/dwm/util.h
@ -0,0 +1,8 @@
+/* See LICENSE file for copyright and license details. */
+
+#define MAX(A, B)               ((A) > (B) ? (A) : (B))
+#define MIN(A, B)               ((A) < (B) ? (A) : (B))
+#define BETWEEN(X, A, B)        ((A) <= (X) && (X) <= (B))
+
+void die(const char *fmt, ...);
+void *ecalloc(size_t nmemb, size_t size);
--- a/_saved/_suckless/dwm/vanitygaps.c
+++ b/_saved/_suckless/dwm/vanitygaps.c
@ -0,0 +1,809 @@
+/* Key binding functions */
+static void defaultgaps(const Arg *arg);
+static void incrgaps(const Arg *arg);
+static void incrigaps(const Arg *arg);
+static void incrogaps(const Arg *arg);
+static void incrohgaps(const Arg *arg);
+static void incrovgaps(const Arg *arg);
+static void incrihgaps(const Arg *arg);
+static void incrivgaps(const Arg *arg);
+static void togglegaps(const Arg *arg);
+/* Layouts (delete the ones you do not need) */
+static void bstack(Monitor *m);
+static void bstackhoriz(Monitor *m);
+static void centeredmaster(Monitor *m);
+static void centeredfloatingmaster(Monitor *m);
+static void deck(Monitor *m);
+static void dwindle(Monitor *m);
+static void fibonacci(Monitor *m, int s);
+static void grid(Monitor *m);
+static void nrowgrid(Monitor *m);
+static void spiral(Monitor *m);
+static void tile(Monitor *m);
+/* Internals */
+static void getgaps(Monitor *m, int *oh, int *ov, int *ih, int *iv, unsigned int *nc);
+static void getfacts(Monitor *m, int msize, int ssize, float *mf, float *sf, int *mr, int *sr);
+static void setgaps(int oh, int ov, int ih, int iv);
+
+/* Settings */
+#if !PERTAG_PATCH
+static int enablegaps = 1;
+#endif // PERTAG_PATCH
+
+  void
+setgaps(int oh, int ov, int ih, int iv)
+{
+  if (oh < 0) oh = 0;
+  if (ov < 0) ov = 0;
+  if (ih < 0) ih = 0;
+  if (iv < 0) iv = 0;
+
+  selmon->gappoh = oh;
+  selmon->gappov = ov;
+  selmon->gappih = ih;
+  selmon->gappiv = iv;
+  arrange(selmon);
+}
+
+  void
+togglegaps(const Arg *arg)
+{
+#if PERTAG_PATCH
+  selmon->pertag->enablegaps[selmon->pertag->curtag] = !selmon->pertag->enablegaps[selmon->pertag->curtag];
+#else
+  enablegaps = !enablegaps;
+#endif // PERTAG_PATCH
+  arrange(NULL);
+}
+
+  void
+defaultgaps(const Arg *arg)
+{
+  setgaps(gappoh, gappov, gappih, gappiv);
+}
+
+  void
+incrgaps(const Arg *arg)
+{
+  setgaps(
+      selmon->gappoh + arg->i,
+      selmon->gappov + arg->i,
+      selmon->gappih + arg->i,
+      selmon->gappiv + arg->i
+      );
+}
+
+  void
+incrigaps(const Arg *arg)
+{
+  setgaps(
+      selmon->gappoh,
+      selmon->gappov,
+      selmon->gappih + arg->i,
+      selmon->gappiv + arg->i
+      );
+}
+
+  void
+incrogaps(const Arg *arg)
+{
+  setgaps(
+      selmon->gappoh + arg->i,
+      selmon->gappov + arg->i,
+      selmon->gappih,
+      selmon->gappiv
+      );
+}
+
+  void
+incrohgaps(const Arg *arg)
+{
+  setgaps(
+      selmon->gappoh + arg->i,
+      selmon->gappov,
+      selmon->gappih,
+      selmon->gappiv
+      );
+}
+
+  void
+incrovgaps(const Arg *arg)
+{
+  setgaps(
+      selmon->gappoh,
+      selmon->gappov + arg->i,
+      selmon->gappih,
+      selmon->gappiv
+      );
+}
+
+  void
+incrihgaps(const Arg *arg)
+{
+  setgaps(
+      selmon->gappoh,
+      selmon->gappov,
+      selmon->gappih + arg->i,
+      selmon->gappiv
+      );
+}
+
+  void
+incrivgaps(const Arg *arg)
+{
+  setgaps(
+      selmon->gappoh,
+      selmon->gappov,
+      selmon->gappih,
+      selmon->gappiv + arg->i
+      );
+}
+
+  void
+getgaps(Monitor *m, int *oh, int *ov, int *ih, int *iv, unsigned int *nc)
+{
+  unsigned int n, oe, ie;
+#if PERTAG_PATCH
+  oe = ie = selmon->pertag->enablegaps[selmon->pertag->curtag];
+#else
+  oe = ie = enablegaps;
+#endif // PERTAG_PATCH
+  Client *c;
+
+  for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
+  if (smartgaps && n == 1) {
+    oe = 0; // outer gaps disabled when only one client
+  }
+
+  *oh = m->gappoh*oe; // outer horizontal gap
+  *ov = m->gappov*oe; // outer vertical gap
+  *ih = m->gappih*ie; // inner horizontal gap
+  *iv = m->gappiv*ie; // inner vertical gap
+  *nc = n;            // number of clients
+}
+
+  void
+getfacts(Monitor *m, int msize, int ssize, float *mf, float *sf, int *mr, int *sr)
+{
+  unsigned int n;
+  float mfacts, sfacts;
+  int mtotal = 0, stotal = 0;
+  Client *c;
+
+  for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
+  mfacts = MIN(n, m->nmaster);
+  sfacts = n - m->nmaster;
+
+  for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++)
+    if (n < m->nmaster)
+      mtotal += msize / mfacts;
+    else
+      stotal += ssize / sfacts;
+
+  *mf = mfacts; // total factor of master area
+  *sf = sfacts; // total factor of stack area
+  *mr = msize - mtotal; // the remainder (rest) of pixels after an even master split
+  *sr = ssize - stotal; // the remainder (rest) of pixels after an even stack split
+}
+
+/***
+ * Layouts
+ */
+
+/*
+ * Bottomstack layout + gaps
+ * https://dwm.suckless.org/patches/bottomstack/
+ */
+  static void
+bstack(Monitor *m)
+{
+  unsigned int i, n;
+  int oh, ov, ih, iv;
+  int mx = 0, my = 0, mh = 0, mw = 0;
+  int sx = 0, sy = 0, sh = 0, sw = 0;
+  float mfacts, sfacts;
+  int mrest, srest;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  sx = mx = m->wx + ov;
+  sy = my = m->wy + oh;
+  sh = mh = m->wh - 2*oh;
+  mw = m->ww - 2*ov - iv * (MIN(n, m->nmaster) - 1);
+  sw = m->ww - 2*ov - iv * (n - m->nmaster - 1);
+
+  if (m->nmaster && n > m->nmaster) {
+    sh = (mh - ih) * (1 - m->mfact);
+    mh = mh - ih - sh;
+    sx = mx;
+    sy = my + mh + ih;
+  }
+
+  getfacts(m, mw, sw, &mfacts, &sfacts, &mrest, &srest);
+
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) {
+    if (i < m->nmaster) {
+      resize(c, mx, my, (mw / mfacts) + (i < mrest ? 1 : 0) - (2*c->bw), mh - (2*c->bw), 0);
+      mx += WIDTH(c) + iv;
+    } else {
+      resize(c, sx, sy, (sw / sfacts) + ((i - m->nmaster) < srest ? 1 : 0) - (2*c->bw), sh - (2*c->bw), 0);
+      sx += WIDTH(c) + iv;
+    }
+  }
+}
+
+  static void
+bstackhoriz(Monitor *m)
+{
+  unsigned int i, n;
+  int oh, ov, ih, iv;
+  int mx = 0, my = 0, mh = 0, mw = 0;
+  int sx = 0, sy = 0, sh = 0, sw = 0;
+  float mfacts, sfacts;
+  int mrest, srest;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  sx = mx = m->wx + ov;
+  sy = my = m->wy + oh;
+  mh = m->wh - 2*oh;
+  sh = m->wh - 2*oh - ih * (n - m->nmaster - 1);
+  mw = m->ww - 2*ov - iv * (MIN(n, m->nmaster) - 1);
+  sw = m->ww - 2*ov;
+
+  if (m->nmaster && n > m->nmaster) {
+    sh = (mh - ih) * (1 - m->mfact);
+    mh = mh - ih - sh;
+    sy = my + mh + ih;
+    sh = m->wh - mh - 2*oh - ih * (n - m->nmaster);
+  }
+
+  getfacts(m, mw, sh, &mfacts, &sfacts, &mrest, &srest);
+
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) {
+    if (i < m->nmaster) {
+      resize(c, mx, my, (mw / mfacts) + (i < mrest ? 1 : 0) - (2*c->bw), mh - (2*c->bw), 0);
+      mx += WIDTH(c) + iv;
+    } else {
+      resize(c, sx, sy, sw - (2*c->bw), (sh / sfacts) + ((i - m->nmaster) < srest ? 1 : 0) - (2*c->bw), 0);
+      sy += HEIGHT(c) + ih;
+    }
+  }
+}
+
+/*
+ * Centred master layout + gaps
+ * https://dwm.suckless.org/patches/centeredmaster/
+ */
+  void
+centeredmaster(Monitor *m)
+{
+  unsigned int i, n;
+  int oh, ov, ih, iv;
+  int mx = 0, my = 0, mh = 0, mw = 0;
+  int lx = 0, ly = 0, lw = 0, lh = 0;
+  int rx = 0, ry = 0, rw = 0, rh = 0;
+  float mfacts = 0, lfacts = 0, rfacts = 0;
+  int mtotal = 0, ltotal = 0, rtotal = 0;
+  int mrest = 0, lrest = 0, rrest = 0;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  /* initialize areas */
+  mx = m->wx + ov;
+  my = m->wy + oh;
+  mh = m->wh - 2*oh - ih * ((!m->nmaster ? n : MIN(n, m->nmaster)) - 1);
+  mw = m->ww - 2*ov;
+  lh = m->wh - 2*oh - ih * (((n - m->nmaster) / 2) - 1);
+  rh = m->wh - 2*oh - ih * (((n - m->nmaster) / 2) - ((n - m->nmaster) % 2 ? 0 : 1));
+
+  if (m->nmaster && n > m->nmaster) {
+    /* go mfact box in the center if more than nmaster clients */
+    if (n - m->nmaster > 1) {
+      /* ||<-S->|<---M--->|<-S->|| */
+      mw = (m->ww - 2*ov - 2*iv) * m->mfact;
+      lw = (m->ww - mw - 2*ov - 2*iv) / 2;
+      rw = (m->ww - mw - 2*ov - 2*iv) - lw;
+      mx += lw + iv;
+    } else {
+      /* ||<---M--->|<-S->|| */
+      mw = (mw - iv) * m->mfact;
+      lw = 0;
+      rw = m->ww - mw - iv - 2*ov;
+    }
+    lx = m->wx + ov;
+    ly = m->wy + oh;
+    rx = mx + mw + iv;
+    ry = m->wy + oh;
+  }
+
+  /* calculate facts */
+  for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++) {
+    if (!m->nmaster || n < m->nmaster)
+      mfacts += 1;
+    else if ((n - m->nmaster) % 2)
+      lfacts += 1; // total factor of left hand stack area
+    else
+      rfacts += 1; // total factor of right hand stack area
+  }
+
+  for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++)
+    if (!m->nmaster || n < m->nmaster)
+      mtotal += mh / mfacts;
+    else if ((n - m->nmaster) % 2)
+      ltotal += lh / lfacts;
+    else
+      rtotal += rh / rfacts;
+
+  mrest = mh - mtotal;
+  lrest = lh - ltotal;
+  rrest = rh - rtotal;
+
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) {
+    if (!m->nmaster || i < m->nmaster) {
+      /* nmaster clients are stacked vertically, in the center of the screen */
+      resize(c, mx, my, mw - (2*c->bw), (mh / mfacts) + (i < mrest ? 1 : 0) - (2*c->bw), 0);
+      my += HEIGHT(c) + ih;
+    } else {
+      /* stack clients are stacked vertically */
+      if ((i - m->nmaster) % 2 ) {
+        resize(c, lx, ly, lw - (2*c->bw), (lh / lfacts) + ((i - 2*m->nmaster) < 2*lrest ? 1 : 0) - (2*c->bw), 0);
+        ly += HEIGHT(c) + ih;
+      } else {
+        resize(c, rx, ry, rw - (2*c->bw), (rh / rfacts) + ((i - 2*m->nmaster) < 2*rrest ? 1 : 0) - (2*c->bw), 0);
+        ry += HEIGHT(c) + ih;
+      }
+    }
+  }
+}
+
+  void
+centeredfloatingmaster(Monitor *m)
+{
+  unsigned int i, n;
+  float mfacts, sfacts;
+  float mivf = 1.0; // master inner vertical gap factor
+  int oh, ov, ih, iv, mrest, srest;
+  int mx = 0, my = 0, mh = 0, mw = 0;
+  int sx = 0, sy = 0, sh = 0, sw = 0;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  sx = mx = m->wx + ov;
+  sy = my = m->wy + oh;
+  sh = mh = m->wh - 2*oh;
+  mw = m->ww - 2*ov - iv*(n - 1);
+  sw = m->ww - 2*ov - iv*(n - m->nmaster - 1);
+
+  if (m->nmaster && n > m->nmaster) {
+    mivf = 0.8;
+    /* go mfact box in the center if more than nmaster clients */
+    if (m->ww > m->wh) {
+      mw = m->ww * m->mfact - iv*mivf*(MIN(n, m->nmaster) - 1);
+      mh = m->wh * 0.9;
+    } else {
+      mw = m->ww * 0.9 - iv*mivf*(MIN(n, m->nmaster) - 1);
+      mh = m->wh * m->mfact;
+    }
+    mx = m->wx + (m->ww - mw) / 2;
+    my = m->wy + (m->wh - mh - 2*oh) / 2;
+
+    sx = m->wx + ov;
+    sy = m->wy + oh;
+    sh = m->wh - 2*oh;
+  }
+
+  getfacts(m, mw, sw, &mfacts, &sfacts, &mrest, &srest);
+
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++)
+    if (i < m->nmaster) {
+      /* nmaster clients are stacked horizontally, in the center of the screen */
+      resize(c, mx, my, (mw / mfacts) + (i < mrest ? 1 : 0) - (2*c->bw), mh - (2*c->bw), 0);
+      mx += WIDTH(c) + iv*mivf;
+    } else {
+      /* stack clients are stacked horizontally */
+      resize(c, sx, sy, (sw / sfacts) + ((i - m->nmaster) < srest ? 1 : 0) - (2*c->bw), sh - (2*c->bw), 0);
+      sx += WIDTH(c) + iv;
+    }
+}
+
+/*
+ * Deck layout + gaps
+ * https://dwm.suckless.org/patches/deck/
+ */
+  void
+deck(Monitor *m)
+{
+  unsigned int i, n;
+  int oh, ov, ih, iv;
+  int mx = 0, my = 0, mh = 0, mw = 0;
+  int sx = 0, sy = 0, sh = 0, sw = 0;
+  float mfacts, sfacts;
+  int mrest, srest;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  sx = mx = m->wx + ov;
+  sy = my = m->wy + oh;
+  sh = mh = m->wh - 2*oh - ih * (MIN(n, m->nmaster) - 1);
+  sw = mw = m->ww - 2*ov;
+
+  if (m->nmaster && n > m->nmaster) {
+    sw = (mw - iv) * (1 - m->mfact);
+    mw = mw - iv - sw;
+    sx = mx + mw + iv;
+    sh = m->wh - 2*oh;
+  }
+
+  getfacts(m, mh, sh, &mfacts, &sfacts, &mrest, &srest);
+
+  if (n - m->nmaster > 0) /* override layout symbol */
+    snprintf(m->ltsymbol, sizeof m->ltsymbol, "D %d", n - m->nmaster);
+
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++)
+    if (i < m->nmaster) {
+      resize(c, mx, my, mw - (2*c->bw), (mh / mfacts) + (i < mrest ? 1 : 0) - (2*c->bw), 0);
+      my += HEIGHT(c) + ih;
+    } else {
+      resize(c, sx, sy, sw - (2*c->bw), sh - (2*c->bw), 0);
+    }
+}
+
+/*
+ * Fibonacci layout + gaps
+ * https://dwm.suckless.org/patches/fibonacci/
+ */
+  void
+fibonacci(Monitor *m, int s)
+{
+  unsigned int i, n;
+  int nx, ny, nw, nh;
+  int oh, ov, ih, iv;
+  int nv, hrest = 0, wrest = 0, r = 1;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  nx = m->wx + ov;
+  ny = m->wy + oh;
+  nw = m->ww - 2*ov;
+  nh = m->wh - 2*oh;
+
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next)) {
+    if (r) {
+      if ((i % 2 && (nh - ih) / 2 <= (bh + 2*c->bw))
+          || (!(i % 2) && (nw - iv) / 2 <= (bh + 2*c->bw))) {
+        r = 0;
+      }
+      if (r && i < n - 1) {
+        if (i % 2) {
+          nv = (nh - ih) / 2;
+          hrest = nh - 2*nv - ih;
+          nh = nv;
+        } else {
+          nv = (nw - iv) / 2;
+          wrest = nw - 2*nv - iv;
+          nw = nv;
+        }
+
+        if ((i % 4) == 2 && !s)
+          nx += nw + iv;
+        else if ((i % 4) == 3 && !s)
+          ny += nh + ih;
+      }
+
+      if ((i % 4) == 0) {
+        if (s) {
+          ny += nh + ih;
+          nh += hrest;
+        }
+        else {
+          nh -= hrest;
+          ny -= nh + ih;
+        }
+      }
+      else if ((i % 4) == 1) {
+        nx += nw + iv;
+        nw += wrest;
+      }
+      else if ((i % 4) == 2) {
+        ny += nh + ih;
+        nh += hrest;
+        if (i < n - 1)
+          nw += wrest;
+      }
+      else if ((i % 4) == 3) {
+        if (s) {
+          nx += nw + iv;
+          nw -= wrest;
+        } else {
+          nw -= wrest;
+          nx -= nw + iv;
+          nh += hrest;
+        }
+      }
+      if (i == 0)	{
+        if (n != 1) {
+          nw = (m->ww - iv - 2*ov) - (m->ww - iv - 2*ov) * (1 - m->mfact);
+          wrest = 0;
+        }
+        ny = m->wy + oh;
+      }
+      else if (i == 1)
+        nw = m->ww - nw - iv - 2*ov;
+      i++;
+    }
+
+    resize(c, nx, ny, nw - (2*c->bw), nh - (2*c->bw), False);
+  }
+}
+
+  void
+dwindle(Monitor *m)
+{
+  fibonacci(m, 1);
+}
+
+  void
+spiral(Monitor *m)
+{
+  fibonacci(m, 0);
+}
+
+/*
+ * Gappless grid layout + gaps (ironically)
+ * https://dwm.suckless.org/patches/gaplessgrid/
+ */
+  void
+gaplessgrid(Monitor *m)
+{
+  unsigned int i, n;
+  int x, y, cols, rows, ch, cw, cn, rn, rrest, crest; // counters
+  int oh, ov, ih, iv;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  /* grid dimensions */
+  for (cols = 0; cols <= n/2; cols++)
+    if (cols*cols >= n)
+      break;
+  if (n == 5) /* set layout against the general calculation: not 1:2:2, but 2:3 */
+    cols = 2;
+  rows = n/cols;
+  cn = rn = 0; // reset column no, row no, client count
+
+  ch = (m->wh - 2*oh - ih * (rows - 1)) / rows;
+  cw = (m->ww - 2*ov - iv * (cols - 1)) / cols;
+  rrest = (m->wh - 2*oh - ih * (rows - 1)) - ch * rows;
+  crest = (m->ww - 2*ov - iv * (cols - 1)) - cw * cols;
+  x = m->wx + ov;
+  y = m->wy + oh;
+
+  for (i = 0, c = nexttiled(m->clients); c; i++, c = nexttiled(c->next)) {
+    if (i/rows + 1 > cols - n%cols) {
+      rows = n/cols + 1;
+      ch = (m->wh - 2*oh - ih * (rows - 1)) / rows;
+      rrest = (m->wh - 2*oh - ih * (rows - 1)) - ch * rows;
+    }
+    resize(c,
+        x,
+        y + rn*(ch + ih) + MIN(rn, rrest),
+        cw + (cn < crest ? 1 : 0) - 2*c->bw,
+        ch + (rn < rrest ? 1 : 0) - 2*c->bw,
+        0);
+    rn++;
+    if (rn >= rows) {
+      rn = 0;
+      x += cw + ih + (cn < crest ? 1 : 0);
+      cn++;
+    }
+  }
+}
+
+/*
+ * Gridmode layout + gaps
+ * https://dwm.suckless.org/patches/gridmode/
+ */
+  void
+grid(Monitor *m)
+{
+  unsigned int i, n;
+  int cx, cy, cw, ch, cc, cr, chrest, cwrest, cols, rows;
+  int oh, ov, ih, iv;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+
+  /* grid dimensions */
+  for (rows = 0; rows <= n/2; rows++)
+    if (rows*rows >= n)
+      break;
+  cols = (rows && (rows - 1) * rows >= n) ? rows - 1 : rows;
+
+  /* window geoms (cell height/width) */
+  ch = (m->wh - 2*oh - ih * (rows - 1)) / (rows ? rows : 1);
+  cw = (m->ww - 2*ov - iv * (cols - 1)) / (cols ? cols : 1);
+  chrest = (m->wh - 2*oh - ih * (rows - 1)) - ch * rows;
+  cwrest = (m->ww - 2*ov - iv * (cols - 1)) - cw * cols;
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) {
+    cc = i / rows;
+    cr = i % rows;
+    cx = m->wx + ov + cc * (cw + iv) + MIN(cc, cwrest);
+    cy = m->wy + oh + cr * (ch + ih) + MIN(cr, chrest);
+    resize(c, cx, cy, cw + (cc < cwrest ? 1 : 0) - 2*c->bw, ch + (cr < chrest ? 1 : 0) - 2*c->bw, False);
+  }
+}
+
+/*
+ * Horizontal grid layout + gaps
+ * https://dwm.suckless.org/patches/horizgrid/
+ */
+void
+horizgrid(Monitor *m) {
+  Client *c;
+  unsigned int n, i;
+  int oh, ov, ih, iv;
+  int mx = 0, my = 0, mh = 0, mw = 0;
+  int sx = 0, sy = 0, sh = 0, sw = 0;
+  int ntop, nbottom = 1;
+  float mfacts, sfacts;
+  int mrest, srest;
+
+  /* Count windows */
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  if (n <= 2)
+    ntop = n;
+  else {
+    ntop = n / 2;
+    nbottom = n - ntop;
+  }
+  sx = mx = m->wx + ov;
+  sy = my = m->wy + oh;
+  sh = mh = m->wh - 2*oh;
+  sw = mw = m->ww - 2*ov;
+
+  if (n > ntop) {
+    sh = (mh - ih) / 2;
+    mh = mh - ih - sh;
+    sy = my + mh + ih;
+    mw = m->ww - 2*ov - iv * (ntop - 1);
+    sw = m->ww - 2*ov - iv * (nbottom - 1);
+  }
+
+  mfacts = ntop;
+  sfacts = nbottom;
+  mrest = mw - (mw / ntop) * ntop;
+  srest = sw - (sw / nbottom) * nbottom;
+
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++)
+    if (i < ntop) {
+      resize(c, mx, my, (mw / mfacts) + (i < mrest ? 1 : 0) - (2*c->bw), mh - (2*c->bw), 0);
+      mx += WIDTH(c) + iv;
+    } else {
+      resize(c, sx, sy, (sw / sfacts) + ((i - ntop) < srest ? 1 : 0) - (2*c->bw), sh - (2*c->bw), 0);
+      sx += WIDTH(c) + iv;
+    }
+}
+
+/*
+ * nrowgrid layout + gaps
+ * https://dwm.suckless.org/patches/nrowgrid/
+ */
+  void
+nrowgrid(Monitor *m)
+{
+  unsigned int n;
+  int ri = 0, ci = 0;  /* counters */
+  int oh, ov, ih, iv;                         /* vanitygap settings */
+  unsigned int cx, cy, cw, ch;                /* client geometry */
+  unsigned int uw = 0, uh = 0, uc = 0;        /* utilization trackers */
+  unsigned int cols, rows = m->nmaster + 1;
+  Client *c;
+
+  /* count clients */
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+
+  /* nothing to do here */
+  if (n == 0)
+    return;
+
+  /* force 2 clients to always split vertically */
+  if (FORCE_VSPLIT && n == 2)
+    rows = 1;
+
+  /* never allow empty rows */
+  if (n < rows)
+    rows = n;
+
+  /* define first row */
+  cols = n / rows;
+  uc = cols;
+  cy = m->wy + oh;
+  ch = (m->wh - 2*oh - ih*(rows - 1)) / rows;
+  uh = ch;
+
+  for (c = nexttiled(m->clients); c; c = nexttiled(c->next), ci++) {
+    if (ci == cols) {
+      uw = 0;
+      ci = 0;
+      ri++;
+
+      /* next row */
+      cols = (n - uc) / (rows - ri);
+      uc += cols;
+      cy = m->wy + oh + uh + ih;
+      uh += ch + ih;
+    }
+
+    cx = m->wx + ov + uw;
+    cw = (m->ww - 2*ov - uw) / (cols - ci);
+    uw += cw + iv;
+
+    resize(c, cx, cy, cw - (2*c->bw), ch - (2*c->bw), 0);
+  }
+}
+
+/*
+ * Default tile layout + gaps
+ */
+  static void
+tile(Monitor *m)
+{
+  unsigned int i, n;
+  int oh, ov, ih, iv;
+  int mx = 0, my = 0, mh = 0, mw = 0;
+  int sx = 0, sy = 0, sh = 0, sw = 0;
+  float mfacts, sfacts;
+  int mrest, srest;
+  Client *c;
+
+  getgaps(m, &oh, &ov, &ih, &iv, &n);
+  if (n == 0)
+    return;
+
+  sx = mx = m->wx + ov;
+  sy = my = m->wy + oh;
+  mh = m->wh - 2*oh - ih * (MIN(n, m->nmaster) - 1);
+  sh = m->wh - 2*oh - ih * (n - m->nmaster - 1);
+  sw = mw = m->ww - 2*ov;
+
+  if (m->nmaster && n > m->nmaster) {
+    sw = (mw - iv) * (1 - m->mfact);
+    mw = mw - iv - sw;
+    sx = mx + mw + iv;
+  }
+
+  getfacts(m, mh, sh, &mfacts, &sfacts, &mrest, &srest);
+
+  for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++)
+    if (i < m->nmaster) {
+      resize(c, mx, my, mw - (2*c->bw), (mh / mfacts) + (i < mrest ? 1 : 0) - (2*c->bw), 0);
+      my += HEIGHT(c) + ih;
+    } else {
+      resize(c, sx, sy, sw - (2*c->bw), (sh / sfacts) + ((i - m->nmaster) < srest ? 1 : 0) - (2*c->bw), 0);
+      sy += HEIGHT(c) + ih;
+    }
+}
--- a/_saved/_suckless/dwmblocks/LICENSE
+++ b/_saved/_suckless/dwmblocks/LICENSE
@ -0,0 +1,7 @@
+ISC License (ISC)
+
+Copyright 2020 torrinfail
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--- a/_saved/_suckless/dwmblocks/Makefile
+++ b/_saved/_suckless/dwmblocks/Makefile
@ -0,0 +1,17 @@
+PREFIX ?= /usr/local
+CC ?= cc
+LDFLAGS = -lX11
+
+output: dwmblocks.c blocks.def.h blocks.h
+	${CC}  dwmblocks.c $(LDFLAGS) -o dwmblocks
+blocks.h:
+	cp blocks.def.h $@
+
+
+clean:
+	rm -f *.o *.gch dwmblocks
+install: output
+	mkdir -p $(DESTDIR)$(PREFIX)/bin
+	install -m 0755 dwmblocks $(DESTDIR)$(PREFIX)/bin/dwmblocks
+uninstall:
+	rm -f $(DESTDIR)$(PREFIX)/bin/dwmblocks
--- a/_saved/_suckless/dwmblocks/_scripts/sb-battery
+++ b/_saved/_suckless/dwmblocks/_scripts/sb-battery
@ -0,0 +1,17 @@
+#!/bin/bash
+
+for battery in /sys/class/power_supply/BAT?*; do
+	# If non-first battery, print a space separator.
+	[ -n "${capacity+x}" ] && printf " "
+	# Sets up the status and capacity
+	case "$(cat "$battery/status")" in
+		"Full") status="\uf102" ;;
+		"Discharging") status="\uf078" ;;
+		"Charging") status="\uf077" ;;
+		"Not charging") status="\uf444" ;;
+		"Unknown") status="\uf128" ;;
+	esac
+	capacity=$(cat "$battery/capacity")
+	# Will make a warn variable if discharging and low
+	[ "$capacity" -le 20 ] && printf "^c#ffffff^^b#770000^${status} ${capacity}%%^d^" || printf "${status} ${capacity}%%"
+done && exit 0
--- a/_saved/_suckless/dwmblocks/_scripts/sb-mail
+++ b/_saved/_suckless/dwmblocks/_scripts/sb-mail
@ -0,0 +1,3 @@
+#!/bin/bash
+
+printf "\uf7aa configure your way to check mail!"
--- a/_saved/_suckless/dwmblocks/_scripts/sb-network
+++ b/_saved/_suckless/dwmblocks/_scripts/sb-network
@ -0,0 +1,9 @@
+#!/bin/bash
+
+case "$(cat /sys/class/net/w*/operstate 2>/dev/null)" in
+  down) printf "^c#ffffff^^b#770000^no wifi^d^" ;;
+  up)
+    [ -n "$(ip address show dev wlan0 | grep 'inet ')" ] \
+      && printf "$(iw dev wlan0 info | grep 'ssid ' | cut -d' ' -f2-)" \
+      || printf "^c#ffffff^^b#770000^no ip^d^" ;;
+esac
--- a/_saved/_suckless/dwmblocks/_scripts/sb-vol-in
+++ b/_saved/_suckless/dwmblocks/_scripts/sb-vol-in
@ -0,0 +1,17 @@
+#!/bin/bash
+
+if [ "${1}" = "micmute" ]; then
+  state=$(pactl get-source-mute @DEFAULT_SOURCE@ | awk -F': ' '{print $2}')
+  case ${state} in
+    yes)
+      echo 0 | doas tee /sys/devices/platform/thinkpad_acpi/leds/platform::micmute/brightness
+      pactl set-source-mute @DEFAULT_SOURCE@ 0 ;;
+    no)
+      echo 1 | doas tee /sys/devices/platform/thinkpad_acpi/leds/platform::micmute/brightness
+      pactl set-source-mute @DEFAULT_SOURCE@ 1 ;;
+  esac
+  kill -44 $(pidof dwmblocks)
+else
+  mic=$(pactl get-source-volume @DEFAULT_SOURCE@ | awk -F' / ' '{print $2}' | tr -d '%')
+  [ $(pactl get-source-mute @DEFAULT_SOURCE@ | awk -F': ' '{print $2}') = yes ] || [ "$mic" -eq 0 ] && printf "^c#ffffff^^b#770000^ \uf131 ^d^"
+fi
--- a/_saved/_suckless/dwmblocks/_scripts/sb-vol-out
+++ b/_saved/_suckless/dwmblocks/_scripts/sb-vol-out
@ -0,0 +1,4 @@
+#!/bin/bash
+
+vol=$(pactl get-sink-volume @DEFAULT_SINK@ | awk -F' / ' '{print $2}' | tr -d '%')
+[ $(pactl get-sink-mute @DEFAULT_SINK@ | awk -F': ' '{print $2}') = yes ] || [ "$vol" -eq 0 ] && printf "^c#ffffff^^b#770000^mute^d^" || printf "${vol}%%"
--- a/_saved/_suckless/dwmblocks/blocks.def.h
+++ b/_saved/_suckless/dwmblocks/blocks.def.h
@ -0,0 +1,11 @@
+//Modify this file to change what commands output to your statusbar, and recompile using the make command.
+static const Block blocks[] = {
+  /*Icon*/	/*Command*/		/*Update Interval*/	/*Update Signal*/
+  {"Mem:", "free -h | awk '/^Mem/ { print $3\"/\"$2 }' | sed s/i//g",	30,		0},
+
+  {"", "date '+%b %d (%a) %I:%M%p'",					5,		0},
+};
+
+//sets delimeter between status commands. NULL character ('\0') means no delimeter.
+static char delim[] = " | ";
+static unsigned int delimLen = 5;
--- a/_saved/_suckless/dwmblocks/blocks.h
+++ b/_saved/_suckless/dwmblocks/blocks.h
@ -0,0 +1,14 @@
+//Modify this file to change what commands output to your statusbar, and recompile using the make command.
+static const Block blocks[] = {
+  /*Icon*/      /*Command*/                     /*Update Interval*/  /*Update Signal*/
+  {"",          "sb-mail",                      1,                   0   },
+  {"",          "sb-vol-in",                    1,                   10  },
+  {"\uf028 ",   "sb-vol-out",                   1,                   12  },
+  {"\uf1eb  ",  "sb-network",                   1,                   0   },
+  {"\uf241  ",  "sb-battery",                   3,                   0   },
+  {"\uf073 ",   "date '+[%d] %I:%M:%S %p |'",   1,                   0   },
+};
+
+//sets delimeter between status commands. NULL character ('\0') means no delimeter.
+static char delim[] = "  ";
+static unsigned int delimLen = 3;
--- a/_saved/_suckless/dwmblocks/dwmblocks.c
+++ b/_saved/_suckless/dwmblocks/dwmblocks.c
@ -0,0 +1,213 @@
+#include<stdlib.h>
+#include<stdio.h>
+#include<string.h>
+#include<unistd.h>
+#include<signal.h>
+#ifndef NO_X
+#include<X11/Xlib.h>
+#endif
+#ifdef __OpenBSD__
+#define SIGPLUS			SIGUSR1+1
+#define SIGMINUS		SIGUSR1-1
+#else
+#define SIGPLUS			SIGRTMIN
+#define SIGMINUS		SIGRTMIN
+#endif
+#define LENGTH(X)               (sizeof(X) / sizeof (X[0]))
+#define CMDLENGTH		50
+#define MIN( a, b ) ( ( a < b) ? a : b )
+#define STATUSLENGTH (LENGTH(blocks) * CMDLENGTH + 1)
+
+typedef struct {
+  char* icon;
+  char* command;
+  unsigned int interval;
+  unsigned int signal;
+} Block;
+#ifndef __OpenBSD__
+void dummysighandler(int num);
+#endif
+void sighandler(int num);
+void getcmds(int time);
+void getsigcmds(unsigned int signal);
+void setupsignals();
+void sighandler(int signum);
+int getstatus(char *str, char *last);
+void statusloop();
+void termhandler();
+void pstdout();
+#ifndef NO_X
+void setroot();
+static void (*writestatus) () = setroot;
+static int setupX();
+static Display *dpy;
+static int screen;
+static Window root;
+#else
+static void (*writestatus) () = pstdout;
+#endif
+
+
+#include "blocks.h"
+
+static char statusbar[LENGTH(blocks)][CMDLENGTH] = {0};
+static char statusstr[2][STATUSLENGTH];
+static int statusContinue = 1;
+static int returnStatus = 0;
+
+//opens process *cmd and stores output in *output
+void getcmd(const Block *block, char *output)
+{
+  strcpy(output, block->icon);
+  FILE *cmdf = popen(block->command, "r");
+  if (!cmdf)
+    return;
+  int i = strlen(block->icon);
+  fgets(output+i, CMDLENGTH-i-delimLen, cmdf);
+  i = strlen(output);
+  if (i == 0) {
+    //return if block and command output are both empty
+    pclose(cmdf);
+    return;
+  }
+  if (delim[0] != '\0') {
+    //only chop off newline if one is present at the end
+    i = output[i-1] == '\n' ? i-1 : i;
+    strncpy(output+i, delim, delimLen); 
+  }
+  else
+    output[i++] = '\0';
+  pclose(cmdf);
+}
+
+void getcmds(int time)
+{
+  const Block* current;
+  for (unsigned int i = 0; i < LENGTH(blocks); i++) {
+    current = blocks + i;
+    if ((current->interval != 0 && time % current->interval == 0) || time == -1)
+      getcmd(current,statusbar[i]);
+  }
+}
+
+void getsigcmds(unsigned int signal)
+{
+  const Block *current;
+  for (unsigned int i = 0; i < LENGTH(blocks); i++) {
+    current = blocks + i;
+    if (current->signal == signal)
+      getcmd(current,statusbar[i]);
+  }
+}
+
+void setupsignals()
+{
+#ifndef __OpenBSD__
+  /* initialize all real time signals with dummy handler */
+  for (int i = SIGRTMIN; i <= SIGRTMAX; i++)
+    signal(i, dummysighandler);
+#endif
+
+  for (unsigned int i = 0; i < LENGTH(blocks); i++) {
+    if (blocks[i].signal > 0)
+      signal(SIGMINUS+blocks[i].signal, sighandler);
+  }
+
+}
+
+int getstatus(char *str, char *last)
+{
+  strcpy(last, str);
+  str[0] = '\0';
+  for (unsigned int i = 0; i < LENGTH(blocks); i++)
+    strcat(str, statusbar[i]);
+  str[strlen(str)-strlen(delim)] = '\0';
+  return strcmp(str, last);//0 if they are the same
+}
+
+#ifndef NO_X
+void setroot()
+{
+  if (!getstatus(statusstr[0], statusstr[1]))//Only set root if text has changed.
+    return;
+  XStoreName(dpy, root, statusstr[0]);
+  XFlush(dpy);
+}
+
+int setupX()
+{
+  dpy = XOpenDisplay(NULL);
+  if (!dpy) {
+    fprintf(stderr, "dwmblocks: Failed to open display\n");
+    return 0;
+  }
+  screen = DefaultScreen(dpy);
+  root = RootWindow(dpy, screen);
+  return 1;
+}
+#endif
+
+void pstdout()
+{
+  if (!getstatus(statusstr[0], statusstr[1]))//Only write out if text has changed.
+    return;
+  printf("%s\n",statusstr[0]);
+  fflush(stdout);
+}
+
+
+void statusloop()
+{
+  setupsignals();
+  int i = 0;
+  getcmds(-1);
+  while (1) {
+    getcmds(i++);
+    writestatus();
+    if (!statusContinue)
+      break;
+    sleep(1.0);
+  }
+}
+
+#ifndef __OpenBSD__
+/* this signal handler should do nothing */
+void dummysighandler(int signum)
+{
+  return;
+}
+#endif
+
+void sighandler(int signum)
+{
+  getsigcmds(signum-SIGPLUS);
+  writestatus();
+}
+
+void termhandler()
+{
+  statusContinue = 0;
+}
+
+int main(int argc, char** argv)
+{
+  for (int i = 0; i < argc; i++) {//Handle command line arguments
+    if (!strcmp("-d",argv[i]))
+      strncpy(delim, argv[++i], delimLen);
+    else if (!strcmp("-p",argv[i]))
+      writestatus = pstdout;
+  }
+#ifndef NO_X
+  if (!setupX())
+    return 1;
+#endif
+  delimLen = MIN(delimLen, strlen(delim));
+  delim[delimLen++] = '\0';
+  signal(SIGTERM, termhandler);
+  signal(SIGINT, termhandler);
+  statusloop();
+#ifndef NO_X
+  XCloseDisplay(dpy);
+#endif
+  return 0;
+}
--- a/_saved/_suckless/dwmblocks/install-scripts.sh
+++ b/_saved/_suckless/dwmblocks/install-scripts.sh
@ -0,0 +1,7 @@
+#!/bin/sh
+
+mkdir -p ~/.local/bin
+
+for i in _scripts/*; do
+  ln -sf $(pwd)/$i ~/.local/bin
+done
--- a/_saved/_suckless/slock/LICENSE
+++ b/_saved/_suckless/slock/LICENSE
@ -0,0 +1,24 @@
+MIT/X Consortium License
+
+© 2015-2016 Markus Teich <markus.teich@stusta.mhn.de>
+© 2014 Dimitris Papastamos <sin@2f30.org>
+© 2006-2014 Anselm R Garbe <anselm@garbe.us>
+© 2014-2016 Laslo Hunhold <dev@frign.de>
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/_saved/_suckless/slock/Makefile
+++ b/_saved/_suckless/slock/Makefile
@ -0,0 +1,61 @@
+# slock - simple screen locker
+# See LICENSE file for copyright and license details.
+
+include config.mk
+
+SRC = slock.c ${COMPATSRC}
+OBJ = ${SRC:.c=.o}
+
+all: options slock
+
+options:
+	@echo slock build options:
+	@echo "CFLAGS   = ${CFLAGS}"
+	@echo "LDFLAGS  = ${LDFLAGS}"
+	@echo "CC       = ${CC}"
+
+.c.o:
+	@echo CC $<
+	@${CC} -c ${CFLAGS} $<
+
+${OBJ}: config.h config.mk arg.h util.h
+
+config.h:
+	@echo creating $@ from config.def.h
+	@cp config.def.h $@
+
+slock: ${OBJ}
+	@echo CC -o $@
+	@${CC} -o $@ ${OBJ} ${LDFLAGS}
+
+clean:
+	@echo cleaning
+	@rm -f slock ${OBJ} slock-${VERSION}.tar.gz
+
+dist: clean
+	@echo creating dist tarball
+	@mkdir -p slock-${VERSION}
+	@cp -R LICENSE Makefile README slock.1 config.mk \
+		${SRC} explicit_bzero.c config.def.h arg.h util.h slock-${VERSION}
+	@tar -cf slock-${VERSION}.tar slock-${VERSION}
+	@gzip slock-${VERSION}.tar
+	@rm -rf slock-${VERSION}
+
+install: all
+	@echo installing executable file to ${DESTDIR}${PREFIX}/bin
+	@mkdir -p ${DESTDIR}${PREFIX}/bin
+	@cp -f slock ${DESTDIR}${PREFIX}/bin
+	@chmod 755 ${DESTDIR}${PREFIX}/bin/slock
+	@chmod u+s ${DESTDIR}${PREFIX}/bin/slock
+	@echo installing manual page to ${DESTDIR}${MANPREFIX}/man1
+	@mkdir -p ${DESTDIR}${MANPREFIX}/man1
+	@sed "s/VERSION/${VERSION}/g" <slock.1 >${DESTDIR}${MANPREFIX}/man1/slock.1
+	@chmod 644 ${DESTDIR}${MANPREFIX}/man1/slock.1
+
+uninstall:
+	@echo removing executable file from ${DESTDIR}${PREFIX}/bin
+	@rm -f ${DESTDIR}${PREFIX}/bin/slock
+	@echo removing manual page from ${DESTDIR}${MANPREFIX}/man1
+	@rm -f ${DESTDIR}${MANPREFIX}/man1/slock.1
+
+.PHONY: all options clean dist install uninstall
--- a/_saved/_suckless/slock/README.md
+++ b/_saved/_suckless/slock/README.md
@ -0,0 +1,7 @@
+# ftpd's slock build
+
+## Patches applied
+
+These patches from suckless.org were applied from the newest versions, in order:
+
+1. `slock-dwmlogo-20210324.diff`
--- a/_saved/_suckless/slock/arg.h
+++ b/_saved/_suckless/slock/arg.h
@ -0,0 +1,65 @@
+/*
+ * Copy me if you can.
+ * by 20h
+ */
+
+#ifndef ARG_H__
+#define ARG_H__
+
+extern char *argv0;
+
+/* use main(int argc, char *argv[]) */
+#define ARGBEGIN	for (argv0 = *argv, argv++, argc--;\
+    argv[0] && argv[0][0] == '-'\
+    && argv[0][1];\
+    argc--, argv++) {\
+  char argc_;\
+  char **argv_;\
+  int brk_;\
+  if (argv[0][1] == '-' && argv[0][2] == '\0') {\
+    argv++;\
+    argc--;\
+    break;\
+  }\
+  for (brk_ = 0, argv[0]++, argv_ = argv;\
+      argv[0][0] && !brk_;\
+      argv[0]++) {\
+    if (argv_ != argv)\
+    break;\
+    argc_ = argv[0][0];\
+    switch (argc_)
+
+    /* Handles obsolete -NUM syntax */
+#define ARGNUM				case '0':\
+    case '1':\
+    case '2':\
+    case '3':\
+    case '4':\
+    case '5':\
+    case '6':\
+    case '7':\
+    case '8':\
+             case '9'
+
+#define ARGEND			}\
+}
+
+#define ARGC()		argc_
+
+#define ARGNUMF()	(brk_ = 1, estrtonum(argv[0], 0, INT_MAX))
+
+#define EARGF(x)	((argv[0][1] == '\0' && argv[1] == NULL)?\
+    ((x), abort(), (char *)0) :\
+    (brk_ = 1, (argv[0][1] != '\0')?\
+     (&argv[0][1]) :\
+     (argc--, argv++, argv[0])))
+
+#define ARGF()		((argv[0][1] == '\0' && argv[1] == NULL)?\
+    (char *)0 :\
+    (brk_ = 1, (argv[0][1] != '\0')?\
+     (&argv[0][1]) :\
+     (argc--, argv++, argv[0])))
+
+#define LNGARG()	&argv[0][0]
+
+#endif
--- a/_saved/_suckless/slock/config.def.h
+++ b/_saved/_suckless/slock/config.def.h
@ -0,0 +1,32 @@
+/* user and group to drop privileges to */
+static const char *user  = "nobody";
+static const char *group = "nogroup";
+
+static const char *colorname[NUMCOLS] = {
+  [BACKGROUND] =   "black",     /* after initialization */
+  [INIT] =   "#2d2d2d",     /* after initialization */
+  [INPUT] =  "#005577",   /* during input */
+  [FAILED] = "#CC3333",   /* wrong password */
+};
+
+/* treat a cleared input like a wrong password (color) */
+static const int failonclear = 1;
+
+/* insert grid pattern with scale 1:1, the size can be changed with logosize */
+static const int logosize = 75;
+static const int logow = 12;	/* grid width and height for right center alignment*/
+static const int logoh = 6;
+
+static XRectangle rectangles[9] = {
+  /* x	y	w	h */
+  { 0,	3,	1,	3 },
+  { 1,	3,	2,	1 },
+  { 0,	5,	8,	1 },
+  { 3,	0,	1,	5 },
+  { 5,	3,	1,	2 },
+  { 7,	3,	1,	2 },
+  { 8,	3,	4,	1 },
+  { 9,	4,	1,	2 },
+  { 11,	4,	1,	2 },
+
+};
--- a/_saved/_suckless/slock/config.h
+++ b/_saved/_suckless/slock/config.h
@ -0,0 +1,32 @@
+/* user and group to drop privileges to */
+static const char *user  = "nobody";
+static const char *group = "nogroup";
+
+static const char *colorname[NUMCOLS] = {
+	[BACKGROUND] =   "black",     /* after initialization */
+	[INIT] =   "#2d2d2d",     /* after initialization */
+	[INPUT] =  "#005577",   /* during input */
+	[FAILED] = "#CC3333",   /* wrong password */
+};
+
+/* treat a cleared input like a wrong password (color) */
+static const int failonclear = 1;
+
+/* insert grid pattern with scale 1:1, the size can be changed with logosize */
+static const int logosize = 75;
+static const int logow = 12;	/* grid width and height for right center alignment*/
+static const int logoh = 6;
+
+static XRectangle rectangles[9] = {
+	/* x	y	w	h */
+	{ 0,	3,	1,	3 },
+	{ 1,	3,	2,	1 },
+	{ 0,	5,	8,	1 },
+	{ 3,	0,	1,	5 },
+	{ 5,	3,	1,	2 },
+	{ 7,	3,	1,	2 },
+	{ 8,	3,	4,	1 },
+	{ 9,	4,	1,	2 },
+	{ 11,	4,	1,	2 },
+
+};
--- a/_saved/_suckless/slock/config.mk
+++ b/_saved/_suckless/slock/config.mk
@ -0,0 +1,40 @@
+# slock version
+VERSION = 1.4
+
+# Customize below to fit your system
+
+# paths
+PREFIX = /usr/local
+MANPREFIX = ${PREFIX}/share/man
+
+X11INC = /usr/X11R6/include
+X11LIB = /usr/X11R6/lib
+
+# Xinerama, comment if you don't want it
+XINERAMALIBS  = -lXinerama
+XINERAMAFLAGS = -DXINERAMA
+
+# freetype
+FREETYPELIBS = -lXft
+FREETYPEINC = /usr/include/freetype2
+
+# includes and libs
+INCS = -I. -I/usr/include -I${X11INC} -I${FREETYPEINC}
+LIBS = -L/usr/lib -lc -lcrypt -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} -lXext -lXrandr
+
+# flags
+CPPFLAGS = -DVERSION=\"${VERSION}\" -D_DEFAULT_SOURCE -DHAVE_SHADOW_H ${XINERAMAFLAGS}
+CFLAGS = -std=c99 -pedantic -Wall -Os ${INCS} ${CPPFLAGS}
+LDFLAGS = -s ${LIBS}
+COMPATSRC = explicit_bzero.c
+
+# On OpenBSD and Darwin remove -lcrypt from LIBS
+#LIBS = -L/usr/lib -lc -L${X11LIB} -lX11 -lXext -lXrandr
+# On *BSD remove -DHAVE_SHADOW_H from CPPFLAGS
+# On NetBSD add -D_NETBSD_SOURCE to CPPFLAGS
+#CPPFLAGS = -DVERSION=\"${VERSION}\" -D_BSD_SOURCE -D_NETBSD_SOURCE
+# On OpenBSD set COMPATSRC to empty
+#COMPATSRC =
+
+# compiler and linker
+CC = cc
--- a/_saved/_suckless/slock/explicit_bzero.c
+++ b/_saved/_suckless/slock/explicit_bzero.c
@ -0,0 +1,19 @@
+/*	$OpenBSD: explicit_bzero.c,v 1.3 2014/06/21 02:34:26 matthew Exp $ */
+/*
+ * Public domain.
+ * Written by Matthew Dempsky.
+ */
+
+#include <string.h>
+
+  __attribute__((weak)) void
+__explicit_bzero_hook(void *buf, size_t len)
+{
+}
+
+  void
+explicit_bzero(void *buf, size_t len)
+{
+  memset(buf, 0, len);
+  __explicit_bzero_hook(buf, len);
+}
--- a/_saved/_suckless/slock/slock.1
+++ b/_saved/_suckless/slock/slock.1
@ -0,0 +1,39 @@
+.Dd 2016-08-23
+.Dt SLOCK 1
+.Sh NAME
+.Nm slock
+.Nd simple X screen locker
+.Sh SYNOPSIS
+.Nm
+.Op Fl v
+.Op Ar cmd Op Ar arg ...
+.Sh DESCRIPTION
+.Nm
+is a simple X screen locker. If provided,
+.Ar cmd Op Ar arg ...
+is executed after the screen has been locked.
+.Sh OPTIONS
+.Bl -tag -width Ds
+.It Fl v
+Print version information to stdout and exit.
+.El
+.Sh SECURITY CONSIDERATIONS
+To make sure a locked screen can not be bypassed by switching VTs
+or killing the X server with Ctrl+Alt+Backspace, it is recommended
+to disable both in
+.Xr xorg.conf 5
+for maximum security:
+.Bd -literal -offset left
+Section "ServerFlags"
+	Option "DontVTSwitch" "True"
+	Option "DontZap"      "True"
+EndSection
+.Ed
+.Sh EXAMPLES
+$
+.Nm
+/usr/sbin/s2ram
+.Sh CUSTOMIZATION
+.Nm
+can be customized by creating a custom config.h from config.def.h and
+(re)compiling the source code. This keeps it fast, secure and simple.
--- a/_saved/_suckless/slock/slock.c
+++ b/_saved/_suckless/slock/slock.c
@ -0,0 +1,462 @@
+/* See LICENSE file for license details. */
+#define _XOPEN_SOURCE   500
+#define LENGTH(X)       (sizeof X / sizeof X[0])
+#if HAVE_SHADOW_H
+#include <shadow.h>
+#endif
+
+#include <ctype.h>
+#include <errno.h>
+#include <grp.h>
+#include <pwd.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <X11/extensions/Xrandr.h>
+#ifdef XINERAMA
+#include <X11/extensions/Xinerama.h>
+#endif
+#include <X11/keysym.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xft/Xft.h>
+
+#include "arg.h"
+#include "util.h"
+
+char *argv0;
+
+enum {
+  BACKGROUND,
+  INIT,
+  INPUT,
+  FAILED,
+  NUMCOLS
+};
+
+#include "config.h"
+
+struct lock {
+  int screen;
+  Window root, win;
+  Pixmap pmap;
+  unsigned long colors[NUMCOLS];
+  unsigned int x, y;
+  unsigned int xoff, yoff, mw, mh;
+  Drawable drawable;
+  GC gc;
+  XRectangle rectangles[LENGTH(rectangles)];
+};
+
+struct xrandr {
+  int active;
+  int evbase;
+  int errbase;
+};
+
+  static void
+die(const char *errstr, ...)
+{
+  va_list ap;
+
+  va_start(ap, errstr);
+  vfprintf(stderr, errstr, ap);
+  va_end(ap);
+  exit(1);
+}
+
+#ifdef __linux__
+#include <fcntl.h>
+#include <linux/oom.h>
+
+  static void
+dontkillme(void)
+{
+  FILE *f;
+  const char oomfile[] = "/proc/self/oom_score_adj";
+
+  if (!(f = fopen(oomfile, "w"))) {
+    if (errno == ENOENT)
+      return;
+    die("slock: fopen %s: %s\n", oomfile, strerror(errno));
+  }
+  fprintf(f, "%d", OOM_SCORE_ADJ_MIN);
+  if (fclose(f)) {
+    if (errno == EACCES)
+      die("slock: unable to disable OOM killer. "
+          "Make sure to suid or sgid slock.\n");
+    else
+      die("slock: fclose %s: %s\n", oomfile, strerror(errno));
+  }
+}
+#endif
+
+  static const char *
+gethash(void)
+{
+  const char *hash;
+  struct passwd *pw;
+
+  /* Check if the current user has a password entry */
+  errno = 0;
+  if (!(pw = getpwuid(getuid()))) {
+    if (errno)
+      die("slock: getpwuid: %s\n", strerror(errno));
+    else
+      die("slock: cannot retrieve password entry\n");
+  }
+  hash = pw->pw_passwd;
+
+#if HAVE_SHADOW_H
+  if (!strcmp(hash, "x")) {
+    struct spwd *sp;
+    if (!(sp = getspnam(pw->pw_name)))
+      die("slock: getspnam: cannot retrieve shadow entry. "
+          "Make sure to suid or sgid slock.\n");
+    hash = sp->sp_pwdp;
+  }
+#else
+  if (!strcmp(hash, "*")) {
+#ifdef __OpenBSD__
+    if (!(pw = getpwuid_shadow(getuid())))
+      die("slock: getpwnam_shadow: cannot retrieve shadow entry. "
+          "Make sure to suid or sgid slock.\n");
+    hash = pw->pw_passwd;
+#else
+    die("slock: getpwuid: cannot retrieve shadow entry. "
+        "Make sure to suid or sgid slock.\n");
+#endif /* __OpenBSD__ */
+  }
+#endif /* HAVE_SHADOW_H */
+
+  return hash;
+}
+
+  static void
+resizerectangles(struct lock *lock)
+{
+  int i;
+
+  for (i = 0; i < LENGTH(rectangles); i++){
+    lock->rectangles[i].x = (rectangles[i].x * logosize)
+      + lock->xoff + ((lock->mw) / 2) - (logow / 2 * logosize);
+    lock->rectangles[i].y = (rectangles[i].y * logosize)
+      + lock->yoff + ((lock->mh) / 2) - (logoh / 2 * logosize);
+    lock->rectangles[i].width = rectangles[i].width * logosize;
+    lock->rectangles[i].height = rectangles[i].height * logosize;
+  }
+}
+
+  static void
+drawlogo(Display *dpy, struct lock *lock, int color)
+{
+  XSetForeground(dpy, lock->gc, lock->colors[BACKGROUND]);
+  XFillRectangle(dpy, lock->drawable, lock->gc, 0, 0, lock->x, lock->y);
+  XSetForeground(dpy, lock->gc, lock->colors[color]);
+  XFillRectangles(dpy, lock->drawable, lock->gc, lock->rectangles, LENGTH(rectangles));
+  XCopyArea(dpy, lock->drawable, lock->win, lock->gc, 0, 0, lock->x, lock->y, 0, 0);
+  XSync(dpy, False);
+}
+
+  static void
+readpw(Display *dpy, struct xrandr *rr, struct lock **locks, int nscreens,
+    const char *hash)
+{
+  XRRScreenChangeNotifyEvent *rre;
+  char buf[32], passwd[256], *inputhash;
+  int num, screen, running, failure, oldc;
+  unsigned int len, color;
+  KeySym ksym;
+  XEvent ev;
+
+  len = 0;
+  running = 1;
+  failure = 0;
+  oldc = INIT;
+
+  while (running && !XNextEvent(dpy, &ev)) {
+    if (ev.type == KeyPress) {
+      explicit_bzero(&buf, sizeof(buf));
+      num = XLookupString(&ev.xkey, buf, sizeof(buf), &ksym, 0);
+      if (IsKeypadKey(ksym)) {
+        if (ksym == XK_KP_Enter)
+          ksym = XK_Return;
+        else if (ksym >= XK_KP_0 && ksym <= XK_KP_9)
+          ksym = (ksym - XK_KP_0) + XK_0;
+      }
+      if (IsFunctionKey(ksym) ||
+          IsKeypadKey(ksym) ||
+          IsMiscFunctionKey(ksym) ||
+          IsPFKey(ksym) ||
+          IsPrivateKeypadKey(ksym))
+        continue;
+      switch (ksym) {
+        case XK_Return:
+          passwd[len] = '\0';
+          errno = 0;
+          if (!(inputhash = crypt(passwd, hash)))
+            fprintf(stderr, "slock: crypt: %s\n", strerror(errno));
+          else
+            running = !!strcmp(inputhash, hash);
+          if (running) {
+            XBell(dpy, 100);
+            failure = 1;
+          }
+          explicit_bzero(&passwd, sizeof(passwd));
+          len = 0;
+          break;
+        case XK_Escape:
+          explicit_bzero(&passwd, sizeof(passwd));
+          len = 0;
+          break;
+        case XK_BackSpace:
+          if (len)
+            passwd[--len] = '\0';
+          break;
+        default:
+          if (num && !iscntrl((int)buf[0]) &&
+              (len + num < sizeof(passwd))) {
+            memcpy(passwd + len, buf, num);
+            len += num;
+          }
+          break;
+      }
+      color = len ? INPUT : ((failure || failonclear) ? FAILED : INIT);
+      if (running && oldc != color) {
+        for (screen = 0; screen < nscreens; screen++) {
+          drawlogo(dpy, locks[screen], color);
+        }
+        oldc = color;
+      }
+    } else if (rr->active && ev.type == rr->evbase + RRScreenChangeNotify) {
+      rre = (XRRScreenChangeNotifyEvent*)&ev;
+      for (screen = 0; screen < nscreens; screen++) {
+        if (locks[screen]->win == rre->window) {
+          if (rre->rotation == RR_Rotate_90 ||
+              rre->rotation == RR_Rotate_270)
+            XResizeWindow(dpy, locks[screen]->win,
+                rre->height, rre->width);
+          else
+            XResizeWindow(dpy, locks[screen]->win,
+                rre->width, rre->height);
+          XClearWindow(dpy, locks[screen]->win);
+          break;
+        }
+      }
+    } else {
+      for (screen = 0; screen < nscreens; screen++)
+        XRaiseWindow(dpy, locks[screen]->win);
+    }
+  }
+}
+
+  static struct lock *
+lockscreen(Display *dpy, struct xrandr *rr, int screen)
+{
+  char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
+  int i, ptgrab, kbgrab;
+  struct lock *lock;
+  XColor color, dummy;
+  XSetWindowAttributes wa;
+  Cursor invisible;
+#ifdef XINERAMA
+  XineramaScreenInfo *info;
+  int n;
+#endif
+
+  if (dpy == NULL || screen < 0 || !(lock = malloc(sizeof(struct lock))))
+    return NULL;
+
+  lock->screen = screen;
+  lock->root = RootWindow(dpy, lock->screen);
+
+  for (i = 0; i < NUMCOLS; i++) {
+    XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen),
+        colorname[i], &color, &dummy);
+    lock->colors[i] = color.pixel;
+  }
+
+  lock->x = DisplayWidth(dpy, lock->screen);
+  lock->y = DisplayHeight(dpy, lock->screen);
+#ifdef XINERAMA
+  if ((info = XineramaQueryScreens(dpy, &n))) {
+    lock->xoff = info[0].x_org;
+    lock->yoff = info[0].y_org;
+    lock->mw = info[0].width;
+    lock->mh = info[0].height;
+  } else
+#endif
+  {
+    lock->xoff = lock->yoff = 0;
+    lock->mw = lock->x;
+    lock->mh = lock->y;
+  }
+  lock->drawable = XCreatePixmap(dpy, lock->root,
+      lock->x, lock->y, DefaultDepth(dpy, screen));
+  lock->gc = XCreateGC(dpy, lock->root, 0, NULL);
+  XSetLineAttributes(dpy, lock->gc, 1, LineSolid, CapButt, JoinMiter);
+
+  /* init */
+  wa.override_redirect = 1;
+  wa.background_pixel = lock->colors[BACKGROUND];
+  lock->win = XCreateWindow(dpy, lock->root, 0, 0,
+      lock->x, lock->y,
+      0, DefaultDepth(dpy, lock->screen),
+      CopyFromParent,
+      DefaultVisual(dpy, lock->screen),
+      CWOverrideRedirect | CWBackPixel, &wa);
+  lock->pmap = XCreateBitmapFromData(dpy, lock->win, curs, 8, 8);
+  invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap,
+      &color, &color, 0, 0);
+  XDefineCursor(dpy, lock->win, invisible);
+
+  resizerectangles(lock);
+
+  /* Try to grab mouse pointer *and* keyboard for 600ms, else fail the lock */
+  for (i = 0, ptgrab = kbgrab = -1; i < 6; i++) {
+    if (ptgrab != GrabSuccess) {
+      ptgrab = XGrabPointer(dpy, lock->root, False,
+          ButtonPressMask | ButtonReleaseMask |
+          PointerMotionMask, GrabModeAsync,
+          GrabModeAsync, None, invisible, CurrentTime);
+    }
+    if (kbgrab != GrabSuccess) {
+      kbgrab = XGrabKeyboard(dpy, lock->root, True,
+          GrabModeAsync, GrabModeAsync, CurrentTime);
+    }
+
+    /* input is grabbed: we can lock the screen */
+    if (ptgrab == GrabSuccess && kbgrab == GrabSuccess) {
+      XMapRaised(dpy, lock->win);
+      if (rr->active)
+        XRRSelectInput(dpy, lock->win, RRScreenChangeNotifyMask);
+
+      XSelectInput(dpy, lock->root, SubstructureNotifyMask);
+      drawlogo(dpy, lock, INIT);
+      return lock;
+    }
+
+    /* retry on AlreadyGrabbed but fail on other errors */
+    if ((ptgrab != AlreadyGrabbed && ptgrab != GrabSuccess) ||
+        (kbgrab != AlreadyGrabbed && kbgrab != GrabSuccess))
+      break;
+
+    usleep(100000);
+  }
+
+  /* we couldn't grab all input: fail out */
+  if (ptgrab != GrabSuccess)
+    fprintf(stderr, "slock: unable to grab mouse pointer for screen %d\n",
+        screen);
+  if (kbgrab != GrabSuccess)
+    fprintf(stderr, "slock: unable to grab keyboard for screen %d\n",
+        screen);
+  return NULL;
+}
+
+  static void
+usage(void)
+{
+  die("usage: slock [-v] [cmd [arg ...]]\n");
+}
+
+int
+main(int argc, char **argv) {
+  struct xrandr rr;
+  struct lock **locks;
+  struct passwd *pwd;
+  struct group *grp;
+  uid_t duid;
+  gid_t dgid;
+  const char *hash;
+  Display *dpy;
+  int s, nlocks, nscreens;
+
+  ARGBEGIN {
+    case 'v':
+      fprintf(stderr, "slock-"VERSION"\n");
+      return 0;
+    default:
+      usage();
+  } ARGEND
+
+  /* validate drop-user and -group */
+  errno = 0;
+  if (!(pwd = getpwnam(user)))
+    die("slock: getpwnam %s: %s\n", user,
+        errno ? strerror(errno) : "user entry not found");
+  duid = pwd->pw_uid;
+  errno = 0;
+  if (!(grp = getgrnam(group)))
+    die("slock: getgrnam %s: %s\n", group,
+        errno ? strerror(errno) : "group entry not found");
+  dgid = grp->gr_gid;
+
+#ifdef __linux__
+  dontkillme();
+#endif
+
+  hash = gethash();
+  errno = 0;
+  if (!crypt("", hash))
+    die("slock: crypt: %s\n", strerror(errno));
+
+  if (!(dpy = XOpenDisplay(NULL)))
+    die("slock: cannot open display\n");
+
+  /* drop privileges */
+  if (setgroups(0, NULL) < 0)
+    die("slock: setgroups: %s\n", strerror(errno));
+  if (setgid(dgid) < 0)
+    die("slock: setgid: %s\n", strerror(errno));
+  if (setuid(duid) < 0)
+    die("slock: setuid: %s\n", strerror(errno));
+
+  /* check for Xrandr support */
+  rr.active = XRRQueryExtension(dpy, &rr.evbase, &rr.errbase);
+
+  /* get number of screens in display "dpy" and blank them */
+  nscreens = ScreenCount(dpy);
+  if (!(locks = calloc(nscreens, sizeof(struct lock *))))
+    die("slock: out of memory\n");
+  for (nlocks = 0, s = 0; s < nscreens; s++) {
+    if ((locks[s] = lockscreen(dpy, &rr, s)) != NULL)
+      nlocks++;
+    else
+      break;
+  }
+  XSync(dpy, 0);
+
+  /* did we manage to lock everything? */
+  if (nlocks != nscreens)
+    return 1;
+
+  /* run post-lock command */
+  if (argc > 0) {
+    switch (fork()) {
+      case -1:
+        die("slock: fork failed: %s\n", strerror(errno));
+      case 0:
+        if (close(ConnectionNumber(dpy)) < 0)
+          die("slock: close: %s\n", strerror(errno));
+        execvp(argv[0], argv);
+        fprintf(stderr, "slock: execvp %s: %s\n", argv[0], strerror(errno));
+        _exit(1);
+    }
+  }
+
+  /* everything is now blank. Wait for the correct password */
+  readpw(dpy, &rr, locks, nscreens, hash);
+
+  for (nlocks = 0, s = 0; s < nscreens; s++) {
+    XFreePixmap(dpy, locks[s]->drawable);
+    XFreeGC(dpy, locks[s]->gc);
+  }
+
+  XSync(dpy, 0);
+  XCloseDisplay(dpy);
+  return 0;
+}
--- a/_saved/_suckless/slock/util.h
+++ b/_saved/_suckless/slock/util.h
@ -0,0 +1,2 @@
+#undef explicit_bzero
+void explicit_bzero(void *, size_t);
--- a/_saved/_suckless/st/LICENSE
+++ b/_saved/_suckless/st/LICENSE
@ -0,0 +1,34 @@
+MIT/X Consortium License
+
+© 2014-2022 Hiltjo Posthuma <hiltjo at codemadness dot org>
+© 2018 Devin J. Pohly <djpohly at gmail dot com>
+© 2014-2017 Quentin Rameau <quinq at fifth dot space>
+© 2009-2012 Aurélien APTEL <aurelien dot aptel at gmail dot com>
+© 2008-2017 Anselm R Garbe <garbeam at gmail dot com>
+© 2012-2017 Roberto E. Vargas Caballero <k0ga at shike2 dot com>
+© 2012-2016 Christoph Lohmann <20h at r-36 dot net>
+© 2013 Eon S. Jeon <esjeon at hyunmu dot am>
+© 2013 Alexander Sedov <alex0player at gmail dot com>
+© 2013 Mark Edgar <medgar123 at gmail dot com>
+© 2013-2014 Eric Pruitt <eric.pruitt at gmail dot com>
+© 2013 Michael Forney <mforney at mforney dot org>
+© 2013-2014 Markus Teich <markus dot teich at stusta dot mhn dot de>
+© 2014-2015 Laslo Hunhold <dev at frign dot de>
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/_saved/_suckless/st/Makefile
+++ b/_saved/_suckless/st/Makefile
@ -0,0 +1,57 @@
+# st - simple terminal
+# See LICENSE file for copyright and license details.
+.POSIX:
+
+include config.mk
+
+SRC = st.c x.c
+OBJ = $(SRC:.c=.o)
+
+all: options st
+
+options:
+	@echo st build options:
+	@echo "CFLAGS  = $(STCFLAGS)"
+	@echo "LDFLAGS = $(STLDFLAGS)"
+	@echo "CC      = $(CC)"
+
+config.h:
+	cp config.def.h config.h
+
+.c.o:
+	$(CC) $(STCFLAGS) -c $<
+
+st.o: config.h st.h win.h
+x.o: arg.h config.h st.h win.h
+
+$(OBJ): config.h config.mk
+
+st: $(OBJ)
+	$(CC) -o $@ $(OBJ) $(STLDFLAGS)
+
+clean:
+	rm -f st $(OBJ) st-$(VERSION).tar.gz
+
+dist: clean
+	mkdir -p st-$(VERSION)
+	cp -R FAQ LEGACY TODO LICENSE Makefile README config.mk\
+		config.def.h st.info st.1 arg.h st.h win.h $(SRC)\
+		st-$(VERSION)
+	tar -cf - st-$(VERSION) | gzip > st-$(VERSION).tar.gz
+	rm -rf st-$(VERSION)
+
+install: st
+	mkdir -p $(DESTDIR)$(PREFIX)/bin
+	cp -f st $(DESTDIR)$(PREFIX)/bin
+	chmod 755 $(DESTDIR)$(PREFIX)/bin/st
+	mkdir -p $(DESTDIR)$(MANPREFIX)/man1
+	sed "s/VERSION/$(VERSION)/g" < st.1 > $(DESTDIR)$(MANPREFIX)/man1/st.1
+	chmod 644 $(DESTDIR)$(MANPREFIX)/man1/st.1
+	tic -sx st.info
+	@echo Please see the README file regarding the terminfo entry of st.
+
+uninstall:
+	rm -f $(DESTDIR)$(PREFIX)/bin/st
+	rm -f $(DESTDIR)$(MANPREFIX)/man1/st.1
+
+.PHONY: all options clean dist install uninstall
--- a/_saved/_suckless/st/README.md
+++ b/_saved/_suckless/st/README.md
@ -0,0 +1,12 @@
+# ftpd's st build
+
+## Patches applied
+
+These patches from suckless.org were applied from the newest versions, in order:
+
+1. `st-font2-0.8.5.diff`
+1. `st-hidecursor-0.8.3.diff`
+1. `st-scrollback-0.8.5.diff`
+1. `st-externalpipe-0.8.4.diff`
+1. `st-glyph-wide-support-20220411-ef05519.diff`
+1. `st-w3m-0.8.3.diff`
--- a/_saved/_suckless/st/arg.h
+++ b/_saved/_suckless/st/arg.h
@ -0,0 +1,50 @@
+/*
+ * Copy me if you can.
+ * by 20h
+ */
+
+#ifndef ARG_H__
+#define ARG_H__
+
+extern char *argv0;
+
+/* use main(int argc, char *argv[]) */
+#define ARGBEGIN	for (argv0 = *argv, argv++, argc--;\
+					argv[0] && argv[0][0] == '-'\
+					&& argv[0][1];\
+					argc--, argv++) {\
+				char argc_;\
+				char **argv_;\
+				int brk_;\
+				if (argv[0][1] == '-' && argv[0][2] == '\0') {\
+					argv++;\
+					argc--;\
+					break;\
+				}\
+				int i_;\
+				for (i_ = 1, brk_ = 0, argv_ = argv;\
+						argv[0][i_] && !brk_;\
+						i_++) {\
+					if (argv_ != argv)\
+						break;\
+					argc_ = argv[0][i_];\
+					switch (argc_)
+
+#define ARGEND			}\
+			}
+
+#define ARGC()		argc_
+
+#define EARGF(x)	((argv[0][i_+1] == '\0' && argv[1] == NULL)?\
+				((x), abort(), (char *)0) :\
+				(brk_ = 1, (argv[0][i_+1] != '\0')?\
+					(&argv[0][i_+1]) :\
+					(argc--, argv++, argv[0])))
+
+#define ARGF()		((argv[0][i_+1] == '\0' && argv[1] == NULL)?\
+				(char *)0 :\
+				(brk_ = 1, (argv[0][i_+1] != '\0')?\
+					(&argv[0][i_+1]) :\
+					(argc--, argv++, argv[0])))
+
+#endif
--- a/_saved/_suckless/st/config.def.h
+++ b/_saved/_suckless/st/config.def.h
@ -0,0 +1,482 @@
+/* See LICENSE file for copyright and license details. */
+
+/*
+ * appearance
+ *
+ * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html
+ */
+static char *font = "Liberation Mono:pixelsize=12:antialias=true:autohint=true";
+/* Spare fonts */
+static char *font2[] = {
+/*	"Inconsolata for Powerline:pixelsize=12:antialias=true:autohint=true", */
+/*	"Hack Nerd Font Mono:pixelsize=11:antialias=true:autohint=true", */
+};
+
+static int borderpx = 2;
+
+/*
+ * What program is execed by st depends of these precedence rules:
+ * 1: program passed with -e
+ * 2: scroll and/or utmp
+ * 3: SHELL environment variable
+ * 4: value of shell in /etc/passwd
+ * 5: value of shell in config.h
+ */
+static char *shell = "/bin/sh";
+char *utmp = NULL;
+/* scroll program: to enable use a string like "scroll" */
+char *scroll = NULL;
+char *stty_args = "stty raw pass8 nl -echo -iexten -cstopb 38400";
+
+/* identification sequence returned in DA and DECID */
+char *vtiden = "\033[?6c";
+
+/* Kerning / character bounding-box multipliers */
+static float cwscale = 1.0;
+static float chscale = 1.0;
+
+/*
+ * word delimiter string
+ *
+ * More advanced example: L" `'\"()[]{}"
+ */
+wchar_t *worddelimiters = L" ";
+
+/* selection timeouts (in milliseconds) */
+static unsigned int doubleclicktimeout = 300;
+static unsigned int tripleclicktimeout = 600;
+
+/* alt screens */
+int allowaltscreen = 1;
+
+/* allow certain non-interactive (insecure) window operations such as:
+   setting the clipboard text */
+int allowwindowops = 0;
+
+/*
+ * draw latency range in ms - from new content/keypress/etc until drawing.
+ * within this range, st draws when content stops arriving (idle). mostly it's
+ * near minlatency, but it waits longer for slow updates to avoid partial draw.
+ * low minlatency will tear/flicker more, as it can "detect" idle too early.
+ */
+static double minlatency = 8;
+static double maxlatency = 33;
+
+/*
+ * blinking timeout (set to 0 to disable blinking) for the terminal blinking
+ * attribute.
+ */
+static unsigned int blinktimeout = 800;
+
+/*
+ * thickness of underline and bar cursors
+ */
+static unsigned int cursorthickness = 2;
+
+/*
+ * bell volume. It must be a value between -100 and 100. Use 0 for disabling
+ * it
+ */
+static int bellvolume = 0;
+
+/* default TERM value */
+char *termname = "st-256color";
+
+/*
+ * spaces per tab
+ *
+ * When you are changing this value, don't forget to adapt the »it« value in
+ * the st.info and appropriately install the st.info in the environment where
+ * you use this st version.
+ *
+ *	it#$tabspaces,
+ *
+ * Secondly make sure your kernel is not expanding tabs. When running `stty
+ * -a` »tab0« should appear. You can tell the terminal to not expand tabs by
+ *  running following command:
+ *
+ *	stty tabs
+ */
+unsigned int tabspaces = 8;
+
+/* Terminal colors (16 first used in escape sequence) */
+static const char *colorname[] = {
+	/* 8 normal colors */
+	"black",
+	"red3",
+	"green3",
+	"yellow3",
+	"blue2",
+	"magenta3",
+	"cyan3",
+	"gray90",
+
+	/* 8 bright colors */
+	"gray50",
+	"red",
+	"green",
+	"yellow",
+	"#5c5cff",
+	"magenta",
+	"cyan",
+	"white",
+
+	[255] = 0,
+
+	/* more colors can be added after 255 to use with DefaultXX */
+	"#cccccc",
+	"#555555",
+	"gray90", /* default foreground colour */
+	"black", /* default background colour */
+};
+
+
+/*
+ * Default colors (colorname index)
+ * foreground, background, cursor, reverse cursor
+ */
+unsigned int defaultfg = 258;
+unsigned int defaultbg = 259;
+unsigned int defaultcs = 256;
+static unsigned int defaultrcs = 257;
+
+/*
+ * Default shape of cursor
+ * 2: Block ("█")
+ * 4: Underline ("_")
+ * 6: Bar ("|")
+ * 7: Snowman ("☃")
+ */
+static unsigned int cursorshape = 2;
+
+/*
+ * Default columns and rows numbers
+ */
+
+static unsigned int cols = 80;
+static unsigned int rows = 24;
+
+/*
+ * Default colour and shape of the mouse cursor
+ */
+static unsigned int mouseshape = XC_xterm;
+static unsigned int mousefg = 7;
+static unsigned int mousebg = 0;
+
+/*
+ * Color used to display font attributes when fontconfig selected a font which
+ * doesn't match the ones requested.
+ */
+static unsigned int defaultattr = 11;
+
+/*
+ * Force mouse select/shortcuts while mask is active (when MODE_MOUSE is set).
+ * Note that if you want to use ShiftMask with selmasks, set this to an other
+ * modifier, set to 0 to not use it.
+ */
+static uint forcemousemod = ShiftMask;
+
+/*
+ * Internal mouse shortcuts.
+ * Beware that overloading Button1 will disable the selection.
+ */
+static MouseShortcut mshortcuts[] = {
+	/* mask                 button   function        argument       release */
+	{ XK_ANY_MOD,           Button2, selpaste,       {.i = 0},      1 },
+	{ ShiftMask,            Button4, ttysend,        {.s = "\033[5;2~"} },
+	{ XK_ANY_MOD,           Button4, ttysend,        {.s = "\031"} },
+	{ ShiftMask,            Button5, ttysend,        {.s = "\033[6;2~"} },
+	{ XK_ANY_MOD,           Button5, ttysend,        {.s = "\005"} },
+};
+
+/* Internal keyboard shortcuts. */
+#define MODKEY Mod1Mask
+#define TERMMOD (ControlMask|ShiftMask)
+
+static Shortcut shortcuts[] = {
+	/* mask                 keysym          function        argument */
+	{ XK_ANY_MOD,           XK_Break,       sendbreak,      {.i =  0} },
+	{ ControlMask,          XK_Print,       toggleprinter,  {.i =  0} },
+	{ ShiftMask,            XK_Print,       printscreen,    {.i =  0} },
+	{ XK_ANY_MOD,           XK_Print,       printsel,       {.i =  0} },
+	{ TERMMOD,              XK_Prior,       zoom,           {.f = +1} },
+	{ TERMMOD,              XK_Next,        zoom,           {.f = -1} },
+	{ TERMMOD,              XK_Home,        zoomreset,      {.f =  0} },
+	{ TERMMOD,              XK_C,           clipcopy,       {.i =  0} },
+	{ TERMMOD,              XK_V,           clippaste,      {.i =  0} },
+	{ TERMMOD,              XK_Y,           selpaste,       {.i =  0} },
+	{ ShiftMask,            XK_Insert,      selpaste,       {.i =  0} },
+	{ TERMMOD,              XK_Num_Lock,    numlock,        {.i =  0} },
+	{ ShiftMask,            XK_Page_Up,     kscrollup,      {.i = -1} },
+	{ ShiftMask,            XK_Page_Down,   kscrolldown,    {.i = -1} },
+};
+
+/*
+ * Special keys (change & recompile st.info accordingly)
+ *
+ * Mask value:
+ * * Use XK_ANY_MOD to match the key no matter modifiers state
+ * * Use XK_NO_MOD to match the key alone (no modifiers)
+ * appkey value:
+ * * 0: no value
+ * * > 0: keypad application mode enabled
+ * *   = 2: term.numlock = 1
+ * * < 0: keypad application mode disabled
+ * appcursor value:
+ * * 0: no value
+ * * > 0: cursor application mode enabled
+ * * < 0: cursor application mode disabled
+ *
+ * Be careful with the order of the definitions because st searches in
+ * this table sequentially, so any XK_ANY_MOD must be in the last
+ * position for a key.
+ */
+
+/*
+ * If you want keys other than the X11 function keys (0xFD00 - 0xFFFF)
+ * to be mapped below, add them to this array.
+ */
+static KeySym mappedkeys[] = { -1 };
+
+/*
+ * State bits to ignore when matching key or button events.  By default,
+ * numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored.
+ */
+static uint ignoremod = Mod2Mask|XK_SWITCH_MOD;
+
+/*
+ * This is the huge key array which defines all compatibility to the Linux
+ * world. Please decide about changes wisely.
+ */
+static Key key[] = {
+	/* keysym           mask            string      appkey appcursor */
+	{ XK_KP_Home,       ShiftMask,      "\033[2J",       0,   -1},
+	{ XK_KP_Home,       ShiftMask,      "\033[1;2H",     0,   +1},
+	{ XK_KP_Home,       XK_ANY_MOD,     "\033[H",        0,   -1},
+	{ XK_KP_Home,       XK_ANY_MOD,     "\033[1~",       0,   +1},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033Ox",       +1,    0},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033[A",        0,   -1},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033OA",        0,   +1},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033Or",       +1,    0},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033[B",        0,   -1},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033OB",        0,   +1},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033Ot",       +1,    0},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033[D",        0,   -1},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033OD",        0,   +1},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033Ov",       +1,    0},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033[C",        0,   -1},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033OC",        0,   +1},
+	{ XK_KP_Prior,      ShiftMask,      "\033[5;2~",     0,    0},
+	{ XK_KP_Prior,      XK_ANY_MOD,     "\033[5~",       0,    0},
+	{ XK_KP_Begin,      XK_ANY_MOD,     "\033[E",        0,    0},
+	{ XK_KP_End,        ControlMask,    "\033[J",       -1,    0},
+	{ XK_KP_End,        ControlMask,    "\033[1;5F",    +1,    0},
+	{ XK_KP_End,        ShiftMask,      "\033[K",       -1,    0},
+	{ XK_KP_End,        ShiftMask,      "\033[1;2F",    +1,    0},
+	{ XK_KP_End,        XK_ANY_MOD,     "\033[4~",       0,    0},
+	{ XK_KP_Next,       ShiftMask,      "\033[6;2~",     0,    0},
+	{ XK_KP_Next,       XK_ANY_MOD,     "\033[6~",       0,    0},
+	{ XK_KP_Insert,     ShiftMask,      "\033[2;2~",    +1,    0},
+	{ XK_KP_Insert,     ShiftMask,      "\033[4l",      -1,    0},
+	{ XK_KP_Insert,     ControlMask,    "\033[L",       -1,    0},
+	{ XK_KP_Insert,     ControlMask,    "\033[2;5~",    +1,    0},
+	{ XK_KP_Insert,     XK_ANY_MOD,     "\033[4h",      -1,    0},
+	{ XK_KP_Insert,     XK_ANY_MOD,     "\033[2~",      +1,    0},
+	{ XK_KP_Delete,     ControlMask,    "\033[M",       -1,    0},
+	{ XK_KP_Delete,     ControlMask,    "\033[3;5~",    +1,    0},
+	{ XK_KP_Delete,     ShiftMask,      "\033[2K",      -1,    0},
+	{ XK_KP_Delete,     ShiftMask,      "\033[3;2~",    +1,    0},
+	{ XK_KP_Delete,     XK_ANY_MOD,     "\033[P",       -1,    0},
+	{ XK_KP_Delete,     XK_ANY_MOD,     "\033[3~",      +1,    0},
+	{ XK_KP_Multiply,   XK_ANY_MOD,     "\033Oj",       +2,    0},
+	{ XK_KP_Add,        XK_ANY_MOD,     "\033Ok",       +2,    0},
+	{ XK_KP_Enter,      XK_ANY_MOD,     "\033OM",       +2,    0},
+	{ XK_KP_Enter,      XK_ANY_MOD,     "\r",           -1,    0},
+	{ XK_KP_Subtract,   XK_ANY_MOD,     "\033Om",       +2,    0},
+	{ XK_KP_Decimal,    XK_ANY_MOD,     "\033On",       +2,    0},
+	{ XK_KP_Divide,     XK_ANY_MOD,     "\033Oo",       +2,    0},
+	{ XK_KP_0,          XK_ANY_MOD,     "\033Op",       +2,    0},
+	{ XK_KP_1,          XK_ANY_MOD,     "\033Oq",       +2,    0},
+	{ XK_KP_2,          XK_ANY_MOD,     "\033Or",       +2,    0},
+	{ XK_KP_3,          XK_ANY_MOD,     "\033Os",       +2,    0},
+	{ XK_KP_4,          XK_ANY_MOD,     "\033Ot",       +2,    0},
+	{ XK_KP_5,          XK_ANY_MOD,     "\033Ou",       +2,    0},
+	{ XK_KP_6,          XK_ANY_MOD,     "\033Ov",       +2,    0},
+	{ XK_KP_7,          XK_ANY_MOD,     "\033Ow",       +2,    0},
+	{ XK_KP_8,          XK_ANY_MOD,     "\033Ox",       +2,    0},
+	{ XK_KP_9,          XK_ANY_MOD,     "\033Oy",       +2,    0},
+	{ XK_Up,            ShiftMask,      "\033[1;2A",     0,    0},
+	{ XK_Up,            Mod1Mask,       "\033[1;3A",     0,    0},
+	{ XK_Up,         ShiftMask|Mod1Mask,"\033[1;4A",     0,    0},
+	{ XK_Up,            ControlMask,    "\033[1;5A",     0,    0},
+	{ XK_Up,      ShiftMask|ControlMask,"\033[1;6A",     0,    0},
+	{ XK_Up,       ControlMask|Mod1Mask,"\033[1;7A",     0,    0},
+	{ XK_Up,ShiftMask|ControlMask|Mod1Mask,"\033[1;8A",  0,    0},
+	{ XK_Up,            XK_ANY_MOD,     "\033[A",        0,   -1},
+	{ XK_Up,            XK_ANY_MOD,     "\033OA",        0,   +1},
+	{ XK_Down,          ShiftMask,      "\033[1;2B",     0,    0},
+	{ XK_Down,          Mod1Mask,       "\033[1;3B",     0,    0},
+	{ XK_Down,       ShiftMask|Mod1Mask,"\033[1;4B",     0,    0},
+	{ XK_Down,          ControlMask,    "\033[1;5B",     0,    0},
+	{ XK_Down,    ShiftMask|ControlMask,"\033[1;6B",     0,    0},
+	{ XK_Down,     ControlMask|Mod1Mask,"\033[1;7B",     0,    0},
+	{ XK_Down,ShiftMask|ControlMask|Mod1Mask,"\033[1;8B",0,    0},
+	{ XK_Down,          XK_ANY_MOD,     "\033[B",        0,   -1},
+	{ XK_Down,          XK_ANY_MOD,     "\033OB",        0,   +1},
+	{ XK_Left,          ShiftMask,      "\033[1;2D",     0,    0},
+	{ XK_Left,          Mod1Mask,       "\033[1;3D",     0,    0},
+	{ XK_Left,       ShiftMask|Mod1Mask,"\033[1;4D",     0,    0},
+	{ XK_Left,          ControlMask,    "\033[1;5D",     0,    0},
+	{ XK_Left,    ShiftMask|ControlMask,"\033[1;6D",     0,    0},
+	{ XK_Left,     ControlMask|Mod1Mask,"\033[1;7D",     0,    0},
+	{ XK_Left,ShiftMask|ControlMask|Mod1Mask,"\033[1;8D",0,    0},
+	{ XK_Left,          XK_ANY_MOD,     "\033[D",        0,   -1},
+	{ XK_Left,          XK_ANY_MOD,     "\033OD",        0,   +1},
+	{ XK_Right,         ShiftMask,      "\033[1;2C",     0,    0},
+	{ XK_Right,         Mod1Mask,       "\033[1;3C",     0,    0},
+	{ XK_Right,      ShiftMask|Mod1Mask,"\033[1;4C",     0,    0},
+	{ XK_Right,         ControlMask,    "\033[1;5C",     0,    0},
+	{ XK_Right,   ShiftMask|ControlMask,"\033[1;6C",     0,    0},
+	{ XK_Right,    ControlMask|Mod1Mask,"\033[1;7C",     0,    0},
+	{ XK_Right,ShiftMask|ControlMask|Mod1Mask,"\033[1;8C",0,   0},
+	{ XK_Right,         XK_ANY_MOD,     "\033[C",        0,   -1},
+	{ XK_Right,         XK_ANY_MOD,     "\033OC",        0,   +1},
+	{ XK_ISO_Left_Tab,  ShiftMask,      "\033[Z",        0,    0},
+	{ XK_Return,        Mod1Mask,       "\033\r",        0,    0},
+	{ XK_Return,        XK_ANY_MOD,     "\r",            0,    0},
+	{ XK_Insert,        ShiftMask,      "\033[4l",      -1,    0},
+	{ XK_Insert,        ShiftMask,      "\033[2;2~",    +1,    0},
+	{ XK_Insert,        ControlMask,    "\033[L",       -1,    0},
+	{ XK_Insert,        ControlMask,    "\033[2;5~",    +1,    0},
+	{ XK_Insert,        XK_ANY_MOD,     "\033[4h",      -1,    0},
+	{ XK_Insert,        XK_ANY_MOD,     "\033[2~",      +1,    0},
+	{ XK_Delete,        ControlMask,    "\033[M",       -1,    0},
+	{ XK_Delete,        ControlMask,    "\033[3;5~",    +1,    0},
+	{ XK_Delete,        ShiftMask,      "\033[2K",      -1,    0},
+	{ XK_Delete,        ShiftMask,      "\033[3;2~",    +1,    0},
+	{ XK_Delete,        XK_ANY_MOD,     "\033[P",       -1,    0},
+	{ XK_Delete,        XK_ANY_MOD,     "\033[3~",      +1,    0},
+	{ XK_BackSpace,     XK_NO_MOD,      "\177",          0,    0},
+	{ XK_BackSpace,     Mod1Mask,       "\033\177",      0,    0},
+	{ XK_Home,          ShiftMask,      "\033[2J",       0,   -1},
+	{ XK_Home,          ShiftMask,      "\033[1;2H",     0,   +1},
+	{ XK_Home,          XK_ANY_MOD,     "\033[H",        0,   -1},
+	{ XK_Home,          XK_ANY_MOD,     "\033[1~",       0,   +1},
+	{ XK_End,           ControlMask,    "\033[J",       -1,    0},
+	{ XK_End,           ControlMask,    "\033[1;5F",    +1,    0},
+	{ XK_End,           ShiftMask,      "\033[K",       -1,    0},
+	{ XK_End,           ShiftMask,      "\033[1;2F",    +1,    0},
+	{ XK_End,           XK_ANY_MOD,     "\033[4~",       0,    0},
+	{ XK_Prior,         ControlMask,    "\033[5;5~",     0,    0},
+	{ XK_Prior,         ShiftMask,      "\033[5;2~",     0,    0},
+	{ XK_Prior,         XK_ANY_MOD,     "\033[5~",       0,    0},
+	{ XK_Next,          ControlMask,    "\033[6;5~",     0,    0},
+	{ XK_Next,          ShiftMask,      "\033[6;2~",     0,    0},
+	{ XK_Next,          XK_ANY_MOD,     "\033[6~",       0,    0},
+	{ XK_F1,            XK_NO_MOD,      "\033OP" ,       0,    0},
+	{ XK_F1, /* F13 */  ShiftMask,      "\033[1;2P",     0,    0},
+	{ XK_F1, /* F25 */  ControlMask,    "\033[1;5P",     0,    0},
+	{ XK_F1, /* F37 */  Mod4Mask,       "\033[1;6P",     0,    0},
+	{ XK_F1, /* F49 */  Mod1Mask,       "\033[1;3P",     0,    0},
+	{ XK_F1, /* F61 */  Mod3Mask,       "\033[1;4P",     0,    0},
+	{ XK_F2,            XK_NO_MOD,      "\033OQ" ,       0,    0},
+	{ XK_F2, /* F14 */  ShiftMask,      "\033[1;2Q",     0,    0},
+	{ XK_F2, /* F26 */  ControlMask,    "\033[1;5Q",     0,    0},
+	{ XK_F2, /* F38 */  Mod4Mask,       "\033[1;6Q",     0,    0},
+	{ XK_F2, /* F50 */  Mod1Mask,       "\033[1;3Q",     0,    0},
+	{ XK_F2, /* F62 */  Mod3Mask,       "\033[1;4Q",     0,    0},
+	{ XK_F3,            XK_NO_MOD,      "\033OR" ,       0,    0},
+	{ XK_F3, /* F15 */  ShiftMask,      "\033[1;2R",     0,    0},
+	{ XK_F3, /* F27 */  ControlMask,    "\033[1;5R",     0,    0},
+	{ XK_F3, /* F39 */  Mod4Mask,       "\033[1;6R",     0,    0},
+	{ XK_F3, /* F51 */  Mod1Mask,       "\033[1;3R",     0,    0},
+	{ XK_F3, /* F63 */  Mod3Mask,       "\033[1;4R",     0,    0},
+	{ XK_F4,            XK_NO_MOD,      "\033OS" ,       0,    0},
+	{ XK_F4, /* F16 */  ShiftMask,      "\033[1;2S",     0,    0},
+	{ XK_F4, /* F28 */  ControlMask,    "\033[1;5S",     0,    0},
+	{ XK_F4, /* F40 */  Mod4Mask,       "\033[1;6S",     0,    0},
+	{ XK_F4, /* F52 */  Mod1Mask,       "\033[1;3S",     0,    0},
+	{ XK_F5,            XK_NO_MOD,      "\033[15~",      0,    0},
+	{ XK_F5, /* F17 */  ShiftMask,      "\033[15;2~",    0,    0},
+	{ XK_F5, /* F29 */  ControlMask,    "\033[15;5~",    0,    0},
+	{ XK_F5, /* F41 */  Mod4Mask,       "\033[15;6~",    0,    0},
+	{ XK_F5, /* F53 */  Mod1Mask,       "\033[15;3~",    0,    0},
+	{ XK_F6,            XK_NO_MOD,      "\033[17~",      0,    0},
+	{ XK_F6, /* F18 */  ShiftMask,      "\033[17;2~",    0,    0},
+	{ XK_F6, /* F30 */  ControlMask,    "\033[17;5~",    0,    0},
+	{ XK_F6, /* F42 */  Mod4Mask,       "\033[17;6~",    0,    0},
+	{ XK_F6, /* F54 */  Mod1Mask,       "\033[17;3~",    0,    0},
+	{ XK_F7,            XK_NO_MOD,      "\033[18~",      0,    0},
+	{ XK_F7, /* F19 */  ShiftMask,      "\033[18;2~",    0,    0},
+	{ XK_F7, /* F31 */  ControlMask,    "\033[18;5~",    0,    0},
+	{ XK_F7, /* F43 */  Mod4Mask,       "\033[18;6~",    0,    0},
+	{ XK_F7, /* F55 */  Mod1Mask,       "\033[18;3~",    0,    0},
+	{ XK_F8,            XK_NO_MOD,      "\033[19~",      0,    0},
+	{ XK_F8, /* F20 */  ShiftMask,      "\033[19;2~",    0,    0},
+	{ XK_F8, /* F32 */  ControlMask,    "\033[19;5~",    0,    0},
+	{ XK_F8, /* F44 */  Mod4Mask,       "\033[19;6~",    0,    0},
+	{ XK_F8, /* F56 */  Mod1Mask,       "\033[19;3~",    0,    0},
+	{ XK_F9,            XK_NO_MOD,      "\033[20~",      0,    0},
+	{ XK_F9, /* F21 */  ShiftMask,      "\033[20;2~",    0,    0},
+	{ XK_F9, /* F33 */  ControlMask,    "\033[20;5~",    0,    0},
+	{ XK_F9, /* F45 */  Mod4Mask,       "\033[20;6~",    0,    0},
+	{ XK_F9, /* F57 */  Mod1Mask,       "\033[20;3~",    0,    0},
+	{ XK_F10,           XK_NO_MOD,      "\033[21~",      0,    0},
+	{ XK_F10, /* F22 */ ShiftMask,      "\033[21;2~",    0,    0},
+	{ XK_F10, /* F34 */ ControlMask,    "\033[21;5~",    0,    0},
+	{ XK_F10, /* F46 */ Mod4Mask,       "\033[21;6~",    0,    0},
+	{ XK_F10, /* F58 */ Mod1Mask,       "\033[21;3~",    0,    0},
+	{ XK_F11,           XK_NO_MOD,      "\033[23~",      0,    0},
+	{ XK_F11, /* F23 */ ShiftMask,      "\033[23;2~",    0,    0},
+	{ XK_F11, /* F35 */ ControlMask,    "\033[23;5~",    0,    0},
+	{ XK_F11, /* F47 */ Mod4Mask,       "\033[23;6~",    0,    0},
+	{ XK_F11, /* F59 */ Mod1Mask,       "\033[23;3~",    0,    0},
+	{ XK_F12,           XK_NO_MOD,      "\033[24~",      0,    0},
+	{ XK_F12, /* F24 */ ShiftMask,      "\033[24;2~",    0,    0},
+	{ XK_F12, /* F36 */ ControlMask,    "\033[24;5~",    0,    0},
+	{ XK_F12, /* F48 */ Mod4Mask,       "\033[24;6~",    0,    0},
+	{ XK_F12, /* F60 */ Mod1Mask,       "\033[24;3~",    0,    0},
+	{ XK_F13,           XK_NO_MOD,      "\033[1;2P",     0,    0},
+	{ XK_F14,           XK_NO_MOD,      "\033[1;2Q",     0,    0},
+	{ XK_F15,           XK_NO_MOD,      "\033[1;2R",     0,    0},
+	{ XK_F16,           XK_NO_MOD,      "\033[1;2S",     0,    0},
+	{ XK_F17,           XK_NO_MOD,      "\033[15;2~",    0,    0},
+	{ XK_F18,           XK_NO_MOD,      "\033[17;2~",    0,    0},
+	{ XK_F19,           XK_NO_MOD,      "\033[18;2~",    0,    0},
+	{ XK_F20,           XK_NO_MOD,      "\033[19;2~",    0,    0},
+	{ XK_F21,           XK_NO_MOD,      "\033[20;2~",    0,    0},
+	{ XK_F22,           XK_NO_MOD,      "\033[21;2~",    0,    0},
+	{ XK_F23,           XK_NO_MOD,      "\033[23;2~",    0,    0},
+	{ XK_F24,           XK_NO_MOD,      "\033[24;2~",    0,    0},
+	{ XK_F25,           XK_NO_MOD,      "\033[1;5P",     0,    0},
+	{ XK_F26,           XK_NO_MOD,      "\033[1;5Q",     0,    0},
+	{ XK_F27,           XK_NO_MOD,      "\033[1;5R",     0,    0},
+	{ XK_F28,           XK_NO_MOD,      "\033[1;5S",     0,    0},
+	{ XK_F29,           XK_NO_MOD,      "\033[15;5~",    0,    0},
+	{ XK_F30,           XK_NO_MOD,      "\033[17;5~",    0,    0},
+	{ XK_F31,           XK_NO_MOD,      "\033[18;5~",    0,    0},
+	{ XK_F32,           XK_NO_MOD,      "\033[19;5~",    0,    0},
+	{ XK_F33,           XK_NO_MOD,      "\033[20;5~",    0,    0},
+	{ XK_F34,           XK_NO_MOD,      "\033[21;5~",    0,    0},
+	{ XK_F35,           XK_NO_MOD,      "\033[23;5~",    0,    0},
+};
+
+/*
+ * Selection types' masks.
+ * Use the same masks as usual.
+ * Button1Mask is always unset, to make masks match between ButtonPress.
+ * ButtonRelease and MotionNotify.
+ * If no match is found, regular selection is used.
+ */
+static uint selmasks[] = {
+	[SEL_RECTANGULAR] = Mod1Mask,
+};
+
+/*
+ * Printable characters in ASCII, used to estimate the advance width
+ * of single wide characters.
+ */
+static char ascii_printable[] =
+	" !\"#$%&'()*+,-./0123456789:;<=>?"
+	"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
+	"`abcdefghijklmnopqrstuvwxyz{|}~";
--- a/_saved/_suckless/st/config.h
+++ b/_saved/_suckless/st/config.h
@ -0,0 +1,474 @@
+/* See LICENSE file for copyright and license details. */
+
+/*
+ * appearance
+ *
+ * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html
+ */
+static char *font = "RobotoMono Nerd Font:style=Medium:pixelsize=14";
+static char *font2[] = { "Noto Color Emoji:pixelsize=12" };
+static int borderpx = 5;
+
+/*
+ * What program is execed by st depends of these precedence rules:
+ * 1: program passed with -e
+ * 2: scroll and/or utmp
+ * 3: SHELL environment variable
+ * 4: value of shell in /etc/passwd
+ * 5: value of shell in config.h
+ */
+static char *shell = "/bin/sh";
+char *utmp = NULL;
+/* scroll program: to enable use a string like "scroll" */
+char *scroll = NULL;
+char *stty_args = "stty raw pass8 nl -echo -iexten -cstopb 38400";
+
+/* identification sequence returned in DA and DECID */
+char *vtiden = "\033[?6c";
+
+/* Kerning / character bounding-box multipliers */
+static float cwscale = 1.0;
+static float chscale = 1.0;
+
+/*
+ * word delimiter string
+ *
+ * More advanced example: L" `'\"()[]{}"
+ */
+wchar_t *worddelimiters = L" ";
+
+/* selection timeouts (in milliseconds) */
+static unsigned int doubleclicktimeout = 300;
+static unsigned int tripleclicktimeout = 600;
+
+/* alt screens */
+int allowaltscreen = 1;
+
+/* allow certain non-interactive (insecure) window operations such as:
+   setting the clipboard text */
+int allowwindowops = 0;
+
+/*
+ * draw latency range in ms - from new content/keypress/etc until drawing.
+ * within this range, st draws when content stops arriving (idle). mostly it's
+ * near minlatency, but it waits longer for slow updates to avoid partial draw.
+ * low minlatency will tear/flicker more, as it can "detect" idle too early.
+ */
+static double minlatency = 8;
+static double maxlatency = 33;
+
+/*
+ * blinking timeout (set to 0 to disable blinking) for the terminal blinking
+ * attribute.
+ */
+static unsigned int blinktimeout = 800;
+
+/*
+ * thickness of underline and bar cursors
+ */
+static unsigned int cursorthickness = 2;
+
+/*
+ * bell volume. It must be a value between -100 and 100. Use 0 for disabling
+ * it
+ */
+static int bellvolume = 0;
+
+/* default TERM value */
+char *termname = "xterm-256color";
+
+/*
+ * spaces per tab
+ *
+ * When you are changing this value, don't forget to adapt the »it« value in
+ * the st.info and appropriately install the st.info in the environment where
+ * you use this st version.
+ *
+ *	it#$tabspaces,
+ *
+ * Secondly make sure your kernel is not expanding tabs. When running `stty
+ * -a` »tab0« should appear. You can tell the terminal to not expand tabs by
+ *  running following command:
+ *
+ *	stty tabs
+ */
+unsigned int tabspaces = 8;
+
+/* Terminal colors (16 first used in escape sequence) */
+static const char *colorname[] = {
+  "#272822",
+  "#fd4285",
+  "#a6e22d",
+  "#e5da72",
+  "#00bdff",
+  "#9a37ff",
+  "#50b6d8",
+  "#c7c7c7",
+  "#676767",
+  "#fa7fac",
+  "#bde271",
+  "#fff27f",
+  "#005577",
+  "#bd9eff",
+  "#5ed6fe",
+  "#feffff",
+  [255] = 0,
+
+  /* more colors can be added after 255 to use with DefaultXX */
+  "#272822", /* 256 -> background  */
+  "#c7c7c7", /* 257 -> foreground  */
+  "#c7c7c7", /* 258 -> cursor      */
+  "#272822", /* 259 -> cursor text */
+};
+
+
+/*
+ * Default colors (colorname index)
+ * foreground, background, cursor, reverse cursor
+ */
+unsigned int defaultbg = 256;
+unsigned int defaultfg = 257;
+unsigned int defaultcs = 258;
+static unsigned int defaultrcs = 259;
+
+/*
+ * Default shape of cursor
+ * 2: Block ("█")
+ * 4: Underline ("_")
+ * 6: Bar ("|")
+ * 7: Snowman ("☃")
+ */
+static unsigned int cursorshape = 6;
+
+/*
+ * Default columns and rows numbers
+ */
+
+static unsigned int cols = 80;
+static unsigned int rows = 24;
+
+/*
+ * Default colour and shape of the mouse cursor
+ */
+static unsigned int mouseshape = XC_xterm;
+static unsigned int mousefg = 7;
+static unsigned int mousebg = 0;
+
+/*
+ * Color used to display font attributes when fontconfig selected a font which
+ * doesn't match the ones requested.
+ */
+static unsigned int defaultattr = 11;
+
+/*
+ * Force mouse select/shortcuts while mask is active (when MODE_MOUSE is set).
+ * Note that if you want to use ShiftMask with selmasks, set this to an other
+ * modifier, set to 0 to not use it.
+ */
+static uint forcemousemod = ShiftMask;
+
+/*
+ * Internal mouse shortcuts.
+ * Beware that overloading Button1 will disable the selection.
+ */
+static MouseShortcut mshortcuts[] = {
+  /* mask                 button   function        argument       release */
+  { XK_ANY_MOD,           Button4, kscrollup,      {.i = 5} },
+  { XK_ANY_MOD,           Button5, kscrolldown,    {.i = 5} },
+  { XK_ANY_MOD,           Button2, selpaste,       {.i = 0},      1 },
+  { ShiftMask,            Button4, ttysend,        {.s = "\033[5;2~"} },
+  { XK_ANY_MOD,           Button4, ttysend,        {.s = "\031"} },
+  { ShiftMask,            Button5, ttysend,        {.s = "\033[6;2~"} },
+  { XK_ANY_MOD,           Button5, ttysend,        {.s = "\005"} },
+};
+
+/* Internal keyboard shortcuts. */
+#define MODKEY ControlMask
+#define SHTKEY (ControlMask|ShiftMask)
+
+static char *openurlcmd[] = {"/bin/sh", "-c", "xurls | dmenu -c -l 20 -i | xargs -r $BROWSER",
+  "externalpipe", NULL};
+
+
+static Shortcut shortcuts[] = {
+  /* mask                 keysym          function        argument */
+  { MODKEY,               XK_equal,   zoom,           {.f = +2} },
+  { MODKEY,               XK_minus,   zoom,           {.f = -2} },
+  { MODKEY,               XK_0,       zoomreset,      {.f =  0} },
+  { SHTKEY,               XK_C,       clipcopy,       {.i =  0} },
+  { SHTKEY,               XK_V,       clippaste,      {.i =  0} },
+  { ShiftMask,            XK_Insert,  selpaste,       {.i =  0} },
+  { MODKEY,               XK_o,       externalpipe,   {.v = openurlcmd } },
+  { MODKEY,               XK_k,       kscrollup,      {.i = 1} },
+  { MODKEY,               XK_j,       kscrolldown,    {.i = 1} },
+};
+
+/*
+ * Special keys (change & recompile st.info accordingly)
+ *
+ * Mask value:
+ * * Use XK_ANY_MOD to match the key no matter modifiers state
+ * * Use XK_NO_MOD to match the key alone (no modifiers)
+ * appkey value:
+ * * 0: no value
+ * * > 0: keypad application mode enabled
+ * *   = 2: term.numlock = 1
+ * * < 0: keypad application mode disabled
+ * appcursor value:
+ * * 0: no value
+ * * > 0: cursor application mode enabled
+ * * < 0: cursor application mode disabled
+ *
+ * Be careful with the order of the definitions because st searches in
+ * this table sequentially, so any XK_ANY_MOD must be in the last
+ * position for a key.
+ */
+
+/*
+ * If you want keys other than the X11 function keys (0xFD00 - 0xFFFF)
+ * to be mapped below, add them to this array.
+ */
+static KeySym mappedkeys[] = { -1 };
+
+/*
+ * State bits to ignore when matching key or button events.  By default,
+ * numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored.
+ */
+static uint ignoremod = Mod2Mask|XK_SWITCH_MOD;
+
+/*
+ * This is the huge key array which defines all compatibility to the Linux
+ * world. Please decide about changes wisely.
+ */
+static Key key[] = {
+	/* keysym           mask            string      appkey appcursor */
+	{ XK_KP_Home,       ShiftMask,      "\033[2J",       0,   -1},
+	{ XK_KP_Home,       ShiftMask,      "\033[1;2H",     0,   +1},
+	{ XK_KP_Home,       XK_ANY_MOD,     "\033[H",        0,   -1},
+	{ XK_KP_Home,       XK_ANY_MOD,     "\033[1~",       0,   +1},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033Ox",       +1,    0},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033[A",        0,   -1},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033OA",        0,   +1},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033Or",       +1,    0},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033[B",        0,   -1},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033OB",        0,   +1},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033Ot",       +1,    0},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033[D",        0,   -1},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033OD",        0,   +1},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033Ov",       +1,    0},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033[C",        0,   -1},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033OC",        0,   +1},
+	{ XK_KP_Prior,      ShiftMask,      "\033[5;2~",     0,    0},
+	{ XK_KP_Prior,      XK_ANY_MOD,     "\033[5~",       0,    0},
+	{ XK_KP_Begin,      XK_ANY_MOD,     "\033[E",        0,    0},
+	{ XK_KP_End,        ControlMask,    "\033[J",       -1,    0},
+	{ XK_KP_End,        ControlMask,    "\033[1;5F",    +1,    0},
+	{ XK_KP_End,        ShiftMask,      "\033[K",       -1,    0},
+	{ XK_KP_End,        ShiftMask,      "\033[1;2F",    +1,    0},
+	{ XK_KP_End,        XK_ANY_MOD,     "\033[4~",       0,    0},
+	{ XK_KP_Next,       ShiftMask,      "\033[6;2~",     0,    0},
+	{ XK_KP_Next,       XK_ANY_MOD,     "\033[6~",       0,    0},
+	{ XK_KP_Insert,     ShiftMask,      "\033[2;2~",    +1,    0},
+	{ XK_KP_Insert,     ShiftMask,      "\033[4l",      -1,    0},
+	{ XK_KP_Insert,     ControlMask,    "\033[L",       -1,    0},
+	{ XK_KP_Insert,     ControlMask,    "\033[2;5~",    +1,    0},
+	{ XK_KP_Insert,     XK_ANY_MOD,     "\033[4h",      -1,    0},
+	{ XK_KP_Insert,     XK_ANY_MOD,     "\033[2~",      +1,    0},
+	{ XK_KP_Delete,     ControlMask,    "\033[M",       -1,    0},
+	{ XK_KP_Delete,     ControlMask,    "\033[3;5~",    +1,    0},
+	{ XK_KP_Delete,     ShiftMask,      "\033[2K",      -1,    0},
+	{ XK_KP_Delete,     ShiftMask,      "\033[3;2~",    +1,    0},
+	{ XK_KP_Delete,     XK_ANY_MOD,     "\033[P",       -1,    0},
+	{ XK_KP_Delete,     XK_ANY_MOD,     "\033[3~",      +1,    0},
+	{ XK_KP_Multiply,   XK_ANY_MOD,     "\033Oj",       +2,    0},
+	{ XK_KP_Add,        XK_ANY_MOD,     "\033Ok",       +2,    0},
+	{ XK_KP_Enter,      XK_ANY_MOD,     "\033OM",       +2,    0},
+	{ XK_KP_Enter,      XK_ANY_MOD,     "\r",           -1,    0},
+	{ XK_KP_Subtract,   XK_ANY_MOD,     "\033Om",       +2,    0},
+	{ XK_KP_Decimal,    XK_ANY_MOD,     "\033On",       +2,    0},
+	{ XK_KP_Divide,     XK_ANY_MOD,     "\033Oo",       +2,    0},
+	{ XK_KP_0,          XK_ANY_MOD,     "\033Op",       +2,    0},
+	{ XK_KP_1,          XK_ANY_MOD,     "\033Oq",       +2,    0},
+	{ XK_KP_2,          XK_ANY_MOD,     "\033Or",       +2,    0},
+	{ XK_KP_3,          XK_ANY_MOD,     "\033Os",       +2,    0},
+	{ XK_KP_4,          XK_ANY_MOD,     "\033Ot",       +2,    0},
+	{ XK_KP_5,          XK_ANY_MOD,     "\033Ou",       +2,    0},
+	{ XK_KP_6,          XK_ANY_MOD,     "\033Ov",       +2,    0},
+	{ XK_KP_7,          XK_ANY_MOD,     "\033Ow",       +2,    0},
+	{ XK_KP_8,          XK_ANY_MOD,     "\033Ox",       +2,    0},
+	{ XK_KP_9,          XK_ANY_MOD,     "\033Oy",       +2,    0},
+	{ XK_Up,            ShiftMask,      "\033[1;2A",     0,    0},
+	{ XK_Up,            Mod1Mask,       "\033[1;3A",     0,    0},
+	{ XK_Up,         ShiftMask|Mod1Mask,"\033[1;4A",     0,    0},
+	{ XK_Up,            ControlMask,    "\033[1;5A",     0,    0},
+	{ XK_Up,      ShiftMask|ControlMask,"\033[1;6A",     0,    0},
+	{ XK_Up,       ControlMask|Mod1Mask,"\033[1;7A",     0,    0},
+	{ XK_Up,ShiftMask|ControlMask|Mod1Mask,"\033[1;8A",  0,    0},
+	{ XK_Up,            XK_ANY_MOD,     "\033[A",        0,   -1},
+	{ XK_Up,            XK_ANY_MOD,     "\033OA",        0,   +1},
+	{ XK_Down,          ShiftMask,      "\033[1;2B",     0,    0},
+	{ XK_Down,          Mod1Mask,       "\033[1;3B",     0,    0},
+	{ XK_Down,       ShiftMask|Mod1Mask,"\033[1;4B",     0,    0},
+	{ XK_Down,          ControlMask,    "\033[1;5B",     0,    0},
+	{ XK_Down,    ShiftMask|ControlMask,"\033[1;6B",     0,    0},
+	{ XK_Down,     ControlMask|Mod1Mask,"\033[1;7B",     0,    0},
+	{ XK_Down,ShiftMask|ControlMask|Mod1Mask,"\033[1;8B",0,    0},
+	{ XK_Down,          XK_ANY_MOD,     "\033[B",        0,   -1},
+	{ XK_Down,          XK_ANY_MOD,     "\033OB",        0,   +1},
+	{ XK_Left,          ShiftMask,      "\033[1;2D",     0,    0},
+	{ XK_Left,          Mod1Mask,       "\033[1;3D",     0,    0},
+	{ XK_Left,       ShiftMask|Mod1Mask,"\033[1;4D",     0,    0},
+	{ XK_Left,          ControlMask,    "\033[1;5D",     0,    0},
+	{ XK_Left,    ShiftMask|ControlMask,"\033[1;6D",     0,    0},
+	{ XK_Left,     ControlMask|Mod1Mask,"\033[1;7D",     0,    0},
+	{ XK_Left,ShiftMask|ControlMask|Mod1Mask,"\033[1;8D",0,    0},
+	{ XK_Left,          XK_ANY_MOD,     "\033[D",        0,   -1},
+	{ XK_Left,          XK_ANY_MOD,     "\033OD",        0,   +1},
+	{ XK_Right,         ShiftMask,      "\033[1;2C",     0,    0},
+	{ XK_Right,         Mod1Mask,       "\033[1;3C",     0,    0},
+	{ XK_Right,      ShiftMask|Mod1Mask,"\033[1;4C",     0,    0},
+	{ XK_Right,         ControlMask,    "\033[1;5C",     0,    0},
+	{ XK_Right,   ShiftMask|ControlMask,"\033[1;6C",     0,    0},
+	{ XK_Right,    ControlMask|Mod1Mask,"\033[1;7C",     0,    0},
+	{ XK_Right,ShiftMask|ControlMask|Mod1Mask,"\033[1;8C",0,   0},
+	{ XK_Right,         XK_ANY_MOD,     "\033[C",        0,   -1},
+	{ XK_Right,         XK_ANY_MOD,     "\033OC",        0,   +1},
+	{ XK_ISO_Left_Tab,  ShiftMask,      "\033[Z",        0,    0},
+	{ XK_Return,        Mod1Mask,       "\033\r",        0,    0},
+	{ XK_Return,        XK_ANY_MOD,     "\r",            0,    0},
+	{ XK_Insert,        ShiftMask,      "\033[4l",      -1,    0},
+	{ XK_Insert,        ShiftMask,      "\033[2;2~",    +1,    0},
+	{ XK_Insert,        ControlMask,    "\033[L",       -1,    0},
+	{ XK_Insert,        ControlMask,    "\033[2;5~",    +1,    0},
+	{ XK_Insert,        XK_ANY_MOD,     "\033[4h",      -1,    0},
+	{ XK_Insert,        XK_ANY_MOD,     "\033[2~",      +1,    0},
+	{ XK_Delete,        ControlMask,    "\033[M",       -1,    0},
+	{ XK_Delete,        ControlMask,    "\033[3;5~",    +1,    0},
+	{ XK_Delete,        ShiftMask,      "\033[2K",      -1,    0},
+	{ XK_Delete,        ShiftMask,      "\033[3;2~",    +1,    0},
+	{ XK_Delete,        XK_ANY_MOD,     "\033[P",       -1,    0},
+	{ XK_Delete,        XK_ANY_MOD,     "\033[3~",      +1,    0},
+	{ XK_BackSpace,     XK_NO_MOD,      "\177",          0,    0},
+	{ XK_BackSpace,     Mod1Mask,       "\033\177",      0,    0},
+	{ XK_Home,          ShiftMask,      "\033[2J",       0,   -1},
+	{ XK_Home,          ShiftMask,      "\033[1;2H",     0,   +1},
+	{ XK_Home,          XK_ANY_MOD,     "\033[H",        0,   -1},
+	{ XK_Home,          XK_ANY_MOD,     "\033[1~",       0,   +1},
+	{ XK_End,           ControlMask,    "\033[J",       -1,    0},
+	{ XK_End,           ControlMask,    "\033[1;5F",    +1,    0},
+	{ XK_End,           ShiftMask,      "\033[K",       -1,    0},
+	{ XK_End,           ShiftMask,      "\033[1;2F",    +1,    0},
+	{ XK_End,           XK_ANY_MOD,     "\033[4~",       0,    0},
+	{ XK_Prior,         ControlMask,    "\033[5;5~",     0,    0},
+	{ XK_Prior,         ShiftMask,      "\033[5;2~",     0,    0},
+	{ XK_Prior,         XK_ANY_MOD,     "\033[5~",       0,    0},
+	{ XK_Next,          ControlMask,    "\033[6;5~",     0,    0},
+	{ XK_Next,          ShiftMask,      "\033[6;2~",     0,    0},
+	{ XK_Next,          XK_ANY_MOD,     "\033[6~",       0,    0},
+	{ XK_F1,            XK_NO_MOD,      "\033OP" ,       0,    0},
+	{ XK_F1, /* F13 */  ShiftMask,      "\033[1;2P",     0,    0},
+	{ XK_F1, /* F25 */  ControlMask,    "\033[1;5P",     0,    0},
+	{ XK_F1, /* F37 */  Mod4Mask,       "\033[1;6P",     0,    0},
+	{ XK_F1, /* F49 */  Mod1Mask,       "\033[1;3P",     0,    0},
+	{ XK_F1, /* F61 */  Mod3Mask,       "\033[1;4P",     0,    0},
+	{ XK_F2,            XK_NO_MOD,      "\033OQ" ,       0,    0},
+	{ XK_F2, /* F14 */  ShiftMask,      "\033[1;2Q",     0,    0},
+	{ XK_F2, /* F26 */  ControlMask,    "\033[1;5Q",     0,    0},
+	{ XK_F2, /* F38 */  Mod4Mask,       "\033[1;6Q",     0,    0},
+	{ XK_F2, /* F50 */  Mod1Mask,       "\033[1;3Q",     0,    0},
+	{ XK_F2, /* F62 */  Mod3Mask,       "\033[1;4Q",     0,    0},
+	{ XK_F3,            XK_NO_MOD,      "\033OR" ,       0,    0},
+	{ XK_F3, /* F15 */  ShiftMask,      "\033[1;2R",     0,    0},
+	{ XK_F3, /* F27 */  ControlMask,    "\033[1;5R",     0,    0},
+	{ XK_F3, /* F39 */  Mod4Mask,       "\033[1;6R",     0,    0},
+	{ XK_F3, /* F51 */  Mod1Mask,       "\033[1;3R",     0,    0},
+	{ XK_F3, /* F63 */  Mod3Mask,       "\033[1;4R",     0,    0},
+	{ XK_F4,            XK_NO_MOD,      "\033OS" ,       0,    0},
+	{ XK_F4, /* F16 */  ShiftMask,      "\033[1;2S",     0,    0},
+	{ XK_F4, /* F28 */  ControlMask,    "\033[1;5S",     0,    0},
+	{ XK_F4, /* F40 */  Mod4Mask,       "\033[1;6S",     0,    0},
+	{ XK_F4, /* F52 */  Mod1Mask,       "\033[1;3S",     0,    0},
+	{ XK_F5,            XK_NO_MOD,      "\033[15~",      0,    0},
+	{ XK_F5, /* F17 */  ShiftMask,      "\033[15;2~",    0,    0},
+	{ XK_F5, /* F29 */  ControlMask,    "\033[15;5~",    0,    0},
+	{ XK_F5, /* F41 */  Mod4Mask,       "\033[15;6~",    0,    0},
+	{ XK_F5, /* F53 */  Mod1Mask,       "\033[15;3~",    0,    0},
+	{ XK_F6,            XK_NO_MOD,      "\033[17~",      0,    0},
+	{ XK_F6, /* F18 */  ShiftMask,      "\033[17;2~",    0,    0},
+	{ XK_F6, /* F30 */  ControlMask,    "\033[17;5~",    0,    0},
+	{ XK_F6, /* F42 */  Mod4Mask,       "\033[17;6~",    0,    0},
+	{ XK_F6, /* F54 */  Mod1Mask,       "\033[17;3~",    0,    0},
+	{ XK_F7,            XK_NO_MOD,      "\033[18~",      0,    0},
+	{ XK_F7, /* F19 */  ShiftMask,      "\033[18;2~",    0,    0},
+	{ XK_F7, /* F31 */  ControlMask,    "\033[18;5~",    0,    0},
+	{ XK_F7, /* F43 */  Mod4Mask,       "\033[18;6~",    0,    0},
+	{ XK_F7, /* F55 */  Mod1Mask,       "\033[18;3~",    0,    0},
+	{ XK_F8,            XK_NO_MOD,      "\033[19~",      0,    0},
+	{ XK_F8, /* F20 */  ShiftMask,      "\033[19;2~",    0,    0},
+	{ XK_F8, /* F32 */  ControlMask,    "\033[19;5~",    0,    0},
+	{ XK_F8, /* F44 */  Mod4Mask,       "\033[19;6~",    0,    0},
+	{ XK_F8, /* F56 */  Mod1Mask,       "\033[19;3~",    0,    0},
+	{ XK_F9,            XK_NO_MOD,      "\033[20~",      0,    0},
+	{ XK_F9, /* F21 */  ShiftMask,      "\033[20;2~",    0,    0},
+	{ XK_F9, /* F33 */  ControlMask,    "\033[20;5~",    0,    0},
+	{ XK_F9, /* F45 */  Mod4Mask,       "\033[20;6~",    0,    0},
+	{ XK_F9, /* F57 */  Mod1Mask,       "\033[20;3~",    0,    0},
+	{ XK_F10,           XK_NO_MOD,      "\033[21~",      0,    0},
+	{ XK_F10, /* F22 */ ShiftMask,      "\033[21;2~",    0,    0},
+	{ XK_F10, /* F34 */ ControlMask,    "\033[21;5~",    0,    0},
+	{ XK_F10, /* F46 */ Mod4Mask,       "\033[21;6~",    0,    0},
+	{ XK_F10, /* F58 */ Mod1Mask,       "\033[21;3~",    0,    0},
+	{ XK_F11,           XK_NO_MOD,      "\033[23~",      0,    0},
+	{ XK_F11, /* F23 */ ShiftMask,      "\033[23;2~",    0,    0},
+	{ XK_F11, /* F35 */ ControlMask,    "\033[23;5~",    0,    0},
+	{ XK_F11, /* F47 */ Mod4Mask,       "\033[23;6~",    0,    0},
+	{ XK_F11, /* F59 */ Mod1Mask,       "\033[23;3~",    0,    0},
+	{ XK_F12,           XK_NO_MOD,      "\033[24~",      0,    0},
+	{ XK_F12, /* F24 */ ShiftMask,      "\033[24;2~",    0,    0},
+	{ XK_F12, /* F36 */ ControlMask,    "\033[24;5~",    0,    0},
+	{ XK_F12, /* F48 */ Mod4Mask,       "\033[24;6~",    0,    0},
+	{ XK_F12, /* F60 */ Mod1Mask,       "\033[24;3~",    0,    0},
+	{ XK_F13,           XK_NO_MOD,      "\033[1;2P",     0,    0},
+	{ XK_F14,           XK_NO_MOD,      "\033[1;2Q",     0,    0},
+	{ XK_F15,           XK_NO_MOD,      "\033[1;2R",     0,    0},
+	{ XK_F16,           XK_NO_MOD,      "\033[1;2S",     0,    0},
+	{ XK_F17,           XK_NO_MOD,      "\033[15;2~",    0,    0},
+	{ XK_F18,           XK_NO_MOD,      "\033[17;2~",    0,    0},
+	{ XK_F19,           XK_NO_MOD,      "\033[18;2~",    0,    0},
+	{ XK_F20,           XK_NO_MOD,      "\033[19;2~",    0,    0},
+	{ XK_F21,           XK_NO_MOD,      "\033[20;2~",    0,    0},
+	{ XK_F22,           XK_NO_MOD,      "\033[21;2~",    0,    0},
+	{ XK_F23,           XK_NO_MOD,      "\033[23;2~",    0,    0},
+	{ XK_F24,           XK_NO_MOD,      "\033[24;2~",    0,    0},
+	{ XK_F25,           XK_NO_MOD,      "\033[1;5P",     0,    0},
+	{ XK_F26,           XK_NO_MOD,      "\033[1;5Q",     0,    0},
+	{ XK_F27,           XK_NO_MOD,      "\033[1;5R",     0,    0},
+	{ XK_F28,           XK_NO_MOD,      "\033[1;5S",     0,    0},
+	{ XK_F29,           XK_NO_MOD,      "\033[15;5~",    0,    0},
+	{ XK_F30,           XK_NO_MOD,      "\033[17;5~",    0,    0},
+	{ XK_F31,           XK_NO_MOD,      "\033[18;5~",    0,    0},
+	{ XK_F32,           XK_NO_MOD,      "\033[19;5~",    0,    0},
+	{ XK_F33,           XK_NO_MOD,      "\033[20;5~",    0,    0},
+	{ XK_F34,           XK_NO_MOD,      "\033[21;5~",    0,    0},
+	{ XK_F35,           XK_NO_MOD,      "\033[23;5~",    0,    0},
+};
+
+/*
+ * Selection types' masks.
+ * Use the same masks as usual.
+ * Button1Mask is always unset, to make masks match between ButtonPress.
+ * ButtonRelease and MotionNotify.
+ * If no match is found, regular selection is used.
+ */
+static uint selmasks[] = {
+	[SEL_RECTANGULAR] = Mod1Mask,
+};
+
+/*
+ * Printable characters in ASCII, used to estimate the advance width
+ * of single wide characters.
+ */
+static char ascii_printable[] =
+	" !\"#$%&'()*+,-./0123456789:;<=>?"
+	"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
+	"`abcdefghijklmnopqrstuvwxyz{|}~";
--- a/_saved/_suckless/st/config.mk
+++ b/_saved/_suckless/st/config.mk
@ -0,0 +1,36 @@
+# st version
+VERSION = 0.9
+
+# Customize below to fit your system
+
+# paths
+PREFIX = /usr/local
+MANPREFIX = $(PREFIX)/share/man
+
+X11INC = /usr/X11R6/include
+X11LIB = /usr/X11R6/lib
+
+PKG_CONFIG = pkg-config
+
+# includes and libs
+INCS = -I$(X11INC) \
+       `$(PKG_CONFIG) --cflags fontconfig` \
+       `$(PKG_CONFIG) --cflags freetype2`
+LIBS = -L$(X11LIB) -lm -lrt -lX11 -lutil -lXft \
+       `$(PKG_CONFIG) --libs fontconfig` \
+       `$(PKG_CONFIG) --libs freetype2`
+
+# flags
+STCPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600
+STCFLAGS = $(INCS) $(STCPPFLAGS) $(CPPFLAGS) $(CFLAGS)
+STLDFLAGS = $(LIBS) $(LDFLAGS)
+
+# OpenBSD:
+#CPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600 -D_BSD_SOURCE
+#LIBS = -L$(X11LIB) -lm -lX11 -lutil -lXft \
+#       `$(PKG_CONFIG) --libs fontconfig` \
+#       `$(PKG_CONFIG) --libs freetype2`
+#MANPREFIX = ${PREFIX}/man
+
+# compiler and linker
+# CC = c99
--- a/_saved/_suckless/st/st.1
+++ b/_saved/_suckless/st/st.1
@ -0,0 +1,177 @@
+.TH ST 1 st\-VERSION
+.SH NAME
+st \- simple terminal
+.SH SYNOPSIS
+.B st
+.RB [ \-aiv ]
+.RB [ \-c
+.IR class ]
+.RB [ \-f
+.IR font ]
+.RB [ \-g
+.IR geometry ]
+.RB [ \-n
+.IR name ]
+.RB [ \-o
+.IR iofile ]
+.RB [ \-T
+.IR title ]
+.RB [ \-t
+.IR title ]
+.RB [ \-l
+.IR line ]
+.RB [ \-w
+.IR windowid ]
+.RB [[ \-e ]
+.IR command
+.RI [ arguments ...]]
+.PP
+.B st
+.RB [ \-aiv ]
+.RB [ \-c
+.IR class ]
+.RB [ \-f
+.IR font ]
+.RB [ \-g
+.IR geometry ]
+.RB [ \-n
+.IR name ]
+.RB [ \-o
+.IR iofile ]
+.RB [ \-T
+.IR title ]
+.RB [ \-t
+.IR title ]
+.RB [ \-w
+.IR windowid ]
+.RB \-l
+.IR line
+.RI [ stty_args ...]
+.SH DESCRIPTION
+.B st
+is a simple terminal emulator.
+.SH OPTIONS
+.TP
+.B \-a
+disable alternate screens in terminal
+.TP
+.BI \-c " class"
+defines the window class (default $TERM).
+.TP
+.BI \-f " font"
+defines the
+.I font
+to use when st is run.
+.TP
+.BI \-g " geometry"
+defines the X11 geometry string.
+The form is [=][<cols>{xX}<rows>][{+-}<xoffset>{+-}<yoffset>]. See
+.BR XParseGeometry (3)
+for further details.
+.TP
+.B \-i
+will fixate the position given with the -g option.
+.TP
+.BI \-n " name"
+defines the window instance name (default $TERM).
+.TP
+.BI \-o " iofile"
+writes all the I/O to
+.I iofile.
+This feature is useful when recording st sessions. A value of "-" means
+standard output.
+.TP
+.BI \-T " title"
+defines the window title (default 'st').
+.TP
+.BI \-t " title"
+defines the window title (default 'st').
+.TP
+.BI \-w " windowid"
+embeds st within the window identified by
+.I windowid
+.TP
+.BI \-l " line"
+use a tty
+.I line
+instead of a pseudo terminal.
+.I line
+should be a (pseudo-)serial device (e.g. /dev/ttyS0 on Linux for serial port
+0).
+When this flag is given
+remaining arguments are used as flags for
+.BR stty(1).
+By default st initializes the serial line to 8 bits, no parity, 1 stop bit
+and a 38400 baud rate. The speed is set by appending it as last argument
+(e.g. 'st -l /dev/ttyS0 115200'). Arguments before the last one are
+.BR stty(1)
+flags. If you want to set odd parity on 115200 baud use for example 'st -l
+/dev/ttyS0 parenb parodd 115200'. Set the number of bits by using for
+example 'st -l /dev/ttyS0 cs7 115200'. See
+.BR stty(1)
+for more arguments and cases.
+.TP
+.B \-v
+prints version information to stderr, then exits.
+.TP
+.BI \-e " command " [ " arguments " "... ]"
+st executes
+.I command
+instead of the shell.  If this is used it
+.B must be the last option
+on the command line, as in xterm / rxvt.
+This option is only intended for compatibility,
+and all the remaining arguments are used as a command
+even without it.
+.SH SHORTCUTS
+.TP
+.B Break
+Send a break in the serial line.
+Break key is obtained in PC keyboards
+pressing at the same time control and pause.
+.TP
+.B Ctrl-Print Screen
+Toggle if st should print to the
+.I iofile.
+.TP
+.B Shift-Print Screen
+Print the full screen to the
+.I iofile.
+.TP
+.B Print Screen
+Print the selection to the
+.I iofile.
+.TP
+.B Ctrl-Shift-Page Up
+Increase font size.
+.TP
+.B Ctrl-Shift-Page Down
+Decrease font size.
+.TP
+.B Ctrl-Shift-Home
+Reset to default font size.
+.TP
+.B Ctrl-Shift-y
+Paste from primary selection (middle mouse button).
+.TP
+.B Ctrl-Shift-c
+Copy the selected text to the clipboard selection.
+.TP
+.B Ctrl-Shift-v
+Paste from the clipboard selection.
+.SH CUSTOMIZATION
+.B st
+can be customized by creating a custom config.h and (re)compiling the source
+code. This keeps it fast, secure and simple.
+.SH AUTHORS
+See the LICENSE file for the authors.
+.SH LICENSE
+See the LICENSE file for the terms of redistribution.
+.SH SEE ALSO
+.BR tabbed (1),
+.BR utmp (1),
+.BR stty (1),
+.BR scroll (1)
+.SH BUGS
+See the TODO file in the distribution.
+
--- a/_saved/_suckless/st/st.c
+++ b/_saved/_suckless/st/st.c
--- a/_saved/_suckless/st/st.h
+++ b/_saved/_suckless/st/st.h
@ -0,0 +1,135 @@
+/* See LICENSE for license details. */
+
+#include <stdint.h>
+#include <sys/types.h>
+
+/* macros */
+#define MIN(a, b)		((a) < (b) ? (a) : (b))
+#define MAX(a, b)		((a) < (b) ? (b) : (a))
+#define LEN(a)			(sizeof(a) / sizeof(a)[0])
+#define BETWEEN(x, a, b)	((a) <= (x) && (x) <= (b))
+#define DIVCEIL(n, d)		(((n) + ((d) - 1)) / (d))
+#define DEFAULT(a, b)		(a) = (a) ? (a) : (b)
+#define LIMIT(x, a, b)		(x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x)
+#define ATTRCMP(a, b)		((a).mode != (b).mode || (a).fg != (b).fg || \
+				(a).bg != (b).bg)
+#define TIMEDIFF(t1, t2)	((t1.tv_sec-t2.tv_sec)*1000 + \
+				(t1.tv_nsec-t2.tv_nsec)/1E6)
+#define MODBIT(x, set, bit)	((set) ? ((x) |= (bit)) : ((x) &= ~(bit)))
+
+#define TRUECOLOR(r,g,b)	(1 << 24 | (r) << 16 | (g) << 8 | (b))
+#define IS_TRUECOL(x)		(1 << 24 & (x))
+
+enum glyph_attribute {
+	ATTR_NULL       = 0,
+	ATTR_BOLD       = 1 << 0,
+	ATTR_FAINT      = 1 << 1,
+	ATTR_ITALIC     = 1 << 2,
+	ATTR_UNDERLINE  = 1 << 3,
+	ATTR_BLINK      = 1 << 4,
+	ATTR_REVERSE    = 1 << 5,
+	ATTR_INVISIBLE  = 1 << 6,
+	ATTR_STRUCK     = 1 << 7,
+	ATTR_WRAP       = 1 << 8,
+	ATTR_WIDE       = 1 << 9,
+	ATTR_WDUMMY     = 1 << 10,
+	ATTR_BOLD_FAINT = ATTR_BOLD | ATTR_FAINT,
+};
+
+enum drawing_mode {
+    DRAW_NONE = 0,
+    DRAW_BG = 1 << 0,
+    DRAW_FG = 1 << 1,
+};
+
+enum selection_mode {
+	SEL_IDLE = 0,
+	SEL_EMPTY = 1,
+	SEL_READY = 2
+};
+
+enum selection_type {
+	SEL_REGULAR = 1,
+	SEL_RECTANGULAR = 2
+};
+
+enum selection_snap {
+	SNAP_WORD = 1,
+	SNAP_LINE = 2
+};
+
+typedef unsigned char uchar;
+typedef unsigned int uint;
+typedef unsigned long ulong;
+typedef unsigned short ushort;
+
+typedef uint_least32_t Rune;
+
+#define Glyph Glyph_
+typedef struct {
+	Rune u;           /* character code */
+	ushort mode;      /* attribute flags */
+	uint32_t fg;      /* foreground  */
+	uint32_t bg;      /* background  */
+} Glyph;
+
+typedef Glyph *Line;
+
+typedef union {
+	int i;
+	uint ui;
+	float f;
+	const void *v;
+	const char *s;
+} Arg;
+
+void die(const char *, ...);
+void redraw(void);
+void draw(void);
+
+void kscrolldown(const Arg *);
+void kscrollup(const Arg *);
+void externalpipe(const Arg *);
+void printscreen(const Arg *);
+void printsel(const Arg *);
+void sendbreak(const Arg *);
+void toggleprinter(const Arg *);
+
+int tattrset(int);
+void tnew(int, int);
+void tresize(int, int);
+void tsetdirtattr(int);
+void ttyhangup(void);
+int ttynew(const char *, char *, const char *, char **);
+size_t ttyread(void);
+void ttyresize(int, int);
+void ttywrite(const char *, size_t, int);
+
+void resettitle(void);
+
+void selclear(void);
+void selinit(void);
+void selstart(int, int, int);
+void selextend(int, int, int, int);
+int selected(int, int);
+char *getsel(void);
+
+size_t utf8encode(Rune, char *);
+
+void *xmalloc(size_t);
+void *xrealloc(void *, size_t);
+char *xstrdup(const char *);
+
+/* config.h globals */
+extern char *utmp;
+extern char *scroll;
+extern char *stty_args;
+extern char *vtiden;
+extern wchar_t *worddelimiters;
+extern int allowaltscreen;
+extern int allowwindowops;
+extern char *termname;
+extern unsigned int tabspaces;
+extern unsigned int defaultfg;
+extern unsigned int defaultbg;
+extern unsigned int defaultcs;
--- a/_saved/_suckless/st/st.info
+++ b/_saved/_suckless/st/st.info
@ -0,0 +1,239 @@
+st-mono| simpleterm monocolor,
+	acsc=+C\,D-A.B0E``aaffgghFiGjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,
+	am,
+	bce,
+	bel=^G,
+	blink=\E[5m,
+	bold=\E[1m,
+	cbt=\E[Z,
+	cvvis=\E[?25h,
+	civis=\E[?25l,
+	clear=\E[H\E[2J,
+	cnorm=\E[?12l\E[?25h,
+	colors#2,
+	cols#80,
+	cr=^M,
+	csr=\E[%i%p1%d;%p2%dr,
+	cub=\E[%p1%dD,
+	cub1=^H,
+	cud1=^J,
+	cud=\E[%p1%dB,
+	cuf1=\E[C,
+	cuf=\E[%p1%dC,
+	cup=\E[%i%p1%d;%p2%dH,
+	cuu1=\E[A,
+	cuu=\E[%p1%dA,
+	dch=\E[%p1%dP,
+	dch1=\E[P,
+	dim=\E[2m,
+	dl=\E[%p1%dM,
+	dl1=\E[M,
+	ech=\E[%p1%dX,
+	ed=\E[J,
+	el=\E[K,
+	el1=\E[1K,
+	enacs=\E)0,
+	flash=\E[?5h$<80/>\E[?5l,
+	fsl=^G,
+	home=\E[H,
+	hpa=\E[%i%p1%dG,
+	hs,
+	ht=^I,
+	hts=\EH,
+	ich=\E[%p1%d@,
+	il1=\E[L,
+	il=\E[%p1%dL,
+	ind=^J,
+	indn=\E[%p1%dS,
+	invis=\E[8m,
+	is2=\E[4l\E>\E[?1034l,
+	it#8,
+	kel=\E[1;2F,
+	ked=\E[1;5F,
+	ka1=\E[1~,
+	ka3=\E[5~,
+	kc1=\E[4~,
+	kc3=\E[6~,
+	kbs=\177,
+	kcbt=\E[Z,
+	kb2=\EOu,
+	kcub1=\EOD,
+	kcud1=\EOB,
+	kcuf1=\EOC,
+	kcuu1=\EOA,
+	kDC=\E[3;2~,
+	kent=\EOM,
+	kEND=\E[1;2F,
+	kIC=\E[2;2~,
+	kNXT=\E[6;2~,
+	kPRV=\E[5;2~,
+	kHOM=\E[1;2H,
+	kLFT=\E[1;2D,
+	kRIT=\E[1;2C,
+	kind=\E[1;2B,
+	kri=\E[1;2A,
+	kclr=\E[3;5~,
+	kdl1=\E[3;2~,
+	kdch1=\E[3~,
+	kich1=\E[2~,
+	kend=\E[4~,
+	kf1=\EOP,
+	kf2=\EOQ,
+	kf3=\EOR,
+	kf4=\EOS,
+	kf5=\E[15~,
+	kf6=\E[17~,
+	kf7=\E[18~,
+	kf8=\E[19~,
+	kf9=\E[20~,
+	kf10=\E[21~,
+	kf11=\E[23~,
+	kf12=\E[24~,
+	kf13=\E[1;2P,
+	kf14=\E[1;2Q,
+	kf15=\E[1;2R,
+	kf16=\E[1;2S,
+	kf17=\E[15;2~,
+	kf18=\E[17;2~,
+	kf19=\E[18;2~,
+	kf20=\E[19;2~,
+	kf21=\E[20;2~,
+	kf22=\E[21;2~,
+	kf23=\E[23;2~,
+	kf24=\E[24;2~,
+	kf25=\E[1;5P,
+	kf26=\E[1;5Q,
+	kf27=\E[1;5R,
+	kf28=\E[1;5S,
+	kf29=\E[15;5~,
+	kf30=\E[17;5~,
+	kf31=\E[18;5~,
+	kf32=\E[19;5~,
+	kf33=\E[20;5~,
+	kf34=\E[21;5~,
+	kf35=\E[23;5~,
+	kf36=\E[24;5~,
+	kf37=\E[1;6P,
+	kf38=\E[1;6Q,
+	kf39=\E[1;6R,
+	kf40=\E[1;6S,
+	kf41=\E[15;6~,
+	kf42=\E[17;6~,
+	kf43=\E[18;6~,
+	kf44=\E[19;6~,
+	kf45=\E[20;6~,
+	kf46=\E[21;6~,
+	kf47=\E[23;6~,
+	kf48=\E[24;6~,
+	kf49=\E[1;3P,
+	kf50=\E[1;3Q,
+	kf51=\E[1;3R,
+	kf52=\E[1;3S,
+	kf53=\E[15;3~,
+	kf54=\E[17;3~,
+	kf55=\E[18;3~,
+	kf56=\E[19;3~,
+	kf57=\E[20;3~,
+	kf58=\E[21;3~,
+	kf59=\E[23;3~,
+	kf60=\E[24;3~,
+	kf61=\E[1;4P,
+	kf62=\E[1;4Q,
+	kf63=\E[1;4R,
+	khome=\E[1~,
+	kil1=\E[2;5~,
+	krmir=\E[2;2~,
+	knp=\E[6~,
+	kmous=\E[M,
+	kpp=\E[5~,
+	lines#24,
+	mir,
+	msgr,
+	npc,
+	op=\E[39;49m,
+	pairs#64,
+	mc0=\E[i,
+	mc4=\E[4i,
+	mc5=\E[5i,
+	rc=\E8,
+	rev=\E[7m,
+	ri=\EM,
+	rin=\E[%p1%dT,
+	ritm=\E[23m,
+	rmacs=\E(B,
+	rmcup=\E[?1049l,
+	rmir=\E[4l,
+	rmkx=\E[?1l\E>,
+	rmso=\E[27m,
+	rmul=\E[24m,
+	rs1=\Ec,
+	rs2=\E[4l\E>\E[?1034l,
+	sc=\E7,
+	sitm=\E[3m,
+	sgr0=\E[0m,
+	smacs=\E(0,
+	smcup=\E[?1049h,
+	smir=\E[4h,
+	smkx=\E[?1h\E=,
+	smso=\E[7m,
+	smul=\E[4m,
+	tbc=\E[3g,
+	tsl=\E]0;,
+	xenl,
+	vpa=\E[%i%p1%dd,
+# XTerm extensions
+	rmxx=\E[29m,
+	smxx=\E[9m,
+# disabled rep for now: causes some issues with older ncurses versions.
+#	rep=%p1%c\E[%p2%{1}%-%db,
+# tmux extensions, see TERMINFO EXTENSIONS in tmux(1)
+	Tc,
+	Ms=\E]52;%p1%s;%p2%s\007,
+	Se=\E[2 q,
+	Ss=\E[%p1%d q,
+
+st| simpleterm,
+	use=st-mono,
+	colors#8,
+	setab=\E[4%p1%dm,
+	setaf=\E[3%p1%dm,
+	setb=\E[4%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m,
+	setf=\E[3%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m,
+	sgr=%?%p9%t\E(0%e\E(B%;\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m,
+
+st-256color| simpleterm with 256 colors,
+	use=st,
+	ccc,
+	colors#256,
+	oc=\E]104\007,
+	pairs#32767,
+#	Nicked from xterm-256color
+	initc=\E]4;%p1%d;rgb\:%p2%{255}%*%{1000}%/%2.2X/%p3%{255}%*%{1000}%/%2.2X/%p4%{255}%*%{1000}%/%2.2X\E\\,
+	setab=\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m,
+	setaf=\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m,
+
+st-meta| simpleterm with meta key,
+	use=st,
+	km,
+	rmm=\E[?1034l,
+	smm=\E[?1034h,
+	rs2=\E[4l\E>\E[?1034h,
+	is2=\E[4l\E>\E[?1034h,
+
+st-meta-256color| simpleterm with meta key and 256 colors,
+	use=st-256color,
+	km,
+	rmm=\E[?1034l,
+	smm=\E[?1034h,
+	rs2=\E[4l\E>\E[?1034h,
+	is2=\E[4l\E>\E[?1034h,
+
+st-bs| simpleterm with backspace as backspace,
+	use=st,
+	kbs=\010,
+	kdch1=\177,
+
+st-bs-256color| simpleterm with backspace as backspace and 256colors,
+	use=st-256color,
+	kbs=\010,
+	kdch1=\177,
--- a/_saved/_suckless/st/win.h
+++ b/_saved/_suckless/st/win.h
@ -0,0 +1,41 @@
+/* See LICENSE for license details. */
+
+enum win_mode {
+	MODE_VISIBLE     = 1 << 0,
+	MODE_FOCUSED     = 1 << 1,
+	MODE_APPKEYPAD   = 1 << 2,
+	MODE_MOUSEBTN    = 1 << 3,
+	MODE_MOUSEMOTION = 1 << 4,
+	MODE_REVERSE     = 1 << 5,
+	MODE_KBDLOCK     = 1 << 6,
+	MODE_HIDE        = 1 << 7,
+	MODE_APPCURSOR   = 1 << 8,
+	MODE_MOUSESGR    = 1 << 9,
+	MODE_8BIT        = 1 << 10,
+	MODE_BLINK       = 1 << 11,
+	MODE_FBLINK      = 1 << 12,
+	MODE_FOCUS       = 1 << 13,
+	MODE_MOUSEX10    = 1 << 14,
+	MODE_MOUSEMANY   = 1 << 15,
+	MODE_BRCKTPASTE  = 1 << 16,
+	MODE_NUMLOCK     = 1 << 17,
+	MODE_MOUSE       = MODE_MOUSEBTN|MODE_MOUSEMOTION|MODE_MOUSEX10\
+	                  |MODE_MOUSEMANY,
+};
+
+void xbell(void);
+void xclipcopy(void);
+void xdrawcursor(int, int, Glyph, int, int, Glyph);
+void xdrawline(Line, int, int, int);
+void xfinishdraw(void);
+void xloadcols(void);
+int xsetcolorname(int, const char *);
+int xgetcolor(int, unsigned char *, unsigned char *, unsigned char *);
+void xseticontitle(char *);
+void xsettitle(char *);
+int xsetcursor(int);
+void xsetmode(int, unsigned int);
+void xsetpointermotion(int);
+void xsetsel(char *);
+int xstartdraw(void);
+void xximspot(int, int);
--- a/_saved/_suckless/st/x.c
+++ b/_saved/_suckless/st/x.c
--- a/_saved/autorandr/home-dp0/config
+++ b/_saved/autorandr/home-dp0/config
@ -0,0 +1,20 @@
+output HDMI-A-0
+off
+output DisplayPort-1
+off
+output eDP
+off
+output DisplayPort-0
+crtc 1
+filter bilinear
+mode 3840x2160
+pos 0x0
+rate 60.00
+transform 0.699997,0.000000,0.000000,0.000000,0.699997,0.000000,0.000000,0.000000,1.000000
+x-prop-max_bpc 8
+x-prop-non_desktop 0
+x-prop-scaling_mode None
+x-prop-tearfree on
+x-prop-underscan off
+x-prop-underscan_hborder 0
+x-prop-underscan_vborder 0
--- a/_saved/autorandr/home-dp0/setup
+++ b/_saved/autorandr/home-dp0/setup
@ -0,0 +1,2 @@
+DisplayPort-0 00ffffffffffff001e6d0777dadb04000c1d0104b53c22789e3e31ae5047ac270c50542108007140818081c0a9c0d1c08100010101014dd000a0f0703e803020650c58542100001a286800a0f0703e800890650c58542100001a000000fd00383d1e8738000a202020202020000000fc004c472048445220344b0a20202001aa0203197144900403012309070783010000e305c000e3060501023a801871382d40582c450058542100001e565e00a0a0a029503020350058542100001a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029
+eDP 00ffffffffffff0006af3d5700000000001c0104a51f1178022285a5544d9a270e505400000001010101010101010101010101010101b43780a070383e401010350035ae100000180000000f0000000000000000000000000020000000fe0041554f0a202020202020202020000000fe004231343048414e30352e37200a0070
--- a/_saved/autorandr/home-dp1/config
+++ b/_saved/autorandr/home-dp1/config
@ -0,0 +1,20 @@
+output HDMI-A-0
+off
+output DisplayPort-0
+off
+output eDP
+off
+output DisplayPort-1
+crtc 1
+filter bilinear
+mode 3840x2160
+pos 0x0
+rate 60.00
+transform 0.699997,0.000000,0.000000,0.000000,0.699997,0.000000,0.000000,0.000000,1.000000
+x-prop-max_bpc 8
+x-prop-non_desktop 0
+x-prop-scaling_mode None
+x-prop-tearfree on
+x-prop-underscan off
+x-prop-underscan_hborder 0
+x-prop-underscan_vborder 0
--- a/_saved/autorandr/home-dp1/setup
+++ b/_saved/autorandr/home-dp1/setup
@ -0,0 +1,2 @@
+DisplayPort-1 00ffffffffffff001e6d0777dadb04000c1d0104b53c22789e3e31ae5047ac270c50542108007140818081c0a9c0d1c08100010101014dd000a0f0703e803020650c58542100001a286800a0f0703e800890650c58542100001a000000fd00383d1e8738000a202020202020000000fc004c472048445220344b0a20202001aa0203197144900403012309070783010000e305c000e3060501023a801871382d40582c450058542100001e565e00a0a0a029503020350058542100001a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029
+eDP 00ffffffffffff0006af3d5700000000001c0104a51f1178022285a5544d9a270e505400000001010101010101010101010101010101b43780a070383e401010350035ae100000180000000f0000000000000000000000000020000000fe0041554f0a202020202020202020000000fe004231343048414e30352e37200a0070
--- a/_saved/autorandr/nomad/config
+++ b/_saved/autorandr/nomad/config
@ -0,0 +1,20 @@
+output HDMI-A-0
+off
+output DisplayPort-0
+off
+output DisplayPort-1
+off
+output eDP
+crtc 0
+gamma 1.0:0.833:0.714
+mode 1920x1080
+pos 0x0
+primary
+rate 60.03
+x-prop-max_bpc 8
+x-prop-non_desktop 0
+x-prop-scaling_mode None
+x-prop-tearfree on
+x-prop-underscan off
+x-prop-underscan_hborder 0
+x-prop-underscan_vborder 0
--- a/_saved/autorandr/nomad/setup
+++ b/_saved/autorandr/nomad/setup
@ -0,0 +1 @@
+eDP 00ffffffffffff0006af3d5700000000001c0104a51f1178022285a5544d9a270e505400000001010101010101010101010101010101b43780a070383e401010350035ae100000180000000f0000000000000000000000000020000000fe0041554f0a202020202020202020000000fe004231343048414e30352e37200a0070
--- a/_saved/clipit/clipitrc
+++ b/_saved/clipit/clipitrc
@ -0,0 +1,28 @@
+[rc]
+use_copy=true
+use_primary=true
+synchronize=true
+automatic_paste=false
+show_indexes=false
+save_uris=true
+use_rmb_menu=false
+save_history=false
+history_limit=50
+history_timeout_seconds=30
+history_timeout=false
+items_menu=20
+statics_show=true
+statics_items=10
+hyperlinks_only=false
+confirm_clear=false
+single_line=true
+reverse_history=false
+item_length=50
+ellipsize=2
+history_key=<Ctrl><Alt>H
+actions_key=<Ctrl><Alt>A
+menu_key=<Ctrl><Alt>P
+search_key=<Ctrl><Alt>F
+offline_key=<Ctrl><Alt>O
+offline_mode=false
+exclude_windows=
--- a/_saved/dunst/dunstrc
+++ b/_saved/dunst/dunstrc
@ -0,0 +1,470 @@
+[global]
+    ### Display ###
+
+    # Which monitor should the notifications be displayed on.
+    monitor = 0
+
+    # Display notification on focused monitor.  Possible modes are:
+    #   mouse: follow mouse pointer
+    #   keyboard: follow window with keyboard focus
+    #   none: don't follow anything
+    #
+    # "keyboard" needs a window manager that exports the
+    # _NET_ACTIVE_WINDOW property.
+    # This should be the case for almost all modern window managers.
+    #
+    # If this option is set to mouse or keyboard, the monitor option
+    # will be ignored.
+    follow = mouse
+
+    # The geometry of the window:
+    #   [{width}]x{height}[+/-{x}+/-{y}]
+    # The geometry of the message window.
+    # The height is measured in number of notifications everything else
+    # in pixels.  If the width is omitted but the height is given
+    # ("-geometry x2"), the message window expands over the whole screen
+    # (dmenu-like).  If width is 0, the window expands to the longest
+    # message displayed.  A positive x is measured from the left, a
+    # negative from the right side of the screen.  Y is measured from
+    # the top and down respectively.
+    # The width can be negative.  In this case the actual width is the
+    # screen width minus the width defined in within the geometry option.
+    geometry = "300x5-30+30"
+
+    # Turn on the progess bar
+    progress_bar = true
+
+    # Set the progress bar height. This includes the frame, so make sure
+    # it's at least twice as big as the frame width.
+    progress_bar_height = 10
+
+    # Set the frame width of the progress bar
+    progress_bar_frame_width = 1
+
+    # Set the minimum width for the progress bar
+    progress_bar_min_width = 150
+
+    # Set the maximum width for the progress bar
+    progress_bar_max_width = 300
+
+
+    # Show how many messages are currently hidden (because of geometry).
+    indicate_hidden = yes
+
+    # Shrink window if it's smaller than the width.  Will be ignored if
+    # width is 0.
+    shrink = no
+
+    # The transparency of the window.  Range: [0; 100].
+    # This option will only work if a compositing window manager is
+    # present (e.g. xcompmgr, compiz, etc.).
+    transparency = 20
+
+    # The height of the entire notification.  If the height is smaller
+    # than the font height and padding combined, it will be raised
+    # to the font height and padding.
+    notification_height = 0
+
+    # Draw a line of "separator_height" pixel height between two
+    # notifications.
+    # Set to 0 to disable.
+    separator_height = 2
+
+    # Padding between text and separator.
+    padding = 8
+
+    # Horizontal padding.
+    horizontal_padding = 8
+
+    # Padding between text and icon.
+    text_icon_padding = 0
+
+    # Defines width in pixels of frame around the notification window.
+    # Set to 0 to disable.
+    frame_width = 3
+
+    # Defines color of the frame around the notification window.
+    frame_color = "#aaaaaa"
+
+    # Define a color for the separator.
+    # possible values are:
+    #  * auto: dunst tries to find a color fitting to the background;
+    #  * foreground: use the same color as the foreground;
+    #  * frame: use the same color as the frame;
+    #  * anything else will be interpreted as a X color.
+    separator_color = frame
+
+    # Sort messages by urgency.
+    sort = yes
+
+    # Don't remove messages, if the user is idle (no mouse or keyboard input)
+    # for longer than idle_threshold seconds.
+    # Set to 0 to disable.
+    # A client can set the 'transient' hint to bypass this. See the rules
+    # section for how to disable this if necessary
+    idle_threshold = 120
+
+    ### Text ###
+
+    font = JetBrainsMono Nerd Font Mono 12
+
+    # The spacing between lines.  If the height is smaller than the
+    # font height, it will get raised to the font height.
+    line_height = 0
+
+    # Possible values are:
+    # full: Allow a small subset of html markup in notifications:
+    #        <b>bold</b>
+    #        <i>italic</i>
+    #        <s>strikethrough</s>
+    #        <u>underline</u>
+    #
+    #        For a complete reference see
+    #        <https://developer.gnome.org/pango/stable/pango-Markup.html>.
+    #
+    # strip: This setting is provided for compatibility with some broken
+    #        clients that send markup even though it's not enabled on the
+    #        server. Dunst will try to strip the markup but the parsing is
+    #        simplistic so using this option outside of matching rules for
+    #        specific applications *IS GREATLY DISCOURAGED*.
+    #
+    # no:    Disable markup parsing, incoming notifications will be treated as
+    #        plain text. Dunst will not advertise that it has the body-markup
+    #        capability if this is set as a global setting.
+    #
+    # It's important to note that markup inside the format option will be parsed
+    # regardless of what this is set to.
+    markup = full
+
+    # The format of the message.  Possible variables are:
+    #   %a  appname
+    #   %s  summary
+    #   %b  body
+    #   %i  iconname (including its path)
+    #   %I  iconname (without its path)
+    #   %p  progress value if set ([  0%] to [100%]) or nothing
+    #   %n  progress value if set without any extra characters
+    #   %%  Literal %
+    # Markup is allowed
+    format = "<b>%s</b>\n%b"
+
+    # Alignment of message text.
+    # Possible values are "left", "center" and "right".
+    alignment = left
+
+    # Vertical alignment of message text and icon.
+    # Possible values are "top", "center" and "bottom".
+    vertical_alignment = center
+
+    # Show age of message if message is older than show_age_threshold
+    # seconds.
+    # Set to -1 to disable.
+    show_age_threshold = 60
+
+    # Split notifications into multiple lines if they don't fit into
+    # geometry.
+    word_wrap = yes
+
+    # When word_wrap is set to no, specify where to make an ellipsis in long lines.
+    # Possible values are "start", "middle" and "end".
+    ellipsize = middle
+
+    # Ignore newlines '\n' in notifications.
+    ignore_newline = no
+
+    # Stack together notifications with the same content
+    stack_duplicates = true
+
+    # Hide the count of stacked notifications with the same content
+    hide_duplicate_count = false
+
+    # Display indicators for URLs (U) and actions (A).
+    show_indicators = yes
+
+    ### Icons ###
+
+    # Align icons left/right/off
+    icon_position = left
+
+    # Scale small icons up to this size, set to 0 to disable. Helpful
+    # for e.g. small files or high-dpi screens. In case of conflict,
+    # max_icon_size takes precedence over this.
+    min_icon_size = 0
+
+    # Scale larger icons down to this size, set to 0 to disable
+    max_icon_size = 32
+
+    # Paths to default icons.
+    icon_path = /usr/share/icons/gnome/16x16/status/:/usr/share/icons/gnome/16x16/devices/
+
+    ### History ###
+
+    # Should a notification popped up from history be sticky or timeout
+    # as if it would normally do.
+    sticky_history = yes
+
+    # Maximum amount of notifications kept in history
+    history_length = 20
+
+    ### Misc/Advanced ###
+
+    # dmenu path.
+    dmenu = /usr/bin/dmenu -p dunst:
+
+    # Browser for opening urls in context menu.
+    browser = xdg-open
+
+    # Always run rule-defined scripts, even if the notification is suppressed
+    always_run_script = true
+
+    # Define the title of the windows spawned by dunst
+    title = Dunst
+
+    # Define the class of the windows spawned by dunst
+    class = Dunst
+
+    # Print a notification on startup.
+    # This is mainly for error detection, since dbus (re-)starts dunst
+    # automatically after a crash.
+    startup_notification = false
+
+    # Manage dunst's desire for talking
+    # Can be one of the following values:
+    #  crit: Critical features. Dunst aborts
+    #  warn: Only non-fatal warnings
+    #  mesg: Important Messages
+    #  info: all unimportant stuff
+    # debug: all less than unimportant stuff
+    verbosity = mesg
+
+    # Define the corner radius of the notification window
+    # in pixel size. If the radius is 0, you have no rounded
+    # corners.
+    # The radius will be automatically lowered if it exceeds half of the
+    # notification height to avoid clipping text and/or icons.
+    corner_radius = 0
+
+    # Ignore the dbus closeNotification message.
+    # Useful to enforce the timeout set by dunst configuration. Without this
+    # parameter, an application may close the notification sent before the
+    # user defined timeout.
+    ignore_dbusclose = false
+
+    ### Wayland ###
+    # These settings are Wayland-specific. They have no effect when using X11
+
+    # Uncomment this if you want to let notications appear under fullscreen
+    # applications (default: overlay)
+    # layer = top
+
+    # Set this to true to use X11 output on Wayland.
+    force_xwayland = false
+
+    ### Legacy
+
+    # Use the Xinerama extension instead of RandR for multi-monitor support.
+    # This setting is provided for compatibility with older nVidia drivers that
+    # do not support RandR and using it on systems that support RandR is highly
+    # discouraged.
+    #
+    # By enabling this setting dunst will not be able to detect when a monitor
+    # is connected or disconnected which might break follow mode if the screen
+    # layout changes.
+    force_xinerama = false
+
+    ### mouse
+
+    # Defines list of actions for each mouse event
+    # Possible values are:
+    # * none: Don't do anything.
+    # * do_action: If the notification has exactly one action, or one is marked as default,
+    #              invoke it. If there are multiple and no default, open the context menu.
+    # * close_current: Close current notification.
+    # * close_all: Close all notifications.
+    # These values can be strung together for each mouse event, and
+    # will be executed in sequence.
+    mouse_left_click = close_current
+    mouse_middle_click = do_action, close_current
+    mouse_right_click = close_all
+
+# Experimental features that may or may not work correctly. Do not expect them
+# to have a consistent behaviour across releases.
+[experimental]
+    # Calculate the dpi to use on a per-monitor basis.
+    # If this setting is enabled the Xft.dpi value will be ignored and instead
+    # dunst will attempt to calculate an appropriate dpi value for each monitor
+    # using the resolution and physical size. This might be useful in setups
+    # where there are multiple screens with very different dpi values.
+    per_monitor_dpi = false
+
+# The internal keyboard shortcut support in dunst is now considered deprecated
+# and should be replaced by dunstctl calls. You can use the configuration of your
+# WM or DE to bind these to shortcuts of your choice.
+# Check the dunstctl manual page for more info.
+[shortcuts]
+
+    # Shortcuts are specified as [modifier+][modifier+]...key
+    # Available modifiers are "ctrl", "mod1" (the alt-key), "mod2",
+    # "mod3" and "mod4" (windows-key).
+    # Xev might be helpful to find names for keys.
+
+    # Close notification. Equivalent dunstctl command:
+    # dunstctl close
+    # close = ctrl+space
+
+    # Close all notifications. Equivalent dunstctl command:
+    # dunstctl close-all
+    # close_all = ctrl+shift+space
+
+    # Redisplay last message(s). Equivalent dunstctl command:
+    # dunstctl history-pop
+    # history = ctrl+grave
+
+    # Context menu. Equivalent dunstctl command:
+    # dunstctl context
+    # context = ctrl+shift+period
+
+[urgency_low]
+    # IMPORTANT: colors have to be defined in quotation marks.
+    # Otherwise the "#" and following would be interpreted as a comment.
+    background = "#272822"
+    foreground = "#c7c7c7"
+    highlight = "#c7c7c7"
+    frame_color = "#c7c7c7"
+    timeout = 1
+    # Icon for notifications with low urgency, uncomment to enable
+    #icon = /path/to/icon
+
+[urgency_normal]
+    background = "#272822"
+    foreground = "#feffff"
+    highlight = "#feffff"
+    frame_color = "#feffff"
+    timeout = 2
+    # Icon for notifications with normal urgency, uncomment to enable
+    #icon = /path/to/icon
+
+[urgency_critical]
+    background = "#ff3333"
+    foreground = "#feffff"
+    frame_color = "#feffff"
+    timeout = 2
+    # Icon for notifications with critical urgency, uncomment to enable
+    #icon = /path/to/icon
+
+# Every section that isn't one of the above is interpreted as a rules to
+# override settings for certain messages.
+#
+# Messages can be matched by
+#    appname (discouraged, see desktop_entry)
+#    body
+#    category
+#    desktop_entry
+#    icon
+#    match_transient
+#    msg_urgency
+#    stack_tag
+#    summary
+#
+# and you can override the
+#    background
+#    foreground
+#    format
+#    frame_color
+#    fullscreen
+#    new_icon
+#    set_stack_tag
+#    set_transient
+#    timeout
+#    urgency
+#
+# Shell-like globbing will get expanded.
+#
+# Instead of the appname filter, it's recommended to use the desktop_entry filter.
+# GLib based applications export their desktop-entry name. In comparison to the appname,
+# the desktop-entry won't get localized.
+#
+# SCRIPTING
+# You can specify a script that gets run when the rule matches by
+# setting the "script" option.
+# The script will be called as follows:
+#   script appname summary body icon urgency
+# where urgency can be "LOW", "NORMAL" or "CRITICAL".
+#
+# NOTE: if you don't want a notification to be displayed, set the format
+# to "".
+# NOTE: It might be helpful to run dunst -print in a terminal in order
+# to find fitting options for rules.
+
+# Disable the transient hint so that idle_threshold cannot be bypassed from the
+# client
+#[transient_disable]
+#    match_transient = yes
+#    set_transient = no
+#
+# Make the handling of transient notifications more strict by making them not
+# be placed in history.
+#[transient_history_ignore]
+#    match_transient = yes
+#    history_ignore = yes
+
+# fullscreen values
+# show: show the notifications, regardless if there is a fullscreen window opened
+# delay: displays the new notification, if there is no fullscreen window active
+#        If the notification is already drawn, it won't get undrawn.
+# pushback: same as delay, but when switching into fullscreen, the notification will get
+#           withdrawn from screen again and will get delayed like a new notification
+#[fullscreen_delay_everything]
+#    fullscreen = delay
+#[fullscreen_show_critical]
+#    msg_urgency = critical
+#    fullscreen = show
+
+#[espeak]
+#    summary = "*"
+#    script = dunst_espeak.sh
+
+#[script-test]
+#    summary = "*script*"
+#    script = dunst_test.sh
+
+#[ignore]
+#    # This notification will not be displayed
+#    summary = "foobar"
+#    format = ""
+
+#[history-ignore]
+#    # This notification will not be saved in history
+#    summary = "foobar"
+#    history_ignore = yes
+
+#[skip-display]
+#    # This notification will not be displayed, but will be included in the history
+#    summary = "foobar"
+#    skip_display = yes
+
+#[signed_on]
+#    appname = Pidgin
+#    summary = "*signed on*"
+#    urgency = low
+#
+#[signed_off]
+#    appname = Pidgin
+#    summary = *signed off*
+#    urgency = low
+#
+#[says]
+#    appname = Pidgin
+#    summary = *says*
+#    urgency = critical
+#
+#[twitter]
+#    appname = Pidgin
+#    summary = *twitter.com*
+#    urgency = normal
+#
+#[stack-volumes]
+#    appname = "some_volume_notifiers"
+#    set_stack_tag = "volume"
+#
+# vim: ft=cfg
--- a/_saved/fastfetch/config.jsonc
+++ b/_saved/fastfetch/config.jsonc
@ -0,0 +1,18 @@
+{
+  "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+  "modules": [
+    "host",
+    "cpu",
+    "gpu",
+    "break",
+    "os",
+    "kernel",
+    "uptime",
+    "packages",
+    "break",
+    "de",
+    "terminal",
+    "break",
+    "colors"
+  ]
+}
--- a/_saved/fastfetch/gentoo.png
+++ b/_saved/fastfetch/gentoo.png
--- a/_saved/rofi/config.rasi
+++ b/_saved/rofi/config.rasi
@ -0,0 +1 @@
+@theme "/usr/local/share/rofi/themes/glue_pro_blue.rasi"
--- a/_saved/urxvt.xresources
+++ b/_saved/urxvt.xresources
@ -0,0 +1,36 @@
+URxvt.perl-ext: -confirm-paste,-option-popup,-selection,-selection-popup,font-size,matcher,readline,searchable-scrollback
+
+URxvt.font: xft:RobotoMono Nerd Font:style=Medium:pixelsize=14, xft:Noto Color Emoji:pixelsize=12
+URxvt.foreground: #c7c7c7
+URxvt.background: [90]#161616
+URxvt.color0: #161616
+URxvt.color1: #fd4285
+URxvt.color2: #a6e22d
+URxvt.color3: #e5da72
+URxvt.color4: #0094d8
+URxvt.color5: #9a37ff
+URxvt.color6: #50b6d8
+URxvt.color7: #c7c7c7
+URxvt.color8: #676767
+URxvt.color9: #fa7fac
+URxvt.color10: #bde271
+URxvt.color11: #fff27f
+URxvt.color12: #00bdff
+URxvt.color13: #bd9eff
+URxvt.color14: #5ed6fe
+URxvt.color15: #feffff
+URxvt*colorUL:  #a0a0a0
+
+URxvt*depth: 32
+URxvt*fading: 20
+URxvt.termName: xterm-256color
+URxvt.scrollBar: False
+URxvt.scrollBar_right: False
+URxvt.url-launcher: xdg-open
+URxvt.urgentOnBell: True
+
+URxvt.keysym.C-o: perl:matcher:list
+URxvt.keysym.C-f: perl:searchable-scrollback:start
+URxvt.keysym.C-0:	perl:font-size:reset
+URxvt.keysym.C-equal:	perl:font-size:increase
+URxvt.keysym.C-minus:	perl:font-size:decrease
--- a/_saved/xinitrc
+++ b/_saved/xinitrc
@ -0,0 +1 @@
+exec dbus-launch --sh-syntax --exit-with-session qtile start
--- a/_saved/zathura/zathurarc
+++ b/_saved/zathura/zathurarc
@ -0,0 +1,8 @@
+set font "RobotoMono Nerd Font Mono 11"
+map r rotate
+map R reload
+map p print
+map g goto top
+map = zoom in
+map - zoom out
+map 0 zoom
				`@ -0,0 +1 @@`
				`eDP 00ffffffffffff0006af3d5700000000001c0104a51f1178022285a5544d9a270e505400000001010101010101010101010101010101b43780a070383e401010350035ae100000180000000f0000000000000000000000000020000000fe0041554f0a202020202020202020000000fe004231343048414e30352e37200a0070`
				`@ -0,0 +1 @@`
				`@theme "/usr/local/share/rofi/themes/glue_pro_blue.rasi"`
				`@ -0,0 +1 @@`
				`exec dbus-launch --sh-syntax --exit-with-session qtile start`