added the rest of bin

81 files changed, 4436 insertions, 0 deletions

diff --git a/bin/cal.sh b/bin/cal.sh
new file mode 100755
index 0000000..e6a38fb
--- /dev/null
+++ b/bin/cal.sh
@@ -0,0 +1,39 @@
+
+#! /bin/sh
+
+width=200
+height=200
+datefmt="+%a %m-%d %H:%M:%S"
+
+OPTIND=1
+while getopts ":f:W:H:" opt; do
+    case $opt in
+        f) datefmt="$OPTARG" ;;
+        W) width="$OPTARG" ;;
+        H) height="$OPTARG" ;;
+        \?)
+            echo "Invalid option: -$OPTARG" >&2
+            exit 1
+            ;;
+        :)
+            echo "Option -$OPTARG requires an argument." >&2
+            exit 1
+            ;;
+    esac
+done
+
+case "$BLOCK_BUTTON" in
+  1|2|3) 
+
+	# the position of the upper left corner of the popup
+	posX=$(($BLOCK_X - $width / 2))
+	posY=$(($BLOCK_Y - $height))
+
+	swaymsg -q "exec gsimplecal \
+        --width=$width --height=$height \
+	    --undecorated --fixed \
+	    --close-on-unfocus --no-buttons \
+	    --posx=$posX --posy=$posY \
+	    > /dev/null"
+esac
+date "$datefmt"
diff --git a/bin/csvtommd.rb b/bin/csvtommd.rb
new file mode 100755
index 0000000..355b0f9
--- /dev/null
+++ b/bin/csvtommd.rb
@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+
+input = STDIN.read
+
+# find quoted cells and replace commas inside quotes with placeholder
+input.gsub!(/"([^,].*?)"/m) { |quoted|
+	quoted.gsub(/[\n\r]*/,'').gsub(/,/,'zXzX')
+}
+# replace remaining commas with table divider (pipe)
+input.gsub!(/,/,"| ")
+# remove quotes from quoted cells
+input.gsub!(/(\| |^)"(.*?)"/,"\\1\\2")
+# replace placeholders with commas
+input.gsub!(/zXzX/,",")
+
+input.each { |l|
+	puts "| #{l.strip} |"
+}
diff --git a/bin/daily-rsync.sh b/bin/daily-rsync.sh
new file mode 100644
index 0000000..f594ef1
--- /dev/null
+++ b/bin/daily-rsync.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+# ----------------------------------------------------------------------
+# rotating-filesystem-snapshot utility
+# essentially, rotate backup-snapshots of /home 
+# on a weekly basis using rsync and cron
+# ----------------------------------------------------------------------
+
+
+rm -rf /Volumes/MiniRSync/daily.4
+mv /Volumes/MiniRSync/daily.3 /Volumes/MiniRSync/daily.4
+mv /Volumes/MiniRSync/daily.2 /Volumes/MiniRSync/daily.3
+mv /Volumes/MiniRSync/daily.1 /Volumes/MiniRSync/daily.2
+mv /Volumes/MiniRSync/daily.0 /Volumes/MiniRSync/daily.1
+
+rsync -avvz \
+--delete-after \
+--exclude-from '/Users/sng/.rsync-exclude-daily' \
+--link-dest=/Volumes/MiniRSync/daily.1 \
+/Users/sng/ /Volumes/MiniRSync/daily.0/
diff --git a/bin/deflac.sh b/bin/deflac.sh
new file mode 100755
index 0000000..24d9780
--- /dev/null
+++ b/bin/deflac.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+for a in ./*.flac; do
+  ffmpeg -i "$a" -qscale:a 0 "${a[@]/%flac/mp3}"
+done
diff --git a/bin/devil.dict.dz b/bin/devil.dict.dz
new file mode 100644
index 0000000..f22d4f5
--- /dev/null
+++ b/bin/devil.dict.dz
diff --git a/bin/devil.index b/bin/devil.index
new file mode 100644
index 0000000..13732c1
--- /dev/null
+++ b/bin/devil.index
@@ -0,0 +1,1008 @@
+00databasealphabet	Bdrn	c
+00databasedictfmt1120	A	b
+00databaseinfo	CP	tM
+00databaseshort	BV	6
+00databaseurl	b	6
+abasement	vb	Cf
+abatis	x6	Br
+abdication	zl	HW
+abdomen	67	Gd
+ability	BBY	FF
+abnormal	BGd	Fy
+aboriginies	BMP	CO
+abracadabra	BOd	cu
+abridge	BrL	FQ
+abrupt	Bwb	EG
+abscond	B0h	ED
+absent	B4k	Hq
+absentee	CAO	By
+absolute	CCA	F0
+abstainer	CH0	HY
+absurdity	CPM	BW
+academe	CQi	BL
+academy	CRt	BL
+accident	CS4	BV
+accomplice	CUN	E0
+accord	CZB	W
+accordion	CZX	BN
+accountability	Cak	EY
+accuse	Ce8	B7
+acephalous	Cg3	DX
+achievement	CkO	BC
+acknowledge	ClQ	B7
+acquaintance	CnL	DX
+actually	Cqi	k
+adage	CrG	p
+adamant	Crv	Bb
+adder	CtK	B1
+adherent	Cu/	BP
+administration	CwO	DA
+admiral	CzO	Bm
+admiration	C00	BP
+admonition	C2D	DX
+adore	C5a	n
+advice	C6B	Fn
+affianced	C/o	BD
+affliction	DAr	Bb
+african	DCG	r
+age	DCx	Ca
+agitator	DFL	Bh
+aim	DGs	EJ
+air	DK1	Bj
+alderman	DMY	Bn
+alien	DN/	9
+allah	DO8	Fl
+allegiance	DUh	EP
+alliance	DYw	Cw
+alligator	Dbg	Fh
+alone	DhB	EC
+altar	DlD	Iw
+ambidextrous	Dtz	BS
+ambition	DvF	B4
+amnesty	Dw9	Bj
+anoint	Dyg	EH
+antipathy	D2n	BB
+aphorism	D3o	D9
+apologize	D7l	+
+apostate	D8j	C2
+apothecary	D/Z	HC
+appeal	EGb	BH
+appetite	EHi	Bl
+applause	EJH	o
+april fool	EJv	BH
+archbishop	EK2	Ep
+architect	EPf	BW
+ardor	EQ1	BD
+arena	ER4	Bf
+aristocracy	ETX	Da
+armor	EWx	BN
+arrayed	EX+	Bc
+arrest	EZa	DK
+arsenic	Eck	FB
+art	Ehl	Nr
+artlessness	EvQ	DG
+asperse	EyW	CC
+ass	E0Y	Ug
+auctioneer	FI4	Bi
+australia	FKa	DW
+avernus	FNw	Im
+baal	FWW	J9
+babe	FgT	ND
+baby	FgT	ND
+bacchus	FtW	E/
+back	FyV	Bh
+backbite	Fz2	BL
+bait	F1B	BZ
+baptism	F2a	IE
+barometer	F+e	Bc
+barrack	F/6	Bx
+basilisk	GBr	IJ
+bastinado	GJ0	9
+bath	GKx	Gv
+battle	GRg	Bo
+beard	GTI	B6
+beauty	GVC	BQ
+befriend	GWS	l
+beg	GW3	ai
+beggar	GxZ	BC
+behavior	Gyb	Gf
+belladonna	G46	CM
+benedictines	G7G	Fh
+benefactor	HAn	CZ
+berenices hair	HDA	IC
+bigamy	HLC	Bt
+bigot	HMv	Bj
+billingsgate	HOS	x
+birth	HPD	Ih
+blackguard	HXk	C2
+blankverse	Haa	C/
+bodysnatcher	HdZ	K2
+bondsman	HoP	Hb
+bore	Hvq	7
+botany	Hwl	DW
+bottlenosed	Hz7	BG
+boundary	H1B	Cd
+bounty	H3e	GV
+brahma	H9z	KU
+brain	IIH	Hg
+brandy	IPn	Ex
+bride	IUY	BC
+brute	IVa	b
+caaba	IV1	Cp
+cabbage	IYe	IK
+calamity	Igo	DT
+callous	Ij7	Fd
+calumnus	IpY	1
+camel	IqN	DR
+cannibal	Ite	CG
+cannon	Ivk	BR
+canonicals	Iw1	BE
+capital	Ix5	F8
+carmelite	I31	gu
+carnivorous	JYj	Bp
+cartesian	JaM	GR
+cat	Jgd	FI
+caviler	Jll	o
+cemetery	JmN	Kg
+centaur	Jwt	G6
+cerberus	J3n	KE
+childhood	KBr	C1
+christian	KEg	R4
+circus	KWY	B2
+clairvoyant	KYO	CR
+clarionet	Kaf	Cl
+clergyman	KdE	B2
+clio	Ke6	EW
+clock	KjQ	HR
+closefisted	Kqh	HY
+coenobite	Kx5	G/
+comfort	K44	BU
+commendation	K6M	Bm
+commerce	K7y	CW
+commonwealth	K+I	VT
+compromise	LTb	DT
+compulsion	LWu	p
+condole	LXX	BK
+confidant	LYh	Be
+confidante	LYh	Be
+congratulation	LZ/	r
+congress	Laq	2
+connoisseur	Lbg	EB
+conservative	Lfh	CN
+consolation	Lhu	BV
+consul	LjD	Cu
+consult	Llx	BO
+contempt	Lm/	Bl
+controversy	Lok	QE
+convent	L4o	Bq
+conversation	L6S	Cy
+coronation	L9E	CY
+corporal	L/c	FF
+corporation	MEh	Bp
+corsair	MGK	o
+court fool	MGy	g
+coward	MHS	BD
+crayfish	MIV	IW
+creditor	MQr	B8
+cremona	MSn	4
+critic	MTf	HJ
+cross	Mao	TU
+cui bono	Mt8	z
+cunning	Muv	D6
+cupid	Myp	JI
+curiosity	M7x	DK
+curse	M+7	Eg
+cynic	NDb	C7
+damn	NGW	Im
+dance	NO8	E9
+danger	NT5	Do
+daring	NXh	BJ
+datary	NYq	DV
+dawn	Nb/	H5
+day	Nj4	ES
+dead	NoK	Dz
+debauchee	Nr9	Bp
+debt	Ntm	Ip
+decalogue	N2P	RK
+decide	OHZ	L/
+defame	OTY	BH
+defenceless	OUf	m
+degenerate	OVF	IA
+degradation	OdF	Bv
+deinotherium	Oe0	EN
+dejeuner	OjB	Ba
+delegation	Okb	BV
+deliberation	Olw	Bf
+deluge	OnP	Bq
+delusion	Oo5	Gt
+dentist	Ovm	Bk
+dependent	OxK	B9
+deputy	OzH	Z1
+destiny	PM8	BM
+diagnosis	POI	BY
+diaphragm	PPg	Bl
+diary	PRF	P8
+dictator	PhB	Bo
+dictionary	Pip	Co
+die	PlR	GX
+digestion	Pro	D5
+diplomacy	Pvh	+
+disabuse	Pwf	CG
+discriminate	Pyl	B8
+discussion	P0h	BA
+disobedience	P1h	BA
+disobey	P2h	E5
+dissemble	P7a	CZ
+distance	P9z	Bf
+distress	P/S	BN
+divination	QAf	Cj
+dog	QDC	JR
+dragoon	QMT	CP
+dramatist	QOi	2
+druids	QPY	Mq
+duckbill	QcC	BP
+duel	QdR	Pq
+dullard	Qs7	S4
+duty	Q/z	GI
+eat	RF7	G+
+eavesdrop	RM5	JS
+eccentricity	RWL	Bp
+economy	RX0	B1
+edible	RZp	CU
+editor	Rb9	aP
+education	R2M	Bs
+effect	R34	Et
+egotist	R8l	JW
+ejection	SF7	Bz
+elector	SHu	Bh
+electricity	SJP	QH
+elegy	SZW	Gj
+eloquence	Sf5	Ca
+elysium	SiT	EK
+emancipation	Smd	Fh
+embalm	Sr+	Kj
+emotion	S2h	C6
+encomiast	S5b	9
+end	S6Y	G5
+enough	TBR	Do
+entertainment	TE5	Ba
+enthusiasm	TGT	D3
+envelope	TKK	B6
+envy	TME	2
+epaulet	TM6	C2
+epicure	TPw	Ct
+epigram	TSd	Nn
+epitaph	TgE	E1
+erudition	Tk5	E2
+esoteric	Tpv	Fk
+ethnology	TvT	CR
+eucharist	Txk	EU
+eulogy	T14	B0
+evangelist	T3s	Ca
+everlasting	T6G	Hx
+exception	UB3	JC
+excess	UK5	Lr
+excommunication	UWk	Fs
+executive	UcQ	gp
+exhort	U85	B7
+exile	U+0	IE
+existence	VG4	DN
+experience	VKF	GN
+expostulation	VQS	BZ
+extinction	VRr	BS
+fairy	VS9	WB
+faith	Vo+	B1
+famous	Vqz	Eh
+fashion	VvU	OV
+feast	V9p	Lm
+felon	WJP	CC
+female	WLR	dB
+fib	WoS	Nx
+fickleness	W2D	BE
+fiddle	W3H	Fx
+fidelity	W84	BI
+finance	W+A	D/
+flag	XB/	DK
+flesh	XFJ	2
+flop	XF/	Da
+flyspeck	XJZ	lN
+folly	Xum	OH
+fool	X8t	QN
+force	YM6	DS
+forefinger	YQM	BL
+foreordination	YRX	M7
+forgetfulness	YeS	Bt
+fork	Yf/	HG
+forma pauperis	YnF	KA
+frankalmoigne	YxF	MA
+freebooter	Y9F	B3
+freedom	Y+8	Pq
+freemasons	ZOm	Mk
+friendless	ZbK	B4
+friendship	ZdC	GT
+frog	ZjV	Pp
+fryingpan	Zy+	Vr
+funeral	aIp	HC
+future	aPr	By
+gallows	aRd	Gs
+gargoyle	aYJ	It
+garther	ag2	B0
+genealogy	alb	Bt
+generous	aiq	Cx
+genteel	anI	FN
+geographer	asV	II
+geology	a0d	J3
+ghost	a+U	XV
+ghoul	bVp	ZY
+glutton	bvB	BU
+gnome	bwV	Jp
+gnostics	b5+	Dq
+gnu	b9o	K0
+good	cIc	B4
+goose	cKU	I8
+gorgon	cTQ	Dv
+gout	cW/	BE
+graces	cYD	Eg
+grammar	ccj	CR
+grape	ce0	K1
+grapeshot	cpp	Bq
+grave	crT	Mz
+gravitation	c4G	Ft
+great	c9z	LS
+guillotine	dJF	NK
+gunpowder	dWP	hQ
+habeas corpus	d3f	Bj
+habit	d5C	k
+hades	d5m	Ri
+hag	eLI	JR
+half	eUZ	Jn
+halo	eeA	Lb
+hand	epb	Bu
+handkerchief	erJ	Id
+hangman	ezm	G8
+happiness	e6i	BZ
+harangue	e77	BO
+harbor	e9J	Bk
+harmonists	e+t	DK
+hash	fB3	BO
+hatchet	fDF	FM
+hatred	fIR	BP
+headmoney	fJg	hW
+hearse	fq2	k
+heart	fra	UQ
+heat	f/q	GB
+heathen	gFr	Rw
+heaven	gXb	Cj
+hebrew	gZ+	Bd
+helpmate	gbb	IK
+hemp	gjl	C1
+hermit	gma	BA
+hers	gna	T
+hibernate	gnt	RD
+hippogriff	g4w	Ev
+historian	g9f	m
+history	g+F	GZ
+hog	hEe	Ij
+homicide	hRQ	Em
+homiletics	hV2	Og
+homoeopathist	hNB	8
+homoeopathy	hN9	DT
+honorable	hkW	C6
+hope	hnQ	Hz
+hospitality	hvD	B5
+hostility	hw8	EK
+houri	h1G	Eb
+house	h5h	Jx
+houseless	iDS	8
+hovel	iEO	Jh
+humanity	iNv	BQ
+humorist	iO/	II
+hurricane	iXH	F1
+hurry	ic8	m
+husband	idi	BM
+hybrid	ieu	d
+hydra	ifL	BM
+hyena	igX	Cp
+hypochondriasis	ijA	E5
+hypocrite	in5	B+
+i	ip3	JA
+ichor	iy3	E8
+iconoclast	i3z	IK
+idiot	i/9	G1
+idleness	jGy	B4
+ignoramus	jIq	JC
+illuminati	jRs	Ch
+illustrious	jUN	BT
+imagination	jVg	BP
+imbecility	jWv	Bv
+immigrant	jYe	BU
+immodest	jZy	Vi
+immoral	jvU	H8
+immortality	j3Q	EL
+impale	j7b	TG
+impartial	kOh	Cj
+impenitence	kRE	Bc
+impiety	kSg	w
+imposition	kTQ	H3
+impostor	kbH	x
+improbability	kb4	PG
+improvidence	kq+	BV
+impunity	ksT	X
+inadmissible	ksq	aV
+inards	oce	Jp
+inauspiciously	lG/	lT
+income	lsS	Qx
+incompatibility	l9D	Dr
+incompossible	mAu	II
+incubus	mI2	PF
+incumbent	mX7	BH
+indecision	mZC	OW
+indifferent	mnY	FT
+indigestion	msr	Er
+indiscretion	mxW	n
+inexpedient	mx9	/
+infalapsarian	nce	eM
+infancy	my8	CV
+inferiae	m1R	S2
+infidel	nIH	S8
+influence	nbD	Bb
+ingrate	n6q	Jm
+injury	oEQ	BA
+injustice	oFQ	CO
+ink	oHe	LT
+innate	oSx	Jt
+inscription	omH	Tt
+insectivora	o50	Er
+insurance	o+f	zJ
+insurrection	pxo	Bx
+intention	pzZ	DF
+interpreter	p2e	DG
+interregnum	p5k	EW
+intimacy	p96	OT
+introduction	qMN	Qc
+inventor	qcp	B4
+irreligion	qeh	BF
+itch	qfm	q
+j	qgQ	KY
+jealous	qqo	Bt
+jester	qsV	Zq
+jewsharp	rF/	B/
+josssticks	rH+	CL
+justice	rKJ	Cj
+k	rMs	Sh
+keep	rfN	FK
+kill	rkX	BB
+kilt	rlY	BX
+kindness	rmv	7
+king	rnq	Jc
+kings evil	rxG	hf
+kiss	sSl	D2
+kleptomaniac	sWb	h
+knight	sW8	HV
+koran	seR	DB
+labor	shS	BF
+land	siX	PW
+language	sxt	BX
+laocoon	szE	F6
+lap	s4+	Fp
+last	s+n	E+
+laughter	tDl	MS
+laureate	tP3	Ht
+laurel	tP3	Ht
+laurel	tXk	Cv
+law	taT	I7
+lawful	tjO	BI
+lawyer	tkW	2
+laziness	tlM	BH
+lead	tmT	RE
+learning	t3X	BC
+lecturer	t4Z	Bo
+legacy	t6B	BK
+leonine	t7L	J5
+lettuce	uFE	Mf
+leviathan	uRj	G3
+lexicographer	uYa	iI
+liar	u6i	u
+liberty	u7Q	FQ
+lickspittle	vAg	JV
+life	vJ1	MP
+lighthouse	vWE	B6
+limb	vX+	VE
+linen	vtC	B+
+litigant	vvA	BX
+litigation	vwX	BU
+liver	vxr	Ic
+lld	v6H	LD
+lockandkey	wFK	BQ
+lodger	wGa	CF
+logic	wIf	Jw
+logomachy	wSP	GY
+longanimity	wYn	Br
+longevity	waS	5
+lookingglass	wbL	cG
+loquacity	w3R	Bn
+lord	w44	k9
+lore	xd1	PF
+loss	xs6	Hc
+love	x0W	G8
+lowbred	x7S	x
+luminary	x8D	Ba
+lunarian	x9d	FW
+lyre	yCz	J5
+mace	yMs	CX
+machination	yPD	Ha
+macrobian	yWd	rz
+mad	zCQ	MG
+magdalene	zOW	Ie
+magic	zW0	Ch
+magnet	zZV	w
+magnetism	zaF	EP
+magnificent	zeU	C2
+magnitude	zhK	NI
+magpie	zuS	Bl
+maiden	zv3	Ok
+majesty	z+b	Dm
+male	0CB	DI
+malefactor	0FJ	BF
+malthusian	0GO	E5
+mammalia	0LH	C1
+mammon	0N8	EZ
+man	0SV	Tu
+manes	0mD	Dl
+manicheism	0po	Cp
+manna	0sR	Dg
+marriage	0vx	B8
+martyr	0xt	BS
+material	0y/	D3
+mausoleum	022	6
+mayonnaise	03w	BY
+me	05I	Ck
+meander	07s	D/
+medal	0/r	FA
+medicine	1Er	BI
+meekness	1Fz	Ft
+meerschaum	1Lg	T5
+mendacious	1fZ	p
+merchant	1gC	B5
+mercy	1h7	4
+mesmerism	1iz	Bo
+metropolis	1kb	w
+millennium	1lL	B6
+mind	1nF	Hw
+mine	1u1	4
+minister	1vt	EY
+minor	10F	i
+minstrel	10n	CU
+miracle	127	CZ
+miscreant	15U	Dc
+misdemeanor	18w	JM
+misericorde	2F8	CE
+misfortune	2IA	4
+miss	2I4	H5
+molecule	2Qx	L/
+monad	2cw	Lf
+monarch	2oP	HS
+monarchical government	2vh	p
+monday	2wK	BG
+money	2xQ	Cm
+monkey	2z2	BS
+monosyllabic	21I	HV
+monsignor	28d	Bt
+monument	2+K	G6
+moral	3FE	H9
+more	3NB	x
+mouse	3Ny	Ol
+mousquetaire	3cX	CN
+mouth	3ek	BQ
+mugwump	3f0	B5
+mulatto	3ht	1
+multitude	3ii	JR
+mummy	3rz	L1
+mustang	33o	B2
+myrmidon	35e	BL
+mythology	36p	C9
+nectar	39m	Gh
+negro	4EH	D2
+neighbor	4H9	B1
+nepotism	4Jy	BQ
+newtonian	4LC	Dw
+nihilist	4Oy	Bx
+nirvana	4Qj	CV
+nobleman	4S4	B5
+noise	4Ux	B0
+nominate	4Wl	Ch
+nominee	4ZG	CR
+noncombatant	4bX	j
+nonsense	4b6	BQ
+nose	4dK	Nw
+notoriety	4q6	Db
+noumenon	4uV	G2
+novel	41L	Py
+november	5E9	0
+oath	5Fx	Bs
+oblivion	5Hd	Ev
+observatory	5MM	Bf
+obsessed	5Nr	NR
+obsolete	5a8	K0
+obstinate	5lw	DB
+occasional	5ox	F7
+occident	5us	E7
+ocean	5zn	Bk
+offensive	51L	ER
+old	55c	HE
+oleaginous	6Ag	FN
+olympian	6Ft	G3
+omen	6Mk	BB
+once	6Nl	V
+opera	6N6	Gw
+opiate	6Uq	BX
+opportunity	6WB	BG
+oppose	6XH	EU
+opposition	6bb	Y+
+optimism	60Z	IH
+optimist	68g	F+
+oratory	7Ce	B1
+orphan	7ET	Hk
+orthodox	7L3	5
+orthography	7Mw	Hn
+ostrich	7UX	Eu
+otherwise	7ZF	d
+outcome	7Zi	Eu
+outdo	7eQ	g
+outofdoors	7ew	SC
+ovation	7wy	Kr
+overeat	77d	EI
+overwork	7/l	Bg
+owe	8BF	Db
+oyster	8Eg	Ck
+pain	8HE	C2
+painting	8J6	Ev
+palace	8Op	D6
+palm	8Sj	Hz
+palmistry	8aW	Gb
+pandemonium	8gx	Ev
+pantaloons	8lg	EB
+pantheism	8ph	By
+pantomime	8rT	CF
+pardon	8tY	B+
+passport	8vW	Ci
+past	8x4	Mb
+pastime	8+T	Bc
+patience	8/v	/
+patriot	9Au	CK
+patriotism	9C4	Et
+peace	9Hl	JS
+pedestrian	9Q3	BS
+pedigree	9SJ	CC
+penitent	9UL	0
+perfection	9U/	GE
+peripatetic	9bD	Du
+peroration	9ex	DZ
+perseverance	9iK	Lf
+pessimism	9tp	Cq
+philanthropist	9wT	CJ
+philistine	9yc	DQ
+philosophy	91s	BI
+phoenix	920	BG
+phonograph	936	BG
+photograph	95A	Cq
+phrenology	97q	CR
+physician	997	BQ
+physiognomy	9/L	Ic
+piano	+Hn	CX
+pickaninny	+J+	CJ
+picture	+MH	Ez
+pie	+Q6	HM
+piety	+YG	EF
+pig	+cL	C0
+pigmy	+e/	Dp
+pilgrim	+io	EH
+pillory	+mv	Co
+piracy	+pX	BH
+pitiful	+qe	Bd
+pity	+r7	/
+plagiarism	+s6	Bt
+plagiarize	+un	Bg
+plague	+wH	Eh
+plan	+0o	BU
+platitude	+18	Hn
+platonic	+9j	CP
+plaudits	+/y	BS
+please	/BE	BH
+pleasure	/CL	0
+plebeian	/C/	Cg
+plebiscite	/Ff	BI
+plenipotentiary	/Gn	Cb
+pleonasm	/JC	BB
+plow	/KD	BK
+plunder	/LN	EN
+pocket	/Pa	DS
+poetry	/Ss	BN
+poker	/T5	Bg
+police	/VZ	+
+politeness	/WX	w
+politician	/ZL	EU
+politics	/XH	CE
+polygamy	/df	CX
+populist	/f2	H/
+portable	/n1	Ef
+portuguese	/sU	CY
+positive	/us	1
+positivism	/vh	C7
+posterity	/yc	CR
+potable	/0t	Jf
+poverty	/+M	GE
+pray	BAEQ	Bz
+preadamite	BAGD	F9
+precedent	BAMA	IP
+precedent	BAXJ	IP
+precipitate	BAUP	C6
+precipitate	BAfY	C6
+predestination	BAiS	If
+predicament	BAqx	r
+predilection	BArc	5
+preexistence	BAsV	z
+preference	BAtI	FN
+prehistoric	BAyV	Hi
+prejudice	BA53	BE
+prelate	BA67	CN
+prerogative	BA9I	z
+presbyterian	BA97	B7
+prescription	BA/2	Bv
+present	BBBl	Bi
+presentable	BBDH	Fj
+preside	BBIq	Kf
+presidency	BBTJ	BJ
+president	BBUS	Jo
+prevaricator	BBd6	1
+price	BBev	Be
+primate	BBgN	EY
+prison	BBkl	Dl
+private	BBoK	Bv
+proboscis	BBp5	LE
+projectile	BB09	Hu
+proof	BB8r	CY
+proofreader	BB/D	CE
+property	BCBH	ED
+prophecy	BCFK	BW
+prospect	BCGg	Eo
+providential	BCLI	Bf
+prude	BCMn	7
+publish	BCNi	Bb
+push	BCO9	Bq
+pyrrhonism	BCQn	Ct
+queen	BCTU	B1
+quill	BCVJ	DW
+quiver	BCYf	GN
+quixotic	BCes	GV
+quorum	BClB	E5
+quotation	BCp6	Fd
+quotient	BCvX	Cz
+rabble	BCyK	FH
+rack	BC3R	Dx
+radicalism	BDfp	BU
+radium	BDg9	Bl
+railroad	BDii	EE
+ramshackle	BDmm	Gh
+rank	BC7C	Eg
+ransom	BC/i	CL
+rapacity	BDBt	BC
+rarebit	BDCv	E6
+rascal	BDHp	1
+rascality	BDIe	BK
+rash	BDJo	Ei
+rational	BDOK	Bf
+rattlesnake	BDPp	/
+razor	BDQo	Cg
+reach	BDTI	GG
+reading	BDZO	Gb
+realism	BDtH	Ce
+reality	BDvl	CN
+really	BDxy	b
+rear	BDyN	Bk
+reason	BD0x	o
+reason	BDzx	BA
+reasonable	BD1Z	B3
+rebel	BD3Q	BJ
+recollect	BD4Z	BJ
+reconciliation	BD5i	Bq
+reconsider	BD7M	BG
+recount	BD8S	B0
+recreation	BD+G	BO
+recruit	BD/U	Fh
+rector	BEE1	CA
+redemption	BEG1	LJ
+redress	BER+	GE
+redskin	BEYC	Be
+redundant	BEZg	Gz
+referendum	BEgT	B6
+reflection	BEiN	C3
+reform	BElE	BN
+refuge	BEmR	Hw
+refusal	BEuB	HD
+regalia	BE1E	Y5
+religion	BFN9	GO
+reliquary	BFUL	PH
+renown	BFjS	I+
+reparation	BFsQ	Bx
+repartee	BFuB	DP
+repentance	BFxQ	Gt
+replica	BF39	Eo
+reporter	BF8l	Fm
+repose	BGCL	o
+representative	BGCz	CN
+reprobation	BGFA	Ek
+republic	BGJk	HY
+requiem	BGQ8	DA
+resident	BGT8	i
+resign	BGUe	IF
+resolute	BGcj	4
+respectability	BGdb	Ba
+respirator	BGe1	Cd
+respite	BGhS	TT
+resplendent	BG0l	F0
+respond	BG6Z	GK
+responsibility	BHAj	I5
+restitutions	BHJc	Bl
+restitutor	BHLB	t
+retaliation	BHLu	BL
+retribution	BHM5	L4
+reveille	BHYx	Ep
+revelation	BHda	CW
+reverence	BHfw	BN
+review	BHg9	Do
+revolution	BHkl	Ko
+rhadomancer	BHvN	Bq
+ribaldry	BHw3	BC
+ribroaster	BHx5	Ez
+ricewater	BH2s	EQ
+rich	BH68	Fa
+riches	BIAW	ID
+ridicule	BIIZ	Hv
+right	BIQI	QF
+righteousness	BIgN	St
+rime	BIy6	Ct
+rimer	BI1n	GW
+riot	BI79	BR
+rip	BI9O	Da
+rite	BJAo	CV
+ritualism	BJC9	Bn
+road	BJEk	Ex
+robber	BJJV	F3
+romance	BJPM	Pf
+rope	BJer	FQ
+rostrum	BJj7	C8
+roundhead	BJm3	MS
+rubbish	BJzJ	Co
+ruin	BJ1x	BZ
+rum	BJ3K	BP
+rumor	BJ4Z	Jo
+russian	BKCB	BV
+sabbath	BKDW	Pb
+sacerdotalist	BKSx	Dd
+sacrament	BKWO	F1
+sacred	BKcD	IV
+safetyclutch	BKuC	gR
+saint	BLOT	Gd
+salacity	BLUw	F9
+salamander	BLat	Er
+sandlotter	BKkY	Jq
+sarcophagus	BLfY	ED
+satan	BLjb	Kz
+satiety	BLuO	Bd
+satire	BLvr	QC
+satyr	BL/t	Gp
+sauce	BMGW	EA
+saw	BMKW	P/
+scarabaeus	BMaV	Ha
+scarabee	BMhv	Pv
+scarification	BMxe	Ke
+scepter	BM78	Di
+scimetar	BM/e	uq
+scrapbook	BNuI	Nx
+scribbler	BN75	BR
+scriptures	BN9K	CS
+seal	BN/c	aT
+seine	BOZv	Ju
+selfesteem	BOjd	t
+selfevident	BOkK	/
+selfish	BOlJ	BH
+senate	BOmQ	BU
+serial	BOnk	Pm
+severalty	BO3K	Mg
+sheriff	BPDq	dc
+siren	BPhG	Da
+slang	BPkg	E+
+smithareen	BPpe	Qo
+sophistry	BP6G	LJ
+sorcery	BQFP	HU
+soul	BQMj	l8
+spooker	BQyf	Hf
+story	BQ5+	Bd2
+success	BSX0	I/
+suffrage	BSgz	Ny
+sycophant	BSul	aM
+syllogism	BTIx	B0
+sylph	BTKl	IH
+symbol	BTSs	Gn
+symbolic	BTZT	KB
+t	BTjU	FO
+table dhote	BToi	HJ
+tail	BTvr	Lr
+take	BT7W	BI
+talk	BT8e	Bc
+tariff	BT96	du
+technicality	BUbo	IE
+tedium	BUjs	Fb
+teetotaler	BUpH	Bl
+telephone	BUqs	CE
+telescope	BUsw	D0
+tenacity	BUwk	M4
+theosophy	BU9c	M4
+tights	BVKU	US
+tomb	BVem	H2
+tope	BVmc	Ph
+tortoise	BV19	e0
+tree	BWUx	Uc
+trial	BWpN	hA
+trichinosis	BXKN	Ia
+trinity	BXSn	LR
+troglodyte	BXd4	Fi
+truce	BXja	Y
+trust	BXoZ	Dh
+truth	BXjy	EB
+truthful	BXnz	m
+tsetse fly	BXxq	Dt
+turkey	BXr6	C5
+twice	BXuz	e
+type	BXvR	CZ
+tzetze fly	BXxq	Dt
+ubiquity	BX1X	ME
+ugliness	BYBb	BX
+ultimatum	BYCy	RD
+unamerican	BYT1	1
+unction	BYUq	H4
+understanding	BYci	Ku
+unitarian	BYnQ	+
+universalist	BYoO	BZ
+urbanity	BYpn	KI
+usage	BYzv	D4
+uxoriousness	BY3n	BN
+valor	BY40	F8
+vanity	BY+w	Mx
+virtues	BZLh	m
+vituperation	BZMH	Bq
+vote	BZNx	Bw
+w	BZPh	KR
+wall street	BZZy	QM
+war	BZp+	R3
+washingtonian	BZ71	HM
+weaknesses	BaDB	DE
+weather	BaGF	RH
+wedding	BaXM	CX
+werewolf	BaZj	LL
+whangdepootenawah	Baku	bO
+wheat	Ba/8	Eb
+white	BbEX	c
+widow	BbEz	C4
+wine	BbHr	CV
+wit	BbKA	Bn
+witch	BbLn	Ct
+witticism	BbOU	B+
+woman	BbQS	Oi
+wormsmeat	Bbe0	Ts
+worship	Bbyg	Cc
+wrath	Bb08	Mw
+x	BcBs	Ko
+yankee	BcMU	Ca
+year	BcOu	BF
+yesterday	BcPz	OU
+yoke	BceH	D4
+youth	Bch/	Jg
+zany	Bcrf	Im
+zanzibari	Bc0F	NH
+zeal	BdBM	GB
+zenith	BdHN	O5
+zeus	BdWG	IF
+zigzag	BdeL	GG
+zoology	BdkR	HW
diff --git a/bin/dictionary.zip b/bin/dictionary.zip
new file mode 100644
index 0000000..18cf68c
--- /dev/null
+++ b/bin/dictionary.zip
diff --git a/bin/download-images.py b/bin/download-images.py
new file mode 100755
index 0000000..5ad7e73
--- /dev/null
+++ b/bin/download-images.py
@@ -0,0 +1,30 @@
+#! /bin/python
+import os
+from shutil import copyfile
+import sys
+if os.path.exists(sys.argv[1]):
+    path = os.path.abspath(sys.argv[1])
+else:
+    print("Cannot find " + sys.argv[1])
+    exit()
+with open('/home/lxf/.photocopyrc', 'r') as f:
+    lastfile = str(f.readline().rstrip())
+sorter = []
+for (dirname, dirs, files) in os.walk(path):
+    dirn = os.path.abspath(dirname)
+    for filename in files:
+        if filename.endswith('.ARW'):
+            if int(filename.split('DSC')[1].split(".ARW")[0]) > int(lastfile.split('DSC')[1].split(".ARW")[0]):
+                sorter.append([int(filename.split('DSC')[1].split(".ARW")[0]), filename])
+for f in sorted(sorter):
+    dest = '/home/lxf/pictures/inbox/'
+    if not os.path.exists(dest):
+        os.makedirs(dest)
+    print("copying:", dirn+'/'+f[1], "--->", dest+f[1])
+    copyfile(dirn+'/'+f[1], dest+f[1])
+    try:
+        out = sorted(sorter)[-1]
+        with open('/home/lxf/.photocopyrc', 'w') as f:
+            f.write(out[1])
+    except IndexError:
+        pass
diff --git a/bin/download-videos.py b/bin/download-videos.py
new file mode 100644
index 0000000..194edf1
--- /dev/null
+++ b/bin/download-videos.py
@@ -0,0 +1,29 @@
+#! /bin/python
+import os
+from shutil import copyfile
+import sys
+if os.path.exists(sys.argv[1]):
+    path = os.path.abspath(sys.argv[1])
+else:
+    print("Cannot find " + sys.argv[1])
+    exit()
+with open('/home/lxf/.videocopyrc', 'r') as f:
+    lastfile = str(f.readline().rstrip())
+sorter = []
+for (dirname, dirs, files) in os.walk(path):
+    dirn = os.path.abspath(dirname)
+    for filename in files:
+        if int(filename.split('.MTS')[0]) > int(lastfile.split('.MTS')[0]):
+            sorter.append([int(filename.split('.MTS')[0]), filename])
+for f in sorted(sorter):
+    dest = '/home/lxf/videos/inbox/'
+    if not os.path.exists(dest):
+        os.makedirs(dest)
+    print("copying:", dirn+'/'+f[1], "--->", dest+f[1])
+    copyfile(dirn+'/'+f[1], dest+f[1])
+    try:
+        out = sorted(sorter)[-1]
+        with open('/home/lxf/.videocopyrc', 'w') as f:
+            f.write(out[1])
+    except IndexError:
+        pass
diff --git a/bin/dropkick.sh b/bin/dropkick.sh
new file mode 100755
index 0000000..ddda1bd
--- /dev/null
+++ b/bin/dropkick.sh
@@ -0,0 +1,66 @@
+#!/bin/bash
+#
+# DROPKICK.SH 
+#
+# Detect and Disconnect the DropCam and Withings devices some people are using to
+# spy on guests in their home, especially in AirBnB rentals. Based on Glasshole.sh:
+#
+#   http://julianoliver.com/output/log_2014-05-30_20-52 
+#
+# This script was named by Adam Harvey (http://ahprojects.com), who also
+# encouraged me to write it. It requires a GNU/Linux host (laptop, Raspberry Pi,
+# etc) and the aircrack-ng suite. I put 'beep' in there for a little audio
+# notification. Comment it out if you don't need it.
+#
+# See also http://plugunplug.net, for a plug-and-play device that does this
+# based on OpenWrt. Code here:
+#
+#   https://github.com/JulianOliver/CyborgUnplug
+# 
+# Save as dropkick.sh, 'chmod +x dropkick.sh' and exec as follows:
+#
+#   sudo ./dropkick.sh <WIRELESS NIC> <BSSID OF ACCESS POINT>
+
+shopt -s nocasematch # Set shell to ignore case
+shopt -s extglob # For non-interactive shell.
+
+readonly NIC=$1 # Your wireless NIC
+readonly BSSID=$2 # Network BSSID (AirBnB WiFi network)
+readonly MAC=$(/sbin/ifconfig | grep $NIC | head -n 1 | awk '{ print $5 }')
+# MAC=$(ip link show "$NIC" | awk '/ether/ {print $2}') # If 'ifconfig' not
+# present.
+readonly GGMAC='@(30:8C:FB*|00:24:E4*)' # Match against DropCam and Withings 
+readonly POLL=30 # Check every 30 seconds
+readonly LOG=/var/log/dropkick.log
+
+airmon-ng stop mon0 # Pull down any lingering monitor devices
+airmon-ng start $NIC # Start a monitor device
+
+while true;
+    do  
+        for TARGET in $(arp-scan -I $NIC --localnet | grep -o -E \
+        '([[:xdigit:]]{1,2}:){5}[[:xdigit:]]{1,2}')
+           do
+               if [[ "$TARGET" == "$GGMAC" ]]
+                   then
+                       # Audio alert
+                       beep -f 1000 -l 500 -n 200 -r 2
+                       echo "WiFi camera discovered: "$TARGET >> $LOG
+                       aireplay-ng -0 1 -a $BSSID -c $TARGET mon0 
+                       echo "De-authed: "$TARGET " from network: " $BSSID >> $LOG
+                       echo '
+                             __              __    _     __          __                      
+                         ___/ /______  ___  / /__ (_)___/ /_____ ___/ / 
+                        / _  / __/ _ \/ _ \/   _// / __/   _/ -_) _  / 
+                        \_,_/_/  \___/ .__/_/\_\/_/\__/_/\_\\__/\_,_/  
+                                    /_/
+
+                       '                                        
+                    else
+                        echo $TARGET": is not a DropCam or Withings device. Leaving alone.."
+               fi
+           done
+           echo "None found this round."
+           sleep $POLL
+done
+airmon-ng stop mon0
diff --git a/bin/facebook.sh b/bin/facebook.sh
new file mode 100755
index 0000000..8baae86
--- /dev/null
+++ b/bin/facebook.sh
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+GDK_BACKEND=x11 exo-open ~/bin/apps/book.desktop
diff --git a/bin/fastmail.sh b/bin/fastmail.sh
new file mode 100755
index 0000000..815afe4
--- /dev/null
+++ b/bin/fastmail.sh
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+GDK_BACKEND=x11 exo-open ~/bin/apps/mail.desktop
diff --git a/bin/generate_video_poster.sh b/bin/generate_video_poster.sh
new file mode 100755
index 0000000..0755ad9
--- /dev/null
+++ b/bin/generate_video_poster.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# take in mp4, take screenshot at given interval, output same filename but with jpg extension
+FILE="$1"
+NEWFILE="${FILE%.mp4}.jpg"
+INTERVAL=$2
+echo "file - $FILE"
+ffmpeg -y -i $FILE -f mjpeg -vframes 1 -ss $INTERVAL $NEWFILE
diff --git a/bin/get_links.sh b/bin/get_links.sh
new file mode 100755
index 0000000..d14cee0
--- /dev/null
+++ b/bin/get_links.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+cd ~/bin 
+source venv/bin/activate
+python pinboard_links_to_markdown_files.py
+deactivate
diff --git a/bin/gmail.sh b/bin/gmail.sh
new file mode 100755
index 0000000..1684967
--- /dev/null
+++ b/bin/gmail.sh
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+GDK_BACKEND=x11 exo-open ~/bin/apps/gmailer.desktop
diff --git a/bin/gvim b/bin/gvim
new file mode 100755
index 0000000..9922ba6
--- /dev/null
+++ b/bin/gvim
@@ -0,0 +1,2 @@
+#!/bin/bash
+urxvt -e vim "$@"
diff --git a/bin/hangouts.sh b/bin/hangouts.sh
new file mode 100755
index 0000000..5579dca
--- /dev/null
+++ b/bin/hangouts.sh
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+GDK_BACKEND=x11 exo-open ~/bin/apps/outs.desktop
diff --git a/bin/havedone.sh b/bin/havedone.sh
new file mode 100755
index 0000000..7b71aca
--- /dev/null
+++ b/bin/havedone.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+cd ~/gtd
+mkdir -p ~/gtd/done/$(date '+%Y-%m-%d')
+OIFS="$IFS"
+IFS=$'\n'
+for f in $(find . -maxdepth 1 -type f -print0 | xargs -0 grep -li @done)
+    do
+        print $f
+        mv $f ~/gtd/done/$(date '+%Y-%m-%d')
+    done
+IFS="$OIFS"
diff --git a/bin/havedonegit.sh b/bin/havedonegit.sh
new file mode 100755
index 0000000..59cb066
--- /dev/null
+++ b/bin/havedonegit.sh
@@ -0,0 +1,10 @@
+OIFS="$IFS"
+IFS=$'\n'
+for f in $(git log --branches --pretty=format:"%s" --since="5am")
+    do
+        #watch out for / in commit messages
+        nf=${f//\//:}
+        echo $nf
+        touch ~/gtd/done/$(date '+%Y-%m-%d')/"$nf".txt 
+    done
+IFS="$OIFS"
diff --git a/bin/html2text.py b/bin/html2text.py
new file mode 100644
index 0000000..1752890
--- /dev/null
+++ b/bin/html2text.py
@@ -0,0 +1,914 @@
+#!/usr/bin/env python
+"""html2text: Turn HTML into equivalent Markdown-structured text."""
+__version__ = "3.200.3"
+__author__ = "Aaron Swartz (me@aaronsw.com)"
+__copyright__ = "(C) 2004-2008 Aaron Swartz. GNU GPL 3."
+__contributors__ = ["Martin 'Joey' Schulze", "Ricardo Reyes", "Kevin Jay North"]
+
+# TODO:
+#   Support decoded entities with unifiable.
+
+try:
+    True
+except NameError:
+    setattr(__builtins__, 'True', 1)
+    setattr(__builtins__, 'False', 0)
+
+def has_key(x, y):
+    if hasattr(x, 'has_key'): return x.has_key(y)
+    else: return y in x
+
+try:
+    import htmlentitydefs
+    import urlparse
+    import HTMLParser
+except ImportError: #Python3
+    import html.entities as htmlentitydefs
+    import urllib.parse as urlparse
+    import html.parser as HTMLParser
+try: #Python3
+    import urllib.request as urllib
+except:
+    import urllib
+import optparse, re, sys, codecs, types
+
+try: from textwrap import wrap
+except: pass
+
+# Use Unicode characters instead of their ascii psuedo-replacements
+UNICODE_SNOB = 0
+
+# Escape all special characters.  Output is less readable, but avoids corner case formatting issues.
+ESCAPE_SNOB = 0
+
+# Put the links after each paragraph instead of at the end.
+LINKS_EACH_PARAGRAPH = 0
+
+# Wrap long lines at position. 0 for no wrapping. (Requires Python 2.3.)
+BODY_WIDTH = 78
+
+# Don't show internal links (href="#local-anchor") -- corresponding link targets
+# won't be visible in the plain text file anyway.
+SKIP_INTERNAL_LINKS = True
+
+# Use inline, rather than reference, formatting for images and links
+INLINE_LINKS = True
+
+# Number of pixels Google indents nested lists
+GOOGLE_LIST_INDENT = 36
+
+IGNORE_ANCHORS = False
+IGNORE_IMAGES = False
+IGNORE_EMPHASIS = False
+
+### Entity Nonsense ###
+
+def name2cp(k):
+    if k == 'apos': return ord("'")
+    if hasattr(htmlentitydefs, "name2codepoint"): # requires Python 2.3
+        return htmlentitydefs.name2codepoint[k]
+    else:
+        k = htmlentitydefs.entitydefs[k]
+        if k.startswith("&#") and k.endswith(";"): return int(k[2:-1]) # not in latin-1
+        return ord(codecs.latin_1_decode(k)[0])
+
+unifiable = {'rsquo':"'", 'lsquo':"'", 'rdquo':'"', 'ldquo':'"',
+'copy':'(C)', 'mdash':'--', 'nbsp':' ', 'rarr':'->', 'larr':'<-', 'middot':'*',
+'ndash':'-', 'oelig':'oe', 'aelig':'ae',
+'agrave':'a', 'aacute':'a', 'acirc':'a', 'atilde':'a', 'auml':'a', 'aring':'a',
+'egrave':'e', 'eacute':'e', 'ecirc':'e', 'euml':'e',
+'igrave':'i', 'iacute':'i', 'icirc':'i', 'iuml':'i',
+'ograve':'o', 'oacute':'o', 'ocirc':'o', 'otilde':'o', 'ouml':'o',
+'ugrave':'u', 'uacute':'u', 'ucirc':'u', 'uuml':'u',
+'lrm':'', 'rlm':''}
+
+unifiable_n = {}
+
+for k in unifiable.keys():
+    unifiable_n[name2cp(k)] = unifiable[k]
+
+### End Entity Nonsense ###
+
+def onlywhite(line):
+    """Return true if the line does only consist of whitespace characters."""
+    for c in line:
+        if c is not ' ' and c is not '  ':
+            return c is ' '
+    return line
+
+def hn(tag):
+    if tag[0] == 'h' and len(tag) == 2:
+        try:
+            n = int(tag[1])
+            if n in range(1, 10): return n
+        except ValueError: return 0
+
+def dumb_property_dict(style):
+    """returns a hash of css attributes"""
+    return dict([(x.strip(), y.strip()) for x, y in [z.split(':', 1) for z in style.split(';') if ':' in z]]);
+
+def dumb_css_parser(data):
+    """returns a hash of css selectors, each of which contains a hash of css attributes"""
+    # remove @import sentences
+    data += ';'
+    importIndex = data.find('@import')
+    while importIndex != -1:
+        data = data[0:importIndex] + data[data.find(';', importIndex) + 1:]
+        importIndex = data.find('@import')
+
+    # parse the css. reverted from dictionary compehension in order to support older pythons
+    elements =  [x.split('{') for x in data.split('}') if '{' in x.strip()]
+    try:
+        elements = dict([(a.strip(), dumb_property_dict(b)) for a, b in elements])
+    except ValueError:
+        elements = {} # not that important
+
+    return elements
+
+def element_style(attrs, style_def, parent_style):
+    """returns a hash of the 'final' style attributes of the element"""
+    style = parent_style.copy()
+    if 'class' in attrs:
+        for css_class in attrs['class'].split():
+            css_style = style_def['.' + css_class]
+            style.update(css_style)
+    if 'style' in attrs:
+        immediate_style = dumb_property_dict(attrs['style'])
+        style.update(immediate_style)
+    return style
+
+def google_list_style(style):
+    """finds out whether this is an ordered or unordered list"""
+    if 'list-style-type' in style:
+        list_style = style['list-style-type']
+        if list_style in ['disc', 'circle', 'square', 'none']:
+            return 'ul'
+    return 'ol'
+
+def google_has_height(style):
+    """check if the style of the element has the 'height' attribute explicitly defined"""
+    if 'height' in style:
+        return True
+    return False
+
+def google_text_emphasis(style):
+    """return a list of all emphasis modifiers of the element"""
+    emphasis = []
+    if 'text-decoration' in style:
+        emphasis.append(style['text-decoration'])
+    if 'font-style' in style:
+        emphasis.append(style['font-style'])
+    if 'font-weight' in style:
+        emphasis.append(style['font-weight'])
+    return emphasis
+
+def google_fixed_width_font(style):
+    """check if the css of the current element defines a fixed width font"""
+    font_family = ''
+    if 'font-family' in style:
+        font_family = style['font-family']
+    if 'Courier New' == font_family or 'Consolas' == font_family:
+        return True
+    return False
+
+def list_numbering_start(attrs):
+    """extract numbering from list element attributes"""
+    if 'start' in attrs:
+        return int(attrs['start']) - 1
+    else:
+        return 0
+
+class HTML2Text(HTMLParser.HTMLParser):
+    def __init__(self, out=None, baseurl=''):
+        HTMLParser.HTMLParser.__init__(self)
+
+        # Config options
+        self.unicode_snob = UNICODE_SNOB
+        self.escape_snob = ESCAPE_SNOB
+        self.links_each_paragraph = LINKS_EACH_PARAGRAPH
+        self.body_width = BODY_WIDTH
+        self.skip_internal_links = SKIP_INTERNAL_LINKS
+        self.inline_links = INLINE_LINKS
+        self.google_list_indent = GOOGLE_LIST_INDENT
+        self.ignore_links = IGNORE_ANCHORS
+        self.ignore_images = IGNORE_IMAGES
+        self.ignore_emphasis = IGNORE_EMPHASIS
+        self.google_doc = False
+        self.ul_item_mark = '*'
+        self.emphasis_mark = '_'
+        self.strong_mark = '**'
+
+        if out is None:
+            self.out = self.outtextf
+        else:
+            self.out = out
+
+        self.outtextlist = []  # empty list to store output characters before they are "joined"
+
+        try:
+            self.outtext = unicode()
+        except NameError:  # Python3
+            self.outtext = str()
+
+        self.quiet = 0
+        self.p_p = 0  # number of newline character to print before next output
+        self.outcount = 0
+        self.start = 1
+        self.space = 0
+        self.a = []
+        self.astack = []
+        self.maybe_automatic_link = None
+        self.absolute_url_matcher = re.compile(r'^[a-zA-Z+]+://')
+        self.acount = 0
+        self.list = []
+        self.blockquote = 0
+        self.pre = 0
+        self.startpre = 0
+        self.code = False
+        self.br_toggle = ''
+        self.lastWasNL = 0
+        self.lastWasList = False
+        self.style = 0
+        self.style_def = {}
+        self.tag_stack = []
+        self.emphasis = 0
+        self.drop_white_space = 0
+        self.inheader = False
+        self.abbr_title = None  # current abbreviation definition
+        self.abbr_data = None  # last inner HTML (for abbr being defined)
+        self.abbr_list = {}  # stack of abbreviations to write later
+        self.baseurl = baseurl
+
+        try: del unifiable_n[name2cp('nbsp')]
+        except KeyError: pass
+        unifiable['nbsp'] = '&nbsp_place_holder;'
+
+
+    def feed(self, data):
+        data = data.replace("</' + 'script>", "</ignore>")
+        HTMLParser.HTMLParser.feed(self, data)
+
+    def handle(self, data):
+        self.feed(data)
+        self.feed("")
+        return self.optwrap(self.close())
+
+    def outtextf(self, s):
+        self.outtextlist.append(s)
+        if s: self.lastWasNL = s[-1] == '\n'
+
+    def close(self):
+        HTMLParser.HTMLParser.close(self)
+
+        self.pbr()
+        self.o('', 0, 'end')
+
+        self.outtext = self.outtext.join(self.outtextlist)
+        if self.unicode_snob:
+            nbsp = unichr(name2cp('nbsp'))
+        else:
+            nbsp = u' '
+        self.outtext = self.outtext.replace(u'&nbsp_place_holder;', nbsp)
+
+        return self.outtext
+
+    def handle_charref(self, c):
+        self.o(self.charref(c), 1)
+
+    def handle_entityref(self, c):
+        self.o(self.entityref(c), 1)
+
+    def handle_starttag(self, tag, attrs):
+        self.handle_tag(tag, attrs, 1)
+
+    def handle_endtag(self, tag):
+        self.handle_tag(tag, None, 0)
+
+    def previousIndex(self, attrs):
+        """ returns the index of certain set of attributes (of a link) in the
+            self.a list
+
+            If the set of attributes is not found, returns None
+        """
+        if not has_key(attrs, 'href'): return None
+
+        i = -1
+        for a in self.a:
+            i += 1
+            match = 0
+
+            if has_key(a, 'href') and a['href'] == attrs['href']:
+                if has_key(a, 'title') or has_key(attrs, 'title'):
+                        if (has_key(a, 'title') and has_key(attrs, 'title') and
+                            a['title'] == attrs['title']):
+                            match = True
+                else:
+                    match = True
+
+            if match: return i
+
+    def drop_last(self, nLetters):
+        if not self.quiet:
+            self.outtext = self.outtext[:-nLetters]
+
+    def handle_emphasis(self, start, tag_style, parent_style):
+        """handles various text emphases"""
+        tag_emphasis = google_text_emphasis(tag_style)
+        parent_emphasis = google_text_emphasis(parent_style)
+
+        # handle Google's text emphasis
+        strikethrough =  'line-through' in tag_emphasis and self.hide_strikethrough
+        bold = 'bold' in tag_emphasis and not 'bold' in parent_emphasis
+        italic = 'italic' in tag_emphasis and not 'italic' in parent_emphasis
+        fixed = google_fixed_width_font(tag_style) and not \
+                google_fixed_width_font(parent_style) and not self.pre
+
+        if start:
+            # crossed-out text must be handled before other attributes
+            # in order not to output qualifiers unnecessarily
+            if bold or italic or fixed:
+                self.emphasis += 1
+            if strikethrough:
+                self.quiet += 1
+            if italic:
+                self.o(self.emphasis_mark)
+                self.drop_white_space += 1
+            if bold:
+                self.o(self.strong_mark)
+                self.drop_white_space += 1
+            if fixed:
+                self.o('`')
+                self.drop_white_space += 1
+                self.code = True
+        else:
+            if bold or italic or fixed:
+                # there must not be whitespace before closing emphasis mark
+                self.emphasis -= 1
+                self.space = 0
+                self.outtext = self.outtext.rstrip()
+            if fixed:
+                if self.drop_white_space:
+                    # empty emphasis, drop it
+                    self.drop_last(1)
+                    self.drop_white_space -= 1
+                else:
+                    self.o('`')
+                self.code = False
+            if bold:
+                if self.drop_white_space:
+                    # empty emphasis, drop it
+                    self.drop_last(2)
+                    self.drop_white_space -= 1
+                else:
+                    self.o(self.strong_mark)
+            if italic:
+                if self.drop_white_space:
+                    # empty emphasis, drop it
+                    self.drop_last(1)
+                    self.drop_white_space -= 1
+                else:
+                    self.o(self.emphasis_mark)
+            # space is only allowed after *all* emphasis marks
+            if (bold or italic) and not self.emphasis:
+                    self.o(" ")
+            if strikethrough:
+                self.quiet -= 1
+
+    def handle_tag(self, tag, attrs, start):
+        #attrs = fixattrs(attrs)
+        if attrs is None:
+            attrs = {}
+        else:
+            attrs = dict(attrs)
+
+        if self.google_doc:
+            # the attrs parameter is empty for a closing tag. in addition, we
+            # need the attributes of the parent nodes in order to get a
+            # complete style description for the current element. we assume
+            # that google docs export well formed html.
+            parent_style = {}
+            if start:
+                if self.tag_stack:
+                  parent_style = self.tag_stack[-1][2]
+                tag_style = element_style(attrs, self.style_def, parent_style)
+                self.tag_stack.append((tag, attrs, tag_style))
+            else:
+                dummy, attrs, tag_style = self.tag_stack.pop()
+                if self.tag_stack:
+                    parent_style = self.tag_stack[-1][2]
+
+        if hn(tag):
+            self.p()
+            if start:
+                self.inheader = True
+                self.o(hn(tag)*"#" + ' ')
+            else:
+                self.inheader = False
+                return # prevent redundant emphasis marks on headers
+
+        if tag in ['p', 'div']:
+            if self.google_doc:
+                if start and google_has_height(tag_style):
+                    self.p()
+                else:
+                    self.soft_br()
+            else:
+                self.p()
+
+        if tag == "br" and start: self.o("  \n")
+
+        if tag == "hr" and start:
+            self.p()
+            self.o("* * *")
+            self.p()
+
+        if tag in ["head", "style", 'script']:
+            if start: self.quiet += 1
+            else: self.quiet -= 1
+
+        if tag == "style":
+            if start: self.style += 1
+            else: self.style -= 1
+
+        if tag in ["body"]:
+            self.quiet = 0 # sites like 9rules.com never close <head>
+
+        if tag == "blockquote":
+            if start:
+                self.p(); self.o('> ', 0, 1); self.start = 1
+                self.blockquote += 1
+            else:
+                self.blockquote -= 1
+                self.p()
+
+        if tag in ['em', 'i', 'u'] and not self.ignore_emphasis: self.o(self.emphasis_mark)
+        if tag in ['strong', 'b'] and not self.ignore_emphasis: self.o(self.strong_mark)
+        if tag in ['del', 'strike', 's']:
+            if start:
+                self.o("<"+tag+">")
+            else:
+                self.o("</"+tag+">")
+
+        if self.google_doc:
+            if not self.inheader:
+                # handle some font attributes, but leave headers clean
+                self.handle_emphasis(start, tag_style, parent_style)
+
+        if tag in ["code", "tt"] and not self.pre: self.o('`') #TODO: `` `this` ``
+        if tag == "abbr":
+            if start:
+                self.abbr_title = None
+                self.abbr_data = ''
+                if has_key(attrs, 'title'):
+                    self.abbr_title = attrs['title']
+            else:
+                if self.abbr_title != None:
+                    self.abbr_list[self.abbr_data] = self.abbr_title
+                    self.abbr_title = None
+                self.abbr_data = ''
+
+        if tag == "a" and not self.ignore_links:
+            if start:
+                if has_key(attrs, 'href') and not (self.skip_internal_links and attrs['href'].startswith('#')):
+                    self.astack.append(attrs)
+                    self.maybe_automatic_link = attrs['href']
+                else:
+                    self.astack.append(None)
+            else:
+                if self.astack:
+                    a = self.astack.pop()
+                    if self.maybe_automatic_link:
+                        self.maybe_automatic_link = None
+                    elif a:
+                        if self.inline_links:
+                            self.o("](" + escape_md(a['href']) + ")")
+                        else:
+                            i = self.previousIndex(a)
+                            if i is not None:
+                                a = self.a[i]
+                            else:
+                                self.acount += 1
+                                a['count'] = self.acount
+                                a['outcount'] = self.outcount
+                                self.a.append(a)
+                            self.o("][" + str(a['count']) + "]")
+
+        if tag == "img" and start and not self.ignore_images:
+            if has_key(attrs, 'src'):
+                attrs['href'] = attrs['src']
+                alt = attrs.get('alt', '')
+                self.o("![" + escape_md(alt) + "]")
+
+                if self.inline_links:
+                    self.o("(" + escape_md(attrs['href']) + ")")
+                else:
+                    i = self.previousIndex(attrs)
+                    if i is not None:
+                        attrs = self.a[i]
+                    else:
+                        self.acount += 1
+                        attrs['count'] = self.acount
+                        attrs['outcount'] = self.outcount
+                        self.a.append(attrs)
+                    self.o("[" + str(attrs['count']) + "]")
+
+        if tag == 'dl' and start: self.p()
+        if tag == 'dt' and not start: self.pbr()
+        if tag == 'dd' and start: self.o('    ')
+        if tag == 'dd' and not start: self.pbr()
+
+        if tag in ["ol", "ul"]:
+            # Google Docs create sub lists as top level lists
+            if (not self.list) and (not self.lastWasList):
+                self.p()
+            if start:
+                if self.google_doc:
+                    list_style = google_list_style(tag_style)
+                else:
+                    list_style = tag
+                numbering_start = list_numbering_start(attrs)
+                self.list.append({'name':list_style, 'num':numbering_start})
+            else:
+                if self.list: self.list.pop()
+            self.lastWasList = True
+        else:
+            self.lastWasList = False
+
+        if tag == 'li':
+            self.pbr()
+            if start:
+                if self.list: li = self.list[-1]
+                else: li = {'name':'ul', 'num':0}
+                if self.google_doc:
+                    nest_count = self.google_nest_count(tag_style)
+                else:
+                    nest_count = len(self.list)
+                self.o("  " * nest_count) #TODO: line up <ol><li>s > 9 correctly.
+                if li['name'] == "ul": self.o(self.ul_item_mark + " ")
+                elif li['name'] == "ol":
+                    li['num'] += 1
+                    self.o(str(li['num'])+". ")
+                self.start = 1
+
+        if tag in ["table", "tr"] and start: self.p()
+        if tag == 'td': self.pbr()
+
+        if tag == "pre":
+            if start:
+                self.startpre = 1
+                self.pre = 1
+            else:
+                self.pre = 0
+            self.p()
+
+    def pbr(self):
+        if self.p_p == 0:
+            self.p_p = 1
+
+    def p(self):
+        self.p_p = 2
+
+    def soft_br(self):
+        self.pbr()
+        self.br_toggle = '  '
+
+    def o(self, data, puredata=0, force=0):
+        if self.abbr_data is not None:
+            self.abbr_data += data
+
+        if not self.quiet:
+            if self.google_doc:
+                # prevent white space immediately after 'begin emphasis' marks ('**' and '_')
+                lstripped_data = data.lstrip()
+                if self.drop_white_space and not (self.pre or self.code):
+                    data = lstripped_data
+                if lstripped_data != '':
+                    self.drop_white_space = 0
+
+            if puredata and not self.pre:
+                data = re.sub('\s+', ' ', data)
+                if data and data[0] == ' ':
+                    self.space = 1
+                    data = data[1:]
+            if not data and not force: return
+
+            if self.startpre:
+                #self.out(" :") #TODO: not output when already one there
+                if not data.startswith("\n"):  # <pre>stuff...
+                    data = "\n" + data
+
+            bq = (">" * self.blockquote)
+            if not (force and data and data[0] == ">") and self.blockquote: bq += " "
+
+            if self.pre:
+                if not self.list:
+                    bq += "    "
+                #else: list content is already partially indented
+                for i in xrange(len(self.list)):
+                    bq += "    "
+                data = data.replace("\n", "\n"+bq)
+
+            if self.startpre:
+                self.startpre = 0
+                if self.list:
+                    data = data.lstrip("\n") # use existing initial indentation
+
+            if self.start:
+                self.space = 0
+                self.p_p = 0
+                self.start = 0
+
+            if force == 'end':
+                # It's the end.
+                self.p_p = 0
+                self.out("\n")
+                self.space = 0
+
+            if self.p_p:
+                self.out((self.br_toggle+'\n'+bq)*self.p_p)
+                self.space = 0
+                self.br_toggle = ''
+
+            if self.space:
+                if not self.lastWasNL: self.out(' ')
+                self.space = 0
+
+            if self.a and ((self.p_p == 2 and self.links_each_paragraph) or force == "end"):
+                if force == "end": self.out("\n")
+
+                newa = []
+                for link in self.a:
+                    if self.outcount > link['outcount']:
+                        self.out("   ["+ str(link['count']) +"]: " + urlparse.urljoin(self.baseurl, link['href']))
+                        if has_key(link, 'title'): self.out(" ("+link['title']+")")
+                        self.out("\n")
+                    else:
+                        newa.append(link)
+
+                if self.a != newa: self.out("\n") # Don't need an extra line when nothing was done.
+
+                self.a = newa
+
+            if self.abbr_list and force == "end":
+                for abbr, definition in self.abbr_list.items():
+                    self.out("  *[" + abbr + "]: " + definition + "\n")
+
+            self.p_p = 0
+            self.out(data)
+            self.outcount += 1
+
+    def handle_data(self, data):
+        if r'\/script>' in data: self.quiet -= 1
+
+        if self.style:
+            self.style_def.update(dumb_css_parser(data))
+
+        if not self.maybe_automatic_link is None:
+            href = self.maybe_automatic_link
+            if href == data and self.absolute_url_matcher.match(href):
+                self.o("<" + data + ">")
+                return
+            else:
+                self.o("[")
+                self.maybe_automatic_link = None
+
+        if not self.code and not self.pre:
+            data = escape_md_section(data, snob=self.escape_snob)
+        self.o(data, 1)
+
+    def unknown_decl(self, data): pass
+
+    def charref(self, name):
+        if name[0] in ['x','X']:
+            c = int(name[1:], 16)
+        else:
+            c = int(name)
+
+        if not self.unicode_snob and c in unifiable_n.keys():
+            return unifiable_n[c]
+        else:
+            try:
+                return unichr(c)
+            except NameError: #Python3
+                return chr(c)
+
+    def entityref(self, c):
+        if not self.unicode_snob and c in unifiable.keys():
+            return unifiable[c]
+        else:
+            try: name2cp(c)
+            except KeyError: return "&" + c + ';'
+            else:
+                try:
+                    return unichr(name2cp(c))
+                except NameError: #Python3
+                    return chr(name2cp(c))
+
+    def replaceEntities(self, s):
+        s = s.group(1)
+        if s[0] == "#":
+            return self.charref(s[1:])
+        else: return self.entityref(s)
+
+    r_unescape = re.compile(r"&(#?[xX]?(?:[0-9a-fA-F]+|\w{1,8}));")
+    def unescape(self, s):
+        return self.r_unescape.sub(self.replaceEntities, s)
+
+    def google_nest_count(self, style):
+        """calculate the nesting count of google doc lists"""
+        nest_count = 0
+        if 'margin-left' in style:
+            nest_count = int(style['margin-left'][:-2]) / self.google_list_indent
+        return nest_count
+
+
+    def optwrap(self, text):
+        """Wrap all paragraphs in the provided text."""
+        if not self.body_width:
+            return text
+
+        assert wrap, "Requires Python 2.3."
+        result = ''
+        newlines = 0
+        for para in text.split("\n"):
+            if len(para) > 0:
+                if not skipwrap(para):
+                    result += "\n".join(wrap(para, self.body_width))
+                    if para.endswith('  '):
+                        result += "  \n"
+                        newlines = 1
+                    else:
+                        result += "\n\n"
+                        newlines = 2
+                else:
+                    if not onlywhite(para):
+                        result += para + "\n"
+                        newlines = 1
+            else:
+                if newlines < 2:
+                    result += "\n"
+                    newlines += 1
+        return result
+
+ordered_list_matcher = re.compile(r'\d+\.\s')
+unordered_list_matcher = re.compile(r'[-\*\+]\s')
+md_chars_matcher = re.compile(r"([\\\[\]\(\)])")
+md_chars_matcher_all = re.compile(r"([`\*_{}\[\]\(\)#!])")
+md_dot_matcher = re.compile(r"""
+    ^             # start of line
+    (\s*\d+)      # optional whitespace and a number
+    (\.)          # dot
+    (?=\s)        # lookahead assert whitespace
+    """, re.MULTILINE | re.VERBOSE)
+md_plus_matcher = re.compile(r"""
+    ^
+    (\s*)
+    (\+)
+    (?=\s)
+    """, flags=re.MULTILINE | re.VERBOSE)
+md_dash_matcher = re.compile(r"""
+    ^
+    (\s*)
+    (-)
+    (?=\s|\-)     # followed by whitespace (bullet list, or spaced out hr)
+                  # or another dash (header or hr)
+    """, flags=re.MULTILINE | re.VERBOSE)
+slash_chars = r'\`*_{}[]()#+-.!'
+md_backslash_matcher = re.compile(r'''
+    (\\)          # match one slash
+    (?=[%s])      # followed by a char that requires escaping
+    ''' % re.escape(slash_chars),
+    flags=re.VERBOSE)
+
+def skipwrap(para):
+    # If the text begins with four spaces or one tab, it's a code block; don't wrap
+    if para[0:4] == '    ' or para[0] == '\t':
+        return True
+    # If the text begins with only two "--", possibly preceded by whitespace, that's
+    # an emdash; so wrap.
+    stripped = para.lstrip()
+    if stripped[0:2] == "--" and len(stripped) > 2 and stripped[2] != "-":
+        return False
+    # I'm not sure what this is for; I thought it was to detect lists, but there's
+    # a <br>-inside-<span> case in one of the tests that also depends upon it.
+    if stripped[0:1] == '-' or stripped[0:1] == '*':
+        return True
+    # If the text begins with a single -, *, or +, followed by a space, or an integer,
+    # followed by a ., followed by a space (in either case optionally preceeded by
+    # whitespace), it's a list; don't wrap.
+    if ordered_list_matcher.match(stripped) or unordered_list_matcher.match(stripped):
+        return True
+    return False
+
+def wrapwrite(text):
+    text = text.encode('utf-8')
+    try: #Python3
+        sys.stdout.buffer.write(text)
+    except AttributeError:
+        sys.stdout.write(text)
+
+def html2text(html, baseurl=''):
+    h = HTML2Text(baseurl=baseurl)
+    return h.handle(html)
+
+def unescape(s, unicode_snob=False):
+    h = HTML2Text()
+    h.unicode_snob = unicode_snob
+    return h.unescape(s)
+
+def escape_md(text):
+    """Escapes markdown-sensitive characters within other markdown constructs."""
+    return md_chars_matcher.sub(r"\\\1", text)
+
+def escape_md_section(text, snob=False):
+    """Escapes markdown-sensitive characters across whole document sections."""
+    text = md_backslash_matcher.sub(r"\\\1", text)
+    if snob:
+        text = md_chars_matcher_all.sub(r"\\\1", text)
+    text = md_dot_matcher.sub(r"\1\\\2", text)
+    text = md_plus_matcher.sub(r"\1\\\2", text)
+    text = md_dash_matcher.sub(r"\1\\\2", text)
+    return text
+
+
+def main():
+    baseurl = ''
+
+    p = optparse.OptionParser('%prog [(filename|url) [encoding]]',
+                              version='%prog ' + __version__)
+    p.add_option("--ignore-emphasis", dest="ignore_emphasis", action="store_true",
+        default=IGNORE_EMPHASIS, help="don't include any formatting for emphasis")
+    p.add_option("--ignore-links", dest="ignore_links", action="store_true",
+        default=IGNORE_ANCHORS, help="don't include any formatting for links")
+    p.add_option("--ignore-images", dest="ignore_images", action="store_true",
+        default=IGNORE_IMAGES, help="don't include any formatting for images")
+    p.add_option("-g", "--google-doc", action="store_true", dest="google_doc",
+        default=False, help="convert an html-exported Google Document")
+    p.add_option("-d", "--dash-unordered-list", action="store_true", dest="ul_style_dash",
+        default=False, help="use a dash rather than a star for unordered list items")
+    p.add_option("-e", "--asterisk-emphasis", action="store_true", dest="em_style_asterisk",
+        default=False, help="use an asterisk rather than an underscore for emphasized text")
+    p.add_option("-b", "--body-width", dest="body_width", action="store", type="int",
+        default=BODY_WIDTH, help="number of characters per output line, 0 for no wrap")
+    p.add_option("-i", "--google-list-indent", dest="list_indent", action="store", type="int",
+        default=GOOGLE_LIST_INDENT, help="number of pixels Google indents nested lists")
+    p.add_option("-s", "--hide-strikethrough", action="store_true", dest="hide_strikethrough",
+        default=False, help="hide strike-through text. only relevant when -g is specified as well")
+    p.add_option("--escape-all", action="store_true", dest="escape_snob",
+        default=False, help="Escape all special characters.  Output is less readable, but avoids corner case formatting issues.")
+    (options, args) = p.parse_args()
+
+    # process input
+    encoding = "utf-8"
+    if len(args) > 0:
+        file_ = args[0]
+        if len(args) == 2:
+            encoding = args[1]
+        if len(args) > 2:
+            p.error('Too many arguments')
+
+        if file_.startswith('http://') or file_.startswith('https://'):
+            baseurl = file_
+            j = urllib.urlopen(baseurl)
+            data = j.read()
+            if encoding is None:
+                try:
+                    from feedparser import _getCharacterEncoding as enc
+                except ImportError:
+                    enc = lambda x, y: ('utf-8', 1)
+                encoding = enc(j.headers, data)[0]
+                if encoding == 'us-ascii':
+                    encoding = 'utf-8'
+        else:
+            data = open(file_, 'rb').read()
+            if encoding is None:
+                try:
+                    from chardet import detect
+                except ImportError:
+                    detect = lambda x: {'encoding': 'utf-8'}
+                encoding = detect(data)['encoding']
+    else:
+        data = sys.stdin.read()
+
+    data = data.decode(encoding)
+    h = HTML2Text(baseurl=baseurl)
+    # handle options
+    if options.ul_style_dash: h.ul_item_mark = '-'
+    if options.em_style_asterisk:
+        h.emphasis_mark = '*'
+        h.strong_mark = '__'
+
+    h.body_width = options.body_width
+    h.list_indent = options.list_indent
+    h.ignore_emphasis = options.ignore_emphasis
+    h.ignore_links = options.ignore_links
+    h.ignore_images = options.ignore_images
+    h.google_doc = options.google_doc
+    h.hide_strikethrough = options.hide_strikethrough
+    h.escape_snob = options.escape_snob
+
+    wrapwrite(h.handle(data))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/bin/importer.py b/bin/importer.py
new file mode 100644
index 0000000..592b84d
--- /dev/null
+++ b/bin/importer.py
@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
+
+# Copyright 2014-2019 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
+# Copyright 2014-2018 Claude (longneck) <longneck@scratchbook.ch>
+
+# This file is part of qutebrowser.
+#
+# qutebrowser is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# qutebrowser is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
+
+
+"""Tool to import data from other browsers.
+
+Currently importing bookmarks from Netscape Bookmark files and Mozilla
+profiles is supported.
+"""
+
+
+import argparse
+import sqlite3
+import os
+import urllib.parse
+import json
+import string
+
+browser_default_input_format = {
+    'chromium': 'chrome',
+    'chrome': 'chrome',
+    'ie': 'netscape',
+    'firefox': 'mozilla',
+    'seamonkey': 'mozilla',
+    'palemoon': 'mozilla',
+}
+
+
+def main():
+    args = get_args()
+    bookmark_types = []
+    output_format = None
+    input_format = args.input_format
+    if args.search_output:
+        bookmark_types = ['search']
+        if args.oldconfig:
+            output_format = 'oldsearch'
+        else:
+            output_format = 'search'
+    else:
+        if args.bookmark_output:
+            output_format = 'bookmark'
+        elif args.quickmark_output:
+            output_format = 'quickmark'
+        if args.import_bookmarks:
+            bookmark_types.append('bookmark')
+        if args.import_keywords:
+            bookmark_types.append('keyword')
+    if not bookmark_types:
+        bookmark_types = ['bookmark', 'keyword']
+    if not output_format:
+        output_format = 'quickmark'
+    if not input_format:
+        if args.browser:
+            input_format = browser_default_input_format[args.browser]
+        else:
+            #default to netscape
+            input_format = 'netscape'
+
+    import_function = {
+        'netscape': import_netscape_bookmarks,
+        'mozilla': import_moz_places,
+        'chrome': import_chrome,
+    }
+    import_function[input_format](args.bookmarks, bookmark_types,
+                                  output_format)
+
+
+def get_args():
+    """Get the argparse parser."""
+    parser = argparse.ArgumentParser(
+        epilog="To import bookmarks from Chromium, Firefox or IE, "
+        "export them to HTML in your browsers bookmark manager. ")
+    parser.add_argument(
+        'browser',
+        help="Which browser? {%(choices)s}",
+        choices=browser_default_input_format.keys(),
+        nargs='?',
+        metavar='browser')
+    parser.add_argument(
+        '-i',
+        '--input-format',
+        help='Which input format? (overrides browser default; "netscape" if '
+        'neither given)',
+        choices=set(browser_default_input_format.values()),
+        required=False)
+    parser.add_argument(
+        '-b',
+        '--bookmark-output',
+        help="Output in bookmark format.",
+        action='store_true',
+        default=False,
+        required=False)
+    parser.add_argument(
+        '-q',
+        '--quickmark-output',
+        help="Output in quickmark format (default).",
+        action='store_true',
+        default=False,
+        required=False)
+    parser.add_argument(
+        '-s',
+        '--search-output',
+        help="Output config.py search engine format (negates -B and -K)",
+        action='store_true',
+        default=False,
+        required=False)
+    parser.add_argument(
+        '--oldconfig',
+        help="Output search engine format for old qutebrowser.conf format",
+        default=False,
+        action='store_true',
+        required=False)
+    parser.add_argument(
+        '-B',
+        '--import-bookmarks',
+        help="Import plain bookmarks (can be combiend with -K)",
+        action='store_true',
+        default=False,
+        required=False)
+    parser.add_argument(
+        '-K',
+        '--import-keywords',
+        help="Import keywords (can be combined with -B)",
+        action='store_true',
+        default=False,
+        required=False)
+    parser.add_argument(
+        'bookmarks',
+        help="Bookmarks file (html format) or "
+        "profile folder (Mozilla format)")
+    args = parser.parse_args()
+    return args
+
+
+def search_escape(url):
+    """Escape URLs such that preexisting { and } are handled properly.
+
+    Will obviously trash a properly-formatted qutebrowser URL.
+    """
+    return url.replace('{', '{{').replace('}', '}}')
+
+
+def opensearch_convert(url):
+    """Convert a basic OpenSearch URL into something qutebrowser can use.
+
+    Exceptions:
+        KeyError:
+            An unknown and required parameter is present in the URL. This
+            usually means there's browser/addon specific functionality needed
+            to build the URL (I'm looking at you and your browser, Google) that
+            obviously won't be present here.
+    """
+    subst = {
+        'searchTerms': '%s',  # for proper escaping later
+        'language': '*',
+        'inputEncoding': 'UTF-8',
+        'outputEncoding': 'UTF-8'
+    }
+
+    # remove optional parameters (even those we don't support)
+    for param in string.Formatter().parse(url):
+        if param[1]:
+            if param[1].endswith('?'):
+                url = url.replace('{' + param[1] + '}', '')
+            elif param[2] and param[2].endswith('?'):
+                url = url.replace('{' + param[1] + ':' + param[2] + '}', '')
+    return search_escape(url.format(**subst)).replace('%s', '{}')
+
+
+def import_netscape_bookmarks(bookmarks_file, bookmark_types, output_format):
+    """Import bookmarks from a NETSCAPE-Bookmark-file v1.
+
+    Generated by Chromium, Firefox, IE and possibly more browsers. Not all
+    export all possible bookmark types:
+        - Firefox mostly works with everything
+        - Chrome doesn't support keywords at all; searches are a separate
+          database
+    """
+    import bs4
+    with open(bookmarks_file, encoding='utf-8') as f:
+        soup = bs4.BeautifulSoup(f, 'html.parser')
+    bookmark_query = {
+        'search': lambda tag: (
+            (tag.name == 'a') and
+            ('shortcuturl' in tag.attrs) and
+            ('%s' in tag['href'])),
+        'keyword': lambda tag: (
+            (tag.name == 'a') and
+            ('shortcuturl' in tag.attrs) and
+            ('%s' not in tag['href'])),
+        'bookmark': lambda tag: (
+            (tag.name == 'a') and
+            ('shortcuturl' not in tag.attrs) and
+            (tag.string)),
+    }
+    output_template = {
+        'search': {
+            'search':
+            "c.url.searchengines['{tag[shortcuturl]}'] = "
+            "'{tag[href]}' #{tag.string}"
+        },
+        'oldsearch': {
+            'search': '{tag[shortcuturl]} = {tag[href]} #{tag.string}',
+        },
+        'bookmark': {
+            'bookmark': '{tag[href]} {tag.string}',
+            'keyword': '{tag[href]} {tag.string}'
+        },
+        'quickmark': {
+            'bookmark': '{tag.string} {tag[href]}',
+            'keyword': '{tag[shortcuturl]} {tag[href]}'
+        }
+    }
+    bookmarks = []
+    for typ in bookmark_types:
+        tags = soup.findAll(bookmark_query[typ])
+        for tag in tags:
+            if typ == 'search':
+                tag['href'] = search_escape(tag['href']).replace('%s', '{}')
+            if tag['href'] not in bookmarks:
+                bookmarks.append(
+                    output_template[output_format][typ].format(tag=tag))
+    for bookmark in bookmarks:
+        print(bookmark)
+
+
+def import_moz_places(profile, bookmark_types, output_format):
+    """Import bookmarks from a Mozilla profile's places.sqlite database."""
+    place_query = {
+        'bookmark': (
+            "SELECT DISTINCT moz_bookmarks.title,moz_places.url "
+            "FROM moz_bookmarks,moz_places "
+            "WHERE moz_places.id=moz_bookmarks.fk "
+            "AND moz_places.id NOT IN (SELECT place_id FROM moz_keywords) "
+            "AND moz_places.url NOT LIKE 'place:%';"
+        ),  # Bookmarks with no keywords assigned
+        'keyword': (
+            "SELECT moz_keywords.keyword,moz_places.url "
+            "FROM moz_keywords,moz_places,moz_bookmarks "
+            "WHERE moz_places.id=moz_bookmarks.fk "
+            "AND moz_places.id=moz_keywords.place_id "
+            "AND moz_places.url NOT LIKE '%!%s%' ESCAPE '!';"
+        ),  # Bookmarks with keywords assigned but no %s substitution
+        'search': (
+            "SELECT moz_keywords.keyword, "
+            "    moz_bookmarks.title, "
+            "    search_conv(moz_places.url) AS url "
+            "FROM moz_keywords,moz_places,moz_bookmarks "
+            "WHERE moz_places.id=moz_bookmarks.fk "
+            "AND moz_places.id=moz_keywords.place_id "
+            "AND moz_places.url LIKE '%!%s%' ESCAPE '!';"
+        )  # bookmarks with keyword and %s substitution
+    }
+    out_template = {
+        'bookmark': {
+            'bookmark': '{url} {title}',
+            'keyword': '{url} {keyword}'
+        },
+        'quickmark': {
+            'bookmark': '{title} {url}',
+            'keyword': '{keyword} {url}'
+        },
+        'oldsearch': {
+            'search': '{keyword} {url} #{title}'
+        },
+        'search': {
+            'search': "c.url.searchengines['{keyword}'] = '{url}' #{title}"
+        }
+    }
+
+    def search_conv(url):
+        return search_escape(url).replace('%s', '{}')
+
+    places = sqlite3.connect(os.path.join(profile, "places.sqlite"))
+    places.create_function('search_conv', 1, search_conv)
+    places.row_factory = sqlite3.Row
+    c = places.cursor()
+    for typ in bookmark_types:
+        c.execute(place_query[typ])
+        for row in c:
+            print(out_template[output_format][typ].format(**row))
+
+
+def import_chrome(profile, bookmark_types, output_format):
+    """Import bookmarks and search keywords from Chrome-type profiles.
+
+    On Chrome, keywords and search engines are the same thing and handled in
+    their own database table; bookmarks cannot have associated keywords. This
+    is why the dictionary lookups here are much simpler.
+    """
+    out_template = {
+        'bookmark': '{url} {name}',
+        'quickmark': '{name} {url}',
+        'search': "c.url.searchengines['{keyword}'] = '{url}'",
+        'oldsearch': '{keyword} {url}'
+    }
+
+    if 'search' in bookmark_types:
+        webdata = sqlite3.connect(os.path.join(profile, 'Web Data'))
+        c = webdata.cursor()
+        c.execute('SELECT keyword,url FROM keywords;')
+        for keyword, url in c:
+            try:
+                url = opensearch_convert(url)
+                print(out_template[output_format].format(
+                    keyword=keyword, url=url))
+            except KeyError:
+                print('# Unsupported parameter in url for {}; skipping....'.
+                      format(keyword))
+
+    else:
+        with open(os.path.join(profile, 'Bookmarks'), encoding='utf-8') as f:
+            bookmarks = json.load(f)
+
+        def bm_tree_walk(bm, template):
+            """Recursive function to walk through bookmarks."""
+            if not isinstance(bm, dict):
+                return
+            assert 'type' in bm, bm
+            if bm['type'] == 'url':
+                if urllib.parse.urlparse(bm['url']).scheme != 'chrome':
+                    print(template.format(**bm))
+            elif bm['type'] == 'folder':
+                for child in bm['children']:
+                    bm_tree_walk(child, template)
+
+        for root in bookmarks['roots'].values():
+            bm_tree_walk(root, out_template[output_format])
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bin/instagram.sh b/bin/instagram.sh
new file mode 100755
index 0000000..0ff8cec
--- /dev/null
+++ b/bin/instagram.sh
@@ -0,0 +1,2 @@
+#! /bin/sh
+GDK_BACKEND=x11 exo-open ~/bin/apps/gram.desktop
diff --git a/bin/kanbanscripts/addtask.sh b/bin/kanbanscripts/addtask.sh
new file mode 100755
index 0000000..6099772
--- /dev/null
+++ b/bin/kanbanscripts/addtask.sh
@@ -0,0 +1,2 @@
+#! /bin/sh
+touch ~/gtd/"${2:-FLW} - $1".txt
diff --git a/bin/kanbanscripts/alltasks.py b/bin/kanbanscripts/alltasks.py
new file mode 100755
index 0000000..197c4ba
--- /dev/null
+++ b/bin/kanbanscripts/alltasks.py
@@ -0,0 +1,62 @@
+#!/usr/bin/python
+import os
+from os.path import abspath, dirname
+from operator import itemgetter
+
+
+class bcolors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+
+
+# assuming that this script is in ~/bin/kanban this will work:
+BASE_DIR = abspath(dirname(dirname(dirname(__file__)))) + '/'
+project_list = []
+waiting_list = []
+for root, dirnames, filenames in os.walk('%sgtd' % (BASE_DIR)):
+    for f in filenames:
+        waiting = False
+        inprogress = False
+        if not f.startswith('@') and not f.startswith('.') and not f.startswith('Notes & Settings') and not f.startswith('projx') and not f.startswith("errands"):
+
+            task = f.split("-")[0].strip()
+            name = f.split("-")[1].strip()
+            if len(task) > 3:
+                inprogress = True
+            with open('%sgtd/%s' % (BASE_DIR, f), "r") as fl:
+                for line in fl:
+                    for part in line.split():
+                        if "@waiting" in part:
+                            waiting = True
+            project_list.append({
+                "file": f,
+                "name": name,
+                "task": task,
+                "inprogress": inprogress,
+                "waiting": waiting,
+            })
+    break
+
+newlist = sorted(project_list, key=itemgetter('name', 'task'))
+
+# projects_file = open("/Users/sng/gtd/@projects.txt", 'w')
+l_name = ''
+for i, p in enumerate(newlist):
+    if not p['inprogress'] and not p['waiting']:
+        if l_name == p['name']:
+            print(p['file'][:-4])
+        else:
+            print(p['file'][:-4])
+            l_name = p['name']
+
+"""
+for i, p in enumerate(newlist):
+    if i == 0:
+        print(bcolors.WARNING + "\n------ TASKS WAITING -----" + bcolors.ENDC)
+    if p['waiting'] is True:
+        print(p['file'][:-4])
+"""
diff --git a/bin/kanbanscripts/alltasks_by_type.py b/bin/kanbanscripts/alltasks_by_type.py
new file mode 100755
index 0000000..e2affd8
--- /dev/null
+++ b/bin/kanbanscripts/alltasks_by_type.py
@@ -0,0 +1,56 @@
+#!/usr/bin/python
+import os
+import sys
+from os.path import abspath, dirname
+from operator import itemgetter
+
+ARG = sys.argv[1]
+
+class bcolors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+# assuming that this script is in ~/bin this will work:
+BASE_DIR = abspath(dirname(dirname(__file__))) + '/'
+project_list = []
+waiting_list = []
+for root, dirnames, filenames in os.walk('%sgtd' % (BASE_DIR)):
+    for f in filenames:
+        waiting = False
+        inprogress = False
+        if not f.startswith('@') and not f.startswith('.') and not f.startswith('Notes & Settings') and not f.startswith('projx') and not f.startswith("errands"):
+            name = f[f.find("[") + 1:f.find("]")]
+            task = f[f.find("]") + 2:-4]
+            with open('%sgtd/%s' % (BASE_DIR, f), "r") as fl:
+                for line in fl:
+                    for part in line.split():
+                        if "@waiting" in part:
+                            waiting = True
+            if name == ARG:
+                project_list.append({
+                    "file": f,
+                    "name": name,
+                    "task": task,
+                    "inprogress": inprogress,
+                    "waiting": waiting,
+                })
+    break
+
+newlist = sorted(project_list, key=itemgetter('name', 'task'))
+
+#projects_file = open("/Users/sng/gtd/@projects.txt", 'w')
+l_name = ''
+for i,p in enumerate(newlist):
+    if i == 0:
+        print bcolors.WARNING + "------ %s TASKS -----" %(ARG) + bcolors.ENDC
+    if not p['inprogress'] and not p['waiting']:
+        if l_name == p['name']:
+            print p['file'][:-4]
+        else:
+            if i != 0:
+                print " "
+            print p['file'][:-4]
+            l_name = p['name']
diff --git a/bin/kanbanscripts/havedone.sh b/bin/kanbanscripts/havedone.sh
new file mode 100755
index 0000000..fb47287
--- /dev/null
+++ b/bin/kanbanscripts/havedone.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+cd ~/gtd
+mkdir -p ~/gtd/done/$(date '+%Y-%m-%d')
+OIFS="$IFS"
+IFS=$'\n'
+for f in $(find . -maxdepth 1 -type f -print0 | xargs -0 grep -li @done)
+    do
+        printf $f
+        mv $f ~/gtd/done/$(date '+%Y-%m-%d')
+    done
+IFS="$OIFS"
diff --git a/bin/kanbanscripts/havedonegit.sh b/bin/kanbanscripts/havedonegit.sh
new file mode 100755
index 0000000..59cb066
--- /dev/null
+++ b/bin/kanbanscripts/havedonegit.sh
@@ -0,0 +1,10 @@
+OIFS="$IFS"
+IFS=$'\n'
+for f in $(git log --branches --pretty=format:"%s" --since="5am")
+    do
+        #watch out for / in commit messages
+        nf=${f//\//:}
+        echo $nf
+        touch ~/gtd/done/$(date '+%Y-%m-%d')/"$nf".txt 
+    done
+IFS="$OIFS"
diff --git a/bin/kanbanscripts/review.py b/bin/kanbanscripts/review.py
new file mode 100755
index 0000000..a17cccc
--- /dev/null
+++ b/bin/kanbanscripts/review.py
@@ -0,0 +1,51 @@
+#!/usr/bin/python
+import os
+from os.path import abspath, dirname
+from operator import itemgetter
+
+"""
+    parse my gtd folder
+    pull out files that start with the project name which is in []
+    loop through and grab the project and then all the associated
+    tasks (rest of the file name)
+    print the results out to a file called @project.txt
+"""
+# assuming that this script is in ~/bin this will work:
+BASE_DIR = abspath(dirname(dirname(__file__))) + '/'
+project_list = []
+inprogress = False
+for root, dirnames, filenames in os.walk('%sgtd' % (BASE_DIR)):
+    for f in filenames:
+        if not f.startswith('@') and not f.startswith('.') and not f.startswith('Notes & Settings') and not f.startswith('projx') and not f.startswith("errands"):
+
+            name = f[f.find("[") + 1:f.find("]")]
+            task = f[f.find("]") + 2:-4]
+
+            if f.find("]") > 5:
+                inprogress = True
+                task = "* " + task
+            with open('%sgtd/%s' % (BASE_DIR, f), "r") as fl:
+                for line in fl:
+                    for part in line.split():
+                        if "@waiting" in part:
+                            task = task + " -- " + line.rstrip()
+            project_list.append({
+                "file": f,
+                "name": name,
+                "task": task,
+                "inprogress": inprogress,
+            })
+    break
+
+newlist = sorted(project_list, key=itemgetter('name', 'task'))
+
+projects_file = open("/Users/sng/gtd/@projects.txt", 'w')
+l_name = ''
+
+for p in newlist:
+    if l_name == p['name']:
+        print >> projects_file, "\t" + p['task']
+    else:
+        print >> projects_file, "\n" + p['name']
+        print >> projects_file, "\t" + p['task']
+        l_name = p['name']
diff --git a/bin/kanbanscripts/showall.sh b/bin/kanbanscripts/showall.sh
new file mode 100755
index 0000000..968e6ce
--- /dev/null
+++ b/bin/kanbanscripts/showall.sh
@@ -0,0 +1,4 @@
+clear
+echo '---- ALL TASKS -----'
+python ~/bin/kanbanscripts/alltasks.py
+echo '----'
diff --git a/bin/kanbanscripts/showalltype.sh b/bin/kanbanscripts/showalltype.sh
new file mode 100755
index 0000000..149fc5c
--- /dev/null
+++ b/bin/kanbanscripts/showalltype.sh
@@ -0,0 +1,11 @@
+GREEN=$(tput setaf 2; tput bold)
+NORMAL=$(tput sgr0)
+function green() {
+    echo "$GREEN$*$NORMAL"
+}
+
+clear
+echo '---- TODO -----'
+python ~/bin/alltasks_by_type.py $1
+echo '.'
+echo '.'
diff --git a/bin/kanbanscripts/showdone.sh b/bin/kanbanscripts/showdone.sh
new file mode 100755
index 0000000..7e3d621
--- /dev/null
+++ b/bin/kanbanscripts/showdone.sh
@@ -0,0 +1,4 @@
+clear
+echo '----- TASKS COMPLETED TODAY -----'
+cd ~/gtd/done/$(date '+%Y-%m-%d')
+ls | grep ''
diff --git a/bin/kanbanscripts/showinprogress.sh b/bin/kanbanscripts/showinprogress.sh
new file mode 100755
index 0000000..9b446dc
--- /dev/null
+++ b/bin/kanbanscripts/showinprogress.sh
@@ -0,0 +1,3 @@
+clear
+echo '----- TASKS IN PROGRESS -----'
+cd ~/gtd && ls | grep ^qq | cut -c 4- | cut -f 1 -d '.'
diff --git a/bin/kanbanscripts/workon.sh b/bin/kanbanscripts/workon.sh
new file mode 100755
index 0000000..90a6e1f
--- /dev/null
+++ b/bin/kanbanscripts/workon.sh
@@ -0,0 +1,2 @@
+#! /bin/sh
+mv {,qq\ }"$1"
diff --git a/bin/lux-video-compress.sh b/bin/lux-video-compress.sh
new file mode 100755
index 0000000..0ff4d9d
--- /dev/null
+++ b/bin/lux-video-compress.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+BITRATE=$2
+FILE=$1
+ffmpeg -i $1 -codec:v libx264 -profile:v high -preset slower -b:v ${BITRATE:=2000}k -vf scale=-1:720 -threads 0 -codec:a aac -strict experimental "${FILE%%.*}"-web.mp4
+ffmpeg -i $1 -c:v libvpx -quality good -cpu-used 0 -b:v ${BITRATE:=2000}k -qmin 10 -qmax 42 -maxrate 500k -bufsize 1500k -threads 8 -vf scale=-1:720 -c:a libvorbis -b:a 192k -f webm "${FILE%%.*}"-web.webm
diff --git a/bin/maildir2mbox.py b/bin/maildir2mbox.py
new file mode 100644
index 0000000..2efc7b5
--- /dev/null
+++ b/bin/maildir2mbox.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Frédéric Grosshans, 19 January 2012
+Nathan R. Yergler, 6 June 2010
+
+This file does not contain sufficient creative expression to invoke
+assertion of copyright. No warranty is expressed or implied; use at
+your own risk.
+
+---
+
+Uses Python's included mailbox library to convert mail archives from
+maildir [http://en.wikipedia.org/wiki/Maildir] to
+mbox [http://en.wikipedia.org/wiki/Mbox] format, icluding subfolder.
+
+See http://docs.python.org/library/mailbox.html#mailbox.Mailbox for
+full documentation on this library.
+
+---
+
+To run, save as md2mb.py and run:
+
+$ python md2mb.py [maildir_path] [mbox_filename]
+
+[maildir_path] should be the the path to the actual maildir (containing new,
+cur, tmp, and the subfolders, which are hidden directories with names like
+.subfolde.subsubfolder.subsubsbfolder);
+
+[mbox_filename] will be newly created, as well as a [mbox_filename].sbd the
+directory.
+"""
+
+import mailbox
+import sys
+import email
+import os
+
+def maildir2mailbox(maildirname, mboxfilename):
+   """
+   slightly adapted from maildir2mbox.py,
+   Nathan R. Yergler, 6 June 2010
+   http://yergler.net/blog/2010/06/06/batteries-included-or-maildir-to-mbox-again/
+
+
+   """
+   # open the existing maildir and the target mbox file
+   maildir = mailbox.Maildir(maildirname, email.message_from_file)
+   mbox = mailbox.mbox(mboxfilename)
+
+   # lock the mbox
+   mbox.lock()
+
+   # iterate over messages in the maildir and add to the mbox
+   for msg in maildir:
+       mbox.add(msg)
+
+   # close and unlock
+   mbox.close()
+   maildir.close()
+
+
+dirname=sys.argv[-2]
+mboxname=sys.argv[-1]
+print(dirname +' -> ' +mboxname)
+mboxdirname=mboxname+'.sbd'
+maildir2mailbox(dirname,mboxname)
+if not os.path.exists(mboxdirname): os.makedirs(mboxdirname)
+
+listofdirs=[dn for dn in os.walk(dirname).next()[1] if dn not in ['new', 'cur', 'tmp']]
+for curfold in listofdirs:
+   curlist=[mboxname]+curfold.split('.')
+   curpath=os.path.join(*[dn+'.sbd' for dn in curlist if dn])
+   if not os.path.exists(curpath): os.makedirs(curpath)
+   print('| ' +curfold +' -> '+curpath[:-4])
+   maildir2mailbox(os.path.join(dirname,curfold),curpath[:-4])
+
+print('Done')
\ No newline at end of file
diff --git a/bin/messages.sh b/bin/messages.sh
new file mode 100755
index 0000000..6798742
--- /dev/null
+++ b/bin/messages.sh
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exo-open ~/bin/apps/messages.desktop
diff --git a/bin/moonphase.py b/bin/moonphase.py
new file mode 100755
index 0000000..1bee795
--- /dev/null
+++ b/bin/moonphase.py
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+"""
+moonphase.py - Calculate Lunar Phase
+Author: Sean B. Palmer, inamidst.com
+Cf. http://en.wikipedia.org/wiki/Lunar_phase#Lunar_phase_calculation
+"""
+
+import math
+import decimal
+import datetime
+
+dec = decimal.Decimal
+
+
+def position(now=None):
+    if now is None:
+        now = datetime.datetime.now()
+
+    diff = now - datetime.datetime(2001, 1, 1)
+    days = dec(diff.days) + (dec(diff.seconds) / dec(86400))
+    lunations = dec("0.20439731") + (days * dec("0.03386319269"))
+
+    return lunations % dec(1)
+
+
+def phase(pos):
+    index = (pos * dec(8)) + dec("0.5")
+    index = math.floor(index)
+    return {
+       0: "New Moon",
+       1: "Waxing Crescent",
+       2: "First Quarter",
+       3: "Waxing Gibbous",
+       4: "Full Moon",
+       5: "Waning Gibbous",
+       6: "Last Quarter",
+       7: "Waning Crescent"
+    }[int(index) & 7]
+
+
+def main():
+    pos = position()
+    phasename = phase(pos)
+
+    roundedpos = round(float(pos), 3)
+    num_days = float(roundedpos * 29.6)
+    print("%s (%s) %s days" % (phasename, roundedpos, num_days))
+
+if __name__=="__main__":
+    main()
diff --git a/bin/mpd-playlist-export.py b/bin/mpd-playlist-export.py
new file mode 100755
index 0000000..0e1e393
--- /dev/null
+++ b/bin/mpd-playlist-export.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+
+"""
+Simple tool that copies current mpd playlist's files to an external directory.
+It also creates a m3u playlist file there (eg. for Android devices).
+"""
+
+__author__ = 'Marcin Rataj (http://lidel.org)'
+__license__ = 'CC0 (public domain)'
+
+
+# requires: python-mpd >=0.3.0 (http://jatreuman.indefero.net/p/python-mpd/)
+from mpd import (MPDClient, CommandError)
+from random import choice
+from socket import error as SocketError
+from shutil import copy
+import argparse
+import os
+import sys
+
+
+## SETTINGS
+HOST = 'localhost'
+PORT = '6600'
+PASSWORD = False
+LIBRARY_DIR = '/home/lxf/music/library'
+
+
+def get_paths(root):
+    client = MPDClient()
+    client.connect(host=HOST, port=PORT)
+
+    if PASSWORD:
+        client.password(PASSWORD)
+
+    playlist = client.playlist()
+    client.disconnect()
+
+    return [entry.replace('file: ', root) for entry in playlist if entry.startswith('file: ')]
+
+
+def copy_files(files, args):
+    dest = args.output
+    if not os.path.exists(dest):
+        os.makedirs(dest)
+    for file in files:
+        if not args.quiet:
+            print("copying '{0}' to '{1}'".format(os.path.basename(file), dest))
+        copy(file, dest)
+
+
+def create_playlist(files, args):
+    dest = args.output
+    name = os.path.basename(os.path.normpath(args.output))
+    playlist_file = open("{0}/{1}.m3u".format(dest, name), 'w')
+    for song in files:
+        playlist_file.write(os.path.basename(song) + '\n')
+    playlist_file.close()
+
+
+def main(parser):
+    try:
+        args = parser.parse_args()
+        playlist_files = get_paths(args.library+"/")
+        copy_files(playlist_files, args)
+        create_playlist(playlist_files, args)
+    except Exception as e:
+        print("Error occured:\n{0}\nAborted.".format(e))
+        return 1
+    else:
+        return 0
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('-quiet', default=False, action='store_true', help='Be quiet.')
+    parser.add_argument('-output', required=True, help='Output directory. (required)')
+    parser.add_argument('-library', default=LIBRARY_DIR, help="MPD library path. Default: {0}".format(LIBRARY_DIR))
+    sys.exit(main(parser))
+
+# vim: ai ts=4 sw=4 sts=4 expandtab
diff --git a/bin/mqq.sh b/bin/mqq.sh
new file mode 100755
index 0000000..6543d8e
--- /dev/null
+++ b/bin/mqq.sh
@@ -0,0 +1,6 @@
+#!/bin/sh
+# $HOME/Scripts/mqq
+
+#message_id=$(grep -E -i "^Message-id:" | sed -e 's/.*<\(.*\)>/\1/')
+BODY=$(sed -n '/^Date/,$ p' | grep -E -i '^[^X]+' | sed -En '/^Date/,/application\// p')
+echo "${BODY}" | sed -En '/^Date/,/text\/html/ p' > /Users/sng/Notes/"$1".txt
diff --git a/bin/mts-convert.sh b/bin/mts-convert.sh
new file mode 100755
index 0000000..8780436
--- /dev/null
+++ b/bin/mts-convert.sh
@@ -0,0 +1,3 @@
+for f in *.MTS; do 
+    ffmpeg -i "$f" -vcodec copy -acodec copy ${f%.MTS}.mp4;
+done
diff --git a/bin/mutt-notmuch-py.py b/bin/mutt-notmuch-py.py
new file mode 100755
index 0000000..60708c5
--- /dev/null
+++ b/bin/mutt-notmuch-py.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+"""
+mutt-notmuch-py
+
+This is a Gmail-only version of the original mutt-notmuch script.
+
+It will interactively ask you for a search query and then symlink the matching
+messages to $HOME/.cache/mutt_results.
+
+Add this to your muttrc.
+
+macro index / "<enter-command>unset wait_key<enter><shell-escape>mutt-notmuch-py<enter><change-folder-readonly>~/.cache/mutt_results<enter>" \
+          "search mail (using notmuch)"
+
+This script overrides the $HOME/.cache/mutt_results each time you run a query.
+
+Install this by adding this file somewhere on your PATH.
+
+Only tested on OSX Lion.
+
+(c) 2012 - Honza Pokorny
+Licensed under BSD
+"""
+import hashlib, sys
+from subprocess import getoutput
+from mailbox import Maildir
+from optparse import OptionParser
+
+
+def digest(filename):
+    with open(filename, "r", encoding='utf-8') as f:
+        return hashlib.sha1(f.read()).hexdigest()
+
+
+def pick_all_mail(messages):
+    for m in messages:
+        if 'All Mail' in m:
+            return m
+
+
+def empty_dir(directory):
+    box = Maildir(directory)
+    box.clear()
+
+
+def command(cmd):
+    return getoutput(cmd)
+
+
+def main(dest_box):
+    query = input('Query: ').encode('utf-8')
+
+    command('mkdir -p %s' % dest_box)
+    command('mkdir -p %s/cur' % dest_box)
+    command('mkdir -p %s/new' % dest_box)
+
+    empty_dir(dest_box)
+
+    files = command('notmuch search --output=files %s' % query).split('\n')
+    files = filter(None, files)
+
+    data = {}
+    messages = []
+
+    for f in files:
+        sha = digest(f)
+        if sha not in data.keys():
+            data[sha] = [f]
+        else:
+            data[sha].append(f)
+
+    for sha in data.keys():
+        if is_gmail and len(data[sha]) > 1:
+            messages.append(pick_all_mail(data[sha]))
+        else:
+            messages.append(data[sha][0])
+
+    for m in messages:
+        command('ln -s "%s" %s/cur/' % (m, dest_box))
+
+
+if __name__ == '__main__':
+    global is_gmail
+
+    p = OptionParser("usage: %prog [OPTIONS] [RESULTDIR]")
+    p.add_option('-g', '--gmail', dest='gmail',
+                 action='store_true', default=True,
+                 help='gmail-specific behavior')
+    p.add_option('-G', '--not-gmail', dest='gmail',
+                 action='store_false',
+                 help='gmail-specific behavior')
+    (options, args) = p.parse_args()
+
+    is_gmail = options.gmail
+
+    if args:
+        dest = args[0]
+    else:
+        dest = '~/.cache/mutt_results'
+
+    main(dest.rstrip('/'))
diff --git a/bin/natlangdate.py b/bin/natlangdate.py
new file mode 100755
index 0000000..4fe7528
--- /dev/null
+++ b/bin/natlangdate.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+import os
+import sys
+import re
+import parsedatetime.parsedatetime as pdt
+#import parsedatetime.parsedatetime_consts as pdc
+import datetime
+
+# Define Globals
+pyDate = os.getenv('KMVAR_myDate')
+
+# Function for parsing a string and returning a datetime value
+def datetimeFromString( s ):
+    #c = pdc.Constants()
+    p = pdt.Calendar()
+    result, what = p.parse( s )
+    dt = 0
+    # See: http://stackoverflow.com/questions/1810432/handling-the-different-results-from-parsedatetime
+    # what was returned (see http://code-bear.com/code/parsedatetime/docs/)
+    # 0 = failed to parse
+    # 1 = date (with current time, as a struct_time)
+    # 2 = time (with current date, as a struct_time)
+    # 3 = datetime
+    if what in (1,2,3):
+        # result is struct_time
+        dt = datetime.datetime( *result[:6] )
+    if what == 0:
+        # Failed to parse
+        raise ValueError, ("Don't understand date '"+s+"'")
+        dt = "Unrecognized Date"
+    return dt
+NLPDate = datetimeFromString(pyDate)
+print NLPDate
diff --git a/bin/open-in-pane b/bin/open-in-pane
new file mode 100755
index 0000000..f5f07ab
--- /dev/null
+++ b/bin/open-in-pane
@@ -0,0 +1,23 @@
+#!/bin/sh
+
+W3M='/usr/bin/w3m'
+
+# If the window has only one pane, create one by splitting.
+pane_count=`tmux list-panes -F '#{line}' | wc -l`
+if [ $pane_count -lt 2 ]; then
+    tmux split-window -h
+fi
+
+# Start my reader if it ain't running already, and send it the URL
+# to
+# open.
+  
+w3m_process_count=`ps auxw | grep "$W3M" | grep -cv grep`
+      
+if [ $w3m_process_count = '1' ];then
+    tmux send-keys -t 2 "TU" "C-u" "$1" enter
+    tmux select-pane -t 2
+else
+    tmux send-keys -t 2 "$W3M \"$1\"" enter
+    tmux select-pane -t 2
+fi
diff --git a/bin/opener.sh b/bin/opener.sh
new file mode 100755
index 0000000..e873b0d
--- /dev/null
+++ b/bin/opener.sh
@@ -0,0 +1,3 @@
+#! /bin/bash
+
+wmctrl -a Ranger; sleep 1 && xdotool key Control_L+n && xdotool key Shift+\: && xdotool type cd ${1} && xdotool key Return
diff --git a/bin/parse_subids.py b/bin/parse_subids.py
new file mode 100644
index 0000000..5e8b8f2
--- /dev/null
+++ b/bin/parse_subids.py
@@ -0,0 +1,19 @@
+from bs4 import BeautifulSoup
+import markdown
+
+
+with open('/home/lxf/writing/wired/bf-photo-deals.txt', 'r') as f:
+    data = f.read()
+result = open('/home/lxf/writing/wired/subid-links.txt', 'a')
+soup = BeautifulSoup(markdown.markdown(data), "lxml")
+subid = "blackfridayphotodeals2019"
+page_url = "https://www.wired.com/story/best-black-friday-photography-deals-2019/"
+for a in soup.find_all('a'):
+    start = a['href'].split('//')[1][:4]
+    if str(start) == 'best' or start == 'goto':
+        l = "%s,,%s,Impact,%s\n" % (page_url, subid, a['href']) 
+        result.write(l)
+result.close()
+
+def parse_links(f):
+    
diff --git a/bin/parse_vivaldi_notes.py b/bin/parse_vivaldi_notes.py
new file mode 100644
index 0000000..078a780
--- /dev/null
+++ b/bin/parse_vivaldi_notes.py
@@ -0,0 +1,8 @@
+import json
+with open("/home/lxf/.config/vivaldi-snapshot/Default/Notes", 'r') as data_file:
+    data = json.load(data_file)
+
+for d in data['children']:
+    if d['subject'] == 'lbh notes':
+        
+    print(d['subject'])
diff --git a/bin/pass-completion.bash b/bin/pass-completion.bash
new file mode 100644
index 0000000..456485b
--- /dev/null
+++ b/bin/pass-completion.bash
@@ -0,0 +1,130 @@
+# completion file for bash
+
+# Copyright (C) 2012 - 2014 Jason A. Donenfeld <Jason@zx2c4.com> and
+# Brian Mattern <rephorm@rephorm.com>. All Rights Reserved.
+# This file is licensed under the GPLv2+. Please see COPYING for more information.
+
+_pass_complete_entries () {
+	prefix="${PASSWORD_STORE_DIR:-$HOME/.password-store/}"
+	prefix="${prefix%/}/"
+	suffix=".gpg"
+	autoexpand=${1:-0}
+
+	local IFS=$'\n'
+	local items=($(compgen -f $prefix$cur))
+
+	# Remember the value of the first item, to see if it is a directory. If
+	# it is a directory, then don't add a space to the completion
+	local firstitem=""
+	# Use counter, can't use ${#items[@]} as we skip hidden directories
+	local i=0
+
+	for item in ${items[@]}; do
+		[[ $item =~ /\.[^/]*$ ]] && continue
+
+		# if there is a unique match, and it is a directory with one entry
+		# autocomplete the subentry as well (recursively)
+		if [[ ${#items[@]} -eq 1 && $autoexpand -eq 1 ]]; then
+			while [[ -d $item ]]; do
+				local subitems=($(compgen -f "$item/"))
+				local filtereditems=( )
+				for item2 in "${subitems[@]}"; do
+					[[ $item2 =~ /\.[^/]*$ ]] && continue
+					filtereditems+=( "$item2" )
+				done
+				if [[ ${#filtereditems[@]} -eq 1 ]]; then
+					item="${filtereditems[0]}"
+				else
+					break
+				fi
+			done
+		fi
+
+		# append / to directories
+		[[ -d $item ]] && item="$item/"
+
+		item="${item%$suffix}"
+		COMPREPLY+=("${item#$prefix}")
+		if [[ $i -eq 0 ]]; then
+			firstitem=$item
+		fi
+		let i+=1
+	done
+
+	# The only time we want to add a space to the end is if there is only
+	# one match, and it is not a directory
+	if [[ $i -gt 1 || ( $i -eq 1 && -d $firstitem ) ]]; then
+		compopt -o nospace
+	fi
+}
+
+_pass_complete_folders () {
+	prefix="${PASSWORD_STORE_DIR:-$HOME/.password-store/}"
+	prefix="${prefix%/}/"
+
+	local IFS=$'\n'
+	local items=($(compgen -d $prefix$cur))
+	for item in ${items[@]}; do
+		[[ $item == $prefix.* ]] && continue
+		COMPREPLY+=("${item#$prefix}/")
+	done
+}
+
+_pass_complete_keys () {
+	local IFS=$'\n'
+	# Extract names and email addresses from gpg --list-keys
+	local keys="$(gpg2 --list-secret-keys --with-colons | cut -d : -f 10 | sort -u | sed '/^$/d')"
+	COMPREPLY+=($(compgen -W "${keys}" -- ${cur}))
+}
+
+_pass()
+{
+	COMPREPLY=()
+	local cur="${COMP_WORDS[COMP_CWORD]}"
+	local commands="init ls find grep show insert generate edit rm mv cp git help version"
+	if [[ $COMP_CWORD -gt 1 ]]; then
+		local lastarg="${COMP_WORDS[$COMP_CWORD-1]}"
+		case "${COMP_WORDS[1]}" in
+			init)
+				if [[ $lastarg == "-p" || $lastarg == "--path" ]]; then
+					_pass_complete_folders
+					compopt -o nospace
+				else
+					COMPREPLY+=($(compgen -W "-p --path" -- ${cur}))
+					_pass_complete_keys
+				fi
+				;;
+			ls|list|edit)
+				_pass_complete_entries
+				;;
+			show|-*)
+				COMPREPLY+=($(compgen -W "-c --clip" -- ${cur}))
+				_pass_complete_entries 1
+				;;
+			insert)
+				COMPREPLY+=($(compgen -W "-e --echo -m --multiline -f --force" -- ${cur}))
+				_pass_complete_entries
+				;;
+			generate)
+				COMPREPLY+=($(compgen -W "-n --no-symbols -c --clip -f --force -i --in-place" -- ${cur}))
+				_pass_complete_entries
+				;;
+			cp|copy|mv|rename)
+				COMPREPLY+=($(compgen -W "-f --force" -- ${cur}))
+				_pass_complete_entries
+				;;
+			rm|remove|delete)
+				COMPREPLY+=($(compgen -W "-r --recursive -f --force" -- ${cur}))
+				_pass_complete_entries
+				;;
+			git)
+				COMPREPLY+=($(compgen -W "init push pull config log reflog rebase" -- ${cur}))
+				;;
+		esac
+	else
+		COMPREPLY+=($(compgen -W "${commands}" -- ${cur}))
+		_pass_complete_entries 1
+	fi
+}
+
+complete -o filenames -F _pass pass
diff --git a/bin/passmenu.sh b/bin/passmenu.sh
new file mode 100755
index 0000000..7a9c517
--- /dev/null
+++ b/bin/passmenu.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+shopt -s nullglob globstar
+
+typeit=0
+if [[ $1 == "--type" ]]; then
+	typeit=1
+	shift
+fi
+
+prefix=${PASSWORD_STORE_DIR-~/.password-store}
+password_files=( "$prefix"/**/*.gpg )
+password_files=( "${password_files[@]#"$prefix"/}" )
+password_files=( "${password_files[@]%.gpg}" )
+
+password=$(printf '%s\n' "${password_files[@]}" | dmenu "$@")
+
+[[ -n $password ]] || exit
+
+if [[ $typeit -eq 0 ]]; then
+	pass show -c "$password" 2>/dev/null
+else
+	pass show "$password" | { read -r pass; printf %s "$pass"; } |
+		xdotool type --clearmodifiers --file -
+fi
diff --git a/bin/pinboard_links_to_markdown_files.py b/bin/pinboard_links_to_markdown_files.py
new file mode 100755
index 0000000..700d1aa
--- /dev/null
+++ b/bin/pinboard_links_to_markdown_files.py
@@ -0,0 +1,39 @@
+#!/usr/bin/python
+import os
+import requests
+
+
+def get_pinboard_links():
+    with open(os.environ['HOME'] + '/.pinboard-credentials') as credentials:
+        for line in credentials:
+            me, token = line.split(':')
+    url = 'https://api.pinboard.in/v1/posts/all?results=80&format=json&auth_token=' + me + ':' + token
+    r = requests.get(url, timeout=9.001)
+    print(url)
+    data = r.json()
+    print(date)
+    for item in data:
+        print(item['description'])
+        md = get_markdown(item['href'])
+        body = md['markdown']
+        body.encode("utf-8")
+        file_name = str(item['description']).replace("/", "")
+        file_path = "%s/Documents/bookmarks-tmp/%s.txt" % (os.environ['HOME'], file_name.lower())
+        date = item['time']
+        tags = ", ".join(t for t in str(item['tags']).split(' '))
+        preamble = "---\ntitle: %s\ndate: %s\nsource: %s\ntags: %s\n\n---\n\n" % (md['title'], date, item['href'], tags)
+        import codecs
+        f = codecs.open(file_path, "w", 'utf8')
+        f.write(preamble)
+        f.write(body)
+        f.close()
+
+
+def get_markdown(source):
+    url = "http://heckyesmarkdown.com/go/?read=1&preview=0&showframe=0&output=json&u=%s" % (source)
+    print(url)
+    r = requests.get(url, timeout=15.001)
+    data = r.json()
+    return data
+
+get_pinboard_links()
diff --git a/bin/pomodoro.sh b/bin/pomodoro.sh
new file mode 100755
index 0000000..3ab09ac
--- /dev/null
+++ b/bin/pomodoro.sh
@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+
+###################
+# Morgan Reece (Phillips)
+# mrrrgn.com
+# wiki.mrrrgn.com
+#
+# This script will notify the user when to work and when to rest
+# in intervals as specified in http://en.wikipedia.org/wiki/Pomodoro_Technique
+# notifications are sent out via terminal-notifier http://rubygems.org/gems/terminal-notifier
+# on OS X or the pynotify library on Linux.  The script will also blacklist any domains listed
+# in a file named .pomodoro.urls.blacklist stored in the users home directory.
+####################
+
+set -e
+
+SUDO_USER=${SUDO_USER}; # So we can run commands as non-root
+
+### INVERVAL CONSTANTS ###
+
+WORK_INTERVAL_SEC=1500; # 25 minutes of work
+WORK_MSG="begin-working....";
+
+REST_INTERVAL_SEC=300; # 5 minutes of rest
+REST_MSG="take-a-rest....";
+
+SET_SIZE=4; # Take a long rest after this many iterations
+SET_INTERVAL_SEC=1200; # 15 minute post-set rest
+SET_MSG="set-has-ended....";
+
+### Set up OS Specific commands and variables ###
+
+if [ `uname` = "Darwin" ]; then
+    ### OS X ###
+
+    # Make sure terminal-notifier is installed
+    if ! which terminal-notifier
+        then gem install terminal-notifier;
+    fi
+
+    CMD="terminal-notifier -title -sound default -message";
+    
+    # Because we can't count on ~
+    USER_HOME="/Users/$SUDO_USER/";
+    CMD_AS_USER="sudo -u $SUDO_USER"; # We need this for notifications to work
+else
+    ### Debian/Linux ###
+    USER_HOME="/home/$SUDO_USER/";
+    CMD_AS_USER="";
+     
+    # Because Linux can run headless, a more complex
+    # notification command is needed, that takes args,
+    # so a function holds all of the logic.
+    function linux_notify() {
+        # A text only notification
+        echo $1 | wall;
+    }
+    CMD="linux_notify";
+    if echo $DISPLAY 1>/dev/null; then
+        if python -m notify2 2>/dev/null; then 
+            function linux_notify() {
+                python -c "import notify2;notify2.init('psh');m=notify2.Notification('pomodoro.sh', $1);m.show();";
+            }
+	    fi
+    fi
+fi
+
+
+### FILE LOCATIONS ###
+
+BACKUPHOSTSFILE=.pomodoro.etc.hosts.bak; # store the unhampered hosts file here
+BLACKLIST=.pomodoro.urls.blacklist; # urls to blacklist during work
+PIDFILE=.pomodoro.pid;
+
+### OS agnostic commands ###
+CMD_WORK_START="$CMD_AS_USER $CMD '$WORK_MSG'";
+CMD_REST_START="$CMD_AS_USER $CMD '$REST_MSG'";
+CMD_SET_END="$CMD_AS_USER $CMD '$SET_MSG'";
+
+### FUNCTIONS ###
+
+function root_check {
+    if [ "$(id -u)" != "0" ]; then
+        echo "This script must be run as root" 1>&2;
+        exit 1;
+    fi
+}
+
+function blacklist_hosts_file {
+    if test -f "$USER_HOME$BLACKLIST"; then
+        cp /etc/hosts "$USER_HOME$BACKUPHOSTSFILE";
+        # A simple checksum for our backup
+        if [ $(wc -l < /etc/hosts) = $(wc -l < "$USER_HOME$BACKUPHOSTSFILE") ]; then
+            # Append our blacklist values
+            cat "$USER_HOME$BLACKLIST" | awk '{print "127.0.0.1 "$1}' >> /etc/hosts;
+        fi
+    fi
+}
+
+function unblacklist_hosts_file {
+    if test -f "$USER_HOME$BACKUPHOSTSFILE"; then
+        # Overwrite the current hosts file with our backup
+        cp "$USER_HOME$BACKUPHOSTSFILE" /etc/hosts;
+        # rm the old backup file after a checksum
+        if [ $(wc -l < /etc/hosts) = $(wc -l < "$USER_HOME$BACKUPHOSTSFILE") ]; then
+            rm "$USER_HOME$BACKUPHOSTSFILE";
+        fi
+    fi
+}
+
+### Only attempt to run if we're root ###
+root_check;
+
+### Start Working! ###
+if [ x"$1" = xstart ]; then
+    if test -f "$USER_HOME$PIDFILE"; then exit; fi
+    echo $$ > "$USER_HOME$PIDFILE"
+    while true; do
+        for i in $(seq 1 $SET_SIZE); do
+            # Work starts
+            blacklist_hosts_file;
+            $CMD_WORK_START;
+            $CMD_AS_USER sleep $WORK_INTERVAL_SEC;
+            # Rest starts
+            unblacklist_hosts_file;
+            $CMD_REST_START;
+            $CMD_AS_USER sleep $REST_INTERVAL_SEC;
+        done
+        # Set interval ends here
+        $CMD_SET_END;
+        $CMD_AS_USER sleep $SET_INTERVAL_SEC;
+    done
+elif [ x"$1" = xstop ]; then
+    # Cleanup hosts file and die.
+    unblacklist_hosts_file;
+    PID=$(cat $USER_HOME$PIDFILE);
+    rm -f $USER_HOME$PIDFILE
+    kill -9 $PID;
+fi
diff --git a/bin/qutebrowser-cookiecleaner b/bin/qutebrowser-cookiecleaner
new file mode 100755
index 0000000..0aa06c1
--- /dev/null
+++ b/bin/qutebrowser-cookiecleaner
@@ -0,0 +1,212 @@
+#!/usr/bin/perl
+# qutebrowser-cookiecleaner
+# Copyright (C) Eskild Hustvedt 2018
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use 5.014;
+use warnings;
+use DBI;
+use List::Util 1.33 qw(all);
+use File::Basename qw(basename);
+use Getopt::Long;
+use File::Glob qw(bsd_glob);
+use constant {
+    V_INFO => 1,
+};
+
+my $VERSION = 0.1;
+my $verbosity = 0;
+my $XDG_DATA_HOME = $ENV{XDG_DATA_HOME} ? $ENV{XDG_DATA_HOME} : $ENV{HOME}.'/.local/share';
+my $XDG_CONFIG_HOME = $ENV{XDG_CONFIG_HOME} ? $ENV{XDG_CONFIG_HOME} : $ENV{HOME}.'/.config';
+
+# Output something in verbose mode
+sub sayv
+{
+    my $level = shift;
+    if ($verbosity >= $level)
+    {
+        say(@_);
+    }
+}
+
+# Retrieve a database handle
+sub DBH
+{
+    my $dbfile = $XDG_DATA_HOME.'/qutebrowser/webengine/Cookies';
+    if (!-e $dbfile)
+    {
+        die($dbfile.': does not exist'."\n");
+    }
+    my $dbh = DBI->connect("dbi:SQLite:dbname=$dbfile",'','');
+
+    return $dbh;
+}
+
+# Expire cookies, local storage, IndexedDB and databases, except those whitelisted
+sub expireContent
+{
+    my $dbh = DBH();
+
+    my @statements;
+    my @exceptions;
+    my @whitelist;
+
+    open(my $i,'<',$XDG_CONFIG_HOME.'/qutebrowser-cookiecleaner.list');
+    my $no = 0;
+    while (my $line = <$i>)
+    {
+        $no++;
+        next if $line =~ /^\s*#/;
+        chomp($line);
+        if (index($line,'%') != -1)
+        {
+            die('Line  '.$no.' contains forbidden character "%"'."\n");
+        }
+        push(@exceptions,'%'.$line);
+        push(@statements,'host_key NOT LIKE ?');
+        push(@whitelist,$line);
+    }
+    close($i);
+
+    if(scalar @exceptions == 0)
+    {
+        die('Your qutebrowser-cookiecleaner.list file has no exceptions. Refusing to continue.'."\n");
+    }
+
+    # --
+    # Cookies
+    # --
+
+    my $sth;
+
+    my $deleteStatement = 'DELETE FROM cookies WHERE '.join(' AND ',@statements);
+    my $deletedEntriesStatement = 'SELECT * FROM cookies WHERE '.join(' AND ',@statements);
+
+    # If verbose mode is on, we need more information, so fetch and output the
+    # entries we will delete.
+    if ($verbosity > 0)
+    {
+        $sth = $dbh->prepare($deletedEntriesStatement);
+        $sth->execute(@exceptions);
+
+        while(my $entry = $sth->fetchrow_hashref)
+        {
+            sayv(V_INFO,'Deleting "'.$entry->{name}.'" for "'.$entry->{host_key}.'"');
+        }
+    }
+
+    $sth = $dbh->prepare($deleteStatement);
+    $sth->execute(@exceptions);
+
+    $sth = $dbh->prepare('VACUUM;');
+    $sth->execute();
+
+    $dbh->disconnect;
+
+    # --
+    # Localstorage
+    # --
+
+    my $localstorageDir = $XDG_DATA_HOME.'/qutebrowser/webengine/Local Storage/*.localstorage';
+
+    foreach my $file (bsd_glob($localstorageDir))
+    {
+        if(all { index(basename($file),$_) == -1 } @whitelist )
+        {
+            sayv(V_INFO,'Deleting Local Storage file '.basename($file));
+            unlink($file);
+            if (-e $file.'-journal')
+            {
+                unlink($file.'-journal');
+            }
+        }
+    }
+
+    foreach my $dirEntry (qw(IndexedDB databases))
+    {
+        my $dirsGlob = $XDG_DATA_HOME.'/qutebrowser/webengine/'.$dirEntry.'/*';
+
+        foreach my $dir (bsd_glob($dirsGlob))
+        {
+            next if ! -d $dir;
+            if(all { index(basename($dir),$_) == -1 } @whitelist )
+            {
+                sayv(V_INFO,'Deleting '.$dirEntry.' for '.basename($dir));
+                unlink(bsd_glob($dir.'/*')) or die("Unlink error for subtree: $dir: $!\n");
+                rmdir($dir) or die("Failed to rmdir $dir: $!\n");
+            }
+        }
+    }
+}
+
+# Main function. Command-line parsing.
+sub main
+{
+    my $wrap = 0;
+
+    GetOptions(
+        'help' => sub {
+            say 'qutebrowser-cookiecleaner version '.$VERSION;
+            say "";
+            say "Usage: qutebrowser-cookiecleaner [OPTIONS]";
+            say "";
+            say "Options:";
+            say "  -v, --verbose     Increase verbosity";
+            say "      --help        Show this help screen";
+            say "      --wrap        Wrap another command, cleaning on start and";
+            say "                    exit. See README.md for details.";
+            exit(0);
+        },
+        'wrap' => \$wrap,
+        'version' => sub
+        {
+            print 'qutebrowser-cookiecleaner version '.$VERSION."\n";
+            exit(0);
+        },
+        'v|verbose+' => \$verbosity,
+    ) or do
+    {
+        if ($wrap)
+        {
+            warn('Maybe you need to add -- after --wrap (--wrap --)?'."\n")
+        }
+        die('See --help for more information'."\n");
+    };
+
+
+    if ($wrap)
+    {
+        if(scalar @ARGV == 0)
+        {
+            die('--wrap requires additional parameters: the command to run'."\n");
+        }
+        $0 = 'qutebrowser-cookiecleaner: cleaning';
+        expireContent();
+        $0 = 'qutebrowser-cookiecleaner: waiting for '.join(' ',@ARGV);
+        system(@ARGV);
+        if ($? == -1)
+        {
+            die('Failed to execute subprocess '.join(' ',@ARGV).': '.$!."\n");
+        }
+        $0 = 'qutebrowser-cookiecleaner: cleaning';
+    }
+    elsif(scalar @ARGV != 0)
+    {
+        die('Unknown parameters: '.join(' ',@ARGV)."\nDid you mean to use --wrap?\n");
+    }
+
+    expireContent();
+}
+
+main();
diff --git a/bin/rename_avi_files.sh b/bin/rename_avi_files.sh
new file mode 100755
index 0000000..f268647
--- /dev/null
+++ b/bin/rename_avi_files.sh
@@ -0,0 +1 @@
+exiftool -ext avi -d %Y-%m-%d_%H%M%S_$1 '-filename<${DateTimeOriginal}.%e' $2
diff --git a/bin/rename_iphone_files.sh b/bin/rename_iphone_files.sh
new file mode 100755
index 0000000..ecb132f
--- /dev/null
+++ b/bin/rename_iphone_files.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+exiftool -d $1_%Y-%m-%d_%H%M%S '-filename<${CreateDate}.%e' $2
+#exiftool -filename=%-.6f%.3nC.%e `ls | sort`
diff --git a/bin/rename_mov_files.sh b/bin/rename_mov_files.sh
new file mode 100755
index 0000000..f1cd2d5
--- /dev/null
+++ b/bin/rename_mov_files.sh
@@ -0,0 +1 @@
+exiftool -ext mov -d %Y-%m-%d_%H%M%S_$1 '-filename<${CreateDate}.%e' $2
diff --git a/bin/rename_mp4_files.sh b/bin/rename_mp4_files.sh
new file mode 100755
index 0000000..c778460
--- /dev/null
+++ b/bin/rename_mp4_files.sh
@@ -0,0 +1 @@
+exiftool -ext mp4 -d %Y-%m-%d_%H%M%S_$1 '-filename<${CreateDate}.%e' $2
diff --git a/bin/rename_mts_files.sh b/bin/rename_mts_files.sh
new file mode 100755
index 0000000..6847a5b
--- /dev/null
+++ b/bin/rename_mts_files.sh
@@ -0,0 +1 @@
+exiftool -ext mts -d %Y-%m-%d_%H%M%S_$1 '-filename<${DateTimeOriginal}.%e' $2
diff --git a/bin/rename_phone_files.sh b/bin/rename_phone_files.sh
new file mode 100755
index 0000000..e1d585f
--- /dev/null
+++ b/bin/rename_phone_files.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+exiftool -d $1_%Y-%m-%d_%H%M%S '-filename<${Exif:CreateDate}_$MyModel.%e' $2
+#exiftool -filename=%-.6f%.3nC.%e `ls | sort`
diff --git a/bin/rename_raw_files.sh b/bin/rename_raw_files.sh
new file mode 100755
index 0000000..6d488b1
--- /dev/null
+++ b/bin/rename_raw_files.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+exiftool -d %Y-%m-%d_%H%M%S%%-c_$1 '-filename<${Exif:CreateDate}.%e' $2
+#exiftool -filename=%-.6f%.3nC.%e `ls | sort`
diff --git a/bin/review.py b/bin/review.py
new file mode 100755
index 0000000..a17cccc
--- /dev/null
+++ b/bin/review.py
@@ -0,0 +1,51 @@
+#!/usr/bin/python
+import os
+from os.path import abspath, dirname
+from operator import itemgetter
+
+"""
+    parse my gtd folder
+    pull out files that start with the project name which is in []
+    loop through and grab the project and then all the associated
+    tasks (rest of the file name)
+    print the results out to a file called @project.txt
+"""
+# assuming that this script is in ~/bin this will work:
+BASE_DIR = abspath(dirname(dirname(__file__))) + '/'
+project_list = []
+inprogress = False
+for root, dirnames, filenames in os.walk('%sgtd' % (BASE_DIR)):
+    for f in filenames:
+        if not f.startswith('@') and not f.startswith('.') and not f.startswith('Notes & Settings') and not f.startswith('projx') and not f.startswith("errands"):
+
+            name = f[f.find("[") + 1:f.find("]")]
+            task = f[f.find("]") + 2:-4]
+
+            if f.find("]") > 5:
+                inprogress = True
+                task = "* " + task
+            with open('%sgtd/%s' % (BASE_DIR, f), "r") as fl:
+                for line in fl:
+                    for part in line.split():
+                        if "@waiting" in part:
+                            task = task + " -- " + line.rstrip()
+            project_list.append({
+                "file": f,
+                "name": name,
+                "task": task,
+                "inprogress": inprogress,
+            })
+    break
+
+newlist = sorted(project_list, key=itemgetter('name', 'task'))
+
+projects_file = open("/Users/sng/gtd/@projects.txt", 'w')
+l_name = ''
+
+for p in newlist:
+    if l_name == p['name']:
+        print >> projects_file, "\t" + p['task']
+    else:
+        print >> projects_file, "\n" + p['name']
+        print >> projects_file, "\t" + p['task']
+        l_name = p['name']
diff --git a/bin/run_pandoc.sh b/bin/run_pandoc.sh
new file mode 100755
index 0000000..1874c01
--- /dev/null
+++ b/bin/run_pandoc.sh
@@ -0,0 +1,4 @@
+#! /bin/sh
+args=("$@")
+echo ${args[0]}
+pandoc -s -smart -c ${args[0]} ${args[1]} -t html5 -o args[2]
diff --git a/bin/showall.sh b/bin/showall.sh
new file mode 100755
index 0000000..bd5fcca
--- /dev/null
+++ b/bin/showall.sh
@@ -0,0 +1,3 @@
+clear
+echo '---- ALL TASKS -----'
+python ~/bin/alltasks.py
diff --git a/bin/showalltype.sh b/bin/showalltype.sh
new file mode 100755
index 0000000..5a6c606
--- /dev/null
+++ b/bin/showalltype.sh
@@ -0,0 +1,8 @@
+GREEN=$(tput setaf 2; tput bold)
+NORMAL=$(tput sgr0)
+function green() {
+    echo "$GREEN$*$NORMAL"
+}
+
+clear
+python ~/bin/alltasks_by_type.py $1
diff --git a/bin/showdone.sh b/bin/showdone.sh
new file mode 100755
index 0000000..4ee3c13
--- /dev/null
+++ b/bin/showdone.sh
@@ -0,0 +1,4 @@
+clear
+echo '----- TASKS COMPLETED TODAY -----'
+cd ~/gtd/done/$(date '+%Y-%m-%d')
+ls
diff --git a/bin/showinprogress.sh b/bin/showinprogress.sh
new file mode 100755
index 0000000..3da0736
--- /dev/null
+++ b/bin/showinprogress.sh
@@ -0,0 +1,3 @@
+clear
+echo '----- TASKS IN PROGRESS -----'
+cd ~/gtd && ls | grep ^qq
diff --git a/bin/smartresize.sh b/bin/smartresize.sh
new file mode 100755
index 0000000..b38771e
--- /dev/null
+++ b/bin/smartresize.sh
@@ -0,0 +1,3 @@
+smartresize() {
+   mogrify -path $3 -filter Triangle -define filter:support=2 -thumbnail $2 -unsharp 0.25x0.08+8.3+0.045 -dither None -posterize 136 -quality 82 -define jpeg:fancy-upsampling=off -define png:compression-filter=5 -define png:compression-level=9 -define png:compression-strategy=1 -define png:exclude-chunk=all -interlace none -colorspace sRGB $1
+}
diff --git a/bin/stardict-dictd-web1913-2.4.2.tar.bz2 b/bin/stardict-dictd-web1913-2.4.2.tar.bz2
new file mode 100644
index 0000000..b73d88b
--- /dev/null
+++ b/bin/stardict-dictd-web1913-2.4.2.tar.bz2
diff --git a/bin/temp.js b/bin/temp.js
new file mode 100644
index 0000000..51585b4
--- /dev/null
+++ b/bin/temp.js
@@ -0,0 +1,13 @@
+var targetDiv = document.getElementById("tag_cloud_header")
+var ul = document.createElement("ul");
+var links = [ "/u:luxagraf/t:luxagraf/t:@post/", "/u:luxagraf/t:%2523lhp/t:@post/", "/u:luxagraf/t:%2523flw/","/u:luxagraf/t:%2523rei/t:@post/"]
+var text = ["Luxagraf Post Research", "LongHandPixels Post Research", "Freelance Writing Ideas", "REI Post Research"];
+for (var i=0; i<links.length; i++) {
+    var li = document.createElement("li");
+    var link = document.createElement("a");
+    link.setAttribute('href',links[i]);
+    link.innerHTML = text[i];
+    li.appendChild(link);
+    ul.appendChild(li);
+}
+targetDiv.appendChild(ul);
diff --git a/bin/tweet_archive_tools.py b/bin/tweet_archive_tools.py
new file mode 100755
index 0000000..2737250
--- /dev/null
+++ b/bin/tweet_archive_tools.py
@@ -0,0 +1,191 @@
+## Last updated 8 Dec 2013
+##
+## This program takes data from a locally downloaded Twitter archive
+## and outputs HTML, Text, JSON, geo-coords in CSV, and best friends in csv.
+## See http://blog.twitter.com/2012/12/your-twitter-archive.html
+##
+## It can run either as a dedicated program or as a module.
+##
+## Please visit https://github.com/mshea/Parse-Twitter-Archive
+## for more information.
+##
+## This work is licensed under the Creative Commons Attribution
+## NonCommercial-ShareAlike 3.0 License. You are free to share, copy,
+## distribute, transmit, remix, and adapt the work as long as you attribute
+## it to Michael E. Shea at http://mikeshea.net/, share the work under
+## the same license, and do so for non-commercial purposes. To view a copy
+## of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/.
+##
+
+import glob
+import json
+import csv
+import datetime
+import collections
+import re
+import sqlite3
+from datetime import datetime
+from datetime import timedelta
+from itertools import islice, izip
+from collections import Counter
+
+params = {
+    'data_files': './data/js/tweets/*.js',
+    'geo_output': 'mshea_tweets_geo.csv',
+    'text_output': 'mshea_tweets.txt',
+    'json_output': 'mshea_tweets.json',
+    'bff_output': 'mshea_bffs.csv',
+    'csv_output': 'mshea_tweets.csv',
+    'sqlite3_output': 'mshea_tweets.sqlite3',
+    'html_output': 'mshea_tweets.html',
+    'twitter_user_id': 'mshea',
+}
+
+
+def load_data(files):
+    items = []
+    files = glob.glob(files)
+    for file in files:
+        with open(file) as f:
+            d = f.readlines()[1:]  # Twitter's JSON first line is bogus
+            d = "".join(d)
+            j = json.loads(d)
+            for tweet in j:
+				items.append(tweet)
+    return sorted(items, key=lambda k: k['id'])
+
+
+def get_bffs(d):
+    words = []
+    for item in d:
+        item_words = item['text'].split()
+        for word in item_words:
+            if '@' in word:
+                words.append(word.replace(':', '').lower().encode('utf-8'))
+    return collections.Counter(words).most_common(50)
+
+
+def get_bigrams(d):
+    words = []
+    for item in d:
+        item_words = re.findall('\w+', item['text'])
+        words += item_words
+    output = (Counter(zip(words, words[1:])).most_common(100))
+    for item in output:
+        print item
+
+def get_csv_output(d):
+    output = [('id', 'date', 'tweet')]
+    for item in d:
+        output.append((
+                item['id_str'],
+                item['created_at'],
+                item['text'].encode('utf-8')
+                ))
+    return output
+		
+
+def get_geo(d):
+    output = [('date', 'tweet', 'lat', 'long')]
+    for item in d:
+        try:
+            lat = item['geo']['coordinates'][0]
+            long = item['geo']['coordinates'][1]
+            date = item['created_at']
+            text = item['text'].encode('utf-8')
+            output.append((date, text, lat, long))
+        except:
+            error = "no coordinates"
+    return output
+
+
+def link_https_in_text(text):
+    parsed_text = re.sub('http://[^ ,]*',
+                         lambda t: "<a href='%s'>%s</a>" %
+                         (t.group(0), t.group(0)), text)
+    return parsed_text
+
+
+def write_html(tweets, output_file):
+    html_output = ""
+    for item in tweets:
+        d = datetime.strptime(item['created_at'],
+                              '%Y-%m-%d %H:%M:%S +0000')
+        - timedelta(hours=5)
+        day_string = d.strftime('%d %b %Y %I:%M %p')
+        true_time_object = d + timedelta(hours=5)
+        time_element = true_time_object.isoformat("T")
+        text = link_https_in_text(item['text'])
+        tweet_link = 'http://twitter.com/%s/status/%s'\
+                     % (params['twitter_user_id'], item['id'])
+        html_output += '<li id=%s>%s - <a href="%s">'\
+                       '<time datetime="%s">%s</time></a></li>\n' \
+            % (item['id'],
+                text,
+                tweet_link,
+                time_element,
+                day_string)
+    with open(output_file, "w") as f:
+        f.write('<!DOCTYPE html>\n'
+                '<title>Twitter Archive Output</title>\n'
+                '<ul>\n')
+        f.write(html_output.encode('utf-8'))
+        f.write('</ul>')
+
+
+def write_sqlite3(json_input, output_file):
+    conn = sqlite3.connect(output_file)
+    c = conn.cursor()
+    try:
+        c.execute('select count(*) from tweets')
+    except:
+        c.execute('CREATE TABLE tweets'
+                  '(id int not null primary key, '
+                  'created_at text, text text)')
+    conn.commit()
+    data_to_write = []
+    for item in json_input:
+        data_to_write.append((int(item['id_str']),
+                              item['created_at'],
+                              item['text']))
+    c.executemany('INSERT OR REPLACE '
+                  'INTO tweets VALUES (?,?,?);',
+                  data_to_write)
+    conn.commit()
+
+
+def write_text(tweets, output_file):
+    text_output = ''
+    for item in tweets:
+        text_output += '%s\n%s\n%s\n\n' % (item['id'],
+                                           item['created_at'],
+                                           item['text'])
+    with open(output_file, "w") as f:
+        f.write(text_output.encode('utf-8'))
+
+
+def write_csv(d, csv_file):
+    with open(csv_file, 'w') as f:
+        writer = csv.writer(f)
+        writer.writerows(d)
+
+
+def write_json(json_data, output_file):
+    with open(output_file, 'w') as f:
+        f.write(json.dumps(json_data, indent=4))
+
+
+def main():
+    d = load_data(params['data_files'])
+    #get_bigrams(d)
+    write_csv(get_bffs(d), params['bff_output'])
+    write_csv(get_geo(d), params['geo_output'])
+    write_csv(get_csv_output(d), params['csv_output'])
+    write_html(d, params['html_output'])
+    write_text(d, params['text_output'])
+    write_json(d, params['json_output'])
+    write_sqlite3(d, params['sqlite3_output'])
+
+
+if __name__ == "__main__":
+    main()
diff --git a/bin/upgrad_pg.sh b/bin/upgrad_pg.sh
new file mode 100755
index 0000000..ccdfbcc
--- /dev/null
+++ b/bin/upgrad_pg.sh
@@ -0,0 +1,8 @@
+FROM_VERSION="$1"
+
+pacman -S --needed postgresql-old-upgrade
+chown postgres:postgres /var/lib/postgres/
+su - postgres -c "mv /var/lib/postgres/data /var/lib/postgres/data-${FROM_VERSION}"
+su - postgres -c 'mkdir /var/lib/postgres/data'
+su - postgres -c "initdb --locale $LANG -E UTF8 -D /var/lib/postgres/data"
+su - postgres -c "pg_upgrade -b /opt/pgsql-${FROM_VERSION}/bin/ -B /usr/bin/ -d /var/lib/postgres/data-${FROM_VERSION} -D /var/lib/postgres/data"
diff --git a/bin/vcs_query.py b/bin/vcs_query.py
new file mode 100755
index 0000000..7862047
--- /dev/null
+++ b/bin/vcs_query.py
@@ -0,0 +1,358 @@
+#!/usr/bin/env python3
+# -*- coding: utf8 -*-
+
+# This file is part of vcs_query - https://github.com/mageta/vcs_query
+# SPDX-License-Identifier: MIT
+# See file LICENSE for more information.
+
+# TODO: modules documentation
+
+import collections
+import email.utils
+import argparse
+import hashlib
+import logging
+import pickle
+import sys
+import os
+import re
+
+# vCard Standards:
+#   3.0 https://tools.ietf.org/html/rfc2426
+#   4.0 https://tools.ietf.org/html/rfc6350
+from vobject        import readComponents   as VObjectRead
+from vobject.base   import VObjectError
+
+LOGGER = logging.getLogger(__name__)
+
+Version = collections.namedtuple("Version", ["major", "minor", "patch"])
+VERSION = Version(
+    major=0,
+    minor=4,
+    patch=0,
+)
+
+def main(argv):
+    optparser = argparse.ArgumentParser(prog=argv[0],
+                                        description="Query vCard Files for "
+                                                    "EMail Addresses")
+    optparser.add_argument("pattern", metavar="PATTERN",
+                           nargs='?', default=None,
+                           help="only those lines that contain PATTERN will be"
+                                "displayed")
+    optparser.add_argument("--version",
+                           action="version",
+                           version="%(prog)s version "
+                                   "{v.major:d}.{v.minor:d}.{v.patch:d}".format(
+                                       v=VERSION))
+    optparser.add_argument("-d", "--vcard-dir",
+                           required=True, action='append',
+                           help="specify directory containing vCards (can be "
+                                "given multiple times)")
+    optparser.add_argument("-a", "--all-addresses",
+                           required=False, action="store_true",
+                           help="display all addresses stored for a contact")
+    optparser.add_argument("-n", "--sort-names",
+                           required=False, action="store_true",
+                           help="sort the result according to the contact name "
+                                "(the default is to sort according to mail-"
+                                "address first)")
+    optparser.add_argument("-r", "--regex",
+                           required=False, action="store_true",
+                           help="interpret PATTERN as regular expression "
+                                "(syntax: https://docs.python.org/3/library/"
+                                "re.html#regular-expression-syntax)")
+    optparser.add_argument("-m", "--mode",
+                           required=False, type=str,
+                           choices=OutputFormat.available,
+                           default=OutputFormat.available[0],
+                           help="select output-mode (default: "
+                                "{})".format(OutputFormat.available[0]))
+    args = optparser.parse_args(argv[1:])
+
+    for vcdir in args.vcard_dir:
+        if not os.path.isdir(vcdir):
+            optparser.error("'{}' is not a directory".format(vcdir))
+
+    try:
+        output = OutputFormat(args.mode)
+    except LookupError as error:
+        optparser.error(error)
+
+    try:
+        pattern = Pattern(args.pattern, args.regex)
+    except re.error as error:
+        optparser.error("Given PATTERN is not a valid regular "
+                        "expression: {!s}".format(error))
+
+    print("vcs_query.py, see https://github.com/mageta/vcs_query")
+
+    # Load all contacts from the given vCard-Directories; duplicates are
+    # automatically handled by using a set
+    contacts_uniq = set()
+    for vcdir in args.vcard_dir:
+        try:
+            for vcard in VcardCache(vcdir).vcards:
+                if vcard:
+                    if args.all_addresses:
+                        contacts_uniq.update(vcard)
+                    else:
+                        contacts_uniq.add(vcard[0])
+        except OSError as error:
+            LOGGER.error("Error while reading vCard Dir: %s: %s", vcdir, error)
+
+    # sort the found contacts according to the given command-line options
+    if not args.sort_names:
+        contacts = sorted(contacts_uniq,
+                          key=(lambda x: (x.mail.lower(), x.name.lower(),
+                                          x.description.lower())))
+    else:
+        contacts = sorted(contacts_uniq,
+                          key=(lambda x: (x.name.lower(), x.mail.lower(),
+                                          x.description.lower())))
+
+    for contact in contacts:
+        if pattern.search(output.format(contact)):
+            print(output.format_escape(contact))
+
+class OutputFormat(object):
+    available = ("mutt", "vim")
+
+    def __init__(self, mode):
+        if mode not in OutputFormat.available:
+            raise LookupError("'{}' is not a supported "
+                              "output-mode".format(mode))
+
+        self.mode = mode
+
+    def format(self, contact):
+        if self.mode == "mutt":
+            return "{}\t{}\t{}".format(contact.mail, contact.name,
+                                       contact.description)
+        elif self.mode == "vim":
+            return "{} <{}>".format(contact.name, contact.mail)
+
+    def format_escape(self, contact):
+        if self.mode == "mutt":
+            return self.format(contact)
+        elif self.mode == "vim":
+            return email.utils.formataddr((contact.name, contact.mail))
+
+class Pattern(object):
+    def __init__(self, pattern, is_regex):
+        self.match_all = False if pattern else True
+        self.is_regex = is_regex
+
+        if not self.match_all:
+            if self.is_regex:
+                self.pattern = re.compile(pattern, re.IGNORECASE)
+            else:
+                self.pattern = pattern.lower()
+
+    def search(self, string):
+        if self.match_all:
+            return True
+
+        if self.is_regex and self.pattern.search(string):
+            return True
+        elif not self.is_regex and self.pattern in string.lower():
+            return True
+
+        return False
+
+class VcardCache(object):
+    def __init__(self, vcard_dir):
+        self.cache_dir = os.path.expanduser("~/.cache/")
+        self.vcard_dir = os.path.normcase(os.path.normpath(vcard_dir))
+
+        dhsh = hashlib.sha256()
+        dhsh.update(self.vcard_dir.encode())
+        self.pickle_path = os.path.join(self.cache_dir,
+                                        "{}.vcs_query".format(dhsh.hexdigest()))
+
+        self.last_vcard_dir_timestamp = 0
+        self.vcard_files = {}
+
+        self._state = self._load()
+        self._update()
+        self._serialize()
+
+    _cache_version = 1
+
+    @property
+    def _default_state(self):
+        return (VcardCache._cache_version, 0, {})
+
+    @property
+    def _state(self):
+        return (VcardCache._cache_version,
+                self.last_vcard_dir_timestamp, self.vcard_files)
+
+    @_state.setter
+    def _state(self, value):
+        self.last_vcard_dir_timestamp = value[1]
+        self.vcard_files = value[2]
+
+    def _load(self):
+        try:
+            with open(self.pickle_path, "rb") as cache:
+                obj = pickle.load(cache)
+
+                # prune invalid or outdated cache-files
+                if not isinstance(obj, tuple) or len(obj) < 3:
+                    raise RuntimeError("Invalid type")
+                elif obj[0] != VcardCache._cache_version:
+                    raise RuntimeError("Invalid Version ({})".format(obj[0]))
+
+                return obj
+        except (OSError, RuntimeError, AttributeError, EOFError, ImportError,
+                IndexError, pickle.UnpicklingError) as error:
+            if not isinstance(error, OSError) or error.errno != 2:
+                LOGGER.warning("Cache file (%s) could not be read: %s",
+                               self.pickle_path, error)
+            return self._default_state
+
+    def _update(self):
+        vcard_dir_timestamp = get_timestamp(self.vcard_dir)
+        if vcard_dir_timestamp > self.last_vcard_dir_timestamp:
+            self.last_vcard_dir_timestamp = vcard_dir_timestamp
+
+            paths = set()
+            # let erros in os.scandir() bubble up.. the whole thing failed
+            with os.scandir(self.vcard_dir) as directory:
+                for node in directory:
+                    try:
+                        path = os.path.abspath(node.path)
+                        if node.is_file():
+                            paths.add(path)
+                    except OSError as err:
+                        LOGGER.error("Error reading vCard: %s: %s", node, err)
+
+            # prune vCards that don't exist anymore
+            removed = list()
+            for path in self.vcard_files.keys():
+                if path not in paths:
+                    # we can not delete items from self.vcard_files while we
+                    # iterate over it, so remember them instead
+                    removed += [path]
+
+            for path in removed:
+                del self.vcard_files[path]
+
+            # add or update vCards
+            for path in paths:
+                vcard = self.vcard_files.get(path)
+                if not vcard or vcard.needs_update():
+                    try:
+                        vcard = VcardFile(path)
+                        self.vcard_files[path] = vcard
+                    except OSError as err:
+                        LOGGER.error("Error reading vCard: %s: %s", path, err)
+                        try:
+                            del self.vcard_files[path]
+                        except KeyError:
+                            pass
+
+    def _serialize(self):
+        try:
+            if not os.path.isdir(self.cache_dir):
+                os.mkdir(self.cache_dir)
+            with open(self.pickle_path, "wb") as cache:
+                pickle.dump(self._state, cache)
+        except OSError:
+            LOGGER.warning("Cannot write to cache file: %s", self.pickle_path)
+
+    @property
+    def vcards(self):
+        for vcard_file in self.vcard_files.values():
+            for vcard in vcard_file.vcards:
+                yield vcard
+
+class Vcard(object):
+    Contact = collections.namedtuple("Contact", ["mail", "name", "description"])
+
+    def __init__(self, component):
+        # Property FN
+        #   https://tools.ietf.org/html/rfc6350#section-6.2.1
+        self.name = ""
+        if "fn" in component.contents:
+            self.name = component.fn.value
+
+        # Property EMAIL
+        #   https://tools.ietf.org/html/rfc6350#section-6.4.2
+        self.mails = []
+        if "email" in component.contents:
+            self.mails = [mail.value for mail in component.contents["email"]]
+
+        # Property NOTE
+        #   https://tools.ietf.org/html/rfc6350#section-6.7.2
+        self.description = ""
+        if "note" in component.contents:
+            self.description = "; ".join([
+                line for line in component.note.value.splitlines() if line
+            ])
+
+    def _get_mail_contact(self, mail):
+        return Vcard.Contact(str(mail), str(self.name), str(self.description))
+
+    def __getitem__(self, i):
+        return self._get_mail_contact(self.mails[i])
+
+    def __iter__(self):
+        for mail in self.mails:
+            yield self._get_mail_contact(mail)
+
+    def __len__(self):
+        return len(self.mails)
+
+class VcardFile(object):
+    vobject_logger = logging.getLogger("vobject.base")
+
+    def __init__(self, path):
+        self.path = path
+        self.timestamp = get_timestamp(path)
+        self.vcards = []
+        self._read_components(path)
+
+    def _read_components(self, path):
+        # As per https://tools.ietf.org/html/rfc6350#section-3.1
+        # the charset for a vCard MUST be UTF-8
+        try:
+            # let errors from FILE-I/O bubble up, this whole vCard is failed
+            with open(path, encoding="utf-8", errors="strict") as vcfile:
+                for component in VObjectRead(vcfile, ignoreUnreadable=True):
+                    if component.name.lower() == "vcard":
+                        # Normal Case: vCard is the top property:
+                        #   https://tools.ietf.org/html/rfc6350#section-6.1.1
+                        self.vcards += [Vcard(component)]
+                    elif "vcard" in component.contents:
+                        # Special case from RFC2426; in that version it was
+                        # possible to nest vCards:
+                        #   https://tools.ietf.org/html/rfc2426#section-2.4.2
+                        # This has since been removed:
+                        #   https://tools.ietf.org/html/rfc6350#appendix-A.2
+                        # But we keep the code as it is rather simple and it
+                        # provides backwards-compatibility
+                        self.vcards += [Vcard(component.vcard)]
+                    else:
+                        LOGGER.warning("No vCard in a component in: %s", path)
+        except VObjectError as error:
+            LOGGER.error("Parser Error in file: %s: %s", path, error)
+        except ValueError as error:
+            LOGGER.error("Bad Encoding in file: %s: %s", path, error)
+
+    def needs_update(self):
+        return get_timestamp(self.path) > self.timestamp
+
+# vobject regularly complains about unparsable streams and such, but as we
+# don't really know which files should be vcards and which not, in the
+# directory we are given, this is a bit much, and will only concern users, so
+# we just ignore most warnings (there are exception, like when we found
+# something that looks like a vCard but is not parsable after all).
+VcardFile.vobject_logger.setLevel(logging.ERROR + 1)
+
+def get_timestamp(path):
+    return os.stat(path).st_mtime
+
+if __name__ == "__main__":
+    main(sys.argv)
diff --git a/bin/web1913.dict.dz b/bin/web1913.dict.dz
new file mode 100644
index 0000000..b234473
--- /dev/null
+++ b/bin/web1913.dict.dz
diff --git a/bin/web1913.idx b/bin/web1913.idx
new file mode 100644
index 0000000..59cf917
--- /dev/null
+++ b/bin/web1913.idx
diff --git a/bin/weekly-rsync.sh b/bin/weekly-rsync.sh
new file mode 100755
index 0000000..8dcdcf6
--- /dev/null
+++ b/bin/weekly-rsync.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+# ----------------------------------------------------------------------
+# rotating-filesystem-snapshot utility
+# essentially, rotate backup-snapshots of /home 
+# on a weekly basis using rsync and cron
+# ----------------------------------------------------------------------
+
+
+rm -rf /mnt/backup/week.6
+mv /mnt/backup/week.5 /mnt/backup/week.6
+mv /mnt/backup/week.4 /mnt/backup/week.5
+mv /mnt/backup/week.3 /mnt/backup/week.4
+mv /mnt/backup/week.2 /mnt/backup/week.3
+mv /mnt/backup/week.1 /mnt/backup/week.2
+mv /mnt/backup/week.0 /mnt/backup/week.1
+rsync -avvz -K ~/ \
+--copy-links \
+--exclude-from '/home/lxf/.rsync-exclude-weekly' \
+--link-dest=/mnt/backup/week.1 \
+ /mnt/backup/week.0/
diff --git a/bin/wired-count-deals-items.py b/bin/wired-count-deals-items.py
new file mode 100755
index 0000000..3fb5bc9
--- /dev/null
+++ b/bin/wired-count-deals-items.py
@@ -0,0 +1,24 @@
+import sys
+from bs4 import BeautifulSoup
+import markdown
+
+filename = '%s' %(sys.argv[1])
+subid  = '%s' %(sys.argv[2])
+page_url = "https://www.wired.com/story/best-black-friday-photography-deals-2019/"
+with open(filename, newline='') as f:
+    content = f.readlines()
+    count = 0
+    for line in content:
+        if line.startswith('- **'):
+            count = count + 1
+    print("count is: ", count)
+
+
+with open(filename, newline='') as f:
+    data = f.read()
+    soup = BeautifulSoup(markdown.markdown(data), "lxml")
+    for a in soup.find_all('a'):
+        start = a['href'].split('//')[1][:4]
+        if str(start) == 'best' or start == 'goto':
+            l = "%s,,%s,Impact,%s\n" % (page_url, subid, a['href']) 
+            print(l)
diff --git a/bin/wired-count-h4-items.py b/bin/wired-count-h4-items.py
new file mode 100755
index 0000000..df39d3c
--- /dev/null
+++ b/bin/wired-count-h4-items.py
@@ -0,0 +1,10 @@
+import sys
+
+filename = '%s' %(sys.argv[1])
+with open(filename, newline='') as f:
+    content = f.readlines()
+    count = 0
+    for line in content:
+        if line.startswith('####'):
+            count = count + 1
+    print(count)
diff --git a/bin/wired-dedup-h4-items.py b/bin/wired-dedup-h4-items.py
new file mode 100644
index 0000000..77858fb
--- /dev/null
+++ b/bin/wired-dedup-h4-items.py
@@ -0,0 +1,13 @@
+import sys, collections
+
+filename = '%s' %(sys.argv[1])
+with open(filename, newline='') as f:
+    content = f.readlines()
+    new_list = []
+    for line in content:
+        if line.startswith('####'):
+            title = line.strip().split('####')[1].split(' for ')[0]
+            new_list.append(title)
+            print(title)
+    print([item for item, count in collections.Counter(new_list).items() if count > 1])
+
diff --git a/bin/xchromium b/bin/xchromium
new file mode 100755
index 0000000..b836a02
--- /dev/null
+++ b/bin/xchromium
@@ -0,0 +1,2 @@
+#! /bin/sh
+GDK_BACKEND=x11 chromium
diff --git a/bin/xslack b/bin/xslack
new file mode 100755
index 0000000..f360352
--- /dev/null
+++ b/bin/xslack
@@ -0,0 +1,2 @@
+#! /bin/sh
+GDK_BACKEND=x11 slack
diff --git a/bin/xvirtualbox b/bin/xvirtualbox
new file mode 100755
index 0000000..aca6406
--- /dev/null
+++ b/bin/xvirtualbox
@@ -0,0 +1,2 @@
+#! /bin/sh
+QT_QPA_PLATFORM=xcb VirtualBox
diff --git a/bin/xvivaldi b/bin/xvivaldi
new file mode 100755
index 0000000..283cf06
--- /dev/null
+++ b/bin/xvivaldi
@@ -0,0 +1,2 @@
+#! /bin/sh
+GDK_BACKEND=x11 vivaldi-stable
diff --git a/bin/xzoom b/bin/xzoom
new file mode 100755
index 0000000..edb5707
--- /dev/null
+++ b/bin/xzoom
@@ -0,0 +1,3 @@
+#! /bin/sh
+QT_QPA_PLATFORM=xcb
+GDK_BACKEND=x11 zoom