From 64157a5c601a16ad1f7f2bedd3e094f322915905 Mon Sep 17 00:00:00 2001
From: gen2brain <gen2brain@users.sourceforge.net>
Date: Sat, 28 Sep 2013 19:55:31 +0200
Subject: [PATCH] add SDL2 library

---
 src/m64py/SDL/__init__.pyc       | Bin 3651 -> 0 bytes
 src/m64py/SDL/active.pyc         | Bin 998 -> 0 bytes
 src/m64py/SDL/array.pyc          | Bin 9687 -> 0 bytes
 src/m64py/SDL/audio.pyc          | Bin 14388 -> 0 bytes
 src/m64py/SDL/cdrom.pyc          | Bin 7201 -> 0 bytes
 src/m64py/SDL/constants.pyc      | Bin 13236 -> 0 bytes
 src/m64py/SDL/dll.pyc            | Bin 8534 -> 0 bytes
 src/m64py/SDL/endian.pyc         | Bin 1442 -> 0 bytes
 src/m64py/SDL/error.pyc          | Bin 1893 -> 0 bytes
 src/m64py/SDL/events.pyc         | Bin 17551 -> 0 bytes
 src/m64py/SDL/joystick.pyc       | Bin 5864 -> 0 bytes
 src/m64py/SDL/keyboard.pyc       | Bin 4880 -> 0 bytes
 src/m64py/SDL/mouse.pyc          | Bin 6215 -> 0 bytes
 src/m64py/SDL/quit.pyc           | Bin 1332 -> 0 bytes
 src/m64py/SDL/rwops.pyc          | Bin 4825 -> 0 bytes
 src/m64py/SDL/timer.pyc          | Bin 5087 -> 0 bytes
 src/m64py/SDL/version.pyc        | Bin 2590 -> 0 bytes
 src/m64py/SDL/video.pyc          | Bin 53456 -> 0 bytes
 src/m64py/SDL2/__init__.py       |  65 ++++++
 src/m64py/SDL2/audio.py          | 162 +++++++++++++
 src/m64py/SDL2/blendmode.py      |  11 +
 src/m64py/SDL2/clipboard.py      |  10 +
 src/m64py/SDL2/cpuinfo.py        |  22 ++
 src/m64py/SDL2/dll.py            | 112 +++++++++
 src/m64py/SDL2/endian.py         |  48 ++++
 src/m64py/SDL2/error.py          |  24 ++
 src/m64py/SDL2/events.py         | 377 +++++++++++++++++++++++++++++++
 src/m64py/SDL2/filesystem.py     |   9 +
 src/m64py/SDL2/gamecontroller.py | 102 +++++++++
 src/m64py/SDL2/gesture.py        |  15 ++
 src/m64py/SDL2/haptic.py         | 193 ++++++++++++++++
 src/m64py/SDL2/hints.py          |  46 ++++
 src/m64py/SDL2/joystick.py       |  57 +++++
 src/m64py/SDL2/keyboard.py       |  40 ++++
 src/m64py/SDL2/keycode.py        | 288 +++++++++++++++++++++++
 src/m64py/SDL2/loadso.py         |   8 +
 src/m64py/SDL2/log.py            |  71 ++++++
 src/m64py/SDL2/messagebox.py     |  54 +++++
 src/m64py/SDL2/mouse.py          |  68 ++++++
 src/m64py/SDL2/pixels.py         | 298 ++++++++++++++++++++++++
 src/m64py/SDL2/platform.py       |   6 +
 src/m64py/SDL2/power.py          |  17 ++
 src/m64py/SDL2/rect.py           |  72 ++++++
 src/m64py/SDL2/render.py         | 128 +++++++++++
 src/m64py/SDL2/rwops.py          | 197 ++++++++++++++++
 src/m64py/SDL2/scancode.py       | 267 ++++++++++++++++++++++
 src/m64py/SDL2/sdlgfx.py         | 142 ++++++++++++
 src/m64py/SDL2/sdlimage.py       | 105 +++++++++
 src/m64py/SDL2/sdlmixer.py       | 207 +++++++++++++++++
 src/m64py/SDL2/sdlttf.py         | 138 +++++++++++
 src/m64py/SDL2/shape.py          |  42 ++++
 src/m64py/SDL2/stdinc.py         |  37 +++
 src/m64py/SDL2/surface.py        |  87 +++++++
 src/m64py/SDL2/syswm.py          | 123 ++++++++++
 src/m64py/SDL2/timer.py          |  19 ++
 src/m64py/SDL2/touch.py          |  24 ++
 src/m64py/SDL2/version.py        |  31 +++
 src/m64py/SDL2/video.py          | 250 ++++++++++++++++++++
 58 files changed, 3972 insertions(+)
 delete mode 100644 src/m64py/SDL/__init__.pyc
 delete mode 100644 src/m64py/SDL/active.pyc
 delete mode 100644 src/m64py/SDL/array.pyc
 delete mode 100644 src/m64py/SDL/audio.pyc
 delete mode 100644 src/m64py/SDL/cdrom.pyc
 delete mode 100644 src/m64py/SDL/constants.pyc
 delete mode 100644 src/m64py/SDL/dll.pyc
 delete mode 100644 src/m64py/SDL/endian.pyc
 delete mode 100644 src/m64py/SDL/error.pyc
 delete mode 100644 src/m64py/SDL/events.pyc
 delete mode 100644 src/m64py/SDL/joystick.pyc
 delete mode 100644 src/m64py/SDL/keyboard.pyc
 delete mode 100644 src/m64py/SDL/mouse.pyc
 delete mode 100644 src/m64py/SDL/quit.pyc
 delete mode 100644 src/m64py/SDL/rwops.pyc
 delete mode 100644 src/m64py/SDL/timer.pyc
 delete mode 100644 src/m64py/SDL/version.pyc
 delete mode 100644 src/m64py/SDL/video.pyc
 create mode 100644 src/m64py/SDL2/__init__.py
 create mode 100644 src/m64py/SDL2/audio.py
 create mode 100644 src/m64py/SDL2/blendmode.py
 create mode 100644 src/m64py/SDL2/clipboard.py
 create mode 100644 src/m64py/SDL2/cpuinfo.py
 create mode 100644 src/m64py/SDL2/dll.py
 create mode 100644 src/m64py/SDL2/endian.py
 create mode 100644 src/m64py/SDL2/error.py
 create mode 100644 src/m64py/SDL2/events.py
 create mode 100644 src/m64py/SDL2/filesystem.py
 create mode 100644 src/m64py/SDL2/gamecontroller.py
 create mode 100644 src/m64py/SDL2/gesture.py
 create mode 100644 src/m64py/SDL2/haptic.py
 create mode 100644 src/m64py/SDL2/hints.py
 create mode 100644 src/m64py/SDL2/joystick.py
 create mode 100644 src/m64py/SDL2/keyboard.py
 create mode 100644 src/m64py/SDL2/keycode.py
 create mode 100644 src/m64py/SDL2/loadso.py
 create mode 100644 src/m64py/SDL2/log.py
 create mode 100644 src/m64py/SDL2/messagebox.py
 create mode 100644 src/m64py/SDL2/mouse.py
 create mode 100644 src/m64py/SDL2/pixels.py
 create mode 100644 src/m64py/SDL2/platform.py
 create mode 100644 src/m64py/SDL2/power.py
 create mode 100644 src/m64py/SDL2/rect.py
 create mode 100644 src/m64py/SDL2/render.py
 create mode 100644 src/m64py/SDL2/rwops.py
 create mode 100644 src/m64py/SDL2/scancode.py
 create mode 100644 src/m64py/SDL2/sdlgfx.py
 create mode 100644 src/m64py/SDL2/sdlimage.py
 create mode 100644 src/m64py/SDL2/sdlmixer.py
 create mode 100644 src/m64py/SDL2/sdlttf.py
 create mode 100644 src/m64py/SDL2/shape.py
 create mode 100644 src/m64py/SDL2/stdinc.py
 create mode 100644 src/m64py/SDL2/surface.py
 create mode 100644 src/m64py/SDL2/syswm.py
 create mode 100644 src/m64py/SDL2/timer.py
 create mode 100644 src/m64py/SDL2/touch.py
 create mode 100644 src/m64py/SDL2/version.py
 create mode 100644 src/m64py/SDL2/video.py

diff --git a/src/m64py/SDL/__init__.pyc b/src/m64py/SDL/__init__.pyc
deleted file mode 100644
index 5673f1eb31ee8b7881cbdc2c4daaaea4a9d7f68b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3651
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
Gef|Ya@3bQT

diff --git a/src/m64py/SDL/active.pyc b/src/m64py/SDL/active.pyc
deleted file mode 100644
index 82aeafe52f25257659ffd1bf6b94faa2da12f027..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 998
zcmZ`&!EPEc5Pd)(32Bt5UoeNLLRAWvDhFCsMG37Ur3nSn1DD0D2XM7(Bil>Lxu4u?
zB`TYcP*wFxBYU3x=8gBc^6R*M@vhrX@i-0vd<5XW0+7H6kR^;tkY$X@kQK;1WEBi$
z6|#nG4|x@%DoR|1+=o1XJj4u;^%#%9HT*1BM*EO2FlZbH>Q?{;S2rXUi%g}$E2C*@
z(!vohS$mobEi<KO&ALAYVA*+Fq`t5$J^%2o2H@;kw&_f**Xwno1i**zT7|e-9{`vZ
zIt}dpWK%Ku%)YZ&47~8{ewTng`@(ASbEdSgHWYUOBr}c49fi$$orq{SXR@19OOX{!
z%8{Un@(;=}r6!*!z3IqIX*{^PNjkmWm%IBx_tV|w{a}0^S+>CSZSQ{g2$0b73Fur7
zufKK2%}v3ag;sjzNLVJ}Xlk;|Jh*n`iXn_G=}xsLY%6`IA({(ExhbOTC0jA$=F|Qy
z*N(s^?0;NJFABf;k^d6KhC0LU_*w6kr*LfJHBK@nZ^$vz$`p22>^T`fXB#hB1&27A
zFzdfGsnlpSRV>L^lF9`>8F$3cwtltXHYx4n+V24ncIJHWys)z*;LaaK%LQM=#BC!u
z$?pS55^2&T@xjD#J~cKMK1t%4Bw4a`%IGBV!J+Aft`go+mi5blr5f^y(!L+kjqv84
zgL?y@H8(l8a+L|KTRm&ObLw3yzj(V?wVX{`gR7gCNWEHebFqphf1ev!Wc(qt<6Z)&
Sm20J1xn4dk*G_7s@cjYl=?6Ff

diff --git a/src/m64py/SDL/array.pyc b/src/m64py/SDL/array.pyc
deleted file mode 100644
index 4e7667c1de8adbb7d76fd3bb86d2a50988455d2d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

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

diff --git a/src/m64py/SDL/audio.pyc b/src/m64py/SDL/audio.pyc
deleted file mode 100644
index 14a4ccdf466390858afe85bbeb9976f3109cb105..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14388
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
N)aL6ea1?c;{{uLK0GI#(

diff --git a/src/m64py/SDL/cdrom.pyc b/src/m64py/SDL/cdrom.pyc
deleted file mode 100644
index caab60d1341c7e19d96ba961d93d6ce83d3024a3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7201
zcmb^#U2_|^agUN{i?$;>w&i>}$VX#3r9?YP)0Ry-RY*CbsU>laN?U6>bA%2ciTa3R
z0Gu3k>?ijh^r?OBL*M%^`UCna`qm%d&Mxkbq)dBkCr1f`!|g5>`@LBD--X(LzuFFC
z$e#-U@EZWI|ET~7fI|Qgz+nKQ0*4h4OCXjZS%L$x0-_4ZGK^Q?a0SLyIIKc|t7jlN
z1LL!BcoqV27UU`n0uZb47l6kA_YP|yYQ^fga`haD^Z0Uj9>fKjTmbPJO<n_e7Q`Be
ziy$t+5J0?6<7JR*Ag&-&k1NZE7YXbth;;-L*I*bRq+FxPWssLZyaDoc0=`VZZ-RL1
z8NgRSo`c5$h_?}?KwLSzN{H`(c$W~b7rPYjxann(>obg9Bb4_*upC9a58?w5AA<M@
zhAYHmfiBmkfB5Ot8Q&mMKLPP^LFxvGIt-T<5W&S$=x-AGO%R_vm-$(#zC|cM1<`n6
zl(z|G1H|SFqr5{XO%S(U80B3;xeeme7e=`b;xp*gKS%riHvqId8$1&#WpS#VNt4Z5
zZAY`z2x*v0S!N}3BWWcYWIA>#)waR<z0TceM=RH7<IFlX;>VI5NvT=PlSB&kK)Dg3
z)jZ_h&Oy}fg!{XFHc0qzld*%5vMlDAm6r87cX1~hbB#F6o>(WxY>*n(?rennyES3d
zv9t}wwO~og1>=*6Nhd~eCmDS-cC+R#0)Ua$nJjjhk;2LEovi}EM?0d$K2lGfJb6+N
z0Knn!iNdj7!S~ky0ME3$^@r#n+-m=}=Mb;miSBfJ9_1_m6e4iva`<+~86Mv+BL^aV
zjgs9000|T`fMP}fatQ_%3?cbs3FI=ZEQ4I3$x1#Mu3#JqdvzpdzYYL;#hI9pHa6-=
z=^^9HDm_djYj+s2v01Az##n3Tm>b295@}nsfKOkEK5H?hUActM0kY3@Ha?Q3{LptN
z6S)X_UrUw_P+`&5x1F7RFDsTBTIy^aZ26Tbr9|qX8!e)Bm%cQZ(rjS(7}c8&m_xgu
z!%S(UgMpQ95siKNGDl-z(lN7+8;9hCviH4E9O_vKw~XpOnMijA0HRE1RtnO!=ai;?
z!#YBc+M`JGv5X>DL!4-wiY&obA`yu+&gXHI9i2EyIB}HOQED6!jH66x=V=X;OoWZ<
zm}{nkZ2&-Xl#XR{tP-wuvun~n$=KQE_>0dcCrxYOX0LO%84Ht+Hzz0I3IM#0_HiBn
zsu!xkYW|}gQAO=eX_u>oU53xIOK*;|cIj7E3QMh`fyyeTw`*4h6&P0G@C+I%I*0wX
z@=QZ*cXHb#zb`$MDa%rwoUk}EMry~n^+q6B!mXodf}w$;NW0T>+-0`^3TECl>bQ&*
zObMx-8mL*5x1RO_7is6bQJg{3a+%#^g)g)_X!7^Ace@Ao8u->b*zb0?JB`wQ@o9IW
z?%l0>JA2;{On2+s-gbwk+hMpLZkE7(osG%-?IKq8$WKW`=(i|5Z{oBGdU>3gh`udC
zFHS-LY?4}q@q8YceDQh61i-wDP@Gq~R38zZ(kmIU^1Dpxn1V;HOaHBe#fM@Moe8r5
zx^AxN5aS@3wU@p_b1nr%Z{@kmH{#Qwm(W%|*rT0>7`#LDnh*=U5VHos#gWpE{3^s?
z5nh_}Q1aE6cT;rHkI_3Y#Z<3M-E=jGG5_E{?$$;aj4uzV*u1|CJxWdX&j9d^I+hya
zJsDqv8R;^kEjuuoWD29EH1dXJoTP>!l_ZE+vv8I!#~|yZDRROFD{S6p1yV)JU~Fu$
zqclxuK~2LHavENqlgUeqgCc0V6YcDE!kyo3Q>w(%!&wpr2Ir+h7{BtuZ~*I%0u+k_
zXgw+fwEn1)iz;7xv;+^A;9&(G1~6DEr1uY`mg-|^oKFot*I-Z?E1fynv@%Y$XwrHv
zghjIQc#C9JSDI3gA8zJyBn`Eg%O(k#ecf+o8_aKL8#yZ;L4ApWB@v?l>XfF??ESt}
zu-u`sN8|1fNF5H%{!X~HyWNWp_M_e2ox4RIfz?{zf7KvHMv8wj&vo>aLIGDE25{|h
zfD*r!o9bUr3wwcxQS$yw&k=Smt6bU?9MD`zQ>Ry-t(c<LIW1c}6XouF8=B|D!?%8*
zfun49dv{Q<Uc`Sy*^-Ud+*(;S?q%Z+6}9#obSttJa#~-CVTkv&uTMK=RP?oR;ncae
z76+x`hMS=eiQEh$^kz%dsy9ela2WffF{z3CDtV=^81}FdYXv1soQ<+E*BeH1ffZ#V
z=U_v~iPV@!XR;}k>{#`q#ytBur`zB2@g$M0mRCAHH=05o`*P-nS1~Sbw`N`l0`ovq
z3E8~e9CPcWx$!K+!Td)tZ&CUpY3I^y_yQ4YXlhh$ZL<9PEv!gpdJrK8JWJ+F=DC9v
zDzMHdJ*0C`E+IastuXStOd0vKsP`vQ+rI?>IAMHF-y}&M$I{wdf;+B^`aCa1MqCRF
zE}GelKpR+z8?Laa;+o0tV>!VLpQi}o&Q~!HxMfNo^F#^6Im+xw(UfWVAUR>_L~1Dt
zo{nUkjwMOP6Y*lf#slkT_FyD6OEC-KQqd(@#*JhXZV_ZJ)e_4)6mH(tp~Czb@-upm
zAS~|&QoNF;<~6h^ntL-@kofZI#1|$GledsY4y3{IrO+Yzk9QYek=ktPFnGSAn)T_r
zsAz|j#A)Y3r<A!%ZDRgzcQAV^*C0X;T@LZFH<#L#wAvl)g-L?NW|M@Ulr>$kXS>55
zs3c)Wl4TRYofJiJ;Q1#CN?XTuTyWJ*tyQ?M4-V{@Cm9-)@w&%IJX`eUHJo3~i{H7m
zyzrf0qXM}9EKlBGed=@it*JtY)xzD%h==tZfl~AD57kZhiLWK?KbHXTm89tvP_`nt
z?(MPoFf}&rs5&yPD5mk|0qZ5>iVAs<`i8l$slK#*U;U!z3D(znTFP_XCSyATc9go&
z4E!7*9S{BGR>P|@(@rJCx71>)&%#X$C-eHX_tk_6?l_V03_S&DM`@M_-*6qt;;M!Z
zoHX=O1hDyT3lsKGy1Z#ndXSnir>Me@(##QurA+UnhROL@zxp9bnqkXj(D$cz5(<-C
zQ47{*J*rMRy?JvAi_dBGdZ-49EdRSX%`f@3)JKv)rnG*neSI%pHX<9h7xF>&H&Dhp
z(zq`)a&e*w+`d(mgkH<a<X?Y$hP{+NZLr&gq!vcUr+km3?;D2FC1&oD$}eQ}r@j>K
zF%Mt($4m&OGR3<X>1*bl=u(-MQ}c80V>8tYx%9u_2l{;Ow3LI(3oO4^9=KmYYNyVh
z-;2#2A43@(Kg9NS=8CaP*QD4W(2T;vOEKbu!Zd4z(q?06zoN<$r>{y9`_;m2(+PEK
zJ(o^imE81Jb(^lfehmOLdx4Dpl+F4>Pf50u)Jpq%Y*BDVaVxK&@TPfMm&~Q;7t=KD
zwO4-+1&R#-bpdoU=%Zy65hGD_ER9vEjv{|8=*x3dcbrlZcGh1#P>X_tNRp6xK?Evq
zf&C=~Rwv<`I9$i!eH`Av;R9p=uR7u=9&r;*s4>9Hg78Ms`*inr_71kg@Dp6Xo$&4h
zFCoKC96rP0XE=O;!_RT}1rEQQ>yKXTQiOQ>(qE(gnywE2j+Y~qYEZ4zD(k_;%KDY{
zcUEhw7gx_$m#cyQtyZcR{q;!|=WBj`-oIVKw>3Y%UJb4WZ~J+z8mt9Z{k%E@^HTHw
E18;N>s{jB1

diff --git a/src/m64py/SDL/constants.pyc b/src/m64py/SDL/constants.pyc
deleted file mode 100644
index 446af72f22698b371a976fae57420a7ccb62abd6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 13236
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
C?B`7Y

diff --git a/src/m64py/SDL/dll.pyc b/src/m64py/SDL/dll.pyc
deleted file mode 100644
index 04f84a91809d075be5977031da024acd1fbe4322..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

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

diff --git a/src/m64py/SDL/endian.pyc b/src/m64py/SDL/endian.pyc
deleted file mode 100644
index 494dc47e1560cc51be700fa5aaae88dd95dd6d05..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1442
zcmb_c%Wl&^6g{>RCwBTq0wgw;=psU*rfrl3LP;<QC{h%V%?59*)H5wEu_v-8rIETT
zpTHOKOMF1kou&z-tf00$x<0;h=bZbn@pIF@Zuk5ci%SR40Z{w^z<>~78bS?BN2r4t
zU?q$Vga%j{%*42aw2ZKf)I?}PV-<V@!U|Yb8C5V#85WqW3>)0Qc@3<FFFNw?;AMmx
z;1z_M;8lcM;1<Gda2w%{T6fjDhwK@+shn-)Y%6D5Iaic(736Fo+#{kveS@?d0C+pi
zVws4na85<;#3H-kxlFP%M+zq!$>f4NCo{<%ku#p#atA=p3z<)2In6nf{8APsfc-vu
z>Fg)-`FuW1Gyru<ncM;pbO({we;4(J-Tv$05*qXe3n(UkdJF(>h}mNRS1QFVrlWIX
zwwZyB7t~7thDjAbf;o`P=`^ZSonlB@E^pomES>{!KZ}&RX)+#VnfoCZ=RB5$n>HJh
znOo$s8*~RQ&sZ|b4kj~cFGvSpN0Y<mCIz80q1CjzRA1bsYM{kR=y*iiK%12pwuUw{
zm4u3tKq~tHi2xRYF#oG6pHg#gqK=Ptm!gcPD^a9U<$s?Nd0T?cwQBR$0?^TBngYF`
zPPB%7s=CtP+*ZLaFRgoJ-fTQtGS_xj%&F*#IZ3zz0@Vw{Ra^W&4N??kLQI|z1L|&Q
zlEj@PXY~h^Fsf=4F%d_Rq^?o+smRljj3QZ6$OX@fL}XE<widHOS^#2^6>^lx!Y3g<
z1@}pbN~2Hn<x_CwOXH}fQJtZN>(j^Hd%xTBC5<&9)VYJ+VRH>QK3W5sjXwZyeT%og
x#p^X2t2X@C0i)S{l?pZ;^A^cee<D*iHB;ZvAL>@gGOdzjY-{Fkw?*HV_b+<_8`=N>

diff --git a/src/m64py/SDL/error.pyc b/src/m64py/SDL/error.pyc
deleted file mode 100644
index b5f0624e415ba39ad4c38b2a98fcc2f6ccd1f071..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1893
zcmbtUO>Y}F5Pd6IvL%1SNgB6D9&%8FLb?<^xJ6quHi`g-5v+WvE;PLyNgM2kN{-S9
z@Gbo_z4cG@7xf3YnAw$sq&X#Ah#;xqaNe6Y)BX2w_}5S8X@+(T0Q?Lf{sX`RGr%X9
zCGZ{0I`Cci9TZ($`5t^9#SY3IW<4Z+7u3f*f#1WQz+2$A*)IG5w5O-T`_loa2fq)0
z0DlO7ghc}X05sIaG5iy}?Q~}cYW5KRk(ezYHZmWJr5GHl!DIL@J~U`O9LZujIuSTy
z0Oujp!FXcIIIk<?DsM>7mag(eUM<XgUFm;uJmg~lfg*=>#_K?y=?%v|fTu6~sd<{;
z-QC@d5&$gIvs~t8zXxFJi4Orx&o1own~YZS?mgFX;TH+c03ayKP?i%RYt|LgWwC>F
zI_iq$jlkGCGQs7MyqVX*xS}xAvx^2#92+w<rk$>qWJ-$BEy(22xM%|LI#lG%&Bk0y
zY`+pKIoD&omURGZf6wJz0dbq)7O*OdsRF%h;O+uw9~j9k-jOR*%u`v6L|Hn;Zvae|
zbxD&lFI-hkUWWP=WgI8vci*lylNhqe^z34yNg1y;N~E=Um9w>v#HqMPk_mI$pT;L4
z+ybxgUS!StVwm=}L40B)@_@CGgSAiI1u_!1ZIqQO$yy$&VOjfiA=~DjuQO{?(M~D{
z?<o1SXj0LFq(tS|-{~iVE`QnT?6T$;<*J~PDkiUK{lDUlK2TiRBs5-qOkaO2sWQAI
z<6gVGa5n|1)QbEjxUey+K;AJ$F;V#h`h882MVW0mja9v=)I};CCKZ-Gn}vM<UkM8$
zvwo+a@IlMLwAFL`TMmdd`pAy+tgZOSA+HwWp$2^V(gjx%Q;4T}Ame&o^7Z{r#=H)t
z<M!(JCa!OyAg$Qs71M%(c9h1mabdBR6hz}fL(6uEaaaWsf?PCtWmX}tcs}~NsXi?q
z7Z#Bv&GV93D05+9d9$L(0=ubTJ-7$GE#i183~Pxi?!rZW54DNJTjW7}p0+_NS{7|c
zQ+QsG3#uP&P`Wj)+I+;9K)W10*k)FHo)y(Mlv%4mTl<<q%<IZpmRiUfJc7~}MXIes
zpx!q))j2-~@DWjK`nC2ln=M_iD<$r-t|%29qz`41uJO4-(?@=2O8Q6bZO>Z4^*h7P
Zapz?Jq}Si=Cj<F9QjYQsIwDE={sXGxv+Do=

diff --git a/src/m64py/SDL/events.pyc b/src/m64py/SDL/events.pyc
deleted file mode 100644
index 1f5c7c282701e3d557789748d19499b19917d9ce..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 17551
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%0ACEIz4TQC?H
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
F{{Y_Ib6)@e

diff --git a/src/m64py/SDL/joystick.pyc b/src/m64py/SDL/joystick.pyc
deleted file mode 100644
index b53bf7427eaf1f91147df904efd8570156d59785..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5864
zcmcIoUvC@75g(EgZBdf{+p!(T-Xv}#C;H>qsa*&~QQKl=wT9%L<hJ3<adkTs&%WDZ
zcK0L^a9*l@fIjw96zDhUYrjH~w*q~vi<!NnD3LN!#}R?m-rn5I?96Ze?AHE0+gNzq
z3?eB0rUBqr0ARnX0w{nMfT}>N0;&qFDySN$2}o+Nr6xhuA(?=55?Ygx)}d90iaG^&
z3OW@~r{T{42LNBUP6JK>o`!=8v>Jeupr$}IKuyCAfSTcP7H}F4s<qY(6Py8cmI%~2
z*r^Z=PV;0IaF)r=Fxh!f7fv8+fVv2H77nTtt#eF#3Do5ih`s3ZOm+p-2TXRg6x}FA
zd$J2mb`8|^w~}3CvJXMscq`c@Ci@7~&9{<WX0ltL#9PU(FxkhTJ|VJU^Qy1dZdaM$
zQ&6{=&rixd4$SNKc#X+^3hJ{$oSK83Dm$XVzNiBE;yUyEkcsbr`n)9mVjS@eCjJPp
z4r>086=7qVurZkIOfd6lPz!{&gG#M+6VxK%sdbBGErGgQ%KGwTS%Qi0fx2H17g#DC
zTG-@cnrzPfj8MM<0Kdul*2U2)fxD=k=t`}USnn)08e1DH8_Qy=8(WcPDo;?vRzz9a
zOVDA`7rAz59je8KI|l#;tuuM#a)Zj@zO!`zxV@&9#qIdbn>TOfDgfYU_&la@u1e3R
z0icuX$i<mvHa!#XN{8WKaTWl=&6Q_isp%kkiNRyq#|Hp_z;O$JRp?Y{^Q{^Ln_eoZ
z5~@5+`*Rbe)G*XC#V~XYdKvmHh9PSdg}Yg-!X7__ofs2k!#PSChl5=LfTeDh;!+wX
zQtPGXCVPpIvrFlNuX_C@Yoevim1j#Y3kxsy`T<ElODdD@^$PEp_O_m<<@T)oEdV^p
za_xlcqR@G|jYec0Q8KbZIwzwpD&aDwv3=_>U2HUj5MtT5eh-&LtQ|i)5-QD(byI#4
z(tGPD`5AP%(Y!FwrBq~HrfB~K0ITRViOKaTYA4BCLSYZJBG8Z_NkKVKu~3D<6G<($
zQA9FHP>F5qWCn%Q{Q<ER(xAwCs8KBnvDOhf^E~~hyo*kjYc($%!Lh`K@akK!o@p$1
z|6CfGqC;bs`9rZF+6s5$2*X$_+;4l!95I!3#+zye0EUT2jIz-~ZMP}_G#T2k=wwFZ
z78jWh4_jRnEK&5NwWx%&LTVw+PEJM?20LhM>B9BTTz6m*k!kWPvnhNlyfHn)*s|Mq
zWs;-V>&8)6?8QkUVsb~^>3cJkcoDH?PMw^B^Kh9X-VVEJ#IRC}tS7(8hrTLg#Atqq
z#oNOX9roI+pgY5m{3eeLhTgaC0su!yiAu6ND*JZ;SRpT`u|^ROV^4IY72AlUIzy`P
z^}7J09c$-xTlV@ai!VtU1?IrK$K=h6%!s>06;nR7LTApy!ks_1nKc5W-5ZKA55B_9
z6jJ3b2IAhfol>Rt@~DB?!XvqX@^AT-yLe2!^*nvFkJkQaNWsH&w1XOrOoZI$x}crO
z5=+P(Ndsd|UrPP{x?UPp@3Bl0Yrh+-pEELgwM_(Ll_~)>OxKmWC^DV&g~3F+co#*Q
zakBHVBBZrh6ibIn?8UC@QQO5-NUaDIu@TluN7+v6%u(L!Wt8{cuh+&n>Zx?r=3@=<
zeB<|`E8TcAyeHpW8RMJWxlCK@#wxY#-;Q<7d(!E6>Uhyp(xLqe0Qf0~ag-ZF>Dc=%
z^RZ2tV-RsiQY2yBS2CHqER`;%$G+I6q>Dutm1J3ulhRO?D<H&>p?Zf}ZZj~bW{=pf
zN!{2cLCOBH0?=gQB^6uxXrNgkjv(fHHsZB**eMKPYfu#5s(I1Ra*^iN@kWj&3U3#m
z@%mYAEGCqLl!&?*z2Y4nu~QkuVy}yu8ShE$2Ft8ZtUH+@LuLBJC=f!lnQ>bjHZJ8~
zrn$SIit)P_&EV^Ko;KGXJ$}}tTuU$3R@XOzX376p2Q<jtxmH=k)fbhw`y@4EWag2W
zT1EG0KeqNiL+~BJ3f1$W^fwmG)CVw8tW_MLB?}rSq${%g-Jzc0|3*IBXhF0|z_`w)
zYyt-+kVV&Eq~3}3j_8;y6$|(8%|CqbbLvIz-+TDrVNtHQaomsXNF=SIqkQw%%3*Uj
zVwxiBoM@7+H^7f(k*;*#%OC~1xFLD^Xe)fuT;FO2&6W22;o6Jm!%xqezus!kd(#te
z34iqE%Elkohv|Z~)u&q{3&d;mTc#b$U{v;a4x|+`D4bUVfUb1oa7|T{TU|6JGexHr
z(UF8aPKTu@6c%*0a(u1f$LhCL__ju8xYq!$E8wc&=)}sC37Q;CK;?B6UQWX68jYPQ
z_!F4@?@$y`O)kQwEA<Wv8|%m?<3w7=>8yxkiXA5B*onsm4;%BH1BbYe!^vE%-8_ZQ
z9nZgP|D<qvFF`S<_UDD_-zh7`@rI!&B*fl3WRC30`6dcu?YNsca;{xP?-)u++kJx_
zJ}mF^*ymO5_xS`HP%p&sNdg?XPVM`D{U3Nl6#(!LazE({GZ!njD(>>J>Q1Wq`u)!#
zzmB8;SycHGbAWFGe$>S1MU3<CNNOCd4rBt)V5D__l4KUSb?4bo(<^!gcjGL#NxwLO
zaIbi@(9$ucU6!kHCzG<Wp4c9*&wWA|IK{UYDvQF<UzO0@7u+!9GkzHEqOozN!;m)=
z`Qtz32bClNVJDymz8=^t?{N64g1JB6Sfh-{hqI%nwtzGU=>DX*HHo^?guQ@{aSYBa
zlVd=aLjm<-0ky3GVJV<?F`#Rk;A%-rXZYY6EnTN2+E*0XZf0C?<8UG0?mG-_64|FT
z5L$yTXjnLMJHtWnE>|?XlVAATpkI>z?cXRTR_m2|wNbrNy;7U0)+g!}`b|~qje2E@
ze%1P{pYiJH!Ro0ov%_!3y`3EJE;vrr>eKbgOl5|ooGE8hm76SU>fF%Vx|jApoYg1D

diff --git a/src/m64py/SDL/keyboard.pyc b/src/m64py/SDL/keyboard.pyc
deleted file mode 100644
index 22bb784e64fccd64eb79bcba6fba48a8e95fc66f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4880
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
XJz9@fuC^9i5&f;it>sFdd3gLkBVgF|

diff --git a/src/m64py/SDL/mouse.pyc b/src/m64py/SDL/mouse.pyc
deleted file mode 100644
index 08bef00e8a5f2599cc6f7b56dbb71b5e276ea5c9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6215
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
F{a<0%=OzFE

diff --git a/src/m64py/SDL/quit.pyc b/src/m64py/SDL/quit.pyc
deleted file mode 100644
index f8a44708645b179514005909766baa0da12bddd9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1332
zcmb7EL5~wR6n>N4%_6s;_Qrw3J8%dhnp_ZvrK*Y`f(Te3Nn0sB%zDRf5*Lp>Yd<H<
znf|)|9sU6FOg2kPFP+24da^%%-}k=fqtCa+AJ3-q687H!0Db|0@B{!9zzRTRu*yIU
zU^M`B1nL;f5!A=9I)?fLRwqyoVKszIoxooJt5Z-zSd2~+$ln8i_fa#_mMr5&T4l6d
z=R!QSc(Hi?x_JNVY&rdHdcM3s9dJ#Sykt_i+mJ=x5XL|r*=q{O4ol+#b#>V^MwgPc
zvtp;Ma=RRHR-xtuq}SGYQs_KZ+AwwN$m8y4za4kl81z(2ZP7Jkb8$Fs9sd`^c#nP+
zDUw3#d@YS>QCjsCu+RaeF>XidKsiVJ{aVrfdL4Q-YK)=uL>6PCBva^#iPF`LA*L~2
z#$?@=&^n~5qLOnVI`?K)^95=fSQ-;B=(Uxmx0!sv%6VMOUd+yyIQl^CrITKvwoKl~
zh98K;dog>loX+3iD71m8MkZft+xd!~t|A3~Fh*V7peon-BaJ7iT0tLm=!}(o=-)TJ
z?fM^32HcS`IpT6do{|UF;ZC-K9V+VY?)zKH7zka3@|&dejs#-Xc8zi`TXg9nkJ@7E
zqW?M}y`^qT-fPw4E2?BP2g=%6bd|U|gtd2%ld9g<T<{M7;3=?=B}Y$+=_7|B0NkIc
zGrX@e02mzs0N(+C6z_MjZl)>w;ZS-hx3n*Pzu%RH;LX#;tA9-4vot_ICNO|c02yb%
z1NfA|VwCO)ZvkLV9KFS*kCa-(*QQFm5t95!gVc{;7u{S4M8q@CZ9`{x>73~b9rt-c
zpQm?Vo}`S@!*KHp4*_7ZaWze9ZKSo6ci#O;C5K7<_)*hNf-fhF=dUM;K;E>R6m)|g
zHP8Dzk-D1%94F+H)9ie7E2&HmMo}nN76sqFURP<vxG4C$uCgT`w6jIQ$@M-||KdAO
fus3|W)&C})2>nz$6%GBI1cX!=4u;uqaBuJhbdrK>

diff --git a/src/m64py/SDL/rwops.pyc b/src/m64py/SDL/rwops.pyc
deleted file mode 100644
index a8a659636a5a54c03e1994ad5dcdd21d2b0c333c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4825
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
SqUQ3cS?hS#6s;SrpZptBP--v$

diff --git a/src/m64py/SDL/timer.pyc b/src/m64py/SDL/timer.pyc
deleted file mode 100644
index 6299552cd1c98ae847406cadccb8aad8d2467705..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5087
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
NX0jCDf5Bf__W!qoVTS+!

diff --git a/src/m64py/SDL/version.pyc b/src/m64py/SDL/version.pyc
deleted file mode 100644
index 0706078fa075fea63ab40368144ad81c897fc0e8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2590
zcmcImO>Z1U5PdzfyUwni*l|Jv2+$w}X@TG+A8=S9izId;OO9jBm`LoUJ)Z8h$C(e)
z-D_o$;bLz54So<et{l1Z1B|L>X5&Q3g}~U;>aL#du6p(A_4<Eb?ESg69ww-tivYd_
zV1EUmfDxbsMgq#i$b<5sTF89ts5VpwSqpg^qc((^gYIA~pf2DS;1u|NGzZnC!RP{X
z8>$C254C`OKwaea5_A`O4yOWY5xNJpMD3~99?e5t=Cun@%ZU0{$f>UYJe(AXOUuFr
zMrX0pDsW}s4s;N$Z3gxrHd+N)x@TfD4UV<3X<4lF+!6qztuvFvO^jAfKX<kR;Kqg;
z1~<~Pv$M0l0N|+kETy&@UjQ(!&vf$uqP0y~Z#;vo1>in;cn^RE0|o|6K>HYbgkRn9
z>(0K9QH$UtgxXMT?sO1FeR9nH4&Z4OKrnNBrPm9BAQ)~O$0m*UGHr)!pl3Ia4@<Kf
z41=_AGb=rhX`(?RC?@%yHnR_Q^R#%wGMaefvZL4~2d_JAn<fIIk5dA_IgZbBZ2;_M
z)uRKr$D1XDI=uwv1H#~aVxhnZa0qUzzK5}oYf;|=uw^MjpQsi7@B08kS|8F;At71i
zk!)6H<32H+8@mEva8TxYkf&K(6oYM39_qx|LH_mKqv^n!WDu=w4jLLAO_>c+8hvD>
z{E&8}Z6SP-kT3MovF!WL#3tZGPz0wQ%!4KZfkT03ZIt)f;?XyU-Z_iU7N0B;#V&Xk
z5AV^U>5E0mKX2kys>P;A0a2fP*<v(Oa+6t|l9PRM+sy$uh;8hgc@;AHD5QCg*ytZ7
zsnP1~u}iJAX_4rU3A;;--J)0)%VNp9BCd%3>_{n#IM-6T9snuxQcW@%(g#wiGO7EC
zoa{}Vt`aj&b*8Kgi4h^y>I;YeZN@_)6se+J0MME5h_2|0MX%dRXr_5N<5#PUD}k$y
z74zzK=iz$9q_lqk*qNAu#j2)MT^yDwwhUq#YLh0xahy$>T7OuYKtGT3qf8HnRT<H<
zy1Gh|C!el|(Z-Xlt?wT9Z`}-T-wf`2IxFp4x4*no3&wVA;#@mz8o~IY(Tj6(K{ghH
zmu*$0S2o^zXx#KjzxXKq%Lh_LfD<6Bq0hOUa{J?J%kr%Xk+}16_@7gfh__gD%k}JL
zT0GNA)-r0J0(hj|OBpD~JXF&n&eJ5$vT2a<D!x$ao1~H5I_}+bcff8XY*bLO*|)A+
zbtEBV`NA;TO-#WCc1&rb$J*#3(XyK3XzC)XP0TLZbfzbFD|Vd%KludliBF<It<P->
zr<I*G=ftBS2?)!d{SCkx<v&jg9i&yzbY(VoWom=i1(}X*h0lI^tc!-HD;#8%`~QVW
zdu5sN_N-aqJ5<0_POs_`A@Yii8Fu`3Y@%Nm=h!6g?QE{!i*_CnrRWMluPfdaTYVCO
zkf`UV$2v4FO&&WbIn}cHWgw-abxFknDhiclA+eJQ5;Z?WSY9|%R<`XY8(TZ;A+u@6
uOmqdr2mgtZu|$4T3F#`~XldV$*AX4B=Ph~HKI&fXv^s+R7DPvMy?+3v*g1{>

diff --git a/src/m64py/SDL/video.pyc b/src/m64py/SDL/video.pyc
deleted file mode 100644
index 47d54cbc83c1fcdc3e7f72a478f801bb8d4d486c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 53456
zcmd_Tdz2hkniqH@tCUj7CChGGvfb{squmde+*PGVx7{AOUnN<R)z)jWB+IJqo~+1>
zo0VZjMx-MmtCWp2%#0cs-VBccW?-H$0|PU#EbnvpW7*wvfZ+hUunX*24(!=oW_TZ%
z;qW{R=lA>Wy%CX>ReHIH0n&CjDkAQ8U*G-S_q#K{aA5yWojKF$D)W0>DfMNgRPG&6
zDpYDssnAnvo(dakt)aph70#-7MqLf}sIaNxSvA<B*7m4DQ>`_Xho^g0yjKnOskMD-
zFsIh$)L_3_+b{3-srWH9m{)7_YH&cU9gwGUDt=rI4yv_-YVd?wdqNGKRBKPlyZtKu
zkQzLt)}B&>r`6ii$_pP;`jF~*Dx6o}RO+r$H`WfT@PK{#xO@7H($A>1XH|I6zI(#G
zdrpN<+NU3KPd}`}r|i?G-P7k)cnE*2eMISxD*b}eFDm`Ky6f@gu)V22xw}WL`6@hY
z!9C-^eN2VV+NaOCr!Ofzr@{}b@Oh;_j!HHfD*Om;?s|>2PpI&tDttkG(^G4oRC=EZ
zUsR#b4{Te)k172rb+^%2dzl}+q{5He4?c!AmLDwegHNdNlPdg_3SU;?f(nnQ@D;T&
z%Lcr_UcR985k8S-G-lRbVIx1yZ(daT!|eJI+te4!@wn@;*`HS7B1dkKH7==e`Mztc
z_bWUqz1y?4#5NqWZIDryIpI`n%%IodA7=xOs_-})aEuK&p~BCw0iRXjt15g=g`ZR5
z>uO`qHfZcSy0*tcYs{=2Cy;Mb;YkBz!>bj<pB$_34HbS~-EGXSonVnKsPKy{@+B31
zS%oWX<nu~@#{4U7)-O~FewN)lW#PYSv8;aM3Ia)9Q{icL_H!)z=7W@dU4>^@_S;zY
ztS#%1`WZHWhyf&Vn0Zo#=UDI!7JRE-Q0Aptmg8x#`tvG0&$3_OD1AkRZ*!C`sPLi+
zFRAddMM#HiUsUq1X~PkPdHE8HUs2(=PZkebmB|%!wGi|d&Ey&&UuOGP+5RKMWcmI@
zd}-Et{iehXud%kG!mI4dDZ;t-0B~Ft8%>LBUSsXF3g02XH`%-EDtwo{d&Mr;8!B8=
z;a64oH5GncZS1o(Ru(Th!hiAhBdmxMDx{!XQ)k%b@33<x-F#3u-t5|06}H*tb8Pdv
z3In#eGkv9Ckv3-5-r~ny6^6TgTw5LISwyR_w_6bd|111>Lxp{Q9I5a<lC0-BAWs>@
zHuQEUvh%hIZ?bC_2rX9Oz*HS3DopK)w#9MdAd@21+J8}nLqfYmXz!~qv(R!C7Tci7
zByNXunZ-vc+^iJex<_%0`4twtrNXf-_>Ib#xK%F{)p4T6%-XjTReqI4m1$oZ+S^j$
zZT4}Mb=^_nce1WXg}<7-W@Z}@$55oFb}%Q=^(p~=mkPhz0{kA%!rcnFs5i`k!i{vw
z60z``5NklIuUW9a<^u)$4#ECf75=&p6zp|^{azLRdV)<<cvpqLVcXQ({(_fn$Delz
z<TtADHxbAV>(q_j<V4(H@!zb%-||q!*I4|ws_?h5xX2+FRQP>%9)$!6HRgnxS$k3G
zm#}On+w)Zd{Ov0I9R&D0D`bb?I|dC*{u)32T`K(k-99!n<m>$ScdPLCn2&*M4U518
z?uNRyUcQ3`f3FIE;67?;^Wz^>;qT+ezh8wvWNSGB0#bv#&XxGXY=iJw$cmM3yvACf
z!XM!p>=5#gs_@4Ec|)NTt|BQlX4bld_Tz;1afqN&ms!i93jYA%XnytwZO1=uIU{ds
zMS3dy2^QI4k)O0h+`=T6sTJv~@DH&_#Mb^{75>y@Ye7Z7X@#rz_}L#(;UDF2?S#G6
zA~#v&r&ahfEb_-JhP+V6jTjwYUHBiM3jKLcsg-V5=eb{`e$m(d>YEq*EZFjUSuoI@
zQLm>ne=ADDbZdG4{*xP7IvV;nuD#=@n>vewvELgd-6Bep{3MFDPiHzP^o?upT$cBX
ze0m}6-mE;^@B2QVUrXZp8$NwA%7<|<t`y+ovze{{c8$3_)XBLEem)uw)2x_m&$$cj
zRb8wUMHY2Ng)XZ;ccFc*`hr#9>#bmTirvm#71!B+e-I?WhR!CdxPB2;oDPN<27z<^
zB7oaRuDkN(`EKPi{1NrWQiCgeHQm^V_1RGzuXZ!7lNyL~S<pG33`fQO;t8cxrt=~j
zb&FA^!$RLG@}^Si6X(N|{wJbe`lVm`r3FtZRp9bUgzG{Bf6pnUFkeBI1!MkIr0s4o
z9_oBy1|RHGO4+$(J;N;83<}+L51&&?1$nNsqP?lJJW7*xHysRvBI?9iYB^wPIdiM4
zIXuO@d2&t{XR<8Kq%!;6Th~{wwa%`bKI5LOtlqeE`qYK<S6#{0g)=LsPoKF^??>x;
zI?M~G_~=#Z`q?ZUoQ-15e(;g*7S0r~M=5m*_}^DbX+<M|q7lGTdPemcunCx(8Kr0W
zWY*kl%)%-FbAbD|slGW2BSE;AOMI^i_wi<*3g>t;r&_BE`%&ZPJ*Ci=AlZnu@1|~f
zKe5EU$^F47FZ_=7lQbIyag^(D(T|q(@}j>L6@9GL2rDxz`hJjveqTo${enO?xCS%7
z=m&}a4V|S1_{sB|K^6s_Sm!7CA%5$(*8P)ylt@wgyP6J{V%;nJTYfi9voK16LNAwv
z#=908PcO7Jt<ZJ!pak5X_RU+;H-1G-zQya9*DYTA5v)92Of3Ebj-SSGFDRvMd+N4Q
zZKZBEc;l(tGrVc2+q1lxfjwxIE9KI{tWv6V5Em@3)|0q=2nz>*3%t#B+?)CZ+Q3V`
zsFXU|PY3$wAc}(|IeH~a-_zY9KRS5rv%~SxJnJ4^ee=T6%_!9A@^DN%ZMUN&D%$N6
zr~?a7d2{@yi-n8-&;<6&SF~Q;R_Z;)EBp8!JNVv=>dmUdt6U+M_^Dk13%9=T$#Bsh
z^SZ@r{|lcCkL=uO)Y^K=_Un;4m+4{FZoiJsVHA}&Go@oMVvwhG30<94cW2!^VJuo$
z@l&Vb18jFU9gf@W&!gSIE9G_ZKm6yW<AZ87fO52nX9GP*9|fmCY}@Tn>!EbvOJx^G
zj11Bx!9cg$1;|soJxIe*j6e5E;k0Y+yY0N6W(CW1+oST2b}!O#n73O`qw$AuIgHD*
zHKchs%;Ee#k7i>9HlJuVWI-Hk9BR(Z&doSJb~=sI>|yD<Q2bd#@j>5bE5x1FV9<9O
zfMF|bTKc}%()WFizJJ<NYSl7iKh(V_iINRJ@bicizl(+%g1o+tb%~~rvh{U8%JJDa
zNt5xw@1<GgeYU>7D-qA8k<FG4eQ@M7(MhrBM~R;W$%gj7dTjB;tFL~&B)S{ZN}q$^
zaew7I)5@QUM|#)dB{|PX!Z&#B6p&v=$tc(14m2H$Z5NteA?1){S|F9JkKyu?rQ%#-
z6E9jHui@(hQ*fgHHJ~awAe7tDZO}W??GNunw|g@s#RkG#%*YlplIaazJ0#ZAy7fWO
zJ1*WebYUBPb{&A!H<do$opF>IAGa_|6GQyLG!n$+J4#CCi17#0L`Q*J&paYNfc^z#
zI~O2ww=jGyAVCY0Od{KDk2>Q*w_d>0Zv_p-Oi<b-4L#5_LdC(xp*^Ibj~R5k62!VF
zw4<UJP?mdjHz|2m={?YtdkrYOpp7#|2yU$s6Y{?V<OkXFhf;%2tz%b$mXJ>7(+JC@
z(V(L<KkW%E%|Y0pxf<XlSt~)1&a%>V_Zq(yXg`1yC854Wav7&tjweusq#T=W$uDQj
zG)`Eg)Uq85j|!CvJ$198vX>?oO)<k2Q_O;teNRKE7Le}}37|j~8HXtOGO*)QxKP%B
z+~c%b(WD&aQg#4Se-zmPNYQR@=prbJtliE_!Zz<6_7)(WP9ig;p>8`$3J%Pb%jYj$
zJ<}38K-~UxZ9zSxK=4WErDzOV(3}G@A8Hg3*FiC_M7MN&78+Bj>;dbE#{cV7G}f~Q
zd!h2}p{6%uZ;0E_2KU$}O?$J~-t4nCbM|Jxy?M;u%q!g_oCEgeaeH&n-aKJ%o;0O4
zo>UMp=)r|1`BbS%f=c9H*#k{72$#|%9{c$y>jhm6xnU3#+Z4;`y5Fg&$gk*(qqh4}
z>qJHF4|V1bF~V*Ut)Chf`hG#+(-OwA?_cdlIi#K>E&N2o3Ke8gJoaDrUvV|yS8ZlR
z32nt`eh&)4X2)q>_`NJ0_(9^ozSM~dKdXvHuCDcS4-avpE-sZYPdz-$PECX=L9RSJ
z$RHl}gHkLjVYc#q)GO`-35wL`r+x;5LwzLut-enDVbHx9B^xE|a}No7VoY~{e(E8i
z*GG2;;42Rad}5q;fZiGe`ORr#{+Sa*Q@jQ<+6i6nv-rd~mJ@U8J^|E+sw}^9pXDb;
zqXa-UcT-O_CtV4;H+AS2S&-zzAk#@94Bx-0$BTZ{^K)HPr~&JkHkPY~GV+7E8st+C
zVsk_nHZlY?=PK2qJ+emY$n8jhct^^?JFa)$ahZ~v%i`j#tOec*;__C|OkiS61*W^>
zJPAxb1Mjm#$H(lOlR+Q}P}^9l$siv$=A!IHbMv03R-r8wGwOT1sssYv-wcHa^AKiC
ztx2JiBBzXTDNS_i2)MeFJzB5SnEZolQ4kXT1lSwQ5z3qQ=DhvhtY}iG#r5s)iXw7X
zsXJo(@*qjUxTk0b^AzlR3f3^()8h9YrL8uNe(&w!^F92g$@?bn_ws%(@AvV3AMfXQ
zKgaw1yx-6J$9Vr3@8@|x&-(+sKfwFPdH*=?5AyyX@1NlP6TE+t_q<wDBt)0iGA@{a
z)-ha;;{pp|>od4~78eNUt=Dk*94;`iwZ09PleoNr3(QxoFW~Y;Twn?+XN{V7?-9gB
zDrJ8T(*_Y0%J2L=|Dg$LLWXPsV=3dcK7sj#D&1|5qNFHANY+)h^&#a*jOrK-M)~Ha
zn%+U97Kwpr`}JUBZm(073{7#W668<Hm_IpH#xxFvimC(|Q$)g9d$ULBz5KEXnN;ty
zV(DJ{!9F+}0cuX^{k++4Up;1T=IuAzB+ZS-)!Ji-7lZ|C9?BWa+qs&VCPhyAC8mpy
zB5Q)?Qo*VS-*q*MFRWw=!;aq>`vrtQBej+c;Zc1Alo#RF7)C{RsxzTfA4MST=weGO
zT}iIHqaxbWewJ=g38b*=hd~i6`~Ic0C>x4j(GLpg#vmBORTBpp{DbtnKqIAhroy5K
zjuI<$73!m|!T5>aQS{M5Z)l^5_O)oE8_}jtoVE)&+>Gh6UjuU{==Oab>j79MRN21K
zxczRLWjY_GNl1UMz7=$fc<iT%o{;PDqb#>>CV9Ea4aHXZ`l5gQH9yV#&zyL}Pm8|J
zwxV47I_Q@E9Q<rcqP$iiMt|A&FQ#GC8^c6Ogy5j~{UG;)q}HiuFwkKX6x!Flp6(WY
zYP5ci1E$D!)!@{!@2~3mgb_>Oi#E&GDfQ4?dvUN~RC>Yd((}XjL?}`DWgg`|?e%gk
z8gIM5g?7*;-HoGRJJVgUm$${9d0dLX=dD9>(Doo0Qh7CXT2Crrv@_l7rlX`FV+Sd8
zCazC<G=Uo9!eR0cMSgyp@ysweJnIQ3%s&TXLpTE~Ln5A)S#ZBQ!XAa`&8qkIszWHS
zPd$BS2ClMjmSBDloW*y9Wj3J+KYhEQ4&B+KZVT(&r=AX*>X~qlI&^17B?A`S!=gWJ
ziYD*!;a)!ci>lZUc*$u#+{cGMSF5CKM)Cqbn&U_RQ5BD|<QzM+9~~-$*EZ<Vn-!A^
z8Lu^|z>Xm%6`57C6q&#rz6vWHCR&HNkEw~04LZsrNLdj?p$L>Rf;}&SF`4$+Yl(?C
zAT=v=zBJU?5&<vJDRmB<Yz3F|xByP8g$ud(Teu@DCyxiSYkd@#H*ujjMZpTQF4k%Y
zRs}4-o#BuONz^FtY5om5Z?K};MAMQxKAZsd3jhiZsl55des8`Z{QSe-yw_|z={-xa
z45Hb**YuvkU1QFB%3FXRf0CoKLuBg|WZ)QWeFPUWcuKPE%`^(zLviMPaHgU&N~ynw
zo?z0NhhQqQOy2(AviXCJ?WTHo3xJ7A4L`;kPZbSJ!Kq?ao%%A?9!%bxfd5M=b!Ib&
zM*(ac2&KtJ8afJSuQkmGiWMnY1!;ia(Y-X&e!vhMYY@E>WWhieI&*INC4b!jS(h*y
zgSDc%oXm7F%94}*)rY85LQCAQq~m9UI5#eT`eDQt`4!CESzKt&hLGOE5~FFK<jpkn
z5m3;DdR)A=diBEP({DfFS%3K4oY!pZ^;~$!J8++$PkO17#IRr}iCx)E5)+RfLpz-H
zx+aNHHrv=k3tW>T6J2~*#reORRq9%<dn58+Kg3iG#Lb84rc2-N2U)lkWZLfr!=Mwz
zQ4wi3!&3t>`djT_Gl*gYXh5dwq-kkr!_Q8y18s&n_q#y?r0O#8BXoRoeQR)^AOjQQ
z<zk%Ri?od?;dSDuX!j|j-Me)~We`v>_c0tm^;l;?QEjJz+dh5z{yJU-O+9$&rXGV3
z-(NK=4_*ru?4?eulkh(4$#);7Jna?4k7{4;r~UaohiNM42OXw->mI{2wU!4Trd|}&
z^t>ZJvEe>G+XaER=Gp^2z|3wBW-5Z%4+apWASB8HMQ}w1LsH`3jN(+3frU|$>6kH6
zM@qEc><u1N%Q0fNRAts_39viLV9#n#)pkzHOH)>K2;X0^s}T)Gkmm8_6U)bsG4?AC
z3Y}H-3=4j${!<4pVPp3PpY12d?nDKHJ}9QTv8Pnh#$ZV-iEYMK{m;I$Q@QY&c1@i9
zsA0QdLwz}%A(w?zE8^%$`*Kh1Ws?%(b^CH}?WM?=g?%|!d%2$_zt6sWtoCxAFMr0q
zJWzZ2IA8v(eR;6<@(I5DdHeFo+RG2|<sJ&?3Z9*6KcD8y1-|rD_6c+IUPG;h&nXVY
zht<ud%37Xy55wox-G=fC%H!d)Fe4ql+fb_oty&O-pHr&~kh${j1HaZq7U@k5=ZJ*v
z_(9I~2Q-LdXvDJA(q7LGI_Ze!YbbaQgQ=@+MRDv0-C`8P@z~!=vzz`xnuR)pHkbA)
z@S~hAhbXRq2=x%eG%1$J@2lKT#BYe7d{yOQ5yUOZ8HQ&>un3CyE6k~V`g8<EiMVN>
ztwd^HwOqaxsVA!CNL3@{SIdC}M%Xf1f&v+e)OVRUK%zS2pc2!ofAu4XM>%Bn_9yd8
zVs5*M8Hgb<;kon_ed4#2FIr#2Cx~zm^#RgM3t|nsZ9KBy3bX555VK%URI~Hmlit1m
zqiJ?#-aFtuIW@dts_g&4$@gDXO1*?OL*Ht?C~*yt><>1aq0WS%JMj=RLh<msb`uXJ
z;CEZ(uegDA(^}@}4A!*UaZ@O5a(iLAgOzTdy_vItW!y3x?x#4p9~L-B&iSCB)YZOb
zRJ{}JgmIW4d#e~s6&p(<+$7&KeK%IDI2flRQ2NV>#_EI#>c%_APqZ(;bEb7+<%R^G
zpTBYK9rwg7cl`MMwHp)PU%T<n4fnl)dE=UWQsGHcSsjCaEw6N)Wp%LOP32z_47_up
zVH_m-9&Taz1~5wVQKhZap#?@9<*aLRY%iGS=2M32!SW@bYp`x<vH4k0I|ZYZAYs{)
ztrz(sjdKVFtUwnsEloGyxk1Bkn5Dp<kaT@qX#0`DBQZm`xMs14aMVa)OqXc3;Di1a
zV*bUGB_=LvfMnxf;h;@)H~m1(-Lxwk|9&z?Pvu{PQXTFAn@SY6?c8aoTW>?nhVISS
zj5oi2Qo$sp=(Cwo&*84Ao`zAX0lQTp4jRUFKX-c;^!n}$mZbOoRdxL~7-v(hit_d=
zlLLY*^|#t)36%V=wF(LWJC$9`H9OTM@u5&3cUC5fVT|-_rC=RHTwrD5L<d8#U0Rro
zcLf+C%00ro#m<Ci!Xd9w>zxn4qxZca(}-FjYiU^1(P8gt?-L%$;8e2_jYYH_(PFfT
z_PvYC2ggJbMZ2lW5mwlI$_B^5RCI{up@WSA;{x(WYr~saw5hX8u+V_n2iZoO+h)je
z#1g{?6hdfK0(%Fu=Nf^3OyVc+dhlEpbX(q55aF_yAiGh}^Q>j*k1M6PxLY*x<TNoL
zxXV&N;S?cTWf{eG3zF}z4}x2<PU@bSi@~jEFdF!=PBschiKQ1hG*DUH8;E5NMsY#&
z*70K}K5Hw>(EXEe8QGu@*+WrazQrWbmX~cIR(#Q(HlUy;u%c-SJrtOTq|$V;evTf=
zPYIXbk2rJE{(0}9x7TwMd`=gfV`E;+{|<1C<IZ6>VxAw$1~seKnSnS@o(fqvOd$aa
zWA?jgVzx(Fm&HW!MM~40W4pJ?%z#YxaMX#TZanrkqa0hSY_*Gwn}WqD(}7ru1Q(3D
zIWa#NZ)-LLlPEwELY?WJ&UDh%ZJBlM^}@GyEMQ&B|7kf8Q6e3S(!?kS+l^l3h)_|0
z_#ebE3@2jmBnw<MgMBd#^*RPY`|F}=uR}TS7+t|=(het`Yf|)&ZkiN<jR39q#7sGM
z^`(x^i<ivk4ARiH&!VnFMf6n$#|9J<9niwdZ|DE2q15TV?%ssWCfBs@2L3R}il{q^
zgRD{ky6pS|W;E;qK4$I0nSOtyb2t#tCKN#+oGa#!l2B)Ukc^>8v00%W7X3x|++;We
zK@j9tdLQh7b>lSGc`;$eV@-Agneix2ZX#Rufy<n^I%u{5_#I(eD7=e|s>95|g-FjX
zy@v3JiA&F#Ls75DliTNBCNdv&yBeF^I?y+vTI#_FmJNgAW~|tTdb6ZIfuHw-Fx{F!
ze@NCrwlRV;l%$LGSEhBHW=ZrRCsj>!?vK-vzm<++scjg@_So$$w@Yk0y<PIxIjrkd
zbJUW*F7}qmr=8(&@)6yU<{|rRkrk4td0@=`6Qf}k%(nTLIRNqy0||qKpf9hsA)rXH
z^iu}ehQu_nQ>4k#lh##G1_&U|CJ#9lD@J0XLDC)bd*3m?+a4GmT#yZwKL@#Q6`ZgE
z?uX6q5;c7Sa^Py%fcOW|a8}(~#77VUvlzSg5YZ!lOF{28U7er1Go#*LQP*!{yBNHt
z`CsO~OZZ9rz=`6{#O>$YXX}U2KquJBDiS@0hF*6LmLcfaZ7GD7bF}E^X@*5i?|)v9
zI1E7U@?v7;FCE9y$AZqIZ@@D^t38&@V#V=NHjfC0Euq4+7q<FQw{L?D^k7(wkCc?w
zDS}b%udgFCYu!*)u6b%7Tvi<h3A1m~BX&-L3p!)7>8MKm7mh5`0=hf83#|2>V?mbu
zosk-?t0VQ&abRjqXDUa68=Gk$qNq&il_BwzDjWiefEI?C&hxZKYf1sN2lRgB(v9|;
z=P#bQw0i#XrPc^CE>Kl;BjPi}wjgWW0?q=1<GgqTr&jBGl~O+k$peC>dh(#x^k%(7
z-mKU3n%)8LY435*@!l$H%>Tv#rB-#}kA{9wWigJ5=R@6%dXWx=k}n#gE)bPtTBi>c
zi~-pJx*S{dqXIXDIFO(>0`({5ovDC8V9mr@j1KT6f<cxpxBRqsQs@<a#ORevH_l#e
zU0k`kUJ@Zoh+x@{qfQoNW5L!U8w<NdsEsapCVOUo^@degh>%Ess~;44Q(F#Ql@n@k
zs$MU~r*j7%q+X6rI-Mm6yc!@wDx#hlSVp)9h%Ji8CDo~z34oGr_xqG_sY!Nj9S`H6
zt3!AM<h}E0^lGgcra2|YMba)XHv}y8gH4U0g=i)dQw@#rqk8-e4ZHYUeAO};^*j-<
zE!i+2k>}W|T2qW{>Uv;Ymgqu0&I>&-eV7;;mj+;BXn-yxY6eY)I>XTWh`f;<_M>4)
zpL~#ylWsptlXR5F<GN`J5(h^GTkeB+D;P^8h!t0*%MfUYIXOa$OvSa%Z3R(*sdtrP
zbko5w*08~d=qngW{Qx@>fYXQtnCS0Y*RQNxICJ&tG*sBOL^ei279@p+q{N6c?7QSX
zrd$_(rygTwg&6K?%8l&R5h2Tz!cc5znhMM5oInTJMnS1=8%Q7*5Wb^*__FQt1)8OG
z#3YfCrrKCEJlYBn9;nBZ%$$_$u(vkmc^`6`AE)U}-*mpdR!V)LNS&{q{jI?fKZe~z
zCL%CKx*H_u%g$pwPU{Ua?X|Qp*VuZy42UKigdH9PLy(lbA7tSEMPJvK8-}6Y4-;c(
z7mO$eA|gW-a|@`}D@zbySjwW%%H)&e27=542A;ik;lk?a)|oSxCYBspwhaX<R66i`
zqc}G5lp#x0xh%294@|?@6AWdQez`ydrxZyDjp0N!7#mqI>_^?)5)K9pPQ)=-Ri@tL
zsBSK;A?ftii;m85a-=KQ_4XJg)KWOE#VB`*>%{oJdHLF@3ujJUJ6ku%+-r14L%-Nc
zZ6)0MxShz#tdrR1TfxwUxE6gq5CsiOyrlbQ<7l{U_G8tCILiG|F7CZNPPeMDt&*0+
z>}p>U!w%3Z@Amb;sCxDX`Z~<?CRMPP3LW6fmwYJBy`WpbI$)!M2QD0R$8K%)BM=p8
zElE_QnT&ET(|JEiHZbLdB@5gd*Qu{`TU9U|#!)w5@*<h7Oow1;0IicE%A8t|CO*W6
zIwcj(GBK^KGppy<R!&{GFTx$faVphGh9w()!`&@GGG6qHI`_;p6$doXln4qx8zn_F
z0D-xV-B;Ax({6VJ=fPAqmFpz*10e$MoPYDoWj6ZEI{KJUe*t<_hG#nECAT!;#GtJl
zHbUr({Y)<bzkm^z<2aqWj`2>6b%b8DqlFZ<55}X(11_k1gg~OAU!T%STaQdk$fe6?
zTPqjuYdR)K5L*W4Hx#xaDq`(-g3<+!Uz$mtEI-uUG$Sf4`#$nEZKHp=k+%@_4su&t
zXW-Mps7MDv5n<S@$B!E%ry2!?uvU|F8M;FS-|Bz95d<NY1W{}qK<9g$;S9oPnz#yr
zI4Z`a^QbfSyE>zB&D4en=|#T_6BwJ18RtW5a}eQ1hqf_5i$QRcCQBoo*xpEGh7vnH
zydqioJqQe)K+J8K4o47mCyEPqpzOdFNo#<<TabuCN)X`RWevu7^2=$mkrg1@&;<FZ
ztODVq%o$#-$?+N`Rw%n-L4o<g1%6{|58MaVad4MGsds18*Jw?-Gh;kw;#Rmzm)PAI
z<&_Qvm~t=H=LGX8`oGn;o&3!GxkBkeW54D=%jbgSW=QMEYUDB_2Lh>~pOSR1OEIdR
z5(m5Mq?oUbVWBpRK8y-zD=cNU?HujWR$vl3L4y}HUMCDRrm{_YL1n;cE24QzY877^
zDqz`6_gcT{5#3?GO)2$m!{*r7|AObTmQ~uZ?(H&3ZgR+<i7j?+D%Psn+??+r(buBC
zKE`Ehow5P^>kP?^W0(LqZe<&cY9R0(#jWwh|H2c0Ytm*qo_w%1`Jif#ZT$||d$8&z
z5`8hm4GKBrqWo$@DclIP%hH5~6(LN<`EJJHa#F@`7-q$sgm4IrI&noxvf`x4oe27$
z)4pSfSTy7W2|0zj33=JYhEU;ky5^>a{~?I+bry6*$+zS=5dl!>w`r}_M6v1<eai+K
zTDcV=Q#8G$hRU-#Y06F=4O5*bT<bOs;|@JG^d5w7Gl-3};RJ;V3|tTtUIcQQe~&mL
zB+X8kq*9O;@tk4_Z5thI>w@tfyNJ`B<d9t)7S!d1W80Z3QfFhZ^Wo-f2<g+Xmmy;K
z9i^K_ySVJ>^vHALdn-fU(6LoroC^knAiso^QpWzZfhV$$i)lC6M23b~vp*B9bo)V)
zXvgp|SW=SS)!Zb4S_p>2EWH&Cf<njRBTi2^wtSrUcl_A$G4_rZ>l1Qg5#`CtRex0&
zfilHo+1*znEUk;cB7*5?YeftF5sfO+vMd-3bCG;)sOz%76SF4S57$rny*Lew8n)!G
zbEEsVr`Wyj9<mLFn1>|qEJQB{KCIecIsC0)FzkYRAV$OS;U9zZbVkkI!GE&~+o6=o
zj*{;(GhflLT)7FZjEz^G%B~p399G%(UT$h)dcy2|e$c3Yun+JP@-JjAoW<6wyEE#}
zoVq=SDA}7cD*GX%eJS=}KeU9>gxH)y*T+X@Ch>=R>SM~QenIsYRx1z$S|cQ10Q?*n
z5ssKeD2rx7QS1^hSkH}z0*|@OEJr@^>T7UYxlBDS4Vi!9l~<0xc0{akNDruUFc{`b
z8w6ZX4k^*P2x(8*uyj=5R+?=vz_ihjOZgT?Z59mmEwn+@6z(z<tp;xmFhiX1<oIjM
zzff5-Vq6LeNfor{=iLAjjR9yNaPe`xhMDe0a3qO3!e=*(;g$YGC!(VZ&@k-!H7gg8
zV+|8+RQRI=k2mx#f|3tGC`9->Xvg-wrDtsjnW=z6GHgn0jgDaH^Win}7hKI43G+ES
zV1KSTM=*wEg<u<!L)Pr$OnWx6<ixA5K{Kg=VXs+l4)1Q#WlW0+MLF^6YZXmS7WR&v
zTgefMuvsdFvgYsoJ=+r@wI*rrCE0Jsh+8aqZpov|h=QV}$RG)_p%2^FBnAtyZ>=B1
z<@Z@hGYc{jnho>+PLPqzWSQ>qX2afeaDy<qOy{Hck=#tbUn%ty5HA^R^~~d5(|g|i
z_aSe-bTXYY{DlM#J}LCr5jf+j#i=-!R^6fMQG4P+8L2(t4mlILN1BHiKGHV1xjRFO
z)lk_0pCON51Ih1JL%3?;g3Hf{t5$;4iGy}W1VV!x36jORjg(nw%=*h0+<K7sRI~Qo
zQ`zU?_Rs}>F&f6&Us&gQg1Bt3kGJF{>qj6pWU|-U?r(OejeXA5<z$pp8}%cRS|T!)
z>{EK<U{rc_1gomP%6j*tsIqjbh>gj;bm@{fIpNwAEXSVH62Yq|A<omhniRVA!zlM7
zxculNYC%7tl=`bcQ{*UB`#$91pI5vC<<>sr)TV2I%om8^;!Kg`Vn-!-2HaG_N5Lr@
zr7G-l$L4!y$q|un6G_8iKeyx;Rl+!L8KNk<;_fgavf*~nsmv3qvNSUo2SW6X(g-ps
z>_b@QM8mihB^!%IxCYxhCI)M9l?d*Odt?jfMl(@finN46A=nMpx)ZhxRR6euWb5L%
zgb7tHi%e4-c<Y7<a_RXtaL1f6(5m>x^}@zrwOU2OCi|OoyI5C?NUG*5Gp4j))<(4o
zG05|@iyQ#(bW09w>lv`ii>?$l#jZCuqts(M+F3Ikh|=&VgDnGA4sOL6w-w}^g(z|3
zUYa$<`n1g-MnJ6GxE4j1@{gASh#jgZFC9&kEjlvk7=*1r%+D}xg*uNiy-0(tbt@Tz
zu<I_|A+pzaE69eh5M(eFi{prGa?YcQj56IWX3>0_9zz?94BYz33MbD>5{tz}G?i3}
ztenMqQI;1hD~kFX>?xlb^k8B}^n=NsSke-98<Ouxw?x;(v6;pasok2XhS?mGUQ2!>
zGJA%GyX=aV;|mcIx_JYn4?!Rd*e+Y&`dxVOsFtBWtd#ou&NB3D#WJ+23!9u13>v$T
z@gD<<u?q&oPzW8Pr%K&}nu#HX9y2z~7zG0xR`#enO?A7;Xsa2OUEiicG}I~?N4`%~
zh<g#tU>9;}V??5y!GdY#cT$ENS8~yVDPOpJ?#jvqizM;`;fvD^nmNo`S%fjM+h_b|
zmd3f?Pq!-jXQ4e*b{OMVq(`00-5|8VL=%^C<*gg5Q>z~K$N4?$me2s9hLW4aLC3FV
zj=Ri^jSM+6eu2p<7-OJeMJPlD-+*vTi1yQ?6C*-XEgfDq-ougxsR<N;065GQqE;@g
z30^``W~!;CZWJLU70@!v{ue~-lDYJ6lN6ZYEloHNNo#21pET_KG7%umBty=OrZ7P_
zU`(`h!z|c}o`5AQB!n9_Ku21C1Q$m=T7U2n#i~E5l=@E~Ay7;}LSBHx56cCX*2Q4h
zI(I5RLgO+_jDG9fDZj`f2)qdGN&IveygxG8fW%lN3aVMyL~@RTL^xS<*EVkog8i6@
z)bfn&$)RAwk!iH9^NL--<tK+#=f1w`?D`ekyd&oTf8E}5mXUzKdJb{7yHEynC10(L
z=!*aTC<rsE5&vzEDk<BNzaD&R#-1CH0*AimbkRC@%56KF<bZd{2i<k1afflk&;~rC
zY8H$)7N6N|?hwNhZZf;OM|lW8p1})TXL*i>O=_M$Wv5uyfLR;PqJ)Lya_vj-@WZSb
zt}hu(H@HYXFfFRKhSCd>r1)o^|6)R?Ej3!B&l+8Jx*`jzA0VKpqSDI#mnrL0#3!cm
z!DdzxKba@mRy$+3%)S#;4H_Juv5z#2^ajPm%6gOlTO4S0ddBA8pZ}=0;JJk=O<Hk@
zv_KvyJ#C5f<gljTsk?IR&8n}>B1T<w$~$}R3z2|POo)EBISr$3?;&2<V@z`Yo_MwL
zD+sZWF5~{O3$~MBHzX4r2Tx6QV*(W<<B=xdWoAZO|05VE5e(*m)}O@XPvKH0*)8m&
zdlc;Y(@LouC3d~y9rw784Q-J_&syhB*?nVwYfh<^I8M8e-VB>HB4<U{x@b;#GS2a!
zSLn=%V5M3q>L^$gxBp;yeiq{M>l{6VKGO=z{Qy=v<{CB)2%Rm%Ho@%gF#rh$nrHRc
zsMif(RLccx7(PCPG%lVSyrnos80+g_ZJj&yb!4brU$?#+`sqYu^9vovjK%hEMo9>*
z(6k6_Qlf8!s^KTHs67yDN)VzgYa$KG{6}Rh<n&<T-Quiw1u9Mt8&m1*2iP~{Fd07+
z{cWP?ts$ZueVg}uR3?!!FYDoVbRyGo0PBso0Q|wI+ecuSUm%Dh2seYI2&f%6cTBA@
zF5wcaTy%DJG)ztK^TLv1JQ$O$bTBv%4;p`6jkY#gnHjE$*h|xI3E78fV_OV%gh1j-
zmNc||GX9GgS`EuC-Q(7FjPBAPf&+Q-zJcj_iJ#bI0N?3}Q$n*>Tc=N7zHqtq_L&>I
zAf+=l!TAhZA{CUIdMpibOR&}e>rS&?^t?WK_QVSZrSy$$)#C&$Hen^yk=6zT+K655
zAmBPSWoiwYD8B4`z~cIKdM08pX|Bx7F0vXF*R2{VIxjCxcD8yqaI&?b2FHasPhZxn
zt<x(PuDrGKAhW`JRR%ZU?=-f0+u~aFCbR(xyGiX<>rdLNL9=OP?|*6#T7dl=)!A?}
zP-}^a?~QtH2C9aw$ZVhNXfufAz)gWt8nZ#n4HAIL+d%UP99VSAnVEw8Ht12CfO|n+
z=uDP!6__E1T-hD%M<IN?h*&YChZsr-wt6X1+DB>C;I4q${u5dD7!GqFjHL?}4!pl9
z$Sm7KN><zBf+^=yIf%3tTL!LdeMt;`fOFh#*tHe7>_>>q4J+~3mP@c(tfInoEO7uM
zHKMfyF4lTt=#jBvnHq&~fS}~*0G|Z8NrY>g)a8B%6L;q}2(cY?Qeg1}pUPe!?Bs$x
zQ)w#Ng?4f-2*ftNf*-Y=JARbpg${OhRZr{#B<Y>DU3Thj*(HCSQqY8sBnK%}_S!D_
z>vB3m{h1tiP=6+e7|1iW#+nH@7B!rp{=)jFWmYecA$FQPh{H&`NEU(os4&J*^?=bp
zGC_pg44b{ELMG#F+?i8%_N(L<sY@v6t9KqN?{Ck-gZlLC8FlD(Lp=>w>feOYia?Nt
z$~J8TXah<wbX}&!MSLj1zW<cjBa4rJeA~y2ESdaRQm;Mbi6yy&+_W(+7IO0C@~wE^
z*uMSSO4i$ijJ|tK7MNlm^0(aH4;wo^<JgFs*ag4bZmQdR)$M)i?wq<ak0_Yi^9m{W
z=WUvo<(ZlU4jLF05zkTGCXjQ||GN;zT?TTqnFtXW)!2)ul6IUs4a{O=P`P-gtDiGx
zB9#wdy`=7jv)WHagCTZrWx?1);~+-}$2sjuvThTXXQ>I2sCFTab^=IDhNhJcf3ut3
z&{MOEUg)>b10js&4-o#Chg$b><d4y1ta!<GFzf{skEz3v01ru=ce7^-x7o?ZMWByN
z$C!I*f<FB+(Kc?6mYmm2cg;-K$WVR3<%Ti*77lE34V<#oH<saY=lt@e1!(D#Ix5I<
zewf4>(7#5Dc|F}VBMq*OhjNY?&y}W%KdDxOj52Pf8{`Gk0*TE@;#!d{T@p|uXHx6e
z;_~Zo!LbyQZ+qHl7|!-iGh?h1lii($`bRMs{CTC+pM=2xd8E}x4mO@>%zH01=Dm-3
z^4}-C!;OzM<{F2*7rZ&oh5zH2b8AO<TPcOVEy*&^cf(R623U(>jeW6CuA+)0ln+ga
zAorMCNdi)ai|H))z+%w|CYW}dvL`4&VuHX$##sTsew0t@Le?VJBXS^YWsx~qf!6X6
zQcWm2*t+e{vRQrWixtxYpIPxTFH#(n6eZRZWhEx#hX94Rj2JVJ0ffDW2zIM?%M_8O
z8M^`(HblrNeL#aV9qS-Rn4TGqOW1A_#}*iN0CJy)O)hUJ6-cH{aE+~3CV4okD^kQ+
zU{k0YB#sH>RgM<EsEXKu-K8`zo4l<gTpJ=2<6`HRw70Y@pk0WUw&`pbi)-Pqxs!6C
z$yg&HGBho?P;T_Dn#Dk-o1JsjB9$3B0wtThnXo}@*ZVQXkQaHml=|rqnWUky8xfQ#
zBP4r(U}I?<8U!IA%3&X<^5`gWG48`4!gjd;YELA}iGheua?3CKIu8AC#Ep)0fpX)W
zks7D@z|2rjU5zdkMQvT=INVU4Af=5ty9%waQ7;_Z>gsyv1|V-HCh9^Ogr_cEX}7ND
zU-Fc~pOw043<;3%=q5vjVL~9&%+pcU)&7D}N3j_$ighg|Nv3t4bxn9wvV_Cvjk+&o
zE&FG(n$Va)#Xbdum)V91G0`ruk8%80w$@f=88u3D5OIWKRiUW6k5$&S6V<w&4s#QO
z0DZ;u<NlNcu(&+yk^!2M+fNrj7LY<2kAf%wVFNjFOvJ_i2hKZnA~48i%1<M=SQ0UG
z)`jKQJoYjQ24(ClGbFNg9sKlc6zc^*T=ZYgIxint^pEf6pvPE5G4NS3y2)hH&|L|l
z>qG@Z=*oufqEaCiG3!Vk7se(2FW}eEl;lhS1iS#!Bk*G91~P~ae}Ww4{+L?>tHGu=
zYv4a&Ss?PdTz_Cp54{4yyqK~ALY)^8a)Q7tYm6z|mjUMwB)`zuTKbTr2J?ni7&qds
z*bVwh6b^Ga)`m+emqTbUL2%?zfh~`MmfeOW7Q<`GRq(&<Fq9S4cpw}uXKBIlYEZE4
z$h_r{`2!y_qU=@`W&espSz<85#Bl2I2Z6Ju%V!+U?spQLjrx3BkMm!wY!afa8OJ30
z3)RyTDGMBdgd`?U*{Na1(NGiwwZi5@gcUAcwRbP1Lm(^@eqV0AY~nEaUF*V`mD8us
zTv$J{Xe2P6>u6CM(#p2RSnHSJ2GPJcGNgS%{p-N34KDXv7tYiTur^}X@=TaVWkZQ*
zjS!wPJxDk8l)}i%)xqWyBb~W1pd4nL7LLSrV;yAhl8>E#!HxODa%0j~jC|cXg+b(#
zMW!6&Xh_(JuqUC9aj?NPdsCOEr>yE?1*g5{&_e9~F)?^kuXY1w_jHP^K`AI54pXyj
zj-EcD3P`0_KR*^Cr6eXs>P6Fay0@f?fe!Lfh9hxcKE)Om3Zd>u&#v3|;%b*2XCedG
z<T>%UhC4-ygFCl>BOyG?{)(78?UA6;6h_UzDyb%{PfFrrrC3caVRu9p@1{ef*0OH0
z3e{dfr%V=;Bg;G=PF!|43Cdz22aLl9RR>PWbkK>gN1hHb=N77t$+WeIxND9*&me)w
z%S4PhM6&4~URGKnvR%yLBbf$GC)0ru(B;<4#`7jNVYdE3)}})tGcs>r%}oHXDKKq9
zGno^&(n(ARrvuYBma;W7)6L8QT89cF=O+PPw2@FRq{&<`++_Qp%{xe{GbDSjKHwEB
zt*VKRCUIkw6mK9NJMA((r4E<<g|p}1y?93AcX&u=jo8Q0ka+=qwo$HVoHU1>r<HBt
zmJ(Kx)#9V0{w0zDjRB<sA<DTIY_WuH>3C>RPO!o_MkY#gJMhc!ZQu|q9M*>_ObcXA
z9VrD|PN@uv96Lo?EgoB2Z-o@F#~7?K-54q$6bDzp<#K2eNWXIcSK3lS#~^Z*J2Z8T
zuL!nw5Q9ty1Zsz_J^^NEabTnn1gV>Q?W<WnY)>q4(cwn9y-9c?n}g<0nM-Sbd0@>G
ztOi?kojizp=x^BnXT&9w)!9aYxgh(*sBu`m=oYnaPLgps2{(yd=PIsAcE<gn3<?&J
zhoM0Z+0W_1BD+hW?Y5@DGAR*SCV#e~)4?;o0`E4GXCs4o{xeFcb7to>r}*L5$;n)6
zyZxbT+>XK}hS*?>9c5>V<1p9(77AGA_@sRlig}rzqB0l^cd7`Pf9uhN%+~**l=>k^
zmI$6w`*DaL^Fl+WreK~G))sjU*^e0_1OtCX9k*5`OSD0L20_7fo`8Ka6BRoRtq@Db
zWDhaMjUt6FG8c;$aLR&|)Y<R~m`@4BQiLF<#~J^(fe2>dRb!57%)mGutch~cz$^|0
zZk*|-xfU@t*Mk85YQ$_{2QS!o5a+3Q5GEOz1WH04!#*v`hioR!$><Bm*?1sYDGXr2
zTW*iA6&rua-Jv$ix)~GKXCxM~X$qLQi`LLWXCkg6wJWCeO-WvUR-&^_>FFe-w1+s{
z<?4kMV27Yo_Z}lqXL^z*o^7asW4NBn9(-*$)Y&QY+M8GEipl2~$W#+KTyT!j8Y*Z6
z+^P^twx&KzVhRC#+XiYnfuE0)G#L-bJ8dEg(~?TgiRu^!c|ICgVS-FWY+94l8ib9x
zD0!$7+r+PtZ5mEC(KyVO(e*s*k~D)HLuZ#iz&b#jg?S2zt@h4eKtWe%{Rl8XBv<2r
z>qSWr%K+9J<mbVri7~*gHdjBoQE32!6S=v{${SH`Q(@GkFqtEZh*Q%5A#=PnY1XF)
zE0+M=s;diblseHe+%Pv6Wnw(Bk~D{f_I=%>oDDjWBGX!4NkrQ^cWMQ6pmpvP3)r8a
zr;8-Yby03lvcDx+n{pbUzaXKIY{-(4Aj`Ak>~G0IE`!I6Xu4bd;Hf*bfrNFk`S>k4
z!MdipGl+wMG%N`etY|s)A02yE+(&4;Q=uw&?lfLeuj@bd4G?643;}}>7i3Xx(<0!<
zEhwCbmHJRW^i)*ZxJ?t2o=lq`1mjd_hiP~LCj+*`JmM@td*1=RAsdyZ*6Na<3?rvO
zWG4Hwqg0~R4){_|y-a(3l1(GroVq4d7Rt9^exzG=)o|vfp|meO&)+a9F}BasC@IoW
zw+~8WN5=kkS$g%4?NFL1!h5Yf5W}?R1_)SJY1foySbg`uvSm4aRla3LX$Nc*a!6Z+
zrH~K0EFW+>Ch^7=e}IL77T(X|FhbM$p5@wB1h)1CZl~WCI0-I=D#+lBeo8c1Iw5?$
z8lT6l=5d<C?kDoGBs!+$BTfSx?<L$YD{%B80ilLW1Ad{ylNEL+iT5D>RYac!+FKX>
zXs`j106A?kt&>IHh#g1#FMPpYI#Hkh5>mwlDUgo%pZAZ|zs4_*wH_`UKUOEYANQ}r
z?Qd+pX4Ihxzy@r*{k1iO#@9ThrczO-XmjlIaI4(pMt+m&sNVHoT|OqxX(FH`8PB((
zqT7c=hNx0Vl&ou<j<RY3;7VRmBSygyD;fxO0A$q!?TI9x4opfi5j@Zv{XwO*c?~v#
z$R<*IV6oduXV#J9^hQv*iigJvw=#nAj*?`pAm3U=bepEnQ$kFFvfe0W4A{~MP%-4}
zK|%uV6VqA71SR%R45`xojBgm<0-2Y6f1ynKBSoptWkHlP%thboYWf%iUFbwLz2?2a
zO>P8Yd6PRW|9<r?P#5YsEt%A+rYI08ot|KosR`SO(`_ywg)()Uzew-y)>5oDH8P#%
z1*t++my^o$AX*w`(Iz$$)g^0g4soGaCh<K7-^usjno%e&Mr=Vak~@;DY8%hu8gH$J
z1R-ZmIel`cjv>wqLvS{VV;Uy^xwmZ+aAc|_kfQgO?Gqz1g$_G-&;TYsgD&F?bX-vt
zMr$<)enQI}dtiyJ=sj#iSuZv*LF=({sj&-0IC#q_Ya$xJ9p;oUXB5Sn-s-32QC!X@
zfqE=qHvM92&?}LxN-`b@)w5$`qU3FMY7#5wkx4>XSH_31p%Xbm-KN?jA{w{Qwpp7N
znDW51f(v@dcB=GIF(jH@bMY)S3q$@_Jf%+42;^qUkVO)G+i!G{U|fDD6Ai?gCB(0~
zJe-D!{KCjfL9GUxFkCgr744GSxi#kOC#lT_HxYIOeH`ig5zNMMtsBDD1vA(zlSmo4
zhS{kdcVtP|;E@HbG=3a&s8@9tNiFgW8UxUP!-BFHqlzL>-NR%9uWE@I?6RGP00y@#
zLvRd({jwBHWGKNx<8DOU3YL6rlEu&X^S^>-n!_ZhV~y0i%r};2)uc(5WU}>?Jl*Pq
z&P{|h@!u;RAiW&$Ky0WtuDxRpD9x|TR_w$g`Izj8?tov8*=ds=9vCjdaB1g-Th4q<
zTAdCwQ)S8e9z=PP4$Sd@9nHf7%tA>Do-ttL@ri{ka$%walR64s95zLgxuGHHrj7%t
zv!8Ays2m4vh#_eSW@-~TkJg#69C9(jk;RJR9$~Y-aqS(($vLWpW7cvcHX004yD!i7
zQm8*Igrx*cp!jheRu5}7f}QzYiGw7_cpA$||Azl*{~iC+{xyH$GuZ!==)9D?38;F;
z^F07vBe0zSRgZ(702DA@aggfpq<`ZWnuE)Y<A8U}UpOu;n`l_|FzH?32`IpO#{k^{
z-i^vp)Vsi|fnrNbc$@;{&I}S?-@<Sjaf(uKUf&#zv*5G{Q2nA9o;-SVYinzHOC#~)
zH<r8U;Ajsf;_gvqwHl8$m;1$_tYVO2`()*KO|uIk(~_z+??>fX9!8oN23;-H3fffa
zP4p;Bm-AkC`KFH2<)FL#-tg#m2J!glFpb9>X>t^G9VMV80$S<?@1sev;R4h6#<o)p
zciN_9!mdk6foh02AMS(e7;+-hCX&CDb^a;npB1|EvlOYjH><Rxj9@o`-exVD_*%2#
zGc0+AFEb=ugi=cO3=l5surlh@fiWxDcFnb)7-SjhHYKa-{jWLy*<}OM5!=ZI<wYe}
zxFnfktcR)!3oQ5f6@6Lz^+9{64uR+tIFh;|29#rz|EQ-FbR2hBoh5NLf@bRBxgsFf
z$+s{MBdAOgZz@9-HGs{6*&k**L$Qs{K6$>WV-J;B9w+w`jv?~f&N&TSS<@-m>}vLy
z^E8ck?4P(rAjlBR@!x(F>;oYXiTuN<@H=A{4*$jcAvU@)c^BP=6U(|cxjc50B+Vz&
z5x+cInfn1&iXw|TqeAmsYXqf1s<IF5#9SWg<lF^6A9akm#v}l+d-%RV8oXPZ0CIx#
z&~`q}Bl!Sp5+MlO&xC{{)vle>W!JU`EPVXl0SoWBL_=RQF$?!KFwPe$*&nTIn6WE8
z9tMz)x_!97HsW_hagk&yI9a_shx;7!skq6hBvoNN>p#NB2u#=v;ztN+ZT(}V)X(p+
z(FU`%XanHKRxms@!qLKc{w3fi&aMKDHuzx9FW|nE$@2v$CdzRO)(7D9(d!o(DI3tN
z#1ug2l?x{^vxA()Ja`s|rg-K3-G=hYM2N`OW@9PkOdu#_Q5UQlXDLibo-!?t>qK1~
z^emzCl=Z}l2n}$^Foy^ml#VZ-SU!GiH}q!BE(qUI2sESqG)J)ZsOT-deu-1bb<fRp
zwLxL-X`P^T@)?sg;m9MRJm5acy#I4#rNg{q+|^ulVi4P6CI;_n6T?MT$;Z^VqfEq4
zxdXX@xspA?9%gVxWnbY`&LH13BGNtNtxlTQU2#VeQqQO?;S^WD@$5G?S6I(&#X#0$
z8%6Y>b8Z>`g5576{};j61y#AE(*(are43VH8dx6q*J^kqyrweG2<71sCf#<oA7t%e
zZPLpDFIPFIA4gb)nmaXR)&ENbwg0O}3^4iyrPSk1rE)MF)qKi(t}*8wYBc3qo_!<e
zc)pv;0tK;g3-nDThbMf7+vPbw@5!~Ho(?_rOxRF|iW$2Xy#XY_X$i9?>l;_FI}M>#
z36$r$b<vVWFsZHCx&hdxuz<CtJk1^?%H*ttPtZme)waJGb7H})J(6DyG^1wW3w)$b
zf)(=O>M5fUns9XHRKn~t2!vCPT21736_hhY(vWCU5aEN}=n39i{#`ToK<;4O#&5ta
z-3&8v`@luOjgXCxyN6ARamKOXu;mtJUNXeF^qA#rOS~JfjFbj-aZB!_keh#_l=>8K
zjzMkn&Bjuhs_Xj2Hjpgpjju;Zm~Q3B`){6bNNcli!dsoK(VS5a7F0MREN7GY!pfB^
zE2poXe`f{fw#I2L4lJIDC-YxCW5llO7u#3Ujg462thiN41p8t`DS23RLGkcz8|?zi
z(}s=9=+?z$p#ubErrNaL;<Xi|ozGxmU#gX|+?H5}W@4zVXr?B%4=89HJi}DtWd;2p
zgR`w=becJ9Xy+9oC9Tbq-7XIjWm8Hyv6duYGT5$+f2p2fDxu{vNJwYG&9&%&9UdE2
zC<uVnJ+{I9#z0h&F9?UU0lo=2p1_L#5f1zvXdXXj;$Gf8e%#2@lKp?TwYZaEmTDJv
z=0j}1ezAQn3p(d<9!mb>m1yvdEa;fQGbg$XQfyv^lyXy#J86*Fka+;;0GS3lNK8yT
zXOsmPKbDB$%V=&DZ>Slia$`-RgA7Mo$FZxXJb}fySKMCm?eHpqQWG~m%rx^sjNO^A
zlgDG4QH1K)(fwdEg7=mJST#&9)I*(wNIK2lxk#pUpxAoFN6saDuC;Qi{q5Jzv?dHj
zEr#q9g3Tx<2h6wumlcj*3Fz|KiQ`?bjxroI&?}2^X2kwU=rBXy59CXAgO&hJ9uO{(
zYP&K@s?X7J%8~s^i3ta%lVgBBJ9a<_d>ZOY3j?r(=Rx$b&$HbQ)2^6{+HFbc(B9M;
zPS0t#DVxZlGL%Zmf#d)Suo&5?7{@J03oS@NEy_Q*qkFi_zsxif-89LIASv<|^6|8g
zjHiXfr7VzbrNg`hrzZEGvcPJQjk?7s(+tX%^zbN!RfyE^qpbBw6j;XP3@&Q`2k58I
zUb}Sq>WwRBsBKBY3M3vyQJ61UNZsB_aQQ`C?%*;;X>{glHqx!{#-qEqKnQAm6PI6)
z%lG2)TX5lFHNPEqI9ad-H+buJ0|+>Bx6K2xTE7=han?uchj76mF|D7(1?O<IehL?4
zpKtv%E=VFRDLN28-}+;?{0Ur;VYT&Va6vZA)}O`YFW`b)7p?yZ7dW<C|1&P!#`~9X
z$K8>C4R?PXm;W7?zlqELi3>u|TYnpuzk^oWQ!p!WDy{z;Z~q=He;=2BfXn}b%m0hZ
z|BuT*#O3F3`FULa2`*4KTmKA~e}N0Mkk-G(1wv`--{JyMq4n=^`471K$C|WD86=0M
ze6*hq^wB{S2T5}DN|wHd6CsZdUi<8Dd^FFxM_1pxaFo`n<>8o9{P{r|j$-{q1oG#n
z8cH=AO|RM5-#F}j#N&UB!!I9xso6OE)ZuG~Pt6^C)_b;b_^rby=Dc}tt}%bGxv$AP
z_y1>_JR)VTG3R~AJJgu_X!E>0nfID}`aG@&ng^TSA>KEiXnJ$rLB4GsXnF_D{haqP
zeEE|3|G_z=A8E`zZ~p#ha~^P?_2yVgV4+nk^#tzZ?c5X1H}K^=bBs5=xf!$!f3rQG
zZSIl!=NiqYDlI9W&ZCF!`vcAWXd})lnrqC>ON$Rl>z~7$Lk7}3+cqcH$D1FLQc`R4
zZ5fkirQF`yU;Ao*aYUpxj2TACz%b)x{(1?ep0$7NcYP}R@i_Xy@oJj4v&}g?!%SjK
m<{ESRIR9wX9+}~}dDDZZ&HtYSMEPgVwFqO;JOrq7-hT#@ZWHVP

diff --git a/src/m64py/SDL2/__init__.py b/src/m64py/SDL2/__init__.py
new file mode 100644
index 0000000..567452c
--- /dev/null
+++ b/src/m64py/SDL2/__init__.py
@@ -0,0 +1,65 @@
+"""SDL2 wrapper package"""
+from .dll import get_dll_file, _bind
+from ctypes import c_int as _cint
+
+from .audio import *
+from .blendmode import *
+from .clipboard import *
+from .cpuinfo import *
+from .endian import *
+from .error import *
+from .events import *
+from .filesystem import *
+from .gamecontroller import *
+from .gesture import *
+from .haptic import *
+from .hints import *
+from .joystick import *
+from .keyboard import *
+from .loadso import *
+from .log import *
+from .messagebox import *
+from .mouse import *
+from .pixels import *
+from .platform import *
+from .power import *
+from .rect import *
+from .render import *
+from .rwops import *
+from .shape import *
+from .stdinc import *
+from .surface import *
+from .syswm import *
+from .timer import *
+from .touch import *
+from .version import *
+from .video import *
+
+from .keycode import *
+from .scancode import *
+
+# At least Win32 platforms need this now.
+_SDL_SetMainReady = _bind("SDL_SetMainReady")
+_SDL_SetMainReady()
+
+
+SDL_INIT_TIMER = 0x00000001
+SDL_INIT_AUDIO = 0x00000010
+SDL_INIT_VIDEO = 0x00000020
+SDL_INIT_JOYSTICK = 0x00000200
+SDL_INIT_HAPTIC = 0x00001000
+SDL_INIT_GAMECONTROLLER = 0x00002000
+SDL_INIT_EVENTS = 0x00004000
+SDL_INIT_NOPARACHUTE = 0x00100000
+SDL_INIT_EVERYTHING = (SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO |
+                       SDL_INIT_EVENTS | SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC |
+                       SDL_INIT_GAMECONTROLLER)
+
+SDL_Init = _bind("SDL_Init", [Uint32], _cint)
+SDL_InitSubSystem = _bind("SDL_InitSubSystem", [Uint32], _cint)
+SDL_QuitSubSystem = _bind("SDL_QuitSubSystem", [Uint32])
+SDL_WasInit = _bind("SDL_WasInit", [Uint32], Uint32)
+SDL_Quit = _bind("SDL_Quit")
+
+__version__ = "0.6.0"
+version_info = (0, 6, 0, "")
diff --git a/src/m64py/SDL2/audio.py b/src/m64py/SDL2/audio.py
new file mode 100644
index 0000000..7eac4e1
--- /dev/null
+++ b/src/m64py/SDL2/audio.py
@@ -0,0 +1,162 @@
+import sys
+from ctypes import Structure, c_int, c_char_p, c_double, c_void_p, CFUNCTYPE, \
+    POINTER
+from .dll import _bind
+from .endian import SDL_BYTEORDER, SDL_LIL_ENDIAN
+from .stdinc import Uint8, Uint16, Uint32
+from .rwops import SDL_RWops, SDL_RWFromFile
+
+__all__ = ["SDL_AudioFormat", "SDL_AUDIO_MASK_BITSIZE",
+           "SDL_AUDIO_MASK_DATATYPE", "SDL_AUDIO_MASK_ENDIAN",
+           "SDL_AUDIO_MASK_SIGNED", "SDL_AUDIO_BITSIZE", "SDL_AUDIO_ISFLOAT",
+           "SDL_AUDIO_ISBIGENDIAN", "SDL_AUDIO_ISSIGNED", "SDL_AUDIO_ISINT",
+           "SDL_AUDIO_ISLITTLEENDIAN", "SDL_AUDIO_ISUNSIGNED", "AUDIO_U8",
+           "AUDIO_S8", "AUDIO_U16LSB", "AUDIO_S16LSB", "AUDIO_U16MSB",
+           "AUDIO_S16MSB", "AUDIO_U16", "AUDIO_S16", "AUDIO_S32LSB",
+           "AUDIO_S32MSB", "AUDIO_S32", "AUDIO_F32LSB", "AUDIO_S32MSB",
+           "AUDIO_F32", "AUDIO_U16SYS", "AUDIO_S16SYS", "AUDIO_S32SYS",
+           "AUDIO_F32SYS", "SDL_AUDIO_ALLOW_FREQUENCY_CHANGE",
+           "SDL_AUDIO_ALLOW_FORMAT_CHANGE", "SDL_AUDIO_ALLOW_CHANNELS_CHANGE",
+           "SDL_AUDIO_ALLOW_ANY_CHANGE", "SDL_AudioCallback", "SDL_AudioSpec",
+           "SDL_AudioCVT", "SDL_AudioFilter", "SDL_GetNumAudioDrivers",
+           "SDL_GetAudioDriver", "SDL_AudioInit", "SDL_AudioQuit",
+           "SDL_GetCurrentAudioDriver", "SDL_OpenAudio", "SDL_AudioDeviceID",
+           "SDL_GetNumAudioDevices", "SDL_GetAudioDeviceName",
+           "SDL_OpenAudioDevice", "SDL_AUDIO_STOPPED", "SDL_AUDIO_PLAYING",
+           "SDL_AUDIO_PAUSED", "SDL_AudioStatus", "SDL_GetAudioStatus",
+           "SDL_GetAudioDeviceStatus", "SDL_PauseAudio", "SDL_PauseAudioDevice",
+           "SDL_LoadWAV_RW", "SDL_LoadWAV", "SDL_FreeWAV", "SDL_BuildAudioCVT",
+           "SDL_ConvertAudio", "SDL_MIX_MAXVOLUME", "SDL_MixAudio",
+           "SDL_MixAudioFormat", "SDL_LockAudio", "SDL_LockAudioDevice",
+           "SDL_UnlockAudio", "SDL_UnlockAudioDevice", "SDL_CloseAudio",
+           "SDL_CloseAudioDevice"
+         ]
+
+SDL_AudioFormat = Uint16
+
+SDL_AUDIO_MASK_BITSIZE = 0xFF
+SDL_AUDIO_MASK_DATATYPE = 1 << 8
+SDL_AUDIO_MASK_ENDIAN = 1 << 12
+SDL_AUDIO_MASK_SIGNED = 1 << 15
+SDL_AUDIO_BITSIZE = lambda x: (x & SDL_AUDIO_MASK_BITSIZE)
+SDL_AUDIO_ISFLOAT = lambda x: (x & SDL_AUDIO_MASK_DATATYPE)
+SDL_AUDIO_ISBIGENDIAN = lambda x: (x & SDL_AUDIO_MASK_ENDIAN)
+SDL_AUDIO_ISSIGNED = lambda x: (x & SDL_AUDIO_MASK_SIGNED)
+SDL_AUDIO_ISINT = lambda x: (not SDL_AUDIO_ISFLOAT(x))
+SDL_AUDIO_ISLITTLEENDIAN = lambda x: (not SDL_AUDIO_ISBIGENDIAN(x))
+SDL_AUDIO_ISUNSIGNED = lambda x: (not SDL_AUDIO_ISSIGNED(x))
+
+AUDIO_U8 = 0x0008
+AUDIO_S8 = 0x8008
+AUDIO_U16LSB = 0x0010
+AUDIO_S16LSB = 0x8010
+AUDIO_U16MSB = 0x1010
+AUDIO_S16MSB = 0x9010
+AUDIO_U16 = AUDIO_U16LSB
+AUDIO_S16 = AUDIO_S16LSB
+AUDIO_S32LSB = 0x8020
+AUDIO_S32MSB = 0x9020
+AUDIO_S32 = AUDIO_S32LSB
+AUDIO_F32LSB = 0x8120
+AUDIO_F32MSB = 0x9120
+AUDIO_F32 = AUDIO_F32LSB
+
+if SDL_BYTEORDER == SDL_LIL_ENDIAN:
+    AUDIO_U16SYS = AUDIO_U16LSB
+    AUDIO_S16SYS = AUDIO_S16LSB
+    AUDIO_S32SYS = AUDIO_S32LSB
+    AUDIO_F32SYS = AUDIO_F32LSB
+else:
+    AUDIO_U16SYS = AUDIO_U16MSB
+    AUDIO_S16SYS = AUDIO_S16MSB
+    AUDIO_S32SYS = AUDIO_S32MSB
+    AUDIO_F32SYS = AUDIO_F32MSB
+
+SDL_AUDIO_ALLOW_FREQUENCY_CHANGE = 0x00000001
+SDL_AUDIO_ALLOW_FORMAT_CHANGE = 0x00000002
+SDL_AUDIO_ALLOW_CHANNELS_CHANGE = 0x00000004
+SDL_AUDIO_ALLOW_ANY_CHANGE = (SDL_AUDIO_ALLOW_FREQUENCY_CHANGE |
+                              SDL_AUDIO_ALLOW_FORMAT_CHANGE |
+                              SDL_AUDIO_ALLOW_CHANNELS_CHANGE)
+
+SDL_AudioCallback = CFUNCTYPE(None, c_void_p, POINTER(Uint8), c_int)
+
+class SDL_AudioSpec(Structure):
+    _fields_ = [("freq", c_int),
+                ("format", SDL_AudioFormat),
+                ("channels", Uint8),
+                ("silence", Uint8),
+                ("samples", Uint16),
+                ("padding", Uint16),
+                ("size", Uint32),
+                ("callback", c_void_p),
+                ("userdata", c_void_p)
+                ]
+    def __init__(self, freq, aformat, channels, samples,
+                 callback=SDL_AudioCallback(), userdata=c_void_p(0)):
+        super(SDL_AudioSpec, self).__init__()
+        self.freq = freq
+        self.format = aformat
+        self.channels = channels
+        self.samples = samples
+        self.callback = callback
+        self.userdata = userdata
+
+class SDL_AudioCVT(Structure):
+    pass
+
+SDL_AudioFilter = CFUNCTYPE(POINTER(SDL_AudioCVT), SDL_AudioFormat)
+# HACK: hack for an IronPython 2.7.2.1+ issue:
+#    ptrarray = (CFUNCTYPE() * int)
+# is not supported properly
+if sys.platform == "cli":
+    _X_SDL_AudioFilter = POINTER(SDL_AudioFilter)
+else:
+    _X_SDL_AudioFilter = SDL_AudioFilter
+
+SDL_AudioCVT._fields_ = [("needed", c_int),
+                         ("src_format", SDL_AudioFormat),
+                         ("dst_format", SDL_AudioFormat),
+                         ("rate_incr", c_double),
+                         ("buf", POINTER(Uint8)),
+                         ("len", c_int),
+                         ("len_cvt", c_int),
+                         ("len_mult", c_int),
+                         ("len_ratio", c_double),
+                         ("filters", (_X_SDL_AudioFilter * 10)),
+                         ("filter_index", c_int)
+                         ]
+
+SDL_GetNumAudioDrivers = _bind("SDL_GetNumAudioDrivers", None, c_int)
+SDL_GetAudioDriver = _bind("SDL_GetAudioDriver", [c_int], c_char_p)
+SDL_AudioInit = _bind("SDL_AudioInit", [c_char_p], c_int)
+SDL_AudioQuit = _bind("SDL_AudioQuit")
+SDL_GetCurrentAudioDriver = _bind("SDL_GetCurrentAudioDriver", None, c_char_p)
+SDL_OpenAudio = _bind("SDL_OpenAudio", [POINTER(SDL_AudioSpec), POINTER(SDL_AudioSpec)], c_int)
+SDL_AudioDeviceID = Uint32
+SDL_GetNumAudioDevices = _bind("SDL_GetNumAudioDevices", [c_int], c_int)
+SDL_GetAudioDeviceName = _bind("SDL_GetAudioDeviceName", [c_int, c_int], c_char_p)
+SDL_OpenAudioDevice = _bind("SDL_OpenAudioDevice", [c_char_p, c_int, POINTER(SDL_AudioSpec), POINTER(SDL_AudioSpec), c_int], SDL_AudioDeviceID)
+SDL_AUDIO_STOPPED = 0
+SDL_AUDIO_PLAYING = 1
+SDL_AUDIO_PAUSED = 2
+SDL_AudioStatus = c_int
+SDL_GetAudioStatus = _bind("SDL_GetAudioStatus", None, SDL_AudioStatus)
+SDL_GetAudioDeviceStatus = _bind("SDL_GetAudioDeviceStatus", [SDL_AudioDeviceID], SDL_AudioStatus)
+SDL_PauseAudio = _bind("SDL_PauseAudio", [c_int])
+SDL_PauseAudioDevice = _bind("SDL_PauseAudioDevice", [SDL_AudioDeviceID, c_int])
+SDL_LoadWAV_RW = _bind("SDL_LoadWAV_RW", [POINTER(SDL_RWops), c_int, POINTER(SDL_AudioSpec), POINTER(POINTER(Uint8)), POINTER(Uint32)], POINTER(SDL_AudioSpec))
+SDL_LoadWAV = lambda f, s, ab, al: SDL_LoadWAV_RW(SDL_RWFromFile(f, "rb"), 1, s, ab , al)
+SDL_FreeWAV = _bind("SDL_FreeWAV", [POINTER(Uint8)])
+SDL_BuildAudioCVT = _bind("SDL_BuildAudioCVT", [POINTER(SDL_AudioCVT), SDL_AudioFormat, Uint8, c_int, SDL_AudioFormat, Uint8, c_int], c_int)
+SDL_ConvertAudio = _bind("SDL_ConvertAudio", [POINTER(SDL_AudioCVT)], c_int)
+SDL_MIX_MAXVOLUME = 128
+SDL_MixAudio = _bind("SDL_MixAudio", [POINTER(Uint8), POINTER(Uint8), Uint32, c_int])
+SDL_MixAudioFormat = _bind("SDL_MixAudioFormat", [POINTER(Uint8), POINTER(Uint8), SDL_AudioFormat, Uint32, c_int])
+SDL_LockAudio = _bind("SDL_LockAudio")
+SDL_LockAudioDevice = _bind("SDL_LockAudioDevice", [SDL_AudioDeviceID])
+SDL_UnlockAudio = _bind("SDL_UnlockAudio")
+SDL_UnlockAudioDevice = _bind("SDL_UnlockAudioDevice", [SDL_AudioDeviceID])
+SDL_CloseAudio = _bind("SDL_CloseAudio")
+SDL_CloseAudioDevice = _bind("SDL_CloseAudioDevice", [SDL_AudioDeviceID])
+
diff --git a/src/m64py/SDL2/blendmode.py b/src/m64py/SDL2/blendmode.py
new file mode 100644
index 0000000..1a1f76f
--- /dev/null
+++ b/src/m64py/SDL2/blendmode.py
@@ -0,0 +1,11 @@
+from ctypes import c_int
+
+__all__ = ["SDL_BLENDMODE_NONE", "SDL_BLENDMODE_BLEND", "SDL_BLENDMODE_ADD",
+           "SDL_BLENDMODE_MOD", "SDL_BlendMode"
+           ]
+
+SDL_BLENDMODE_NONE = 0x00000000
+SDL_BLENDMODE_BLEND = 0x00000001
+SDL_BLENDMODE_ADD = 0x00000002
+SDL_BLENDMODE_MOD = 0x00000004
+SDL_BlendMode = c_int
diff --git a/src/m64py/SDL2/clipboard.py b/src/m64py/SDL2/clipboard.py
new file mode 100644
index 0000000..0e998a7
--- /dev/null
+++ b/src/m64py/SDL2/clipboard.py
@@ -0,0 +1,10 @@
+from ctypes import c_char_p, c_int
+from .dll import _bind
+from .stdinc import SDL_bool
+
+__all__ = ["SDL_SetClipboardText", "SDL_GetClipboardText",
+           "SDL_HasClipboardText"]
+
+SDL_SetClipboardText = _bind("SDL_SetClipboardText", [c_char_p], c_int)
+SDL_GetClipboardText = _bind("SDL_GetClipboardText", None, c_char_p)
+SDL_HasClipboardText = _bind("SDL_HasClipboardText", None, SDL_bool)
diff --git a/src/m64py/SDL2/cpuinfo.py b/src/m64py/SDL2/cpuinfo.py
new file mode 100644
index 0000000..fa687b7
--- /dev/null
+++ b/src/m64py/SDL2/cpuinfo.py
@@ -0,0 +1,22 @@
+from ctypes import c_int
+from .dll import _bind
+from .stdinc import SDL_bool
+
+__all__ = ["SDL_CACHELINE_SIZE", "SDL_GetCPUCount", "SDL_GetCPUCacheLineSize",
+           "SDL_HasRDTSC", "SDL_HasAltiVec", "SDL_HasMMX", "SDL_Has3DNow",
+           "SDL_HasSSE", "SDL_HasSSE2", "SDL_HasSSE3", "SDL_HasSSE41",
+           "SDL_HasSSE42"
+           ]
+
+SDL_CACHELINE_SIZE = 128
+SDL_GetCPUCount = _bind("SDL_GetCPUCount", None, c_int)
+SDL_GetCPUCacheLineSize = _bind("SDL_GetCPUCacheLineSize", None, c_int)
+SDL_HasRDTSC = _bind("SDL_HasRDTSC", None, SDL_bool)
+SDL_HasAltiVec = _bind("SDL_HasAltiVec", None, SDL_bool)
+SDL_HasMMX = _bind("SDL_HasMMX", None, SDL_bool)
+SDL_Has3DNow = _bind("SDL_Has3DNow", None, SDL_bool)
+SDL_HasSSE = _bind("SDL_HasSSE", None, SDL_bool)
+SDL_HasSSE2 = _bind("SDL_HasSSE2", None, SDL_bool)
+SDL_HasSSE3 = _bind("SDL_HasSSE3", None, SDL_bool)
+SDL_HasSSE41 = _bind("SDL_HasSSE41", None, SDL_bool)
+SDL_HasSSE42 = _bind("SDL_HasSSE42", None, SDL_bool)
diff --git a/src/m64py/SDL2/dll.py b/src/m64py/SDL2/dll.py
new file mode 100644
index 0000000..602611f
--- /dev/null
+++ b/src/m64py/SDL2/dll.py
@@ -0,0 +1,112 @@
+"""DLL wrapper"""
+import os
+import sys
+import warnings
+from ctypes import CDLL
+#from ctypes.util import find_library
+from m64py.loader import find_library
+
+__all__ = ["get_dll_file"]
+
+
+def _findlib(libnames, path=None):
+    """."""
+    platform = sys.platform
+    if platform in ("win32", "cli"):
+        pattern = "%s.dll"
+    elif platform == "darwin":
+        pattern = "lib%s.dylib"
+    else:
+        pattern = "lib%s.so"
+    searchfor = libnames
+    if type(libnames) is dict:
+        # different library names for the platforms
+        if platform == "cli" and platform not in libnames:
+            # if not explicitly specified, use the Win32 libs for IronPython
+            platform = "win32"
+        if platform not in libnames:
+            platform = "DEFAULT"
+        searchfor = libnames[platform]
+    results = []
+    if path:
+        for libname in searchfor:
+            dllfile = os.path.join(path, pattern % libname)
+            if os.path.exists(dllfile):
+                results.append(dllfile)
+    for libname in searchfor:
+        dllfile = find_library(libname)
+        if dllfile:
+            results.append(dllfile)
+    return results
+
+
+class _DLL(object):
+    """Function wrapper around the different DLL functions. Do not use or
+    instantiate this one directly from your user code.
+    """
+    def __init__(self, libinfo, libnames, path=None):
+        self._dll = None
+        foundlibs = _findlib(libnames, path)
+        if len(foundlibs) == 0:
+            raise RuntimeError("could not find any library for %s" % libinfo)
+        for libfile in foundlibs:
+            try:
+                self._dll = CDLL(libfile)
+                self._libfile = libfile
+                break
+            except Exception as exc:
+                # Could not load it, silently ignore that issue and move
+                # to the next one.
+                warnings.warn(repr(exc), ImportWarning)
+        if self._dll is None:
+            raise RuntimeError("could not load any library for %s" % libinfo)
+        if path is not None and sys.platform in ("win32", "cli") and \
+            path in self._libfile:
+            os.environ["PATH"] = "%s;%s" % (path, os.environ["PATH"])
+
+    def bind_function(self, funcname, args=None, returns=None, optfunc=None):
+        """Binds the passed argument and return value types to the specified
+        function."""
+        func = getattr(self._dll, funcname, None)
+        if not func:
+            if optfunc:
+                #warnings.warn\
+                #    ("function '%s' not found in %r, using replacement" %
+                #     (funcname, self._dll))
+                func = _nonexistent(funcname, optfunc)
+            else:
+                raise ValueError("could not find function '%s' in %r" %
+                                 (funcname, self._dll))
+        func.argtypes = args
+        func.restype = returns
+        return func
+
+    @property
+    def libfile(self):
+        """Gets the filename of the loaded library."""
+        return self._libfile
+
+def _nonexistent(funcname, func):
+    """A simple wrapper to mark functions and methods as nonexistent."""
+    def wrapper(*fargs, **kw):
+        warnings.warn("%s does not exist" % funcname,
+                      category=RuntimeWarning, stacklevel=2)
+        return func(*fargs, **kw)
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+try:
+    dll = _DLL("SDL2", ["SDL2", "SDL2-2.0"], os.getenv("PYSDL2_DLL_PATH"))
+except RuntimeError as exc:
+    raise ImportError(exc)
+
+def nullfunc(*args):
+    """A simple no-op function to be used as dll replacement."""
+    return
+
+def get_dll_file():
+    """Gets the file name of the loaded SDL2 library."""
+    return dll.libfile
+
+_bind = dll.bind_function
diff --git a/src/m64py/SDL2/endian.py b/src/m64py/SDL2/endian.py
new file mode 100644
index 0000000..920f3d5
--- /dev/null
+++ b/src/m64py/SDL2/endian.py
@@ -0,0 +1,48 @@
+import sys
+import array
+
+__all__ = ["SDL_LIL_ENDIAN", "SDL_BIG_ENDIAN", "SDL_BYTEORDER", "SDL_Swap16",
+           "SDL_Swap32", "SDL_Swap64", "SDL_SwapFloat", "SDL_SwapLE16",
+           "SDL_SwapLE32", "SDL_SwapLE64", "SDL_SwapFloatLE", "SDL_SwapBE16",
+           "SDL_SwapBE32", "SDL_SwapBE64", "SDL_SwapFloatBE"
+           ]
+
+SDL_LIL_ENDIAN = 1234
+SDL_BIG_ENDIAN = 4321
+if sys.byteorder == "little":
+    SDL_BYTEORDER = SDL_LIL_ENDIAN
+else:
+    SDL_BYTEORDER = SDL_BIG_ENDIAN
+
+SDL_Swap16 = lambda x: ((x << 8 & 0xFF00) | (x >> 8 & 0x00FF))
+SDL_Swap32 = lambda x: (((x << 24) & 0xFF000000) |
+                        ((x << 8) & 0x00FF0000) |
+                        ((x >> 8) & 0x0000FF00) |
+                        ((x >> 24) & 0x000000FF))
+SDL_Swap64 = lambda x: ((SDL_Swap32(x & 0xFFFFFFFF) << 32) |
+                        (SDL_Swap32(x >> 32 & 0xFFFFFFFF)))
+def SDL_SwapFloat(x):
+    ar = array.array("d", (x,))
+    ar.byteswap()
+    return ar[0]
+
+def _nop(x):
+    return x
+if SDL_BYTEORDER == SDL_LIL_ENDIAN:
+    SDL_SwapLE16 = _nop
+    SDL_SwapLE32 = _nop
+    SDL_SwapLE64 = _nop
+    SDL_SwapFloatLE = _nop
+    SDL_SwapBE16 = SDL_Swap16
+    SDL_SwapBE32 = SDL_Swap32
+    SDL_SwapBE64 = SDL_Swap64
+    SDL_SwapFloatBE = SDL_SwapFloat
+else:
+    SDL_SwapLE16 = SDL_Swap16
+    SDL_SwapLE32 = SDL_Swap32
+    SDL_SwapLE64 = SDL_Swap64
+    SDL_SwapFloatLE = SDL_SwapFloat
+    SDL_SwapBE16 = _nop
+    SDL_SwapBE32 = _nop
+    SDL_SwapBE64 = _nop
+    SDL_SwapFloatBE = _nop
diff --git a/src/m64py/SDL2/error.py b/src/m64py/SDL2/error.py
new file mode 100644
index 0000000..62c75c4
--- /dev/null
+++ b/src/m64py/SDL2/error.py
@@ -0,0 +1,24 @@
+from ctypes import c_char_p, c_int
+from .dll import _bind
+
+__all__ = ["SDL_SetError", "SDL_GetError", "SDL_ClearError", "SDL_ENOMEM",
+           "SDL_EFREAD", "SDL_EFWRITE", "SDL_EFSEEK", "SDL_UNSUPPORTED",
+           "SDL_LASTERROR", "SDL_errorcode", "SDL_Error", "SDL_OutOfMemory",
+           "SDL_Unsupported", "SDL_InvalidParamError"
+           ]
+
+SDL_SetError = _bind("SDL_SetError", [c_char_p], c_int)
+SDL_GetError = _bind("SDL_GetError", None, c_char_p)
+SDL_ClearError = _bind("SDL_ClearError")
+
+SDL_ENOMEM = 0
+SDL_EFREAD = 1
+SDL_EFWRITE = 2
+SDL_EFSEEK = 3
+SDL_UNSUPPORTED = 4
+SDL_LASTERROR = 5
+SDL_errorcode = c_int
+SDL_Error = _bind("SDL_Error", [c_int], c_int)
+SDL_OutOfMemory = SDL_Error(SDL_ENOMEM)
+SDL_Unsupported = SDL_Error(SDL_UNSUPPORTED)
+SDL_InvalidParamError = lambda x: SDL_SetError("Parameter '%s' is invalid" % (x))
diff --git a/src/m64py/SDL2/events.py b/src/m64py/SDL2/events.py
new file mode 100644
index 0000000..dc4dd56
--- /dev/null
+++ b/src/m64py/SDL2/events.py
@@ -0,0 +1,377 @@
+from ctypes import c_char, c_char_p, c_float, c_void_p, c_int, Structure, \
+    Union, CFUNCTYPE, POINTER
+from .dll import _bind
+from .stdinc import Sint16, Sint32, Uint8, Uint16, Uint32, SDL_bool
+from .keyboard import SDL_Keysym
+from .joystick import SDL_JoystickID
+from .touch import SDL_FingerID, SDL_TouchID
+from .gesture import SDL_GestureID
+
+__all__ = ["SDL_FIRSTEVENT", "SDL_QUIT", "SDL_APP_TERMINATING",
+           "SDL_APP_LOWMEMORY", "SDL_APP_WILLENTERBACKGROUND",
+           "SDL_APP_DIDENTERBACKGROUND", "SDL_APP_WILLENTERFOREGROUND",
+           "SDL_APP_DIDENTERFOREGROUND", "SDL_WINDOWEVENT", "SDL_SYSWMEVENT",
+           "SDL_KEYDOWN", "SDL_KEYUP", "SDL_TEXTEDITING", "SDL_TEXTINPUT",
+           "SDL_MOUSEMOTION", "SDL_MOUSEBUTTONDOWN", "SDL_MOUSEBUTTONUP",
+           "SDL_MOUSEWHEEL", "SDL_JOYAXISMOTION", "SDL_JOYBALLMOTION",
+           "SDL_JOYHATMOTION", "SDL_JOYBUTTONDOWN", "SDL_JOYBUTTONUP",
+           "SDL_JOYDEVICEADDED", "SDL_JOYDEVICEREMOVED",
+           "SDL_CONTROLLERAXISMOTION", "SDL_CONTROLLERBUTTONDOWN",
+           "SDL_CONTROLLERBUTTONUP", "SDL_CONTROLLERDEVICEADDED",
+           "SDL_CONTROLLERDEVICEREMOVED", "SDL_CONTROLLERDEVICEREMAPPED",
+           "SDL_FINGERDOWN", "SDL_FINGERUP", "SDL_FINGERMOTION",
+           "SDL_DOLLARGESTURE", "SDL_DOLLARRECORD", "SDL_MULTIGESTURE",
+           "SDL_CLIPBOARDUPDATE", "SDL_DROPFILE", "SDL_USEREVENT",
+           "SDL_LASTEVENT", "SDL_EventType", "SDL_GenericEvent",
+           "SDL_WindowEvent", "SDL_KeyboardEvent",
+           "SDL_TEXTEDITINGEVENT_TEXT_SIZE", "SDL_TextEditingEvent",
+           "SDL_TEXTINPUTEVENT_TEXT_SIZE", "SDL_TextInputEvent",
+           "SDL_MouseMotionEvent", "SDL_MouseButtonEvent",
+           "SDL_MouseWheelEvent", "SDL_JoyAxisEvent", "SDL_JoyBallEvent",
+           "SDL_JoyHatEvent", "SDL_JoyButtonEvent", "SDL_JoyDeviceEvent",
+           "SDL_ControllerAxisEvent", "SDL_ControllerButtonEvent",
+           "SDL_ControllerDeviceEvent", "SDL_TouchFingerEvent",
+           "SDL_MultiGestureEvent", "SDL_DollarGestureEvent", "SDL_DropEvent",
+           "SDL_QuitEvent", "SDL_UserEvent", "SDL_SysWMmsg", "SDL_SysWMEvent",
+           "SDL_Event", "SDL_PumpEvents", "SDL_ADDEVENT", "SDL_PEEKEVENT",
+           "SDL_GETEVENT", "SDL_eventaction", "SDL_PeepEvents", "SDL_HasEvent",
+           "SDL_HasEvents", "SDL_FlushEvent", "SDL_FlushEvents",
+           "SDL_PollEvent", "SDL_WaitEvent", "SDL_WaitEventTimeout",
+           "SDL_PushEvent", "SDL_EventFilter", "SDL_SetEventFilter",
+           "SDL_GetEventFilter", "SDL_AddEventWatch", "SDL_DelEventWatch",
+           "SDL_FilterEvents", "SDL_QUERY", "SDL_IGNORE", "SDL_DISABLE",
+           "SDL_ENABLE", "SDL_EventState", "SDL_GetEventState",
+           "SDL_RegisterEvents", "SDL_QuitRequested"
+           ]
+
+SDL_FIRSTEVENT = 0
+SDL_QUIT = 0x100
+SDL_APP_TERMINATING = 0x101
+SDL_APP_LOWMEMORY = 0x102
+SDL_APP_WILLENTERBACKGROUND = 0x103
+SDL_APP_DIDENTERBACKGROUND = 0x104
+SDL_APP_WILLENTERFOREGROUND = 0x105
+SDL_APP_DIDENTERFOREGROUND = 0x106
+SDL_WINDOWEVENT = 0x200
+SDL_SYSWMEVENT = 0x201
+SDL_KEYDOWN = 0x300
+SDL_KEYUP = 0x301
+SDL_TEXTEDITING = 0x302
+SDL_TEXTINPUT = 0x303
+SDL_MOUSEMOTION = 0x400
+SDL_MOUSEBUTTONDOWN = 0x401
+SDL_MOUSEBUTTONUP = 0x402
+SDL_MOUSEWHEEL = 0x403
+SDL_JOYAXISMOTION = 0x600
+SDL_JOYBALLMOTION = 0x601
+SDL_JOYHATMOTION = 0x602
+SDL_JOYBUTTONDOWN = 0x603
+SDL_JOYBUTTONUP = 0x604
+SDL_JOYDEVICEADDED = 0x605
+SDL_JOYDEVICEREMOVED = 0x606
+SDL_CONTROLLERAXISMOTION = 0x650
+SDL_CONTROLLERBUTTONDOWN = 0x651
+SDL_CONTROLLERBUTTONUP = 0x652
+SDL_CONTROLLERDEVICEADDED = 0x653
+SDL_CONTROLLERDEVICEREMOVED = 0x654
+SDL_CONTROLLERDEVICEREMAPPED = 0x655
+SDL_FINGERDOWN = 0x700
+SDL_FINGERUP = 0x701
+SDL_FINGERMOTION = 0x702
+SDL_DOLLARGESTURE = 0x800
+SDL_DOLLARRECORD = 0x801
+SDL_MULTIGESTURE = 0x802
+SDL_CLIPBOARDUPDATE = 0x900
+SDL_DROPFILE = 0x1000
+SDL_USEREVENT = 0x8000
+SDL_LASTEVENT = 0xFFFF
+SDL_EventType = c_int
+
+class SDL_GenericEvent(Structure):
+    _fields_ = [("type", Uint32), ("timestamp", Uint32)]
+
+class SDL_WindowEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("windowID", Uint32),
+                ("event", Uint8),
+                ("padding1", Uint8),
+                ("padding2", Uint8),
+                ("padding3", Uint8),
+                ("data1", Sint32),
+                ("data2", Sint32)
+                ]
+
+class SDL_KeyboardEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("windowID", Uint32),
+                ("state", Uint8),
+                ("repeat", Uint8),
+                ("padding2", Uint8),
+                ("padding3", Uint8),
+                ("keysym", SDL_Keysym)
+                ]
+
+SDL_TEXTEDITINGEVENT_TEXT_SIZE = 32
+
+class SDL_TextEditingEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("windowID", Uint32),
+                ("text", (c_char * SDL_TEXTEDITINGEVENT_TEXT_SIZE)),
+                ("start", Sint32),
+                ("length", Sint32)
+                ]
+
+SDL_TEXTINPUTEVENT_TEXT_SIZE = 32
+class SDL_TextInputEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("windowID", Uint32),
+                ("text", (c_char * SDL_TEXTINPUTEVENT_TEXT_SIZE))
+                ]
+
+class SDL_MouseMotionEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("windowID", Uint32),
+                ("which", Uint32),
+                ("state", Uint32),
+                ("x", Sint32),
+                ("y", Sint32),
+                ("xrel", Sint32),
+                ("yrel", Sint32)
+                ]
+
+class SDL_MouseButtonEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("windowID", Uint32),
+                ("which", Uint32),
+                ("button", Uint8),
+                ("state", Uint8),
+                ("padding1", Uint8),
+                ("padding2", Uint8),
+                ("x", Sint32),
+                ("y", Sint32)
+                ]
+
+class SDL_MouseWheelEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("windowID", Uint32),
+                ("which", Uint32),
+                ("x", Sint32),
+                ("y", Sint32)
+                ]
+
+class SDL_JoyAxisEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("which", SDL_JoystickID),
+                ("axis", Uint8),
+                ("padding1", Uint8),
+                ("padding2", Uint8),
+                ("padding3", Uint8),
+                ("value", Sint16),
+                ("padding4", Uint16)
+                ]
+
+class SDL_JoyBallEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("which", SDL_JoystickID),
+                ("ball", Uint8),
+                ("padding1", Uint8),
+                ("padding2", Uint8),
+                ("padding3", Uint8),
+                ("xrel", Sint16),
+                ("yrel", Sint16)
+                ]
+
+class SDL_JoyHatEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("which", SDL_JoystickID),
+                ("hat", Uint8),
+                ("value", Uint8),
+                ("padding1", Uint8),
+                ("padding2", Uint8)
+                ]
+
+class SDL_JoyButtonEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("which", SDL_JoystickID),
+                ("button", Uint8),
+                ("state", Uint8),
+                ("padding1", Uint8),
+                ("padding2", Uint8)
+                ]
+
+class SDL_JoyDeviceEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("which", Sint32)
+                ]
+
+class SDL_ControllerAxisEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("which", SDL_JoystickID),
+                ("axis", Uint8),
+                ("padding1", Uint8),
+                ("padding2", Uint8),
+                ("padding3", Uint8),
+                ("value", Sint16),
+                ("padding4", Uint16)
+                ]
+
+class SDL_ControllerButtonEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("which", SDL_JoystickID),
+                ("button", Uint8),
+                ("state", Uint8),
+                ("padding1", Uint8),
+                ("padding2", Uint8)
+                ]
+
+class SDL_ControllerDeviceEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("which", Sint32)
+                ]
+
+class SDL_TouchFingerEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("touchId", SDL_TouchID),
+                ("fingerId", SDL_FingerID),
+                ("x", c_float),
+                ("y", c_float),
+                ("dx", c_float),
+                ("dy", c_float),
+                ("pressure", c_float)
+                ]
+
+class SDL_MultiGestureEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("touchId", SDL_TouchID),
+                ("dTheta", c_float),
+                ("dDist", c_float),
+                ("x", c_float),
+                ("y", c_float),
+                ("numFingers", Uint16),
+                ("padding", Uint16)
+                ]
+
+class SDL_DollarGestureEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("touchId", SDL_TouchID),
+                ("gestureId", SDL_GestureID),
+                ("numFingers", Uint32),
+                ("error", c_float),
+                ("x", c_float),
+                ("y", c_float)
+                ]
+
+class SDL_DropEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("file", c_char_p)
+                ]
+
+class SDL_QuitEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32)
+                ]
+
+class SDL_OSEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32)
+                ]
+
+class SDL_UserEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("windowID", Uint32),
+                ("code", Sint32),
+                ("data1", c_void_p),
+                ("data2", c_void_p)
+                ]
+
+# TODO
+class SDL_SysWMmsg(Structure):
+    pass
+
+class SDL_SysWMEvent(Structure):
+    _fields_ = [("type", Uint32),
+                ("timestamp", Uint32),
+                ("msg", POINTER(SDL_SysWMmsg))
+                ]
+
+class SDL_Event(Union):
+    _fields_ = [("type", Uint32),
+                ("generic", SDL_GenericEvent),
+                ("window", SDL_WindowEvent),
+                ("key", SDL_KeyboardEvent),
+                ("edit", SDL_TextEditingEvent),
+                ("text", SDL_TextInputEvent),
+                ("motion", SDL_MouseMotionEvent),
+                ("button", SDL_MouseButtonEvent),
+                ("wheel", SDL_MouseWheelEvent),
+                ("jaxis", SDL_JoyAxisEvent),
+                ("jball", SDL_JoyBallEvent),
+                ("jhat", SDL_JoyHatEvent),
+                ("jbutton", SDL_JoyButtonEvent),
+                ("jdevice", SDL_JoyDeviceEvent),
+                ("caxis", SDL_ControllerAxisEvent),
+                ("cbutton", SDL_ControllerButtonEvent),
+                ("cdevice", SDL_ControllerDeviceEvent),
+                ("quit", SDL_QuitEvent),
+                ("user", SDL_UserEvent),
+                ("syswm", SDL_SysWMEvent),
+                ("tfinger", SDL_TouchFingerEvent),
+                ("mgesture", SDL_MultiGestureEvent),
+                ("dgesture", SDL_DollarGestureEvent),
+                ("drop", SDL_DropEvent),
+                ("padding", (Uint8 * 56)),
+                ]
+
+SDL_PumpEvents = _bind("SDL_PumpEvents")
+SDL_ADDEVENT = 0
+SDL_PEEKEVENT = 1
+SDL_GETEVENT = 2
+SDL_eventaction = c_int
+SDL_PeepEvents = _bind("SDL_PeepEvents", [POINTER(SDL_Event), c_int, SDL_eventaction, Uint32, Uint32], c_int)
+SDL_HasEvent = _bind("SDL_HasEvent", [Uint32], SDL_bool)
+SDL_HasEvents = _bind("SDL_HasEvents", [Uint32, Uint32], SDL_bool)
+SDL_FlushEvent = _bind("SDL_FlushEvent", [Uint32])
+SDL_FlushEvents = _bind("SDL_FlushEvents", [Uint32, Uint32])
+SDL_PollEvent = _bind("SDL_PollEvent", [POINTER(SDL_Event)], c_int)
+SDL_WaitEvent = _bind("SDL_WaitEvent", [POINTER(SDL_Event)], c_int)
+SDL_WaitEventTimeout = _bind("SDL_WaitEventTimeout", [POINTER(SDL_Event), c_int], c_int)
+SDL_PushEvent = _bind("SDL_PushEvent", [POINTER(SDL_Event)], c_int)
+SDL_EventFilter = CFUNCTYPE(c_int, c_void_p, POINTER(SDL_Event))
+SDL_SetEventFilter = _bind("SDL_SetEventFilter", [SDL_EventFilter, c_void_p])
+SDL_GetEventFilter = _bind("SDL_GetEventFilter", [POINTER(SDL_EventFilter), POINTER(c_void_p)], SDL_bool)
+SDL_AddEventWatch = _bind("SDL_AddEventWatch", [SDL_EventFilter, c_void_p])
+SDL_DelEventWatch = _bind("SDL_DelEventWatch", [SDL_EventFilter, c_void_p])
+SDL_FilterEvents = _bind("SDL_FilterEvents", [SDL_EventFilter, c_void_p])
+SDL_QUERY = -1
+SDL_IGNORE = 0
+SDL_DISABLE = 0
+SDL_ENABLE = 1
+SDL_EventState = _bind("SDL_EventState", [Uint32, c_int], Uint8)
+SDL_GetEventState = lambda t: SDL_EventState(t, SDL_QUERY)
+SDL_RegisterEvents = _bind("SDL_RegisterEvents", [c_int], Uint32)
+
+
+# SDL_quit.h
+def SDL_QuitRequested():
+    SDL_PumpEvents()
+    return SDL_PeepEvents(None, 0, SDL_PEEKEVENT, SDL_QUIT, SDL_QUIT) > 0
diff --git a/src/m64py/SDL2/filesystem.py b/src/m64py/SDL2/filesystem.py
new file mode 100644
index 0000000..76a911f
--- /dev/null
+++ b/src/m64py/SDL2/filesystem.py
@@ -0,0 +1,9 @@
+from ctypes import c_char, c_char_p, POINTER
+from .dll import _bind, nullfunc
+
+__all__ = ["SDL_GetBasePath", "SDL_GetPrefPath"]
+
+# The filesystem API came in after the 2.0 release
+SDL_GetBasePath = _bind("SDL_GetBasePath", None, POINTER(c_char), nullfunc)
+SDL_GetPrefPath = _bind("SDL_GetPrefPath", [c_char_p, c_char_p], POINTER(c_char),
+                        nullfunc)
diff --git a/src/m64py/SDL2/gamecontroller.py b/src/m64py/SDL2/gamecontroller.py
new file mode 100644
index 0000000..82547c9
--- /dev/null
+++ b/src/m64py/SDL2/gamecontroller.py
@@ -0,0 +1,102 @@
+from ctypes import Structure, Union, c_int, c_char_p, POINTER
+from .dll import _bind
+from .stdinc import SDL_bool, Sint16, Uint8
+from .joystick import SDL_JoystickGUID, SDL_Joystick
+
+__all__ = ["SDL_GameController", "SDL_CONTROLLER_BINDTYPE_NONE",
+           "SDL_CONTROLLER_BINDTYPE_BUTTON", "SDL_CONTROLLER_BINDTYPE_AXIS",
+           "SDL_CONTROLLER_BINDTYPE_HAT", "SDL_GameControllerBindType",
+           "SDL_GameControllerButtonBind", "SDL_GameControllerAddMapping",
+           "SDL_GameControllerMappingForGUID", "SDL_GameControllerMapping",
+           "SDL_IsGameController", "SDL_GameControllerNameForIndex",
+           "SDL_GameControllerOpen", "SDL_GameControllerName",
+           "SDL_GameControllerGetAttached", "SDL_GameControllerGetJoystick",
+           "SDL_GameControllerEventState", "SDL_GameControllerUpdate",
+           "SDL_CONTROLLER_AXIS_INVALID", "SDL_CONTROLLER_AXIS_LEFTX",
+           "SDL_CONTROLLER_AXIS_LEFTY", "SDL_CONTROLLER_AXIS_RIGHTX",
+           "SDL_CONTROLLER_AXIS_RIGHTY", "SDL_CONTROLLER_AXIS_TRIGGERLEFT",
+           "SDL_CONTROLLER_AXIS_TRIGGERRIGHT", "SDL_CONTROLLER_AXIS_MAX",
+           "SDL_GameControllerAxis", "SDL_GameControllerGetAxisFromString",
+           "SDL_GameControllerGetStringForAxis",
+           "SDL_GameControllerGetBindForAxis", "SDL_GameControllerGetAxis",
+           "SDL_CONTROLLER_BUTTON_INVALID", "SDL_CONTROLLER_BUTTON_A",
+           "SDL_CONTROLLER_BUTTON_B", "SDL_CONTROLLER_BUTTON_X",
+           "SDL_CONTROLLER_BUTTON_Y", "SDL_CONTROLLER_BUTTON_BACK",
+           "SDL_CONTROLLER_BUTTON_GUIDE", "SDL_CONTROLLER_BUTTON_START",
+           "SDL_CONTROLLER_BUTTON_LEFTSTICK", "SDL_CONTROLLER_BUTTON_RIGHTSTICK",
+           "SDL_CONTROLLER_BUTTON_LEFTSHOULDER",
+           "SDL_CONTROLLER_BUTTON_RIGHTSHOULDER",
+           "SDL_CONTROLLER_BUTTON_DPAD_UP", "SDL_CONTROLLER_BUTTON_DPAD_DOWN",
+           "SDL_CONTROLLER_BUTTON_DPAD_LEFT", "SDL_CONTROLLER_BUTTON_DPAD_RIGHT",
+           "SDL_CONTROLLER_BUTTON_MAX", "SDL_GameControllerButton",
+           "SDL_GameControllerGetButtonFromString",
+           "SDL_GameControllerGetStringForButton",
+           "SDL_GameControllerGetBindForButton", "SDL_GameControllerGetButton",
+           "SDL_GameControllerClose"
+           ]
+
+class SDL_GameController(Structure):
+    pass
+
+SDL_CONTROLLER_BINDTYPE_NONE = 0
+SDL_CONTROLLER_BINDTYPE_BUTTON = 1
+SDL_CONTROLLER_BINDTYPE_AXIS = 2
+SDL_CONTROLLER_BINDTYPE_HAT = 3
+SDL_GameControllerBindType = c_int
+
+class _gchat(Structure):
+    _fields_ = [("hat", c_int), ("hat_mask", c_int)]
+
+class _gcvalue(Union):
+    _fields_ = [("button", c_int), ("axis", c_int), ("hat", _gchat)]
+
+class SDL_GameControllerButtonBind(Structure):
+    _fields_ = [("bindType", SDL_GameControllerBindType), ("value", _gcvalue)]
+
+SDL_GameControllerAddMapping = _bind("SDL_GameControllerAddMapping", [c_char_p], c_int)
+SDL_GameControllerMappingForGUID = _bind("SDL_GameControllerMappingForGUID", [SDL_JoystickGUID], c_char_p)
+SDL_GameControllerMapping = _bind("SDL_GameControllerMapping", [POINTER(SDL_GameController)], c_char_p)
+SDL_IsGameController = _bind("SDL_IsGameController", [c_int], SDL_bool)
+SDL_GameControllerNameForIndex = _bind("SDL_GameControllerNameForIndex", [c_int], c_char_p)
+SDL_GameControllerOpen = _bind("SDL_GameControllerOpen", [c_int], POINTER(SDL_GameController))
+SDL_GameControllerName = _bind("SDL_GameControllerName", [POINTER(SDL_GameController)], c_char_p)
+SDL_GameControllerGetAttached = _bind("SDL_GameControllerGetAttached", [POINTER(SDL_GameController)], SDL_bool)
+SDL_GameControllerGetJoystick = _bind("SDL_GameControllerGetJoystick", [POINTER(SDL_GameController)], POINTER(SDL_Joystick))
+SDL_GameControllerEventState = _bind("SDL_GameControllerEventState", [c_int], c_int)
+SDL_GameControllerUpdate = _bind("SDL_GameControllerUpdate")
+SDL_CONTROLLER_AXIS_INVALID = -1
+SDL_CONTROLLER_AXIS_LEFTX = 0
+SDL_CONTROLLER_AXIS_LEFTY = 1
+SDL_CONTROLLER_AXIS_RIGHTX = 2
+SDL_CONTROLLER_AXIS_RIGHTY = 3
+SDL_CONTROLLER_AXIS_TRIGGERLEFT = 4
+SDL_CONTROLLER_AXIS_TRIGGERRIGHT = 5
+SDL_CONTROLLER_AXIS_MAX = 6
+SDL_GameControllerAxis = c_int
+SDL_GameControllerGetAxisFromString = _bind("SDL_GameControllerGetAxisFromString", [c_char_p], SDL_GameControllerAxis)
+SDL_GameControllerGetStringForAxis = _bind("SDL_GameControllerGetStringForAxis", [SDL_GameControllerAxis], c_char_p)
+SDL_GameControllerGetBindForAxis = _bind("SDL_GameControllerGetBindForAxis", [POINTER(SDL_GameController), SDL_GameControllerAxis], SDL_GameControllerButtonBind)
+SDL_GameControllerGetAxis = _bind("SDL_GameControllerGetAxis", [POINTER(SDL_GameController), SDL_GameControllerAxis], Sint16)
+SDL_CONTROLLER_BUTTON_INVALID = -1
+SDL_CONTROLLER_BUTTON_A = 0
+SDL_CONTROLLER_BUTTON_B = 1
+SDL_CONTROLLER_BUTTON_X = 2
+SDL_CONTROLLER_BUTTON_Y = 3
+SDL_CONTROLLER_BUTTON_BACK = 4
+SDL_CONTROLLER_BUTTON_GUIDE = 5
+SDL_CONTROLLER_BUTTON_START = 6
+SDL_CONTROLLER_BUTTON_LEFTSTICK = 7
+SDL_CONTROLLER_BUTTON_RIGHTSTICK = 8
+SDL_CONTROLLER_BUTTON_LEFTSHOULDER = 9
+SDL_CONTROLLER_BUTTON_RIGHTSHOULDER = 10
+SDL_CONTROLLER_BUTTON_DPAD_UP = 11
+SDL_CONTROLLER_BUTTON_DPAD_DOWN = 12
+SDL_CONTROLLER_BUTTON_DPAD_LEFT = 13
+SDL_CONTROLLER_BUTTON_DPAD_RIGHT = 14
+SDL_CONTROLLER_BUTTON_MAX = 15
+SDL_GameControllerButton = c_int
+SDL_GameControllerGetButtonFromString = _bind("SDL_GameControllerGetButtonFromString", [c_char_p], SDL_GameControllerButton)
+SDL_GameControllerGetStringForButton = _bind("SDL_GameControllerGetStringForButton", [SDL_GameControllerButton], c_char_p)
+SDL_GameControllerGetBindForButton = _bind("SDL_GameControllerGetBindForButton", [POINTER(SDL_GameController), SDL_GameControllerButton], SDL_GameControllerButtonBind)
+SDL_GameControllerGetButton = _bind("SDL_GameControllerGetButton", [POINTER(SDL_GameController), SDL_GameControllerButton], Uint8)
+SDL_GameControllerClose = _bind("SDL_GameControllerClose", [POINTER(SDL_GameController)])
diff --git a/src/m64py/SDL2/gesture.py b/src/m64py/SDL2/gesture.py
new file mode 100644
index 0000000..d55fc0a
--- /dev/null
+++ b/src/m64py/SDL2/gesture.py
@@ -0,0 +1,15 @@
+from ctypes import c_int, POINTER
+from .dll import _bind
+from .stdinc import Sint64
+from .touch import SDL_TouchID
+from .rwops import SDL_RWops
+
+__all__ = ["SDL_GestureID", "SDL_RecordGesture", "SDL_SaveAllDollarTemplates",
+           "SDL_SaveDollarTemplate", "SDL_LoadDollarTemplates"
+           ]
+
+SDL_GestureID = Sint64
+SDL_RecordGesture = _bind("SDL_RecordGesture", [SDL_TouchID], c_int)
+SDL_SaveAllDollarTemplates = _bind("SDL_SaveAllDollarTemplates", [POINTER(SDL_RWops)], c_int)
+SDL_SaveDollarTemplate = _bind("SDL_SaveDollarTemplate", [SDL_GestureID, POINTER(SDL_RWops)], c_int)
+SDL_LoadDollarTemplates = _bind("SDL_LoadDollarTemplates", [SDL_TouchID, POINTER(SDL_RWops)], c_int)
diff --git a/src/m64py/SDL2/haptic.py b/src/m64py/SDL2/haptic.py
new file mode 100644
index 0000000..24be0a1
--- /dev/null
+++ b/src/m64py/SDL2/haptic.py
@@ -0,0 +1,193 @@
+from ctypes import Structure, Union, POINTER, c_int, c_uint, c_float, c_char_p
+from .dll import _bind
+from .stdinc import Uint8, Uint16, Uint32, Sint16, Sint32
+from .joystick import SDL_Joystick
+
+__all__ = ["SDL_Haptic", "SDL_HAPTIC_CONSTANT", "SDL_HAPTIC_SINE",
+           "SDL_HAPTIC_LEFTRIGHT", "SDL_HAPTIC_TRIANGLE",
+           "SDL_HAPTIC_SAWTOOTHUP", "SDL_HAPTIC_SAWTOOTHDOWN",
+           "SDL_HAPTIC_RAMP", "SDL_HAPTIC_SPRING", "SDL_HAPTIC_DAMPER",
+           "SDL_HAPTIC_INERTIA", "SDL_HAPTIC_FRICTION", "SDL_HAPTIC_CUSTOM",
+           "SDL_HAPTIC_GAIN", "SDL_HAPTIC_AUTOCENTER", "SDL_HAPTIC_STATUS",
+           "SDL_HAPTIC_PAUSE", "SDL_HAPTIC_POLAR", "SDL_HAPTIC_CARTESIAN",
+           "SDL_HAPTIC_SPHERICAL", "SDL_HAPTIC_INFINITY",
+           "SDL_HapticDirection", "SDL_HapticConstant", "SDL_HapticPeriodic",
+           "SDL_HapticCondition", "SDL_HapticRamp", "SDL_HapticCustom",
+           "SDL_HapticLeftRight", "SDL_HapticEffect", "SDL_NumHaptics",
+           "SDL_HapticName", "SDL_HapticOpen", "SDL_HapticOpened",
+           "SDL_HapticIndex", "SDL_MouseIsHaptic", "SDL_HapticOpenFromMouse",
+           "SDL_JoystickIsHaptic", "SDL_HapticOpenFromJoystick",
+           "SDL_HapticClose", "SDL_HapticNumEffects",
+           "SDL_HapticNumEffectsPlaying", "SDL_HapticQuery",
+           "SDL_HapticNumAxes", "SDL_HapticEffectSupported",
+           "SDL_HapticNewEffect", "SDL_HapticUpdateEffect",
+           "SDL_HapticRunEffect", "SDL_HapticStopEffect",
+           "SDL_HapticDestroyEffect", "SDL_HapticGetEffectStatus",
+           "SDL_HapticSetGain", "SDL_HapticSetAutocenter", "SDL_HapticPause",
+           "SDL_HapticUnpause", "SDL_HapticStopAll",
+           "SDL_HapticRumbleSupported", "SDL_HapticRumbleInit",
+           "SDL_HapticRumblePlay", "SDL_HapticRumbleStop"
+           ]
+
+class SDL_Haptic(Structure):
+    pass
+
+SDL_HAPTIC_CONSTANT = 1 << 0
+SDL_HAPTIC_SINE = 1 << 1
+SDL_HAPTIC_LEFTRIGHT = 1 << 2
+SDL_HAPTIC_TRIANGLE = 1 << 3
+SDL_HAPTIC_SAWTOOTHUP = 1 << 4
+SDL_HAPTIC_SAWTOOTHDOWN = 1 << 5
+SDL_HAPTIC_RAMP = 1 << 6
+SDL_HAPTIC_SPRING = 1 << 7
+SDL_HAPTIC_DAMPER = 1 << 8
+SDL_HAPTIC_INERTIA = 1 << 9
+SDL_HAPTIC_FRICTION = 1 << 10
+SDL_HAPTIC_CUSTOM = 1 << 11
+SDL_HAPTIC_GAIN = 1 << 12
+SDL_HAPTIC_AUTOCENTER = 1 << 13
+SDL_HAPTIC_STATUS = 1 << 14
+SDL_HAPTIC_PAUSE = 1 << 15
+SDL_HAPTIC_POLAR = 0
+SDL_HAPTIC_CARTESIAN = 1
+SDL_HAPTIC_SPHERICAL = 2
+SDL_HAPTIC_INFINITY = 4294967295
+
+class SDL_HapticDirection(Structure):
+    _fields_ = [("type", Uint8), ("dir", (Sint32 * 3))]
+
+class SDL_HapticConstant(Structure):
+    _fields_ = [("type", Uint16),
+                ("direction", SDL_HapticDirection),
+                ("length", Uint32),
+                ("delay", Uint16),
+                ("button", Uint16),
+                ("interval", Uint16),
+                ("level", Sint16),
+                ("attack_length", Uint16),
+                ("attack_level", Uint16),
+                ("fade_length", Uint16),
+                ("fade_level", Uint16),
+                ]
+
+
+class SDL_HapticPeriodic(Structure):
+    _fields_ = [("type", Uint16),
+                ("direction", SDL_HapticDirection),
+                ("length", Uint32),
+                ("delay", Uint16),
+                ("button", Uint16),
+                ("interval", Uint16),
+                ("period", Uint16),
+                ("magnitude", Sint16),
+                ("offset", Sint16),
+                ("phase", Uint16),
+                ("attack_length", Uint16),
+                ("attack_level", Uint16),
+                ("fade_length", Uint16),
+                ("fade_level", Uint16),
+                ]
+
+
+class SDL_HapticCondition(Structure):
+    """A conditionally running effect."""
+    _fields_ = [("type", Uint16),
+                ("direction", SDL_HapticDirection),
+                ("length", Uint32),
+                ("delay", Uint16),
+                ("button", Uint16),
+                ("interval", Uint16),
+                ("right_sat", (Uint16 * 3)),
+                ("left_sat", (Uint16 * 3)),
+                ("right_coeff", (Sint16 * 3)),
+                ("left_coeff", (Sint16 * 3)),
+                ("deadband", (Uint16 * 3)),
+                ("center", (Sint16 * 3)),
+                ]
+
+
+class SDL_HapticRamp(Structure):
+    """A ramp-like effect."""
+    _fields_ = [("type", Uint16),
+                ("direction", SDL_HapticDirection),
+                ("length", Uint32),
+                ("delay", Uint16),
+                ("button", Uint16),
+                ("interval", Uint16),
+                ("start", Sint16),
+                ("end", Sint16),
+                ("attack_length", Uint16),
+                ("attack_level", Uint16),
+                ("fade_length", Uint16),
+                ("fade_level", Uint16),
+                ]
+
+
+class SDL_HapticLeftRight(Structure):
+    """A left-right effect."""
+    _fields_ = [("type", Uint16),
+                ("length", Uint32),
+                ("large_magnitude", Uint16),
+                ("small_magnitude", Uint16)
+            ]
+
+
+class SDL_HapticCustom(Structure):
+    """A custom effect."""
+    _fields_ = [("type", Uint16),
+                ("direction", SDL_HapticDirection),
+                ("length", Uint32),
+                ("delay", Uint16),
+                ("button", Uint16),
+                ("interval", Uint16),
+                ("channels", Uint8),
+                ("period", Uint16),
+                ("samples", Uint16),
+                ("data", POINTER(Uint16)),
+                ("attack_length", Uint16),
+                ("attack_level", Uint16),
+                ("fade_length", Uint16),
+                ("fade_level", Uint16),
+                ]
+
+
+class SDL_HapticEffect(Union):
+    """A generic haptic effect, containing the concrete haptic effect."""
+    _fields_ = [("type", Uint16),
+                ("constant", SDL_HapticConstant),
+                ("periodic", SDL_HapticPeriodic),
+                ("condition", SDL_HapticCondition),
+                ("ramp", SDL_HapticRamp),
+                ("custom", SDL_HapticCustom),
+                ]
+
+SDL_NumHaptics = _bind("SDL_NumHaptics", None, c_int)
+SDL_HapticName = _bind("SDL_HapticName", [c_int], c_char_p)
+SDL_HapticOpen = _bind("SDL_HapticOpen", [c_int], POINTER(SDL_Haptic))
+SDL_HapticOpened = _bind("SDL_HapticOpened", [c_int], c_int)
+SDL_HapticIndex = _bind("SDL_HapticIndex", [POINTER(SDL_Haptic)], c_int)
+SDL_MouseIsHaptic = _bind("SDL_MouseIsHaptic", None, c_int)
+SDL_HapticOpenFromMouse = _bind("SDL_HapticOpenFromMouse", None, POINTER(SDL_Haptic))
+SDL_JoystickIsHaptic = _bind("SDL_JoystickIsHaptic", [POINTER(SDL_Joystick)], c_int)
+SDL_HapticOpenFromJoystick = _bind("SDL_HapticOpenFromJoystick", [POINTER(SDL_Joystick)], POINTER(SDL_Haptic))
+SDL_HapticClose = _bind("SDL_HapticClose", [POINTER(SDL_Haptic)])
+SDL_HapticNumEffects = _bind("SDL_HapticNumEffects", [POINTER(SDL_Haptic)], c_int)
+SDL_HapticNumEffectsPlaying = _bind("SDL_HapticNumEffectsPlaying", [POINTER(SDL_Haptic)], c_int)
+SDL_HapticQuery = _bind("SDL_HapticQuery", [POINTER(SDL_Haptic)], c_uint)
+SDL_HapticNumAxes = _bind("SDL_HapticNumAxes", [POINTER(SDL_Haptic)], c_int)
+SDL_HapticEffectSupported = _bind("SDL_HapticEffectSupported", [POINTER(SDL_Haptic), POINTER(SDL_HapticEffect)], c_int)
+SDL_HapticNewEffect = _bind("SDL_HapticNewEffect", [POINTER(SDL_Haptic), POINTER(SDL_HapticEffect)], c_int)
+SDL_HapticUpdateEffect = _bind("SDL_HapticUpdateEffect", [POINTER(SDL_Haptic), c_int, POINTER(SDL_HapticEffect)], c_int)
+SDL_HapticRunEffect = _bind("SDL_HapticRunEffect", [POINTER(SDL_Haptic), c_int, Uint32], c_int)
+SDL_HapticStopEffect = _bind("SDL_HapticStopEffect", [POINTER(SDL_Haptic), c_int], c_int)
+SDL_HapticDestroyEffect = _bind("SDL_HapticDestroyEffect", [POINTER(SDL_Haptic), c_int])
+SDL_HapticGetEffectStatus = _bind("SDL_HapticGetEffectStatus", [POINTER(SDL_Haptic), c_int], c_int)
+SDL_HapticSetGain = _bind("SDL_HapticSetGain", [POINTER(SDL_Haptic), c_int], c_int)
+SDL_HapticSetAutocenter = _bind("SDL_HapticSetAutocenter", [POINTER(SDL_Haptic), c_int], c_int)
+SDL_HapticPause = _bind("SDL_HapticPause", [POINTER(SDL_Haptic)], c_int)
+SDL_HapticUnpause = _bind("SDL_HapticUnpause", [POINTER(SDL_Haptic)], c_int)
+SDL_HapticStopAll = _bind("SDL_HapticStopAll", [POINTER(SDL_Haptic)], c_int)
+SDL_HapticRumbleSupported = _bind("SDL_HapticRumbleSupported", [POINTER(SDL_Haptic)], c_int)
+SDL_HapticRumbleInit = _bind("SDL_HapticRumbleInit", [POINTER(SDL_Haptic)], c_int)
+SDL_HapticRumblePlay = _bind("SDL_HapticRumblePlay", [POINTER(SDL_Haptic), c_float, Uint32], c_int)
+SDL_HapticRumbleStop = _bind("SDL_HapticRumbleStop", [POINTER(SDL_Haptic)], c_int)
diff --git a/src/m64py/SDL2/hints.py b/src/m64py/SDL2/hints.py
new file mode 100644
index 0000000..77d3c25
--- /dev/null
+++ b/src/m64py/SDL2/hints.py
@@ -0,0 +1,46 @@
+from ctypes import CFUNCTYPE, c_int, c_char_p, c_void_p
+from .dll import _bind
+from .stdinc import SDL_bool
+
+__all__ = ["SDL_HINT_FRAMEBUFFER_ACCELERATION", "SDL_HINT_RENDER_DRIVER",
+           "SDL_HINT_RENDER_OPENGL_SHADERS", "SDL_HINT_RENDER_SCALE_QUALITY",
+           "SDL_HINT_RENDER_VSYNC", "SDL_HINT_VIDEO_X11_XVIDMODE",
+           "SDL_HINT_VIDEO_X11_XINERAMA", "SDL_HINT_VIDEO_X11_XRANDR",
+           "SDL_HINT_GRAB_KEYBOARD", "SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS",
+           "SDL_HINT_IDLE_TIMER_DISABLED", "SDL_HINT_ORIENTATIONS",
+           "SDL_HINT_XINPUT_ENABLED", "SDL_HINT_GAMECONTROLLERCONFIG",
+           "SDL_HINT_ALLOW_TOPMOST", "SDL_HINT_DEFAULT", "SDL_HINT_NORMAL",
+           "SDL_HINT_OVERRIDE", "SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS",
+           "SDL_HintPriority", "SDL_SetHintWithPriority", "SDL_SetHint",
+           "SDL_GetHint", "SDL_ClearHints"
+           ]
+
+SDL_HINT_FRAMEBUFFER_ACCELERATION = b"SDL_FRAMEBUFFER_ACCELERATION"
+SDL_HINT_RENDER_DRIVER = b"SDL_RENDER_DRIVER"
+SDL_HINT_RENDER_OPENGL_SHADERS = b"SDL_RENDER_OPENGL_SHADERS"
+SDL_HINT_RENDER_SCALE_QUALITY = b"SDL_RENDER_SCALE_QUALITY"
+SDL_HINT_RENDER_VSYNC = b"SDL_RENDER_VSYNC"
+SDL_HINT_VIDEO_X11_XVIDMODE = b"SDL_VIDEO_X11_XVIDMODE"
+SDL_HINT_VIDEO_X11_XINERAMA = b"SDL_VIDEO_X11_XINERAMA"
+SDL_HINT_VIDEO_X11_XRANDR = b"SDL_VIDEO_X11_XRANDR"
+SDL_HINT_GRAB_KEYBOARD = b"SDL_GRAB_KEYBOARD"
+SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS = b"SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"
+SDL_HINT_IDLE_TIMER_DISABLED = b"SDL_IOS_IDLE_TIMER_DISABLED"
+SDL_HINT_ORIENTATIONS = b"SDL_IOS_ORIENTATIONS"
+SDL_HINT_XINPUT_ENABLED = b"SDL_XINPUT_ENABLED"
+SDL_HINT_GAMECONTROLLERCONFIG = b"SDL_GAMECONTROLLERCONFIG"
+SDL_HINT_ALLOW_TOPMOST = b"SDL_ALLOW_TOPMOST"
+SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS = b"SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"
+SDL_HINT_TIMER_RESOLUTION = b"SDL_TIMER_RESOLUTION"
+
+SDL_HINT_DEFAULT = 0
+SDL_HINT_NORMAL = 1
+SDL_HINT_OVERRIDE = 2
+SDL_HintPriority = c_int
+SDL_SetHintWithPriority = _bind("SDL_SetHintWithPriority", [c_char_p, c_char_p, SDL_HintPriority], SDL_bool)
+SDL_SetHint = _bind("SDL_SetHint", [c_char_p, c_char_p], SDL_bool)
+SDL_GetHint = _bind("SDL_GetHint", [c_char_p], c_char_p)
+SDL_ClearHints = _bind("SDL_ClearHints")
+SDL_HintCallback = CFUNCTYPE(None, c_void_p, c_char_p, c_char_p, c_char_p)
+SDL_AddHintCallback = _bind("SDL_AddHintCallback", [c_char_p, SDL_HintCallback, c_void_p])
+SDL_DelHintCallback = _bind("SDL_DelHintCallback",[c_char_p, SDL_HintCallback, c_void_p])
diff --git a/src/m64py/SDL2/joystick.py b/src/m64py/SDL2/joystick.py
new file mode 100644
index 0000000..961e0c4
--- /dev/null
+++ b/src/m64py/SDL2/joystick.py
@@ -0,0 +1,57 @@
+from ctypes import Structure, c_int, c_char_p, POINTER
+from .dll import _bind
+from .stdinc import Sint16, Sint32, Uint8, SDL_bool
+
+__all__ = ["SDL_Joystick", "SDL_JoystickGUID", "SDL_JoystickID",
+           "SDL_NumJoysticks", "SDL_JoystickNameForIndex", "SDL_JoystickOpen",
+           "SDL_JoystickName", "SDL_JoystickGetDeviceGUID",
+           "SDL_JoystickGetGUID", "SDL_JoystickGetGUIDString",
+           "SDL_JoystickGetGUIDFromString", "SDL_JoystickGetAttached",
+           "SDL_JoystickInstanceID", "SDL_JoystickNumAxes",
+           "SDL_JoystickNumBalls", "SDL_JoystickNumHats",
+           "SDL_JoystickNumButtons", "SDL_JoystickUpdate",
+           "SDL_JoystickEventState", "SDL_JoystickGetAxis", "SDL_HAT_CENTERED",
+           "SDL_HAT_UP", "SDL_HAT_RIGHT", "SDL_HAT_DOWN", "SDL_HAT_LEFT",
+           "SDL_HAT_RIGHTUP", "SDL_HAT_RIGHTDOWN", "SDL_HAT_LEFTUP",
+           "SDL_HAT_LEFTDOWN", "SDL_JoystickGetHat", "SDL_JoystickGetBall",
+           "SDL_JoystickGetButton", "SDL_JoystickClose"
+           ]
+
+class SDL_Joystick(Structure):
+    pass
+
+class SDL_JoystickGUID(Structure):
+    _fields_ = [("data", (Uint8 * 16))]
+
+SDL_JoystickID = Sint32
+
+SDL_NumJoysticks = _bind("SDL_NumJoysticks", None, c_int)
+SDL_JoystickNameForIndex = _bind("SDL_JoystickNameForIndex", [c_int], c_char_p)
+SDL_JoystickOpen = _bind("SDL_JoystickOpen", [c_int], POINTER(SDL_Joystick))
+SDL_JoystickName = _bind("SDL_JoystickName", [POINTER(SDL_Joystick)], c_char_p)
+SDL_JoystickGetDeviceGUID = _bind("SDL_JoystickGetDeviceGUID", [c_int], SDL_JoystickGUID)
+SDL_JoystickGetGUID = _bind("SDL_JoystickGetGUID", [POINTER(SDL_Joystick)], SDL_JoystickGUID)
+SDL_JoystickGetGUIDString = _bind("SDL_JoystickGetGUIDString", [SDL_JoystickGUID, c_char_p, c_int])
+SDL_JoystickGetGUIDFromString = _bind("SDL_JoystickGetGUIDFromString", [c_char_p], SDL_JoystickGUID)
+SDL_JoystickGetAttached = _bind("SDL_JoystickGetAttached", [POINTER(SDL_Joystick)], SDL_bool)
+SDL_JoystickInstanceID = _bind("SDL_JoystickInstanceID", [POINTER(SDL_Joystick)], SDL_JoystickID)
+SDL_JoystickNumAxes = _bind("SDL_JoystickNumAxes", [POINTER(SDL_Joystick)], c_int)
+SDL_JoystickNumBalls = _bind("SDL_JoystickNumBalls", [POINTER(SDL_Joystick)], c_int)
+SDL_JoystickNumHats = _bind("SDL_JoystickNumHats", [POINTER(SDL_Joystick)], c_int)
+SDL_JoystickNumButtons = _bind("SDL_JoystickNumButtons", [POINTER(SDL_Joystick)], c_int)
+SDL_JoystickUpdate = _bind("SDL_JoystickUpdate")
+SDL_JoystickEventState = _bind("SDL_JoystickEventState", [c_int], c_int)
+SDL_JoystickGetAxis = _bind("SDL_JoystickGetAxis", [POINTER(SDL_Joystick), c_int], Sint16)
+SDL_HAT_CENTERED = 0x00
+SDL_HAT_UP = 0x01
+SDL_HAT_RIGHT = 0x02
+SDL_HAT_DOWN = 0x04
+SDL_HAT_LEFT = 0x08
+SDL_HAT_RIGHTUP = SDL_HAT_RIGHT | SDL_HAT_UP
+SDL_HAT_RIGHTDOWN = SDL_HAT_RIGHT | SDL_HAT_DOWN
+SDL_HAT_LEFTUP = SDL_HAT_LEFT | SDL_HAT_UP
+SDL_HAT_LEFTDOWN = SDL_HAT_LEFT | SDL_HAT_DOWN
+SDL_JoystickGetHat = _bind("SDL_JoystickGetHat", [POINTER(SDL_Joystick), c_int], Uint8)
+SDL_JoystickGetBall = _bind("SDL_JoystickGetBall", [POINTER(SDL_Joystick), c_int, POINTER(c_int), POINTER(c_int)], c_int)
+SDL_JoystickGetButton = _bind("SDL_JoystickGetButton", [POINTER(SDL_Joystick), c_int], Uint8)
+SDL_JoystickClose = _bind("SDL_JoystickClose", [POINTER(SDL_Joystick)])
diff --git a/src/m64py/SDL2/keyboard.py b/src/m64py/SDL2/keyboard.py
new file mode 100644
index 0000000..74ccf47
--- /dev/null
+++ b/src/m64py/SDL2/keyboard.py
@@ -0,0 +1,40 @@
+from ctypes import Structure, c_int, c_char_p, POINTER
+from .dll import _bind
+from .stdinc import Uint8, Uint16, Uint32, SDL_bool
+from .keycode import SDL_Keycode, SDL_Keymod
+from .scancode import SDL_Scancode
+from .rect import SDL_Rect
+from .video import SDL_Window
+
+__all__ = ["SDL_Keysym", "SDL_GetKeyboardFocus", "SDL_GetKeyboardState",
+           "SDL_GetModState", "SDL_SetModState", "SDL_GetKeyFromScancode",
+           "SDL_GetScancodeFromKey", "SDL_GetScancodeName",
+           "SDL_GetScancodeFromName", "SDL_GetKeyName", "SDL_GetKeyFromName",
+           "SDL_StartTextInput", "SDL_IsTextInputActive", "SDL_StopTextInput",
+           "SDL_SetTextInputRect", "SDL_HasScreenKeyboardSupport",
+           "SDL_IsScreenKeyboardShown"
+           ]
+
+class SDL_Keysym(Structure):
+    _fields_ = [("scancode", SDL_Scancode),
+                ("sym", SDL_Keycode),
+                ("mod", Uint16),
+                ("unicode", Uint32)
+                ]
+
+SDL_GetKeyboardFocus = _bind("SDL_GetKeyboardFocus", None, POINTER(SDL_Window))
+SDL_GetKeyboardState = _bind("SDL_GetKeyboardState", [POINTER(c_int)], POINTER(Uint8))
+SDL_GetModState = _bind("SDL_GetModState", None, SDL_Keymod)
+SDL_SetModState = _bind("SDL_SetModState", [SDL_Keymod])
+SDL_GetKeyFromScancode = _bind("SDL_GetKeyFromScancode", [SDL_Scancode], SDL_Keycode)
+SDL_GetScancodeFromKey = _bind("SDL_GetScancodeFromKey", [SDL_Keycode], SDL_Scancode)
+SDL_GetScancodeName = _bind("SDL_GetScancodeName", [SDL_Scancode], c_char_p)
+SDL_GetScancodeFromName = _bind("SDL_GetScancodeFromName", [c_char_p], SDL_Scancode)
+SDL_GetKeyName = _bind("SDL_GetKeyName", [SDL_Keycode], c_char_p)
+SDL_GetKeyFromName = _bind("SDL_GetKeyFromName", [c_char_p], SDL_Keycode)
+SDL_StartTextInput = _bind("SDL_StartTextInput")
+SDL_IsTextInputActive = _bind("SDL_IsTextInputActive", None, SDL_bool)
+SDL_StopTextInput = _bind("SDL_StopTextInput")
+SDL_SetTextInputRect = _bind("SDL_SetTextInputRect", [POINTER(SDL_Rect)])
+SDL_HasScreenKeyboardSupport = _bind("SDL_HasScreenKeyboardSupport", None, SDL_bool)
+SDL_IsScreenKeyboardShown = _bind("SDL_IsScreenKeyboardShown", [POINTER(SDL_Window)], SDL_bool)
diff --git a/src/m64py/SDL2/keycode.py b/src/m64py/SDL2/keycode.py
new file mode 100644
index 0000000..4b21778
--- /dev/null
+++ b/src/m64py/SDL2/keycode.py
@@ -0,0 +1,288 @@
+from .stdinc import Sint32
+from .scancode import *
+
+SDL_Keycode = Sint32
+SDLK_SCANCODE_MASK = 1 << 30
+SDL_SCANCODE_TO_KEYCODE = lambda x: (x | SDLK_SCANCODE_MASK)
+
+SDL_Keymod = c_int
+
+KMOD_NONE = 0x0000
+KMOD_LSHIFT = 0x0001
+KMOD_RSHIFT = 0x0002
+KMOD_LCTRL = 0x0040
+KMOD_RCTRL = 0x0080
+KMOD_LALT = 0x0100
+KMOD_RALT = 0x0200
+KMOD_LGUI = 0x0400
+KMOD_RGUI = 0x0800
+KMOD_NUM = 0x1000
+KMOD_CAPS = 0x2000
+KMOD_MODE = 0x4000
+KMOD_RESERVED = 0x8000
+
+KMOD_CTRL = KMOD_LCTRL | KMOD_RCTRL
+KMOD_SHIFT = KMOD_LSHIFT | KMOD_RSHIFT
+KMOD_ALT = KMOD_LALT | KMOD_RALT
+KMOD_GUI = KMOD_LGUI | KMOD_RGUI
+
+SDLK_UNKNOWN = 0
+
+SDLK_RETURN = ord('\r')
+SDLK_ESCAPE = ord('\033')
+SDLK_BACKSPACE = ord('\b')
+SDLK_TAB = ord('\t')
+SDLK_SPACE = ord(' ')
+SDLK_EXCLAIM = ord('!')
+SDLK_QUOTEDBL = ord('"')
+SDLK_HASH = ord('#')
+SDLK_PERCENT = ord('%')
+SDLK_DOLLAR = ord('$')
+SDLK_AMPERSAND = ord('&')
+SDLK_QUOTE = ord('\'')
+SDLK_LEFTPAREN = ord('(')
+SDLK_RIGHTPAREN = ord(')')
+SDLK_ASTERISK = ord('*')
+SDLK_PLUS = ord('+')
+SDLK_COMMA = ord(',')
+SDLK_MINUS = ord('-')
+SDLK_PERIOD = ord('.')
+SDLK_SLASH = ord('/')
+
+SDLK_0 = ord('0')
+SDLK_1 = ord('1')
+SDLK_2 = ord('2')
+SDLK_3 = ord('3')
+SDLK_4 = ord('4')
+SDLK_5 = ord('5')
+SDLK_6 = ord('6')
+SDLK_7 = ord('7')
+SDLK_8 = ord('8')
+SDLK_9 = ord('9')
+
+SDLK_COLON = ord(':')
+SDLK_SEMICOLON = ord(';')
+SDLK_LESS = ord('<')
+SDLK_EQUALS = ord('=')
+SDLK_GREATER = ord('>')
+SDLK_QUESTION = ord('?')
+SDLK_AT = ord('@')
+
+SDLK_LEFTBRACKET = ord('[')
+SDLK_BACKSLASH = ord('\\')
+SDLK_RIGHTBRACKET = ord(']')
+SDLK_CARET = ord('^')
+SDLK_UNDERSCORE = ord('_')
+SDLK_BACKQUOTE = ord('`')
+
+SDLK_a = ord('a')
+SDLK_b = ord('b')
+SDLK_c = ord('c')
+SDLK_d = ord('d')
+SDLK_e = ord('e')
+SDLK_f = ord('f')
+SDLK_g = ord('g')
+SDLK_h = ord('h')
+SDLK_i = ord('i')
+SDLK_j = ord('j')
+SDLK_k = ord('k')
+SDLK_l = ord('l')
+SDLK_m = ord('m')
+SDLK_n = ord('n')
+SDLK_o = ord('o')
+SDLK_p = ord('p')
+SDLK_q = ord('q')
+SDLK_r = ord('r')
+SDLK_s = ord('s')
+SDLK_t = ord('t')
+SDLK_u = ord('u')
+SDLK_v = ord('v')
+SDLK_w = ord('w')
+SDLK_x = ord('x')
+SDLK_y = ord('y')
+SDLK_z = ord('z')
+
+SDLK_CAPSLOCK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CAPSLOCK)
+
+SDLK_F1 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F1)
+SDLK_F2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F2)
+SDLK_F3 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F3)
+SDLK_F4 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F4)
+SDLK_F5 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F5)
+SDLK_F6 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F6)
+SDLK_F7 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F7)
+SDLK_F8 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F8)
+SDLK_F9 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F9)
+SDLK_F10 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F10)
+SDLK_F11 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F11)
+SDLK_F12 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F12)
+
+SDLK_PRINTSCREEN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PRINTSCREEN)
+SDLK_SCROLLLOCK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SCROLLLOCK)
+SDLK_PAUSE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAUSE)
+SDLK_INSERT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_INSERT)
+SDLK_HOME = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_HOME)
+SDLK_PAGEUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAGEUP)
+SDLK_DELETE = ord('\177')
+SDLK_END = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_END)
+SDLK_PAGEDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAGEDOWN)
+SDLK_RIGHT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RIGHT)
+SDLK_LEFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LEFT)
+SDLK_DOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DOWN)
+SDLK_UP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_UP)
+
+SDLK_NUMLOCKCLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_NUMLOCKCLEAR)
+SDLK_KP_DIVIDE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DIVIDE)
+SDLK_KP_MULTIPLY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MULTIPLY)
+SDLK_KP_MINUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MINUS)
+SDLK_KP_PLUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PLUS)
+SDLK_KP_ENTER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_ENTER)
+SDLK_KP_1 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_1)
+SDLK_KP_2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_2)
+SDLK_KP_3 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_3)
+SDLK_KP_4 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_4)
+SDLK_KP_5 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_5)
+SDLK_KP_6 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_6)
+SDLK_KP_7 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_7)
+SDLK_KP_8 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_8)
+SDLK_KP_9 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_9)
+SDLK_KP_0 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_0)
+SDLK_KP_PERIOD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PERIOD)
+
+SDLK_APPLICATION = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_APPLICATION)
+SDLK_POWER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_POWER)
+SDLK_KP_EQUALS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EQUALS)
+
+SDLK_F13 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F13)
+SDLK_F14 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F14)
+SDLK_F15 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F15)
+SDLK_F16 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F16)
+SDLK_F17 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F17)
+SDLK_F18 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F18)
+SDLK_F19 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F19)
+SDLK_F20 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F20)
+SDLK_F21 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F21)
+SDLK_F22 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F22)
+SDLK_F23 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F23)
+SDLK_F24 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F24)
+
+SDLK_EXECUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EXECUTE)
+SDLK_HELP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_HELP)
+SDLK_MENU = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MENU)
+SDLK_SELECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SELECT)
+SDLK_STOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_STOP)
+SDLK_AGAIN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AGAIN)
+SDLK_UNDO = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_UNDO)
+SDLK_CUT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CUT)
+SDLK_COPY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_COPY)
+SDLK_PASTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PASTE)
+SDLK_FIND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_FIND)
+SDLK_MUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MUTE)
+SDLK_VOLUMEUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_VOLUMEUP)
+SDLK_VOLUMEDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_VOLUMEDOWN)
+SDLK_KP_COMMA = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_COMMA)
+
+SDLK_KP_EQUALSAS400 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EQUALSAS400)
+
+SDLK_ALTERASE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_ALTERASE)
+SDLK_SYSREQ = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SYSREQ)
+SDLK_CANCEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CANCEL)
+SDLK_CLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CLEAR)
+SDLK_PRIOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PRIOR)
+SDLK_RETURN2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RETURN2)
+SDLK_SEPARATOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SEPARATOR)
+SDLK_OUT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_OUT)
+SDLK_OPER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_OPER)
+SDLK_CLEARAGAIN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CLEARAGAIN)
+SDLK_CRSEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CRSEL)
+SDLK_EXSEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EXSEL)
+
+SDLK_KP_00 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_00)
+SDLK_KP_000 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_000)
+
+SDLK_THOUSANDSSEPARATOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_THOUSANDSSEPARATOR)
+SDLK_DECIMALSEPARATOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DECIMALSEPARATOR)
+SDLK_CURRENCYUNIT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CURRENCYUNIT)
+SDLK_CURRENCYSUBUNIT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CURRENCYSUBUNIT)
+
+SDLK_KP_LEFTPAREN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LEFTPAREN)
+SDLK_KP_RIGHTPAREN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_RIGHTPAREN)
+SDLK_KP_LEFTBRACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LEFTBRACE)
+SDLK_KP_RIGHTBRACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_RIGHTBRACE)
+
+SDLK_KP_TAB = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_TAB)
+SDLK_KP_BACKSPACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_BACKSPACE)
+
+SDLK_KP_A = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_A)
+SDLK_KP_B = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_B)
+SDLK_KP_C = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_C)
+SDLK_KP_D = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_D)
+SDLK_KP_E = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_E)
+SDLK_KP_F = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_F)
+
+SDLK_KP_XOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_XOR)
+SDLK_KP_POWER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_POWER)
+SDLK_KP_PERCENT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PERCENT)
+SDLK_KP_LESS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LESS)
+SDLK_KP_GREATER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_GREATER)
+SDLK_KP_AMPERSAND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_AMPERSAND)
+SDLK_KP_DBLAMPERSAND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DBLAMPERSAND)
+SDLK_KP_VERTICALBAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_VERTICALBAR)
+SDLK_KP_DBLVERTICALBAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DBLVERTICALBAR)
+SDLK_KP_COLON = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_COLON)
+SDLK_KP_HASH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_HASH)
+SDLK_KP_SPACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_SPACE)
+SDLK_KP_AT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_AT)
+SDLK_KP_EXCLAM = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EXCLAM)
+SDLK_KP_MEMSTORE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMSTORE)
+SDLK_KP_MEMRECALL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMRECALL)
+SDLK_KP_MEMCLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMCLEAR)
+SDLK_KP_MEMADD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMADD)
+SDLK_KP_MEMSUBTRACT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMSUBTRACT)
+SDLK_KP_MEMMULTIPLY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMMULTIPLY)
+SDLK_KP_MEMDIVIDE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMDIVIDE)
+SDLK_KP_PLUSMINUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PLUSMINUS)
+SDLK_KP_CLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_CLEAR)
+SDLK_KP_CLEARENTRY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_CLEARENTRY)
+SDLK_KP_BINARY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_BINARY)
+SDLK_KP_OCTAL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_OCTAL)
+SDLK_KP_DECIMAL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DECIMAL)
+SDLK_KP_HEXADECIMAL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_HEXADECIMAL)
+
+SDLK_LCTRL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LCTRL)
+SDLK_LSHIFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LSHIFT)
+SDLK_LALT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LALT)
+SDLK_LGUI = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LGUI)
+SDLK_RCTRL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RCTRL)
+SDLK_RSHIFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RSHIFT)
+SDLK_RALT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RALT)
+SDLK_RGUI = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RGUI)
+
+SDLK_MODE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MODE)
+
+SDLK_AUDIONEXT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIONEXT)
+SDLK_AUDIOPREV = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOPREV)
+SDLK_AUDIOSTOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOSTOP)
+SDLK_AUDIOPLAY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOPLAY)
+SDLK_AUDIOMUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOMUTE)
+SDLK_MEDIASELECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MEDIASELECT)
+SDLK_WWW = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_WWW)
+SDLK_MAIL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MAIL)
+SDLK_CALCULATOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CALCULATOR)
+SDLK_COMPUTER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_COMPUTER)
+SDLK_AC_SEARCH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_SEARCH)
+SDLK_AC_HOME = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_HOME)
+SDLK_AC_BACK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_BACK)
+SDLK_AC_FORWARD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_FORWARD)
+SDLK_AC_STOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_STOP)
+SDLK_AC_REFRESH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_REFRESH)
+SDLK_AC_BOOKMARKS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_BOOKMARKS)
+
+SDLK_BRIGHTNESSDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_BRIGHTNESSDOWN)
+SDLK_BRIGHTNESSUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_BRIGHTNESSUP)
+SDLK_DISPLAYSWITCH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DISPLAYSWITCH)
+SDLK_KBDILLUMTOGGLE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMTOGGLE)
+SDLK_KBDILLUMDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMDOWN)
+SDLK_KBDILLUMUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMUP)
+SDLK_EJECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EJECT)
+SDLK_SLEEP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SLEEP)
diff --git a/src/m64py/SDL2/loadso.py b/src/m64py/SDL2/loadso.py
new file mode 100644
index 0000000..31bb4cd
--- /dev/null
+++ b/src/m64py/SDL2/loadso.py
@@ -0,0 +1,8 @@
+from ctypes import c_char_p, c_void_p
+from .dll import _bind
+
+__all__ = ["SDL_LoadObject", "SDL_LoadFunction", "SDL_UnloadObject"]
+
+SDL_LoadObject = _bind("SDL_LoadObject", [c_char_p], c_void_p)
+SDL_LoadFunction = _bind("SDL_LoadFunction", [c_void_p, c_char_p], c_void_p)
+SDL_UnloadObject = _bind("SDL_UnloadObject", [c_void_p])
diff --git a/src/m64py/SDL2/log.py b/src/m64py/SDL2/log.py
new file mode 100644
index 0000000..fd90aaa
--- /dev/null
+++ b/src/m64py/SDL2/log.py
@@ -0,0 +1,71 @@
+from ctypes import c_int, c_char_p, c_void_p, CFUNCTYPE, POINTER, py_object
+from .dll import _bind
+
+__all__ = ["SDL_MAX_LOG_MESSAGE", "SDL_LOG_CATEGORY_APPLICATION",
+           "SDL_LOG_CATEGORY_ERROR", "SDL_LOG_CATEGORY_ASSERT",
+           "SDL_LOG_CATEGORY_SYSTEM", "SDL_LOG_CATEGORY_AUDIO",
+           "SDL_LOG_CATEGORY_VIDEO", "SDL_LOG_CATEGORY_RENDER",
+           "SDL_LOG_CATEGORY_INPUT", "SDL_LOG_CATEGORY_TEST",
+           "SDL_LOG_CATEGORY_RESERVED1", "SDL_LOG_CATEGORY_RESERVED2",
+           "SDL_LOG_CATEGORY_RESERVED3", "SDL_LOG_CATEGORY_RESERVED4",
+           "SDL_LOG_CATEGORY_RESERVED5", "SDL_LOG_CATEGORY_RESERVED6",
+           "SDL_LOG_CATEGORY_RESERVED7", "SDL_LOG_CATEGORY_RESERVED8",
+           "SDL_LOG_CATEGORY_RESERVED9", "SDL_LOG_CATEGORY_RESERVED10",
+           "SDL_LOG_CATEGORY_CUSTOM", "SDL_LOG_PRIORITY_VERBOSE",
+           "SDL_LOG_PRIORITY_DEBUG", "SDL_LOG_PRIORITY_INFO",
+           "SDL_LOG_PRIORITY_WARN", "SDL_LOG_PRIORITY_ERROR",
+           "SDL_LOG_PRIORITY_CRITICAL", "SDL_NUM_LOG_PRIORITIES",
+           "SDL_LogPriority", "SDL_LogSetAllPriority", "SDL_LogSetPriority",
+           "SDL_LogGetPriority", "SDL_LogResetPriorities", "SDL_Log",
+           "SDL_LogVerbose", "SDL_LogDebug", "SDL_LogInfo", "SDL_LogWarn",
+           "SDL_LogError", "SDL_LogCritical", "SDL_LogMessage",
+           "SDL_LogOutputFunction", "SDL_LogGetOutputFunction",
+           "SDL_LogSetOutputFunction"
+           ]
+
+SDL_MAX_LOG_MESSAGE = 4096
+SDL_LOG_CATEGORY_APPLICATION = 0
+SDL_LOG_CATEGORY_ERROR = 1
+SDL_LOG_CATEGORY_ASSERT = 2
+SDL_LOG_CATEGORY_SYSTEM = 3
+SDL_LOG_CATEGORY_AUDIO = 4
+SDL_LOG_CATEGORY_VIDEO = 5
+SDL_LOG_CATEGORY_RENDER = 6
+SDL_LOG_CATEGORY_INPUT = 7
+SDL_LOG_CATEGORY_TEST = 8
+SDL_LOG_CATEGORY_RESERVED1 = 9
+SDL_LOG_CATEGORY_RESERVED2 = 10
+SDL_LOG_CATEGORY_RESERVED3 = 11
+SDL_LOG_CATEGORY_RESERVED4 = 12
+SDL_LOG_CATEGORY_RESERVED5 = 13
+SDL_LOG_CATEGORY_RESERVED6 = 14
+SDL_LOG_CATEGORY_RESERVED7 = 15
+SDL_LOG_CATEGORY_RESERVED8 = 16
+SDL_LOG_CATEGORY_RESERVED9 = 17
+SDL_LOG_CATEGORY_RESERVED10 = 18
+SDL_LOG_CATEGORY_CUSTOM = 19
+SDL_LOG_PRIORITY_VERBOSE = 1
+SDL_LOG_PRIORITY_DEBUG = 2
+SDL_LOG_PRIORITY_INFO = 3
+SDL_LOG_PRIORITY_WARN = 4
+SDL_LOG_PRIORITY_ERROR = 5
+SDL_LOG_PRIORITY_CRITICAL = 6
+SDL_NUM_LOG_PRIORITIES = 7
+SDL_LogPriority = c_int
+
+SDL_LogSetAllPriority = _bind("SDL_LogSetAllPriority", [SDL_LogPriority])
+SDL_LogSetPriority = _bind("SDL_LogSetPriority", [c_int, SDL_LogPriority])
+SDL_LogGetPriority = _bind("SDL_LogGetPriority", [c_int], SDL_LogPriority)
+SDL_LogResetPriorities = _bind("SDL_LogResetPriorities")
+SDL_Log = _bind("SDL_Log", [c_char_p])
+SDL_LogVerbose = _bind("SDL_LogVerbose", [c_int, c_char_p])
+SDL_LogDebug = _bind("SDL_LogDebug", [c_int, c_char_p])
+SDL_LogInfo = _bind("SDL_LogInfo", [c_int, c_char_p])
+SDL_LogWarn = _bind("SDL_LogWarn", [c_int, c_char_p])
+SDL_LogError = _bind("SDL_LogError", [c_int, c_char_p])
+SDL_LogCritical = _bind("SDL_LogCritical", [c_int, c_char_p])
+SDL_LogMessage = _bind("SDL_LogMessage", [c_int, SDL_LogPriority, c_char_p])
+# TODO: do we want SDL_LogMessageV?
+SDL_LogOutputFunction = CFUNCTYPE(None, c_void_p, c_int, SDL_LogPriority, c_char_p)
+SDL_LogGetOutputFunction = _bind("SDL_LogGetOutputFunction", [POINTER(SDL_LogOutputFunction), c_void_p])
+SDL_LogSetOutputFunction = _bind("SDL_LogSetOutputFunction", [SDL_LogOutputFunction, c_void_p])
diff --git a/src/m64py/SDL2/messagebox.py b/src/m64py/SDL2/messagebox.py
new file mode 100644
index 0000000..7be8efa
--- /dev/null
+++ b/src/m64py/SDL2/messagebox.py
@@ -0,0 +1,54 @@
+from ctypes import Structure, c_int, c_char_p, POINTER
+from .dll import _bind
+from .stdinc import Uint8, Uint32
+from .video import SDL_Window
+
+__all__ = ["SDL_MESSAGEBOX_ERROR", "SDL_MESSAGEBOX_WARNING",
+           "SDL_MESSAGEBOX_INFORMATION", "SDL_MessageBoxFlags",
+           "SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT",
+           "SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT",
+           "SDL_MessageBoxButtonFlags", "SDL_MessageBoxButtonData",
+           "SDL_MessageBoxColor", "SDL_MESSAGEBOX_COLOR_BACKGROUND",
+           "SDL_MESSAGEBOX_COLOR_TEXT", "SDL_MESSAGEBOX_COLOR_BUTTON_BORDER",
+           "SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND",
+           "SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED", "SDL_MESSAGEBOX_COLOR_MAX",
+           "SDL_MessageBoxColorType", "SDL_MessageBoxColorScheme",
+           "SDL_MessageBoxData", "SDL_ShowMessageBox",
+           "SDL_ShowSimpleMessageBox"
+           ]
+
+SDL_MESSAGEBOX_ERROR = 0x00000010
+SDL_MESSAGEBOX_WARNING = 0x00000020
+SDL_MESSAGEBOX_INFORMATION = 0x00000040
+SDL_MessageBoxFlags = c_int
+SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = 0x00000001
+SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = 0x00000002
+SDL_MessageBoxButtonFlags = c_int
+class SDL_MessageBoxButtonData(Structure):
+    _fields_ = [("flags", Uint32), ("buttonid", c_int), ("text", c_char_p)]
+
+class SDL_MessageBoxColor(Structure):
+    _fields_ = [("r", Uint8), ("g", Uint8), ("b", Uint8)]
+
+SDL_MESSAGEBOX_COLOR_BACKGROUND = 0
+SDL_MESSAGEBOX_COLOR_TEXT = 1
+SDL_MESSAGEBOX_COLOR_BUTTON_BORDER = 2
+SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND = 3
+SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED = 4
+SDL_MESSAGEBOX_COLOR_MAX = 5
+SDL_MessageBoxColorType = c_int
+
+class SDL_MessageBoxColorScheme(Structure):
+    _fields_ = [("colors", (SDL_MessageBoxColor * SDL_MESSAGEBOX_COLOR_MAX))]
+
+class SDL_MessageBoxData(Structure):
+    _fields_ = [("flags", Uint32),
+                ("window", POINTER(SDL_Window)),
+                ("title", c_char_p),
+                ("message", c_char_p),
+                ("numbuttons", c_int),
+                ("buttons", POINTER(SDL_MessageBoxButtonData)),
+                ("colorScheme", POINTER(SDL_MessageBoxColorScheme))
+                ]
+SDL_ShowMessageBox = _bind("SDL_ShowMessageBox", [POINTER(SDL_MessageBoxData), POINTER(c_int)], c_int)
+SDL_ShowSimpleMessageBox = _bind("SDL_ShowSimpleMessageBox", [Uint32, c_char_p, c_char_p, POINTER(SDL_Window)], c_int)
diff --git a/src/m64py/SDL2/mouse.py b/src/m64py/SDL2/mouse.py
new file mode 100644
index 0000000..b563829
--- /dev/null
+++ b/src/m64py/SDL2/mouse.py
@@ -0,0 +1,68 @@
+from ctypes import Structure, POINTER, c_int
+from .dll import _bind
+from .stdinc import Uint8, Uint32, SDL_bool
+from .video import SDL_Window
+from .surface import SDL_Surface
+
+__all__ = ["SDL_Cursor", "SDL_SYSTEM_CURSOR_ARROW", "SDL_SYSTEM_CURSOR_IBEAM",
+           "SDL_SYSTEM_CURSOR_WAIT", "SDL_SYSTEM_CURSOR_CROSSHAIR",
+           "SDL_SYSTEM_CURSOR_WAITARROW", "SDL_SYSTEM_CURSOR_SIZENWSE",
+           "SDL_SYSTEM_CURSOR_SIZENESW", "SDL_SYSTEM_CURSOR_SIZEWE",
+           "SDL_SYSTEM_CURSOR_SIZENS", "SDL_SYSTEM_CURSOR_SIZEALL",
+           "SDL_SYSTEM_CURSOR_NO", "SDL_SYSTEM_CURSOR_HAND",
+           "SDL_NUM_SYSTEM_CURSORS", "SDL_SystemCursor", "SDL_GetMouseFocus",
+           "SDL_GetMouseState", "SDL_GetRelativeMouseState",
+           "SDL_WarpMouseInWindow", "SDL_SetRelativeMouseMode",
+           "SDL_GetRelativeMouseMode", "SDL_CreateCursor",
+           "SDL_CreateColorCursor", "SDL_CreateSystemCursor", "SDL_SetCursor",
+           "SDL_GetCursor", "SDL_GetDefaultCursor", "SDL_FreeCursor",
+           "SDL_ShowCursor", "SDL_BUTTON", "SDL_BUTTON_LEFT",
+           "SDL_BUTTON_MIDDLE", "SDL_BUTTON_RIGHT", "SDL_BUTTON_X1",
+           "SDL_BUTTON_X2", "SDL_BUTTON_LMASK", "SDL_BUTTON_MMASK",
+           "SDL_BUTTON_RMASK", "SDL_BUTTON_X1MASK", "SDL_BUTTON_X2MASK"
+           ]
+
+
+class SDL_Cursor(Structure):
+    pass
+
+
+SDL_SYSTEM_CURSOR_ARROW = 0
+SDL_SYSTEM_CURSOR_IBEAM = 1
+SDL_SYSTEM_CURSOR_WAIT = 2
+SDL_SYSTEM_CURSOR_CROSSHAIR = 3
+SDL_SYSTEM_CURSOR_WAITARROW = 4
+SDL_SYSTEM_CURSOR_SIZENWSE = 5
+SDL_SYSTEM_CURSOR_SIZENESW = 6
+SDL_SYSTEM_CURSOR_SIZEWE = 7
+SDL_SYSTEM_CURSOR_SIZENS = 8
+SDL_SYSTEM_CURSOR_SIZEALL = 9
+SDL_SYSTEM_CURSOR_NO = 10
+SDL_SYSTEM_CURSOR_HAND = 11
+SDL_NUM_SYSTEM_CURSORS = 12
+SDL_SystemCursor = c_int
+SDL_GetMouseFocus = _bind("SDL_GetMouseFocus", None, POINTER(SDL_Window))
+SDL_GetMouseState = _bind("SDL_GetMouseState", [POINTER(c_int), POINTER(c_int)], Uint32)
+SDL_GetRelativeMouseState = _bind("SDL_GetRelativeMouseState", [POINTER(c_int), POINTER(c_int)], Uint32)
+SDL_WarpMouseInWindow = _bind("SDL_WarpMouseInWindow", [POINTER(SDL_Window), c_int, c_int])
+SDL_SetRelativeMouseMode = _bind("SDL_SetRelativeMouseMode", [SDL_bool], c_int)
+SDL_GetRelativeMouseMode = _bind("SDL_GetRelativeMouseMode", None, SDL_bool)
+SDL_CreateCursor = _bind("SDL_CreateCursor", [POINTER(Uint8), POINTER(Uint8), c_int, c_int, c_int, c_int], POINTER(SDL_Cursor))
+SDL_CreateColorCursor = _bind("SDL_CreateColorCursor", [POINTER(SDL_Surface), c_int, c_int], POINTER(SDL_Cursor))
+SDL_CreateSystemCursor = _bind("SDL_CreateSystemCursor", [SDL_SystemCursor], POINTER(SDL_Cursor))
+SDL_SetCursor = _bind("SDL_SetCursor", [POINTER(SDL_Cursor)])
+SDL_GetCursor = _bind("SDL_GetCursor", None, POINTER(SDL_Cursor))
+SDL_GetDefaultCursor = _bind("SDL_GetDefaultCursor", None, POINTER(SDL_Cursor))
+SDL_FreeCursor = _bind("SDL_FreeCursor", [POINTER(SDL_Cursor)])
+SDL_ShowCursor = _bind("SDL_ShowCursor", [c_int], c_int)
+SDL_BUTTON = lambda X: (1 << ((X) - 1))
+SDL_BUTTON_LEFT = 1
+SDL_BUTTON_MIDDLE = 2
+SDL_BUTTON_RIGHT = 3
+SDL_BUTTON_X1 = 4
+SDL_BUTTON_X2 = 5
+SDL_BUTTON_LMASK = SDL_BUTTON(SDL_BUTTON_LEFT)
+SDL_BUTTON_MMASK = SDL_BUTTON(SDL_BUTTON_MIDDLE)
+SDL_BUTTON_RMASK = SDL_BUTTON(SDL_BUTTON_RIGHT)
+SDL_BUTTON_X1MASK = SDL_BUTTON(SDL_BUTTON_X1)
+SDL_BUTTON_X2MASK = SDL_BUTTON(SDL_BUTTON_X2)
diff --git a/src/m64py/SDL2/pixels.py b/src/m64py/SDL2/pixels.py
new file mode 100644
index 0000000..5fc0826
--- /dev/null
+++ b/src/m64py/SDL2/pixels.py
@@ -0,0 +1,298 @@
+from ctypes import Structure, POINTER, c_int, c_char_p, c_float
+from .dll import _bind
+from .stdinc import Uint8, Uint16, Uint32, SDL_bool
+
+SDL_ALPHA_OPAQUE = 255
+SDL_ALPHA_TRANSPARENT = 0
+
+SDL_PIXELTYPE_UNKNOWN = 0
+SDL_PIXELTYPE_INDEX1 = 1
+SDL_PIXELTYPE_INDEX4 = 2
+SDL_PIXELTYPE_INDEX8 = 3
+SDL_PIXELTYPE_PACKED8 = 4
+SDL_PIXELTYPE_PACKED16 = 5
+SDL_PIXELTYPE_PACKED32 = 6
+SDL_PIXELTYPE_ARRAYU8 = 7
+SDL_PIXELTYPE_ARRAYU16 = 8
+SDL_PIXELTYPE_ARRAYU32 = 9
+SDL_PIXELTYPE_ARRAYF16 = 10
+SDL_PIXELTYPE_ARRAYF32 = 11
+
+SDL_BITMAPORDER_NONE = 0
+SDL_BITMAPORDER_4321 = 1
+SDL_BITMAPORDER_1234 = 2
+
+SDL_PACKEDORDER_NONE = 0
+SDL_PACKEDORDER_XRGB = 1
+SDL_PACKEDORDER_RGBX = 2
+SDL_PACKEDORDER_ARGB = 3
+SDL_PACKEDORDER_RGBA = 4
+SDL_PACKEDORDER_XBGR = 5
+SDL_PACKEDORDER_BGRX = 6
+SDL_PACKEDORDER_ABGR = 7
+SDL_PACKEDORDER_BGRA = 8
+
+SDL_ARRAYORDER_NONE = 0
+SDL_ARRAYORDER_RGB = 1
+SDL_ARRAYORDER_RGBA = 2
+SDL_ARRAYORDER_ARGB = 3
+SDL_ARRAYORDER_BGR = 4
+SDL_ARRAYORDER_BGRA = 5
+SDL_ARRAYORDER_ABGR = 6
+
+SDL_PACKEDLAYOUT_NONE = 0
+SDL_PACKEDLAYOUT_332 = 1
+SDL_PACKEDLAYOUT_4444 = 2
+SDL_PACKEDLAYOUT_1555 = 3
+SDL_PACKEDLAYOUT_5551 = 4
+SDL_PACKEDLAYOUT_565 = 5
+SDL_PACKEDLAYOUT_8888 = 6
+SDL_PACKEDLAYOUT_2101010 = 7
+SDL_PACKEDLAYOUT_1010102 = 8
+
+SDL_FOURCC = lambda a, b, c, d: (ord(a) << 0) | (ord(b) << 8) | (ord(c) << 16) | (ord(d) << 24)
+SDL_DEFINE_PIXELFOURCC = SDL_FOURCC
+SDL_DEFINE_PIXELFORMAT = lambda ptype, order, layout, bits, pbytes: ((1 << 28) | ((ptype) << 24) | ((order) << 20) | ((layout) << 16) | ((bits) << 8) | ((pbytes) << 0))
+SDL_PIXELFLAG = lambda X: (((X) >> 28) & 0x0F)
+SDL_PIXELTYPE = lambda X: (((X) >> 24) & 0x0F)
+SDL_PIXELORDER = lambda X: (((X) >> 20) & 0x0F)
+SDL_PIXELLAYOUT = lambda X: (((X) >> 16) & 0x0F)
+SDL_BITSPERPIXEL = lambda X: (((X) >> 8) & 0xFF)
+def SDL_BYTESPERPIXEL(x):
+    valid = (SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YVYU)
+    if SDL_ISPIXELFORMAT_FOURCC(x):
+        if x in valid:
+            return 2
+        else:
+            return 1
+    else:
+        return(((x) >> 0) & 0xFF)
+def SDL_ISPIXELFORMAT_INDEXED(pformat):
+    """Checks, if the passed format value is an indexed format."""
+    return ((not SDL_ISPIXELFORMAT_FOURCC(pformat)) and
+            ((SDL_PIXELTYPE(pformat) == SDL_PIXELTYPE_INDEX1) or
+             (SDL_PIXELTYPE(pformat) == SDL_PIXELTYPE_INDEX4) or
+             (SDL_PIXELTYPE(pformat) == SDL_PIXELTYPE_INDEX8)))
+def SDL_ISPIXELFORMAT_ALPHA(pformat):
+    """Checks, if the passed format value is an alpha channel supporting
+    format.
+    """
+    return ((not SDL_ISPIXELFORMAT_FOURCC(pformat)) and
+            ((SDL_PIXELORDER(pformat) == SDL_PACKEDORDER_ARGB) or
+             (SDL_PIXELORDER(pformat) == SDL_PACKEDORDER_RGBA) or
+             (SDL_PIXELORDER(pformat) == SDL_PACKEDORDER_ABGR) or
+             (SDL_PIXELORDER(pformat) == SDL_PACKEDORDER_BGRA)))
+
+SDL_ISPIXELFORMAT_FOURCC = lambda fmt: ((fmt) and (SDL_PIXELFLAG(fmt) != 1))
+SDL_PIXELFORMAT_UNKNOWN = 0
+SDL_PIXELFORMAT_INDEX1LSB = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1,
+                                                   SDL_BITMAPORDER_4321,
+                                                   0, 1, 0)
+SDL_PIXELFORMAT_INDEX1MSB = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1,
+                                                   SDL_BITMAPORDER_1234,
+                                                   0, 1, 0)
+SDL_PIXELFORMAT_INDEX4LSB = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4,
+                                                   SDL_BITMAPORDER_4321,
+                                                   0, 4, 0)
+SDL_PIXELFORMAT_INDEX4MSB = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4,
+                                                   SDL_BITMAPORDER_1234,
+                                                   0, 4, 0)
+SDL_PIXELFORMAT_INDEX8 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX8, 0,
+                                                0, 8, 1)
+SDL_PIXELFORMAT_RGB332 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED8,
+                                                SDL_PACKEDORDER_XRGB,
+                                                SDL_PACKEDLAYOUT_332, 8, 1)
+SDL_PIXELFORMAT_RGB444 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                SDL_PACKEDORDER_XRGB,
+                                                SDL_PACKEDLAYOUT_4444, 12, 2)
+SDL_PIXELFORMAT_RGB555 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                SDL_PACKEDORDER_XRGB,
+                                                SDL_PACKEDLAYOUT_1555, 15, 2)
+SDL_PIXELFORMAT_BGR555 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                SDL_PACKEDORDER_XBGR,
+                                                SDL_PACKEDLAYOUT_1555, 15, 2)
+SDL_PIXELFORMAT_ARGB4444 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                  SDL_PACKEDORDER_ARGB,
+                                                  SDL_PACKEDLAYOUT_4444, 16, 2)
+SDL_PIXELFORMAT_RGBA4444 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                  SDL_PACKEDORDER_RGBA,
+                                                  SDL_PACKEDLAYOUT_4444, 16, 2)
+SDL_PIXELFORMAT_ABGR4444 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                  SDL_PACKEDORDER_ABGR,
+                                                  SDL_PACKEDLAYOUT_4444, 16, 2)
+SDL_PIXELFORMAT_BGRA4444 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                  SDL_PACKEDORDER_BGRA,
+                                                  SDL_PACKEDLAYOUT_4444, 16, 2)
+SDL_PIXELFORMAT_ARGB1555 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                  SDL_PACKEDORDER_ARGB,
+                                                  SDL_PACKEDLAYOUT_1555, 16, 2)
+SDL_PIXELFORMAT_RGBA5551 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                  SDL_PACKEDORDER_RGBA,
+                                                  SDL_PACKEDLAYOUT_5551, 16, 2)
+SDL_PIXELFORMAT_ABGR1555 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                  SDL_PACKEDORDER_ABGR,
+                                                  SDL_PACKEDLAYOUT_1555, 16, 2)
+SDL_PIXELFORMAT_BGRA5551 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                  SDL_PACKEDORDER_BGRA,
+                                                  SDL_PACKEDLAYOUT_5551, 16, 2)
+SDL_PIXELFORMAT_RGB565 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                SDL_PACKEDORDER_XRGB,
+                                                SDL_PACKEDLAYOUT_565, 16, 2)
+SDL_PIXELFORMAT_BGR565 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16,
+                                                SDL_PACKEDORDER_XBGR,
+                                                SDL_PACKEDLAYOUT_565, 16, 2)
+SDL_PIXELFORMAT_RGB24 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8,
+                                               SDL_ARRAYORDER_RGB, 0, 24, 3)
+SDL_PIXELFORMAT_BGR24 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8,
+                                               SDL_ARRAYORDER_BGR, 0, 24, 3)
+SDL_PIXELFORMAT_RGB888 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                SDL_PACKEDORDER_XRGB,
+                                                SDL_PACKEDLAYOUT_8888, 24, 4)
+SDL_PIXELFORMAT_RGBX8888 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                  SDL_PACKEDORDER_RGBX,
+                                                  SDL_PACKEDLAYOUT_8888, 24, 4)
+SDL_PIXELFORMAT_BGR888 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                SDL_PACKEDORDER_XBGR,
+                                                SDL_PACKEDLAYOUT_8888, 24, 4)
+SDL_PIXELFORMAT_BGRX8888 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                  SDL_PACKEDORDER_BGRX,
+                                                  SDL_PACKEDLAYOUT_8888, 24, 4)
+SDL_PIXELFORMAT_ARGB8888 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                  SDL_PACKEDORDER_ARGB,
+                                                  SDL_PACKEDLAYOUT_8888, 32, 4)
+SDL_PIXELFORMAT_RGBA8888 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                  SDL_PACKEDORDER_RGBA,
+                                                  SDL_PACKEDLAYOUT_8888, 32, 4)
+SDL_PIXELFORMAT_ABGR8888 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                  SDL_PACKEDORDER_ABGR,
+                                                  SDL_PACKEDLAYOUT_8888, 32, 4)
+SDL_PIXELFORMAT_BGRA8888 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                  SDL_PACKEDORDER_BGRA,
+                                                  SDL_PACKEDLAYOUT_8888, 32, 4)
+SDL_PIXELFORMAT_ARGB2101010 = SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32,
+                                                     SDL_PACKEDORDER_ARGB,
+                                                     SDL_PACKEDLAYOUT_2101010,
+                                                     32, 4)
+SDL_PIXELFORMAT_YV12 = SDL_DEFINE_PIXELFOURCC('Y', 'V', '1', '2')
+SDL_PIXELFORMAT_IYUV = SDL_DEFINE_PIXELFOURCC('I', 'Y', 'U', 'V')
+SDL_PIXELFORMAT_YUY2 = SDL_DEFINE_PIXELFOURCC('Y', 'U', 'Y', '2')
+SDL_PIXELFORMAT_UYVY = SDL_DEFINE_PIXELFOURCC('U', 'Y', 'V', 'Y')
+SDL_PIXELFORMAT_YVYU = SDL_DEFINE_PIXELFOURCC('Y', 'V', 'Y', 'U')
+
+ALL_PIXELFORMATS = (
+    SDL_PIXELFORMAT_INDEX1LSB,
+    SDL_PIXELFORMAT_INDEX1MSB,
+    SDL_PIXELFORMAT_INDEX4LSB,
+    SDL_PIXELFORMAT_INDEX4MSB,
+    SDL_PIXELFORMAT_INDEX8,
+    SDL_PIXELFORMAT_RGB332,
+    SDL_PIXELFORMAT_RGB444,
+    SDL_PIXELFORMAT_RGB555,
+    SDL_PIXELFORMAT_BGR555,
+    SDL_PIXELFORMAT_ARGB4444,
+    SDL_PIXELFORMAT_RGBA4444,
+    SDL_PIXELFORMAT_ABGR4444,
+    SDL_PIXELFORMAT_BGRA4444,
+    SDL_PIXELFORMAT_ARGB1555,
+    SDL_PIXELFORMAT_RGBA5551,
+    SDL_PIXELFORMAT_ABGR1555,
+    SDL_PIXELFORMAT_BGRA5551,
+    SDL_PIXELFORMAT_RGB565,
+    SDL_PIXELFORMAT_BGR565,
+    SDL_PIXELFORMAT_RGB24,
+    SDL_PIXELFORMAT_BGR24,
+    SDL_PIXELFORMAT_RGB888,
+    SDL_PIXELFORMAT_RGBX8888,
+    SDL_PIXELFORMAT_BGR888,
+    SDL_PIXELFORMAT_BGRX8888,
+    SDL_PIXELFORMAT_ARGB8888,
+    SDL_PIXELFORMAT_RGBA8888,
+    SDL_PIXELFORMAT_ABGR8888,
+    SDL_PIXELFORMAT_BGRA8888,
+    SDL_PIXELFORMAT_ARGB2101010,
+    SDL_PIXELFORMAT_YV12,
+    SDL_PIXELFORMAT_IYUV,
+    SDL_PIXELFORMAT_YUY2,
+    SDL_PIXELFORMAT_UYVY,
+    SDL_PIXELFORMAT_YVYU,
+    )
+
+
+class SDL_Color(Structure):
+    _fields_ = [("r", Uint8),
+                ("g", Uint8),
+                ("b", Uint8),
+                ("a", Uint8),
+                ]
+
+    def __init__(self, r=255, g=255, b=255, a=255):
+        super(SDL_Color, self).__init__()
+        self.r = r
+        self.g = g
+        self.b = b
+        self.a = a
+
+    def __repr__(self):
+        return "SDL_Color(r=%d, g=%d, b=%d, a=%d)" % (self.r, self.g, self.b,
+                                                      self.a)
+
+    def __copy__(self):
+        return SDL_Color(self.r, self.g, self.b, self.a)
+
+    def __deepcopy__(self, memo):
+        return SDL_Color(self.r, self.g, self.b, self.a)
+
+    def __eq__(self, color):
+        return self.r == color.r and self.g == color.g and \
+            self.b == color.b and self.a == color.a
+
+    def __ne__(self, color):
+        return self.r != color.r or self.g != color.g or self.b != color.b or \
+            self.a != color.a
+
+SDL_Colour = SDL_Color
+
+class SDL_Palette(Structure):
+    _fields_ = [("ncolors", c_int),
+                ("colors", POINTER(SDL_Color)),
+                ("version", Uint32),
+                ("refcount", c_int)]
+
+
+class SDL_PixelFormat(Structure):
+    pass
+SDL_PixelFormat._fields_ = \
+    [("format", Uint32),
+     ("palette", POINTER(SDL_Palette)),
+     ("BitsPerPixel", Uint8),
+     ("BytesPerPixel", Uint8),
+     ("padding", Uint8 * 2),
+     ("Rmask", Uint32),
+     ("Gmask", Uint32),
+     ("Bmask", Uint32),
+     ("Amask", Uint32),
+     ("Rloss", Uint8),
+     ("Gloss", Uint8),
+     ("Bloss", Uint8),
+     ("Aloss", Uint8),
+     ("Rshift", Uint8),
+     ("Gshift", Uint8),
+     ("Bshift", Uint8),
+     ("Ashift", Uint8),
+     ("refcount", c_int),
+     ("next", POINTER(SDL_PixelFormat))]
+
+SDL_GetPixelFormatName = _bind("SDL_GetPixelFormatName", [Uint32], c_char_p)
+SDL_PixelFormatEnumToMasks = _bind("SDL_PixelFormatEnumToMasks", [Uint32, POINTER(c_int), POINTER(Uint32), POINTER(Uint32), POINTER(Uint32), POINTER(Uint32)], SDL_bool)
+SDL_MasksToPixelFormatEnum = _bind("SDL_MasksToPixelFormatEnum", [c_int, Uint32, Uint32, Uint32, Uint32], Uint32)
+SDL_AllocFormat = _bind("SDL_AllocFormat", [Uint32], POINTER(SDL_PixelFormat))
+SDL_FreeFormat = _bind("SDL_FreeFormat", [POINTER(SDL_PixelFormat)])
+SDL_AllocPalette = _bind("SDL_AllocPalette", [c_int], POINTER(SDL_Palette))
+SDL_SetPixelFormatPalette = _bind("SDL_SetPixelFormatPalette", [POINTER(SDL_PixelFormat), POINTER(SDL_Palette)], c_int)
+SDL_SetPaletteColors = _bind("SDL_SetPaletteColors", [POINTER(SDL_Palette), POINTER(SDL_Color), c_int, c_int], c_int)
+SDL_FreePalette = _bind("SDL_FreePalette", [POINTER(SDL_Palette)])
+SDL_MapRGB = _bind("SDL_MapRGB", [POINTER(SDL_PixelFormat), Uint8, Uint8, Uint8], Uint32)
+SDL_MapRGBA = _bind("SDL_MapRGBA", [POINTER(SDL_PixelFormat), Uint8, Uint8, Uint8, Uint8], Uint32)
+SDL_GetRGB = _bind("SDL_GetRGB", [Uint32, POINTER(SDL_PixelFormat), POINTER(Uint8), POINTER(Uint8), POINTER(Uint8)])
+SDL_GetRGBA = _bind("SDL_GetRGBA", [Uint32, POINTER(SDL_PixelFormat), POINTER(Uint8), POINTER(Uint8), POINTER(Uint8), POINTER(Uint8)])
+SDL_CalculateGammaRamp = _bind("SDL_CalculateGammaRamp", [c_float, POINTER(Uint16)])
diff --git a/src/m64py/SDL2/platform.py b/src/m64py/SDL2/platform.py
new file mode 100644
index 0000000..43db76d
--- /dev/null
+++ b/src/m64py/SDL2/platform.py
@@ -0,0 +1,6 @@
+from ctypes import c_char_p
+from .dll import _bind
+
+__all__ = ["SDL_GetPlatform"]
+
+SDL_GetPlatform = _bind("SDL_GetPlatform", None, c_char_p)
diff --git a/src/m64py/SDL2/power.py b/src/m64py/SDL2/power.py
new file mode 100644
index 0000000..01efbf3
--- /dev/null
+++ b/src/m64py/SDL2/power.py
@@ -0,0 +1,17 @@
+from ctypes import POINTER, c_int
+from .dll import _bind
+
+__all__ = ["SDL_PowerState", "SDL_POWERSTATE_UNKNOWN",
+          "SDL_POWERSTATE_ON_BATTERY", "SDL_POWERSTATE_NO_BATTERY",
+          "SDL_POWERSTATE_CHARGING", "SDL_POWERSTATE_CHARGED",
+          "SDL_GetPowerInfo"
+          ]
+
+SDL_PowerState = c_int
+SDL_POWERSTATE_UNKNOWN = 0
+SDL_POWERSTATE_ON_BATTERY = 1
+SDL_POWERSTATE_NO_BATTERY = 2
+SDL_POWERSTATE_CHARGING = 3
+SDL_POWERSTATE_CHARGED = 4
+
+SDL_GetPowerInfo = _bind("SDL_GetPowerInfo", [POINTER(c_int), POINTER(c_int)], SDL_PowerState)
diff --git a/src/m64py/SDL2/rect.py b/src/m64py/SDL2/rect.py
new file mode 100644
index 0000000..b44beca
--- /dev/null
+++ b/src/m64py/SDL2/rect.py
@@ -0,0 +1,72 @@
+from ctypes import Structure, c_int, POINTER
+from .dll import _bind
+from .stdinc import SDL_bool
+
+__all__ = ["SDL_Point", "SDL_Rect", "SDL_RectEmpty", "SDL_RectEquals",
+           "SDL_HasIntersection", "SDL_IntersectRect", "SDL_UnionRect",
+           "SDL_EnclosePoints", "SDL_IntersectRectAndLine"
+           ]
+
+
+class SDL_Point(Structure):
+    _fields_ = [("x", c_int), ("y", c_int)]
+
+    def __init__(self, x=0, y=0):
+        super(SDL_Point, self).__init__()
+        self.x = x
+        self.y = y
+
+    def __repr__(self):
+        return "SDL_Point(x=%d, y=%d)" % (self.x, self.y)
+
+    def __copy__(self):
+        return SDL_Point(self.x, self.y)
+
+    def __deepcopy__(self, memo):
+        return SDL_Point(self.x, self.y)
+
+    def __eq__(self, pt):
+        return self.x == pt.x and self.y == pt.y
+
+    def __ne__(self, pt):
+        return self.x != pt.x or self.y != pt.y
+
+
+class SDL_Rect(Structure):
+    _fields_ = [("x", c_int), ("y", c_int),
+                ("w", c_int), ("h", c_int)]
+
+    def __init__(self, x=0, y=0, w=0, h=0):
+        super(SDL_Rect, self).__init__()
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+
+    def __repr__(self):
+        return "SDL_Rect(x=%d, y=%d, w=%d, h=%d)" % (self.x, self.y, self.w,
+                                                     self.h)
+
+    def __copy__(self):
+        return SDL_Rect(self.x, self.y, self.w, self.h)
+
+    def __deepcopy__(self, memo):
+        return SDL_Rect(self.x, self.y, self.w, self.h)
+
+    def __eq__(self, rt):
+        return self.x == rt.x and self.y == rt.y and \
+            self.w == rt.w and self.h == rt.h
+
+    def __ne__(self, rt):
+        return self.x != rt.x or self.y != rt.y or \
+            self.w != rt.w or self.h != rt.h
+
+
+SDL_RectEmpty = lambda x: ((not x) or (x.w <= 0) or (x.h <= 0))
+SDL_RectEquals = lambda a, b: ((a.x == b.x) and (a.y == b.y) and
+                              (a.w == b.w) and (a.h == b.h))
+SDL_HasIntersection = _bind("SDL_HasIntersection", [POINTER(SDL_Rect), POINTER(SDL_Rect)], SDL_bool)
+SDL_IntersectRect = _bind("SDL_IntersectRect", [POINTER(SDL_Rect), POINTER(SDL_Rect), POINTER(SDL_Rect)], SDL_bool)
+SDL_UnionRect = _bind("SDL_UnionRect", [POINTER(SDL_Rect), POINTER(SDL_Rect), POINTER(SDL_Rect)])
+SDL_EnclosePoints = _bind("SDL_EnclosePoints", [POINTER(SDL_Point), c_int, POINTER(SDL_Rect), POINTER(SDL_Rect)], SDL_bool)
+SDL_IntersectRectAndLine = _bind("SDL_IntersectRectAndLine", [POINTER(SDL_Rect), POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)], SDL_bool)
diff --git a/src/m64py/SDL2/render.py b/src/m64py/SDL2/render.py
new file mode 100644
index 0000000..37c5c22
--- /dev/null
+++ b/src/m64py/SDL2/render.py
@@ -0,0 +1,128 @@
+from ctypes import Structure, POINTER, c_int, c_char_p, c_void_p, c_float, \
+    c_double
+from .dll import _bind
+from .stdinc import Uint8, Uint32, SDL_bool
+from .blendmode import SDL_BlendMode
+from .rect import SDL_Point, SDL_Rect
+from .surface import SDL_Surface
+from .video import SDL_Window
+
+__all__ = ["SDL_RendererFlags", "SDL_RENDERER_SOFTWARE",
+           "SDL_RENDERER_ACCELERATED", "SDL_RENDERER_PRESENTVSYNC",
+           "SDL_RENDERER_TARGETTEXTURE", "SDL_RendererInfo",
+           "SDL_TextureAccess", "SDL_TEXTUREACCESS_STATIC",
+           "SDL_TEXTUREACCESS_STREAMING", "SDL_TEXTUREACCESS_TARGET",
+           "SDL_TextureModulate", "SDL_TEXTUREMODULATE_NONE",
+           "SDL_TEXTUREMODULATE_COLOR", "SDL_TEXTUREMODULATE_ALPHA",
+           "SDL_RendererFlip", "SDL_FLIP_NONE", "SDL_FLIP_HORIZONTAL",
+           "SDL_FLIP_VERTICAL", "SDL_Renderer", "SDL_Texture",
+           "SDL_GetNumRenderDrivers", "SDL_GetRenderDriverInfo",
+           "SDL_CreateWindowAndRenderer", "SDL_CreateRenderer",
+           "SDL_CreateSoftwareRenderer", "SDL_GetRenderer",
+           "SDL_GetRendererInfo", "SDL_CreateTexture",
+           "SDL_CreateTextureFromSurface", "SDL_QueryTexture",
+           "SDL_SetTextureColorMod", "SDL_GetTextureColorMod",
+           "SDL_SetTextureAlphaMod", "SDL_GetTextureAlphaMod",
+           "SDL_SetTextureBlendMode", "SDL_GetTextureBlendMode",
+           "SDL_UpdateTexture", "SDL_LockTexture", "SDL_UnlockTexture",
+           "SDL_RenderTargetSupported", "SDL_SetRenderTarget",
+           "SDL_GetRenderTarget", "SDL_RenderSetLogicalSize",
+           "SDL_RenderGetLogicalSize", "SDL_RenderSetViewport",
+           "SDL_RenderGetClipRect", "SDL_RenderSetClipRect",
+           "SDL_RenderGetViewport", "SDL_RenderSetScale", "SDL_RenderGetScale",
+           "SDL_SetRenderDrawColor", "SDL_GetRenderDrawColor",
+           "SDL_SetRenderDrawBlendMode", "SDL_GetRenderDrawBlendMode",
+           "SDL_RenderClear", "SDL_RenderDrawPoint", "SDL_RenderDrawPoints",
+           "SDL_RenderDrawLine", "SDL_RenderDrawLines", "SDL_RenderDrawRect",
+           "SDL_RenderDrawRects", "SDL_RenderFillRect", "SDL_RenderFillRects",
+           "SDL_RenderCopy", "SDL_RenderCopyEx", "SDL_RenderReadPixels",
+           "SDL_RenderPresent", "SDL_DestroyTexture", "SDL_DestroyRenderer",
+           "SDL_GL_BindTexture", "SDL_GL_UnbindTexture"
+           ]
+
+SDL_RendererFlags = c_int
+SDL_RENDERER_SOFTWARE = 0x00000001
+SDL_RENDERER_ACCELERATED = 0x00000002
+SDL_RENDERER_PRESENTVSYNC = 0x00000004
+SDL_RENDERER_TARGETTEXTURE = 0x00000008
+
+class SDL_RendererInfo(Structure):
+    _fields_ = [("name", c_char_p),
+                ("flags", Uint32),
+                ("num_texture_formats", Uint32),
+                ("texture_formats", Uint32 * 16),
+                ("max_texture_width", c_int),
+                ("max_texture_height", c_int)]
+
+SDL_TextureAccess = c_int
+SDL_TEXTUREACCESS_STATIC = 0
+SDL_TEXTUREACCESS_STREAMING = 1
+SDL_TEXTUREACCESS_TARGET = 2
+
+SDL_TextureModulate = c_int
+SDL_TEXTUREMODULATE_NONE = 0x00000000
+SDL_TEXTUREMODULATE_COLOR = 0x00000001
+SDL_TEXTUREMODULATE_ALPHA = 0x00000002
+
+SDL_RendererFlip = c_int
+SDL_FLIP_NONE = 0x00000000
+SDL_FLIP_HORIZONTAL = 0x00000001
+SDL_FLIP_VERTICAL = 0x00000002
+
+class SDL_Renderer(Structure):
+    pass
+class SDL_Texture(Structure):
+    pass
+
+SDL_GetNumRenderDrivers = _bind("SDL_GetNumRenderDrivers", None, c_int)
+SDL_GetRenderDriverInfo = _bind("SDL_GetRenderDriverInfo", [c_int, POINTER(SDL_RendererInfo)], c_int)
+SDL_CreateWindowAndRenderer = _bind("SDL_CreateWindowAndRenderer", [c_int, c_int, Uint32, POINTER(POINTER(SDL_Window)), POINTER(POINTER(SDL_Renderer))], c_int)
+SDL_CreateRenderer = _bind("SDL_CreateRenderer", [POINTER(SDL_Window), c_int, Uint32], POINTER(SDL_Renderer))
+SDL_CreateSoftwareRenderer = _bind("SDL_CreateSoftwareRenderer", [POINTER(SDL_Surface)], POINTER(SDL_Renderer))
+SDL_GetRenderer = _bind("SDL_GetRenderer", [POINTER(SDL_Window)], POINTER(SDL_Renderer))
+SDL_GetRendererInfo = _bind("SDL_GetRendererInfo", [POINTER(SDL_Renderer), POINTER(SDL_RendererInfo)], c_int)
+SDL_GetRendererOutputSize = _bind("SDL_GetRendererOutputSize", [POINTER(SDL_Renderer), POINTER(c_int), POINTER(c_int)], c_int)
+SDL_CreateTexture = _bind("SDL_CreateTexture", [POINTER(SDL_Renderer), Uint32, c_int, c_int, c_int], POINTER(SDL_Texture))
+SDL_CreateTextureFromSurface = _bind("SDL_CreateTextureFromSurface", [POINTER(SDL_Renderer), POINTER(SDL_Surface)], POINTER(SDL_Texture))
+SDL_QueryTexture = _bind("SDL_QueryTexture", [POINTER(SDL_Texture), POINTER(Uint32), POINTER(c_int), POINTER(c_int), POINTER(c_int)], c_int)
+SDL_SetTextureColorMod = _bind("SDL_SetTextureColorMod", [POINTER(SDL_Texture), Uint8, Uint8, Uint8], c_int)
+SDL_GetTextureColorMod = _bind("SDL_GetTextureColorMod", [POINTER(SDL_Texture), POINTER(Uint8), POINTER(Uint8), POINTER(Uint8)], c_int)
+SDL_SetTextureAlphaMod = _bind("SDL_SetTextureAlphaMod", [POINTER(SDL_Texture), Uint8], c_int)
+SDL_GetTextureAlphaMod = _bind("SDL_GetTextureAlphaMod", [POINTER(SDL_Texture), POINTER(Uint8)], c_int)
+SDL_SetTextureBlendMode = _bind("SDL_SetTextureBlendMode", [POINTER(SDL_Texture), SDL_BlendMode], c_int)
+SDL_GetTextureBlendMode = _bind("SDL_GetTextureBlendMode", [POINTER(SDL_Texture), POINTER(SDL_BlendMode)], c_int)
+SDL_UpdateTexture = _bind("SDL_UpdateTexture", [POINTER(SDL_Texture), POINTER(SDL_Rect), c_void_p, c_int], c_int)
+SDL_LockTexture = _bind("SDL_LockTexture", [POINTER(SDL_Texture), POINTER(SDL_Rect), POINTER(c_void_p), POINTER(c_int)], c_int)
+SDL_UnlockTexture = _bind("SDL_UnlockTexture", [POINTER(SDL_Texture)])
+SDL_RenderTargetSupported = _bind("SDL_RenderTargetSupported", [POINTER(SDL_Renderer)], SDL_bool)
+SDL_SetRenderTarget = _bind("SDL_SetRenderTarget", [POINTER(SDL_Renderer), POINTER(SDL_Texture)], c_int)
+SDL_GetRenderTarget = _bind("SDL_GetRenderTarget", [POINTER(SDL_Renderer)], POINTER(SDL_Texture))
+SDL_RenderSetLogicalSize = _bind("SDL_RenderSetLogicalSize", [POINTER(SDL_Renderer), c_int, c_int], c_int)
+SDL_RenderGetLogicalSize = _bind("SDL_RenderGetLogicalSize", [POINTER(SDL_Renderer), POINTER(c_int), POINTER(c_int)])
+SDL_RenderSetViewport = _bind("SDL_RenderSetViewport", [POINTER(SDL_Renderer), POINTER(SDL_Rect)], c_int)
+SDL_RenderGetViewport = _bind("SDL_RenderGetViewport", [POINTER(SDL_Renderer), POINTER(SDL_Rect)])
+SDL_RenderGetClipRect = _bind("SDL_RenderGetClipRect", [POINTER(SDL_Renderer), POINTER(SDL_Rect)])
+SDL_RenderSetClipRect = _bind("SDL_RenderSetClipRect", [POINTER(SDL_Renderer), POINTER(SDL_Rect)], c_int)
+SDL_RenderSetScale = _bind("SDL_RenderSetScale", [POINTER(SDL_Renderer), c_float, c_float], c_int)
+SDL_RenderGetScale = _bind("SDL_RenderGetScale", [POINTER(SDL_Renderer), POINTER(c_float), POINTER(c_float)])
+SDL_SetRenderDrawColor = _bind("SDL_SetRenderDrawColor", [POINTER(SDL_Renderer), Uint8, Uint8, Uint8, Uint8], c_int)
+SDL_GetRenderDrawColor = _bind("SDL_GetRenderDrawColor", [POINTER(SDL_Renderer), POINTER(Uint8), POINTER(Uint8), POINTER(Uint8), POINTER(Uint8)], c_int)
+SDL_SetRenderDrawBlendMode = _bind("SDL_SetRenderDrawBlendMode", [POINTER(SDL_Renderer), SDL_BlendMode], c_int)
+SDL_GetRenderDrawBlendMode = _bind("SDL_GetRenderDrawBlendMode", [POINTER(SDL_Renderer), POINTER(SDL_BlendMode)], c_int)
+SDL_RenderClear = _bind("SDL_RenderClear", [POINTER(SDL_Renderer)], c_int)
+SDL_RenderDrawPoint = _bind("SDL_RenderDrawPoint", [POINTER(SDL_Renderer), c_int, c_int], c_int)
+SDL_RenderDrawPoints = _bind("SDL_RenderDrawPoints", [POINTER(SDL_Renderer), POINTER(SDL_Point), c_int], c_int)
+SDL_RenderDrawLine = _bind("SDL_RenderDrawLine", [POINTER(SDL_Renderer), c_int, c_int, c_int, c_int], c_int)
+SDL_RenderDrawLines = _bind("SDL_RenderDrawLines", [POINTER(SDL_Renderer), POINTER(SDL_Point), c_int], c_int)
+SDL_RenderDrawRect = _bind("SDL_RenderDrawRect", [POINTER(SDL_Renderer), POINTER(SDL_Rect)], c_int)
+SDL_RenderDrawRects = _bind("SDL_RenderDrawRects", [POINTER(SDL_Renderer), POINTER(SDL_Rect), c_int], c_int)
+SDL_RenderFillRect = _bind("SDL_RenderFillRect", [POINTER(SDL_Renderer), POINTER(SDL_Rect)], c_int)
+SDL_RenderFillRects = _bind("SDL_RenderFillRects", [POINTER(SDL_Renderer), POINTER(SDL_Rect), c_int], c_int)
+SDL_RenderCopy = _bind("SDL_RenderCopy", [POINTER(SDL_Renderer), POINTER(SDL_Texture), POINTER(SDL_Rect), POINTER(SDL_Rect)], c_int)
+SDL_RenderCopyEx = _bind("SDL_RenderCopyEx", [POINTER(SDL_Renderer), POINTER(SDL_Texture), POINTER(SDL_Rect), POINTER(SDL_Rect), c_double, POINTER(SDL_Point), SDL_RendererFlip], c_int)
+SDL_RenderReadPixels = _bind("SDL_RenderReadPixels", [POINTER(SDL_Renderer), POINTER(SDL_Rect), Uint32, c_void_p, c_int], c_int)
+SDL_RenderPresent = _bind("SDL_RenderPresent", [POINTER(SDL_Renderer)])
+SDL_DestroyTexture = _bind("SDL_DestroyTexture", [POINTER(SDL_Texture)])
+SDL_DestroyRenderer = _bind("SDL_DestroyRenderer", [POINTER(SDL_Renderer)])
+SDL_GL_BindTexture = _bind("SDL_GL_BindTexture", [POINTER(SDL_Texture), POINTER(c_float), POINTER(c_float)], c_int)
+SDL_GL_UnbindTexture = _bind("SDL_GL_UnbindTexture", [POINTER(SDL_Texture)], c_int)
diff --git a/src/m64py/SDL2/rwops.py b/src/m64py/SDL2/rwops.py
new file mode 100644
index 0000000..02b935e
--- /dev/null
+++ b/src/m64py/SDL2/rwops.py
@@ -0,0 +1,197 @@
+import sys
+from ctypes import Structure, POINTER, CFUNCTYPE, c_int, c_size_t, c_void_p, \
+    c_char_p, memmove, string_at
+from .dll import _bind
+from .stdinc import Sint64, Uint8, Uint16, Uint32, Uint64, SDL_bool
+
+__all__ = ["SDL_RWOPS_UNKNOWN", "SDL_RWOPS_WINFILE", "SDL_RWOPS_STDFILE",
+           "SDL_RWOPS_JNIFILE", "SDL_RWOPS_MEMORY", "SDL_RWOPS_MEMORY_RO",
+           "SDL_RWops", "SDL_RWFromFile", "SDL_RWFromFP", "SDL_RWFromMem",
+           "SDL_RWFromConstMem", "SDL_AllocRW", "SDL_FreeRW", "RW_SEEK_SET",
+           "RW_SEEK_CUR", "RW_SEEK_END", "SDL_RWsize", "SDL_RWseek",
+           "SDL_RWtell", "SDL_RWread", "SDL_RWwrite", "SDL_RWclose",
+           "SDL_ReadU8", "SDL_ReadLE16", "SDL_ReadBE16", "SDL_ReadLE32",
+           "SDL_ReadBE32", "SDL_ReadLE64", "SDL_ReadBE64", "SDL_WriteU8",
+           "SDL_WriteLE16", "SDL_WriteBE16", "SDL_WriteLE32", "SDL_WriteBE32",
+           "SDL_WriteLE64", "SDL_WriteBE64", "rw_from_object"
+           ]
+
+SDL_RWOPS_UNKNOWN = 0
+SDL_RWOPS_WINFILE = 1
+SDL_RWOPS_STDFILE = 2
+SDL_RWOPS_JNIFILE = 3
+SDL_RWOPS_MEMORY = 4
+SDL_RWOPS_MEMORY_RO = 5
+
+class SDL_RWops(Structure):
+    pass
+
+_sdlsize = CFUNCTYPE(Sint64, POINTER(SDL_RWops))
+_sdlseek = CFUNCTYPE(Sint64, POINTER(SDL_RWops), Sint64, c_int)
+_sdlread = CFUNCTYPE(c_size_t, POINTER(SDL_RWops), c_void_p, c_size_t, c_size_t)
+_sdlwrite = CFUNCTYPE(c_size_t, POINTER(SDL_RWops), c_void_p, c_size_t, c_size_t)
+_sdlclose = CFUNCTYPE(c_int, POINTER(SDL_RWops))
+SDL_RWops._fields_ = [("size", _sdlsize),
+                      ("seek", _sdlseek),
+                      ("read", _sdlread),
+                      ("write", _sdlwrite),
+                      ("close", _sdlclose),
+                      ("type", Uint32),
+                      # TODO: Union hidden
+                      ]
+
+SDL_RWFromFile = _bind("SDL_RWFromFile", [c_char_p, c_char_p], POINTER(SDL_RWops))
+SDL_RWFromFP = _bind("SDL_RWFromFP", [c_void_p, SDL_bool], POINTER(SDL_RWops))
+SDL_RWFromMem = _bind("SDL_RWFromMem", [c_void_p, c_int], POINTER(SDL_RWops))
+SDL_RWFromConstMem = _bind("SDL_RWFromConstMem", [c_void_p, c_int], POINTER(SDL_RWops))
+SDL_AllocRW = _bind("SDL_AllocRW", None, POINTER(SDL_RWops))
+SDL_FreeRW = _bind("SDL_AllocRW", [POINTER(SDL_RWops)])
+
+RW_SEEK_SET = 0
+RW_SEEK_CUR = 1
+RW_SEEK_END = 2
+
+SDL_RWsize = lambda ctx: ctx.size(ctx)
+SDL_RWseek = lambda ctx, offset, whence: ctx.seek(ctx, offset, whence)
+SDL_RWtell = lambda ctx: ctx.seek(ctx, 0, RW_SEEK_CUR)
+SDL_RWread = lambda ctx, ptr, size, n: ctx.read(ctx, ptr, size, n)
+SDL_RWwrite = lambda ctx, ptr, size, n: ctx.write(ctx, ptr, size, n)
+SDL_RWclose = lambda ctx: ctx.close(ctx)
+
+SDL_ReadU8 = _bind("SDL_ReadU8", [POINTER(SDL_RWops)], Uint8)
+SDL_ReadLE16 = _bind("SDL_ReadLE16", [POINTER(SDL_RWops)], Uint16)
+SDL_ReadBE16 = _bind("SDL_ReadBE16", [POINTER(SDL_RWops)], Uint16)
+SDL_ReadLE32 = _bind("SDL_ReadLE32", [POINTER(SDL_RWops)], Uint32)
+SDL_ReadBE32 = _bind("SDL_ReadBE32", [POINTER(SDL_RWops)], Uint32)
+SDL_ReadLE64 = _bind("SDL_ReadLE64", [POINTER(SDL_RWops)], Uint64)
+SDL_ReadBE64 = _bind("SDL_ReadBE64", [POINTER(SDL_RWops)], Uint64)
+
+SDL_WriteU8 = _bind("SDL_WriteU8", [POINTER(SDL_RWops), Uint8], c_size_t)
+SDL_WriteLE16 = _bind("SDL_WriteLE16", [POINTER(SDL_RWops), Uint16], c_size_t)
+SDL_WriteBE16 = _bind("SDL_WriteBE16", [POINTER(SDL_RWops), Uint16], c_size_t)
+SDL_WriteLE32 = _bind("SDL_WriteLE32", [POINTER(SDL_RWops), Uint32], c_size_t)
+SDL_WriteBE32 = _bind("SDL_WriteBE32", [POINTER(SDL_RWops), Uint32], c_size_t)
+SDL_WriteLE64 = _bind("SDL_WriteLE64", [POINTER(SDL_RWops), Uint64], c_size_t)
+SDL_WriteBE64 = _bind("SDL_WriteBE64", [POINTER(SDL_RWops), Uint64], c_size_t)
+
+if sys.version_info[0] >= 3:
+    import collections
+    callable = lambda x: isinstance(x, collections.Callable)
+
+def rw_from_object(obj):
+    """Creats a SDL_RWops from any Python object.
+
+    The Python object must at least support the following methods:
+
+        read(length) -> data
+            length is the size in bytes to be read. A call to len(data) must
+            return the correct amount of bytes for the data, so that
+            len(data) / [size in bytes for a single element from data] returns
+            the amount of elements.
+            Must raise an error on failure.
+
+        seek(offset, whence) -> int
+            offset denotes the offset to move the read/write pointer of the
+            object to. whence indicates the movement behaviour and can be one
+            of the following values:
+                RW_SEEK_SET - move to offset from the start of the file
+                RW_SEEK_CUR - move by offset from the relative location
+                RW_SEEK_END - move to offset from the end of the file
+            If it could not move read/write pointer to the desired location,
+            an error must be raised.
+
+        tell() -> int
+            Must return the current offset. This method must only be
+            provided, if seek() does not return any value.
+
+        close() -> None
+            Closes the object(or its internal data access methods). Must raise
+            an error on failure.
+
+        write(data) -> None
+            Writes the passed data(which is a string of bytes) to the object.
+            Must raise an error on failure.
+
+        Note: The write() method is optional and only necessary, if the passed
+        object should be able to write data.
+
+    The returned SDL_RWops is a pure Python object and must not be freed via
+    free_rw().
+    """
+    if not hasattr(obj, "read"):
+        raise TypeError("obj must have a read(len) -> data method")
+    if not hasattr(obj, "seek") or not callable(obj.seek):
+        raise TypeError("obj must have a seek(offset, whence) method")
+    if not hasattr(obj, "close") or not callable(obj.close):
+        raise TypeError("obj must have a close() -> int method")
+
+    rwops = SDL_RWops()
+
+    def _rwsize(context):
+        try:
+            if hasattr(obj, "size"):
+                if callable(obj.size):
+                    return obj.size()
+                else:
+                    return obj.size
+            else:
+                cur = obj.seek(0, RW_SEEK_CUR)
+                length = obj.seek(0, RW_SEEK_END)
+                obj.seek(cur, RW_SEEK_CUR)
+                return length
+        except Exception:
+            #print(e)
+            return -1
+    rwops.size = _sdlsize(_rwsize)
+
+    def _rwseek(context, offset, whence):
+        try:
+            retval = obj.seek(offset, whence)
+            if retval is None:
+                retval = obj.tell()
+            return retval
+        except Exception:
+            #print(e)
+            return -1
+    rwops.seek = _sdlseek(_rwseek)
+
+    def _rwread(context, ptr, size, maxnum):
+        try:
+            data = obj.read(size * maxnum)
+            num = len(data)
+            memmove(ptr, data, num)
+            return num // size
+        except Exception:
+            #print(e)
+            return 0
+    rwops.read = _sdlread(_rwread)
+
+    def _rwclose(context):
+        try:
+            retval = obj.close()
+            if retval is None:
+                # No return value; we assume that everything is okay.
+                return 0
+            return retval
+        except Exception:
+            #print(e)
+            return -1
+    rwops.close = _sdlclose(_rwclose)
+
+    def _rwwrite(context, ptr, size, num):
+        try:
+            # string_at feels wrong, since we access a raw byte buffer...
+            retval = obj.write(string_at(ptr, size * num))
+            if retval is None:
+                # No return value; we assume that everything is okay.
+                return num
+            return retval
+        except Exception:
+            #print(e)
+            return 0
+
+    if hasattr(obj, "write") and callable(obj.write):
+        rwops.write = _sdlwrite(_rwwrite)
+    else:
+        rwops.write = _sdlwrite()
+    return rwops
diff --git a/src/m64py/SDL2/scancode.py b/src/m64py/SDL2/scancode.py
new file mode 100644
index 0000000..5ccc23d
--- /dev/null
+++ b/src/m64py/SDL2/scancode.py
@@ -0,0 +1,267 @@
+from ctypes import c_int
+
+SDL_Scancode = c_int
+
+SDL_SCANCODE_UNKNOWN = 0
+SDL_SCANCODE_A = 4
+SDL_SCANCODE_B = 5
+SDL_SCANCODE_C = 6
+SDL_SCANCODE_D = 7
+SDL_SCANCODE_E = 8
+SDL_SCANCODE_F = 9
+SDL_SCANCODE_G = 10
+SDL_SCANCODE_H = 11
+SDL_SCANCODE_I = 12
+SDL_SCANCODE_J = 13
+SDL_SCANCODE_K = 14
+SDL_SCANCODE_L = 15
+SDL_SCANCODE_M = 16
+SDL_SCANCODE_N = 17
+SDL_SCANCODE_O = 18
+SDL_SCANCODE_P = 19
+SDL_SCANCODE_Q = 20
+SDL_SCANCODE_R = 21
+SDL_SCANCODE_S = 22
+SDL_SCANCODE_T = 23
+SDL_SCANCODE_U = 24
+SDL_SCANCODE_V = 25
+SDL_SCANCODE_W = 26
+SDL_SCANCODE_X = 27
+SDL_SCANCODE_Y = 28
+SDL_SCANCODE_Z = 29
+
+SDL_SCANCODE_1 = 30
+SDL_SCANCODE_2 = 31
+SDL_SCANCODE_3 = 32
+SDL_SCANCODE_4 = 33
+SDL_SCANCODE_5 = 34
+SDL_SCANCODE_6 = 35
+SDL_SCANCODE_7 = 36
+SDL_SCANCODE_8 = 37
+SDL_SCANCODE_9 = 38
+SDL_SCANCODE_0 = 39
+
+SDL_SCANCODE_RETURN = 40
+SDL_SCANCODE_ESCAPE = 41
+SDL_SCANCODE_BACKSPACE = 42
+SDL_SCANCODE_TAB = 43
+SDL_SCANCODE_SPACE = 44
+
+SDL_SCANCODE_MINUS = 45
+SDL_SCANCODE_EQUALS = 46
+SDL_SCANCODE_LEFTBRACKET = 47
+SDL_SCANCODE_RIGHTBRACKET = 48
+SDL_SCANCODE_BACKSLASH = 49
+
+SDL_SCANCODE_NONUSHASH = 50
+
+SDL_SCANCODE_SEMICOLON = 51
+SDL_SCANCODE_APOSTROPHE = 52
+SDL_SCANCODE_GRAVE = 53
+
+SDL_SCANCODE_COMMA = 54
+SDL_SCANCODE_PERIOD = 55
+SDL_SCANCODE_SLASH = 56
+
+SDL_SCANCODE_CAPSLOCK = 57
+
+SDL_SCANCODE_F1 = 58
+SDL_SCANCODE_F2 = 59
+SDL_SCANCODE_F3 = 60
+SDL_SCANCODE_F4 = 61
+SDL_SCANCODE_F5 = 62
+SDL_SCANCODE_F6 = 63
+SDL_SCANCODE_F7 = 64
+SDL_SCANCODE_F8 = 65
+SDL_SCANCODE_F9 = 66
+SDL_SCANCODE_F10 = 67
+SDL_SCANCODE_F11 = 68
+SDL_SCANCODE_F12 = 69
+
+SDL_SCANCODE_PRINTSCREEN = 70
+SDL_SCANCODE_SCROLLLOCK = 71
+SDL_SCANCODE_PAUSE = 72
+SDL_SCANCODE_INSERT = 73
+
+SDL_SCANCODE_HOME = 74
+SDL_SCANCODE_PAGEUP = 75
+SDL_SCANCODE_DELETE = 76
+SDL_SCANCODE_END = 77
+SDL_SCANCODE_PAGEDOWN = 78
+SDL_SCANCODE_RIGHT = 79
+SDL_SCANCODE_LEFT = 80
+SDL_SCANCODE_DOWN = 81
+SDL_SCANCODE_UP = 82
+
+SDL_SCANCODE_NUMLOCKCLEAR = 83
+SDL_SCANCODE_KP_DIVIDE = 84
+SDL_SCANCODE_KP_MULTIPLY = 85
+SDL_SCANCODE_KP_MINUS = 86
+SDL_SCANCODE_KP_PLUS = 87
+SDL_SCANCODE_KP_ENTER = 88
+SDL_SCANCODE_KP_1 = 89
+SDL_SCANCODE_KP_2 = 90
+SDL_SCANCODE_KP_3 = 91
+SDL_SCANCODE_KP_4 = 92
+SDL_SCANCODE_KP_5 = 93
+SDL_SCANCODE_KP_6 = 94
+SDL_SCANCODE_KP_7 = 95
+SDL_SCANCODE_KP_8 = 96
+SDL_SCANCODE_KP_9 = 97
+SDL_SCANCODE_KP_0 = 98
+SDL_SCANCODE_KP_PERIOD = 99
+
+SDL_SCANCODE_NONUSBACKSLASH = 100
+
+SDL_SCANCODE_APPLICATION = 101
+SDL_SCANCODE_POWER = 102
+
+SDL_SCANCODE_KP_EQUALS = 103
+
+SDL_SCANCODE_F13 = 104
+SDL_SCANCODE_F14 = 105
+SDL_SCANCODE_F15 = 106
+SDL_SCANCODE_F16 = 107
+SDL_SCANCODE_F17 = 108
+SDL_SCANCODE_F18 = 109
+SDL_SCANCODE_F19 = 110
+SDL_SCANCODE_F20 = 111
+SDL_SCANCODE_F21 = 112
+SDL_SCANCODE_F22 = 113
+SDL_SCANCODE_F23 = 114
+SDL_SCANCODE_F24 = 115
+SDL_SCANCODE_EXECUTE = 116
+SDL_SCANCODE_HELP = 117
+SDL_SCANCODE_MENU = 118
+SDL_SCANCODE_SELECT = 119
+SDL_SCANCODE_STOP = 120
+SDL_SCANCODE_AGAIN = 121
+SDL_SCANCODE_UNDO = 122
+SDL_SCANCODE_CUT = 123
+SDL_SCANCODE_COPY = 124
+SDL_SCANCODE_PASTE = 125
+SDL_SCANCODE_FIND = 126
+SDL_SCANCODE_MUTE = 127
+SDL_SCANCODE_VOLUMEUP = 128
+SDL_SCANCODE_VOLUMEDOWN = 129
+SDL_SCANCODE_KP_COMMA = 133
+SDL_SCANCODE_KP_EQUALSAS400 = 134
+
+SDL_SCANCODE_INTERNATIONAL1 = 135
+SDL_SCANCODE_INTERNATIONAL2 = 136
+SDL_SCANCODE_INTERNATIONAL3 = 137
+SDL_SCANCODE_INTERNATIONAL4 = 138
+SDL_SCANCODE_INTERNATIONAL5 = 139
+SDL_SCANCODE_INTERNATIONAL6 = 140
+SDL_SCANCODE_INTERNATIONAL7 = 141
+SDL_SCANCODE_INTERNATIONAL8 = 142
+SDL_SCANCODE_INTERNATIONAL9 = 143
+
+SDL_SCANCODE_LANG1 = 144
+SDL_SCANCODE_LANG2 = 145
+SDL_SCANCODE_LANG3 = 146
+SDL_SCANCODE_LANG4 = 147
+SDL_SCANCODE_LANG5 = 148
+SDL_SCANCODE_LANG6 = 149
+SDL_SCANCODE_LANG7 = 150
+SDL_SCANCODE_LANG8 = 151
+SDL_SCANCODE_LANG9 = 152
+
+SDL_SCANCODE_ALTERASE = 153
+SDL_SCANCODE_SYSREQ = 154
+SDL_SCANCODE_CANCEL = 155
+SDL_SCANCODE_CLEAR = 156
+SDL_SCANCODE_PRIOR = 157
+SDL_SCANCODE_RETURN2 = 158
+SDL_SCANCODE_SEPARATOR = 159
+SDL_SCANCODE_OUT = 160
+SDL_SCANCODE_OPER = 161
+SDL_SCANCODE_CLEARAGAIN = 162
+SDL_SCANCODE_CRSEL = 163
+SDL_SCANCODE_EXSEL = 164
+
+SDL_SCANCODE_KP_00 = 176
+SDL_SCANCODE_KP_000 = 177
+SDL_SCANCODE_THOUSANDSSEPARATOR = 178
+SDL_SCANCODE_DECIMALSEPARATOR = 179
+SDL_SCANCODE_CURRENCYUNIT = 180
+SDL_SCANCODE_CURRENCYSUBUNIT = 181
+SDL_SCANCODE_KP_LEFTPAREN = 182
+SDL_SCANCODE_KP_RIGHTPAREN = 183
+SDL_SCANCODE_KP_LEFTBRACE = 184
+SDL_SCANCODE_KP_RIGHTBRACE = 185
+SDL_SCANCODE_KP_TAB = 186
+SDL_SCANCODE_KP_BACKSPACE = 187
+SDL_SCANCODE_KP_A = 188
+SDL_SCANCODE_KP_B = 189
+SDL_SCANCODE_KP_C = 190
+SDL_SCANCODE_KP_D = 191
+SDL_SCANCODE_KP_E = 192
+SDL_SCANCODE_KP_F = 193
+SDL_SCANCODE_KP_XOR = 194
+SDL_SCANCODE_KP_POWER = 195
+SDL_SCANCODE_KP_PERCENT = 196
+SDL_SCANCODE_KP_LESS = 197
+SDL_SCANCODE_KP_GREATER = 198
+SDL_SCANCODE_KP_AMPERSAND = 199
+SDL_SCANCODE_KP_DBLAMPERSAND = 200
+SDL_SCANCODE_KP_VERTICALBAR = 201
+SDL_SCANCODE_KP_DBLVERTICALBAR = 202
+SDL_SCANCODE_KP_COLON = 203
+SDL_SCANCODE_KP_HASH = 204
+SDL_SCANCODE_KP_SPACE = 205
+SDL_SCANCODE_KP_AT = 206
+SDL_SCANCODE_KP_EXCLAM = 207
+SDL_SCANCODE_KP_MEMSTORE = 208
+SDL_SCANCODE_KP_MEMRECALL = 209
+SDL_SCANCODE_KP_MEMCLEAR = 210
+SDL_SCANCODE_KP_MEMADD = 211
+SDL_SCANCODE_KP_MEMSUBTRACT = 212
+SDL_SCANCODE_KP_MEMMULTIPLY = 213
+SDL_SCANCODE_KP_MEMDIVIDE = 214
+SDL_SCANCODE_KP_PLUSMINUS = 215
+SDL_SCANCODE_KP_CLEAR = 216
+SDL_SCANCODE_KP_CLEARENTRY = 217
+SDL_SCANCODE_KP_BINARY = 218
+SDL_SCANCODE_KP_OCTAL = 219
+SDL_SCANCODE_KP_DECIMAL = 220
+SDL_SCANCODE_KP_HEXADECIMAL = 221
+
+SDL_SCANCODE_LCTRL = 224
+SDL_SCANCODE_LSHIFT = 225
+SDL_SCANCODE_LALT = 226
+SDL_SCANCODE_LGUI = 227
+SDL_SCANCODE_RCTRL = 228
+SDL_SCANCODE_RSHIFT = 229
+SDL_SCANCODE_RALT = 230
+SDL_SCANCODE_RGUI = 231
+
+SDL_SCANCODE_MODE = 257
+
+SDL_SCANCODE_AUDIONEXT = 258
+SDL_SCANCODE_AUDIOPREV = 259
+SDL_SCANCODE_AUDIOSTOP = 260
+SDL_SCANCODE_AUDIOPLAY = 261
+SDL_SCANCODE_AUDIOMUTE = 262
+SDL_SCANCODE_MEDIASELECT = 263
+SDL_SCANCODE_WWW = 264
+SDL_SCANCODE_MAIL = 265
+SDL_SCANCODE_CALCULATOR = 266
+SDL_SCANCODE_COMPUTER = 267
+SDL_SCANCODE_AC_SEARCH = 268
+SDL_SCANCODE_AC_HOME = 269
+SDL_SCANCODE_AC_BACK = 270
+SDL_SCANCODE_AC_FORWARD = 271
+SDL_SCANCODE_AC_STOP = 272
+SDL_SCANCODE_AC_REFRESH = 273
+SDL_SCANCODE_AC_BOOKMARKS = 274
+SDL_SCANCODE_BRIGHTNESSDOWN = 275
+SDL_SCANCODE_BRIGHTNESSUP = 276
+SDL_SCANCODE_DISPLAYSWITCH = 277
+SDL_SCANCODE_KBDILLUMTOGGLE = 278
+SDL_SCANCODE_KBDILLUMDOWN = 279
+SDL_SCANCODE_KBDILLUMUP = 280
+SDL_SCANCODE_EJECT = 281
+SDL_SCANCODE_SLEEP = 282
+
+SDL_NUM_SCANCODES = 512
diff --git a/src/m64py/SDL2/sdlgfx.py b/src/m64py/SDL2/sdlgfx.py
new file mode 100644
index 0000000..fe0c1a2
--- /dev/null
+++ b/src/m64py/SDL2/sdlgfx.py
@@ -0,0 +1,142 @@
+import os
+from ctypes import Structure, POINTER, c_int, c_float, c_void_p, c_char, \
+    c_char_p, c_double
+from .dll import _DLL
+from .stdinc import Uint8, Uint32, Sint16
+from .render import SDL_Renderer
+from .surface import SDL_Surface
+
+__all__ = ["get_dll_file", "FPS_UPPER_LIMIT", "FPS_LOWER_LIMIT", "FPS_DEFAULT",
+           "FPSManager", "SDL_initFramerate", "SDL_getFramerate",
+           "SDL_setFramerate", "SDL_getFramecount", "SDL_framerateDelay",
+           "SDL2_GFXPRIMITIVES_MAJOR", "SDL2_GFXPRIMITIVES_MAJOR",
+           "SDL2_GFXPRIMITIVES_MICRO", "pixelColor", "pixelRGBA", "hlineColor",
+           "hlineRGBA", "vlineColor", "vlineRGBA", "rectangleColor",
+           "rectangleRGBA", "roundedRectangleColor", "roundedRectangleRGBA",
+           "boxColor", "boxRGBA", "roundedBoxColor", "roundedBoxRGBA",
+           "lineColor", "lineRGBA", "aalineColor", "aalineRGBA",
+           "thickLineColor", "thickLineRGBA", "circleColor", "circleRGBA",
+           "arcColor", "arcRGBA", "aacircleColor", "aacircleRGBA",
+           "filledCircleColor", "filledCircleRGBA", "ellipseColor",
+           "ellipseRGBA", "aaellipseColor", "aaellipseRGBA",
+           "filledEllipseColor", "filledEllipseRGBA", "pieColor", "pieRGBA",
+           "filledPieColor", "filledPieRGBA", "trigonColor", "trigonRGBA",
+           "aatrigonColor", "aatrigonRGBA", "filledTrigonColor",
+           "filledTrigonRGBA", "polygonColor", "polygonRGBA", "aapolygonColor",
+           "aapolygonRGBA", "filledPolygonColor", "filledPolygonRGBA",
+           "texturedPolygon", "bezierColor", "bezierRGBA",
+           "gfxPrimitivesSetFont", "gfxPrimitivesSetFontRotation",
+           "characterColor", "characterRGBA", "stringColor", "stringRGBA",
+           "SMOOTHING_OFF", "SMOOTHING_ON", "rotozoomSurface",
+           "rotozoomSurfaceXY", "rotozoomSurfaceSize", "rotozoomSurfaceSizeXY",
+           "zoomSurface", "zoomSurfaceSize", "shrinkSurface",
+           "rotateSurface90Degrees"
+           ]
+
+try:
+    dll = _DLL("SDL2_gfx", ["SDL2_gfx", "SDL2_gfx-1.0"],
+               os.getenv("PYSDL2_DLL_PATH"))
+except RuntimeError as exc:
+    raise ImportError(exc)
+
+
+def get_dll_file():
+    """Gets the file name of the loaded SDL2_gfx library."""
+    return dll.libfile
+
+_bind = dll.bind_function
+
+
+FPS_UPPER_LIMIT = 200
+FPS_LOWER_LIMIT = 1
+FPS_DEFAULT = 30
+
+
+class FPSManager(Structure):
+    _fields_ = [("framecount", Uint32),
+                ("rateticks", c_float),
+                ("baseticks", Uint32),
+                ("lastticks", Uint32),
+                ("rate", Uint32)
+                ]
+
+SDL_initFramerate = _bind("SDL_initFramerate", [POINTER(FPSManager)])
+SDL_setFramerate = _bind("SDL_setFramerate", [POINTER(FPSManager), Uint32], c_int)
+SDL_getFramerate = _bind("SDL_getFramerate", [POINTER(FPSManager)], c_int)
+SDL_getFramecount = _bind("SDL_getFramecount", [POINTER(FPSManager)], Uint32)
+SDL_framerateDelay = _bind("SDL_framerateDelay", [POINTER(FPSManager)], Uint32)
+
+SDL2_GFXPRIMITIVES_MAJOR = 1
+SDL2_GFXPRIMITIVES_MINOR = 0
+SDL2_GFXPRIMITIVES_MICRO = 0
+
+pixelColor = _bind("pixelColor", [POINTER(SDL_Renderer), Sint16, Sint16, Uint32], c_int)
+pixelRGBA = _bind("pixelRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+hlineColor = _bind("hlineColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint32], c_int)
+hlineRGBA = _bind("hlineRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+vlineColor = _bind("vlineColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint32], c_int)
+vlineRGBA = _bind("vlineRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+rectangleColor = _bind("rectangleColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+rectangleRGBA = _bind("rectangleRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+roundedRectangleColor = _bind("roundedRectangleColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+roundedRectangleRGBA = _bind("roundedRectangleRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+boxColor = _bind("boxColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+boxRGBA = _bind("boxRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+roundedBoxColor = _bind("roundedBoxColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+roundedBoxRGBA = _bind("roundedBoxRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+lineColor = _bind("lineColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+lineRGBA = _bind("lineRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+aalineColor = _bind("aalineColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+aalineRGBA = _bind("aalineRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+thickLineColor = _bind("thickLineColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint32], c_int)
+thickLineRGBA = _bind("thickLineRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8, Uint8], c_int)
+circleColor = _bind("circleColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint32], c_int)
+circleRGBA = _bind("circleRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+arcColor = _bind("arcColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+arcRGBA = _bind("arcRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+aacircleColor = _bind("aacircleColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint32], c_int)
+aacircleRGBA = _bind("aacircleRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+filledCircleColor = _bind("filledCircleColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint32], c_int)
+filledCircleRGBA = _bind("filledCircleRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+ellipseColor = _bind("ellipseColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+ellipseRGBA = _bind("ellipseRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+aaellipseColor = _bind("aaellipseColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+aaellipseRGBA = _bind("aaellipseRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+filledEllipseColor = _bind("filledEllipseColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+filledEllipseRGBA = _bind("filledEllipseRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+pieColor = _bind("pieColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+pieRGBA = _bind("pieRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+filledPieColor = _bind("filledPieColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+filledPieRGBA = _bind("filledPieRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+trigonColor = _bind("trigonColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+trigonRGBA = _bind("trigonRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+aatrigonColor = _bind("aatrigonColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+aatrigonRGBA = _bind("aatrigonRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+filledTrigonColor = _bind("filledTrigonColor", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Sint16, Uint32], c_int)
+filledTrigonRGBA = _bind("filledTrigonRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, Sint16, Sint16, Sint16, Sint16, Uint8, Uint8, Uint8, Uint8], c_int)
+polygonColor = _bind("polygonColor", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, Uint32], c_int)
+polygonRGBA = _bind("polygonRGBA", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, Uint8, Uint8, Uint8, Uint8], c_int) 
+aapolygonColor = _bind("aapolygonColor", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, Uint32], c_int)
+aapolygonRGBA = _bind("aapolygonRGBA", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, Uint8, Uint8, Uint8, Uint8], c_int) 
+filledPolygonColor = _bind("filledPolygonColor", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, Uint32], c_int)
+filledPolygonRGBA = _bind("filledPolygonRGBA", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, Uint8, Uint8, Uint8, Uint8], c_int) 
+texturedPolygon = _bind("texturedPolygon", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, POINTER(SDL_Surface), c_int, c_int], c_int)
+bezierColor = _bind("bezierColor", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, c_int, Uint32], c_int)
+bezierRGBA = _bind("bezierRGBA", [POINTER(SDL_Renderer), POINTER(Sint16), POINTER(Sint16), c_int, c_int, Uint8, Uint8, Uint8, Uint8], c_int)
+gfxPrimitivesSetFont = _bind("gfxPrimitivesSetFont", [c_void_p, Uint32, Uint32])
+gfxPrimitivesSetFontRotation = _bind("gfxPrimitivesSetFontRotation", [Uint32])
+characterColor = _bind("characterColor", [POINTER(SDL_Renderer), Sint16, Sint16, c_char, Uint32], c_int)
+characterRGBA = _bind("characterRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, c_char, Uint8, Uint8, Uint8, Uint8], c_int)
+stringColor = _bind("stringColor", [POINTER(SDL_Renderer), Sint16, Sint16, c_char_p, Uint32], c_int)
+stringRGBA = _bind("stringRGBA", [POINTER(SDL_Renderer), Sint16, Sint16, c_char_p, Uint8, Uint8, Uint8, Uint8], c_int)
+
+SMOOTHING_OFF = 0
+SMOOTHING_ON = 1
+rotozoomSurface = _bind("rotozoomSurface", [POINTER(SDL_Surface), c_double, c_double, c_int], POINTER(SDL_Surface))
+rotozoomSurfaceXY = _bind("rotozoomSurfaceXY", [POINTER(SDL_Surface), c_double, c_double, c_double, c_int], POINTER(SDL_Surface))
+rotozoomSurfaceSize = _bind("rotozoomSurfaceSize", [c_int, c_int, c_double, c_double, POINTER(c_int), POINTER(c_int)])
+rotozoomSurfaceSizeXY = _bind("rotozoomSurfaceSizeXY", [c_int, c_int, c_double, c_double, c_double, POINTER(c_int), POINTER(c_int)])
+zoomSurface = _bind("zoomSurface", [POINTER(SDL_Surface), c_double, c_double, c_int], POINTER(SDL_Surface))
+zoomSurfaceSize = _bind("zoomSurfaceSize", [c_int, c_int, c_double, c_double, POINTER(c_int), POINTER(c_int)])
+shrinkSurface = _bind("shrinkSurface", [POINTER(SDL_Surface), c_int, c_int], POINTER(SDL_Surface))
+rotateSurface90Degrees = _bind("rotateSurface90Degrees", [POINTER(SDL_Surface), c_int], POINTER(SDL_Surface))
diff --git a/src/m64py/SDL2/sdlimage.py b/src/m64py/SDL2/sdlimage.py
new file mode 100644
index 0000000..8593384
--- /dev/null
+++ b/src/m64py/SDL2/sdlimage.py
@@ -0,0 +1,105 @@
+import os
+from ctypes import POINTER, c_int, c_char_p
+from .dll import _DLL
+from .version import SDL_version
+from .surface import SDL_Surface
+from .rwops import SDL_RWops
+from .render import SDL_Texture, SDL_Renderer
+from .error import SDL_SetError, SDL_GetError
+
+__all__ = ["SDL_IMAGE_MAJOR_VERSION", "SDL_IMAGE_MINOR_VERSION", \
+           "SDL_IMAGE_PATCHLEVEL", "SDL_IMAGE_VERSION", "IMG_Linked_Version",
+           "IMG_InitFlags", "IMG_INIT_JPG", "IMG_INIT_PNG", "IMG_INIT_TIF",
+           "IMG_INIT_WEBP", "IMG_Init", "IMG_Quit", "IMG_LoadTyped_RW",
+           "IMG_Load", "IMG_Load_RW", "IMG_LoadTexture", "IMG_LoadTexture_RW",
+           "IMG_LoadTextureTyped_RW", "IMG_isICO", "IMG_isCUR", "IMG_isBMP",
+           "IMG_isGIF", "IMG_isJPG", "IMG_isLBM", "IMG_isPNG", "IMG_isPNM",
+           "IMG_isPCX", "IMG_isTIF", "IMG_isXCF", "IMG_isXV", "IMG_isWEBP",
+           "IMG_LoadBMP_RW", "IMG_LoadCUR_RW", "IMG_LoadCUR_RW",
+           "IMG_LoadGIF_RW", "IMG_LoadICO_RW", "IMG_LoadJPG_RW",
+           "IMG_LoadLBM_RW", "IMG_LoadPCX_RW", "IMG_LoadPNM_RW",
+           "IMG_LoadPNG_RW", "IMG_LoadTGA_RW", "IMG_LoadTIF_RW",
+           "IMG_LoadXCF_RW", "IMG_LoadWEBP_RW", "IMG_LoadXPM_RW",
+           "IMG_LoadXV_RW", "IMG_ReadXPMFromArray",
+           "IMG_GetError", "IMG_SetError",
+           "get_dll_file"
+           ]
+
+try:
+    dll = _DLL("SDL2_image", ["SDL2_image", "SDL2_image-2.0"],
+               os.getenv("PYSDL2_DLL_PATH"))
+except RuntimeError as exc:
+    raise ImportError(exc)
+
+
+def get_dll_file():
+    """Gets the file name of the loaded SDL2_image library."""
+    return dll.libfile
+
+_bind = dll.bind_function
+
+SDL_IMAGE_MAJOR_VERSION = 2
+SDL_IMAGE_MINOR_VERSION = 0
+SDL_IMAGE_PATCHLEVEL = 0
+
+
+def SDL_IMAGE_VERSION(x):
+    x.major = SDL_IMAGE_MAJOR_VERSION
+    x.minor = SDL_IMAGE_MINOR_VERSION
+    x.patch = SDL_IMAGE_PATCHLEVEL
+
+IMG_Linked_Version = _bind("IMG_Linked_Version", None, POINTER(SDL_version))
+
+IMG_InitFlags = c_int
+IMG_INIT_JPG = 0x00000001
+IMG_INIT_PNG = 0x00000002
+IMG_INIT_TIF = 0x00000004
+IMG_INIT_WEBP = 0x00000008
+
+IMG_Init = _bind("IMG_Init", [c_int], c_int)
+IMG_Quit = _bind("IMG_Quit")
+IMG_LoadTyped_RW = _bind("IMG_LoadTyped_RW", [POINTER(SDL_RWops), c_int, c_char_p], POINTER(SDL_Surface))
+IMG_Load = _bind("IMG_Load", [c_char_p], POINTER(SDL_Surface))
+IMG_Load_RW = _bind("IMG_Load_RW", [POINTER(SDL_RWops), c_int], POINTER(SDL_Surface))
+IMG_LoadTexture = _bind("IMG_LoadTexture", [POINTER(SDL_Renderer), c_char_p], POINTER(SDL_Texture))
+IMG_LoadTexture_RW = _bind("IMG_LoadTexture_RW", [POINTER(SDL_Renderer), POINTER(SDL_RWops), c_int], POINTER(SDL_Texture))
+IMG_LoadTextureTyped_RW = _bind("IMG_LoadTextureTyped_RW", [POINTER(SDL_Renderer), POINTER(SDL_RWops), c_int, c_char_p], POINTER(SDL_Texture))
+
+IMG_isICO = _bind("IMG_isICO", [POINTER(SDL_RWops)], c_int)
+IMG_isCUR = _bind("IMG_isCUR", [POINTER(SDL_RWops)], c_int)
+IMG_isBMP = _bind("IMG_isBMP", [POINTER(SDL_RWops)], c_int)
+IMG_isGIF = _bind("IMG_isGIF", [POINTER(SDL_RWops)], c_int)
+IMG_isJPG = _bind("IMG_isJPG", [POINTER(SDL_RWops)], c_int)
+IMG_isLBM = _bind("IMG_isLBM", [POINTER(SDL_RWops)], c_int)
+IMG_isPCX = _bind("IMG_isPCX", [POINTER(SDL_RWops)], c_int)
+IMG_isPNG = _bind("IMG_isPNG", [POINTER(SDL_RWops)], c_int)
+IMG_isPNM = _bind("IMG_isPNM", [POINTER(SDL_RWops)], c_int)
+IMG_isTIF = _bind("IMG_isTIF", [POINTER(SDL_RWops)], c_int)
+IMG_isXCF = _bind("IMG_isXCF", [POINTER(SDL_RWops)], c_int)
+IMG_isXPM = _bind("IMG_isXPM", [POINTER(SDL_RWops)], c_int)
+IMG_isXV = _bind("IMG_isXV", [POINTER(SDL_RWops)], c_int)
+IMG_isWEBP = _bind("IMG_isWEBP", [POINTER(SDL_RWops)], c_int)
+
+IMG_LoadICO_RW = _bind("IMG_LoadICO_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadCUR_RW = _bind("IMG_LoadCUR_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadBMP_RW = _bind("IMG_LoadBMP_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadGIF_RW = _bind("IMG_LoadGIF_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadJPG_RW = _bind("IMG_LoadJPG_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadLBM_RW = _bind("IMG_LoadLBM_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadPCX_RW = _bind("IMG_LoadPCX_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadPNG_RW = _bind("IMG_LoadPNG_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadPNM_RW = _bind("IMG_LoadPNM_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadTGA_RW = _bind("IMG_LoadTGA_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadTIF_RW = _bind("IMG_LoadTIF_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadXCF_RW = _bind("IMG_LoadXCF_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadXPM_RW = _bind("IMG_LoadXPM_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadXV_RW = _bind("IMG_LoadXV_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+IMG_LoadWEBP_RW = _bind("IMG_LoadWEBP_RW", [POINTER(SDL_RWops)], POINTER(SDL_Surface))
+
+IMG_ReadXPMFromArray = _bind("IMG_ReadXPMFromArray", [POINTER(c_char_p)], POINTER(SDL_Surface))
+
+IMG_SavePNG = _bind("IMG_SavePNG", [POINTER(SDL_Surface), c_char_p], c_int)
+IMG_SavePNG_RW = _bind("IMG_SavePNG_RW", [POINTER(SDL_Surface), POINTER(SDL_RWops), c_int], c_int)
+
+IMG_SetError = SDL_SetError
+IMG_GetError = SDL_GetError
diff --git a/src/m64py/SDL2/sdlmixer.py b/src/m64py/SDL2/sdlmixer.py
new file mode 100644
index 0000000..13bca25
--- /dev/null
+++ b/src/m64py/SDL2/sdlmixer.py
@@ -0,0 +1,207 @@
+import os
+from ctypes import Structure, POINTER, CFUNCTYPE, c_int, c_char_p, c_void_p, \
+    c_double
+from .dll import _DLL
+from .version import SDL_version
+from .audio import AUDIO_S16LSB, AUDIO_S16MSB
+from .stdinc import Uint8, Uint16, Uint32, Sint16
+from .endian import SDL_LIL_ENDIAN, SDL_BYTEORDER
+from .rwops import SDL_RWops, SDL_RWFromFile
+from .error import SDL_SetError, SDL_GetError
+
+__all__ = ["get_dll_file", "SDL_MIXER_MAJOR_VERSION", "SDL_MIXER_MINOR_VERSION",
+           "SDL_MIXER_PATCHLEVEL", "SDL_MIXER_VERSION", "MIX_MAJOR_VERSION",
+           "MIX_MINOR_VERSION", "MIX_PATCHLEVEL", "MIX_VERSION",
+           "Mix_Linked_Version", "MIX_InitFlags", "MIX_INIT_FLAC",
+           "MIX_INIT_MOD", "MIX_INIT_MP3", "MIX_INIT_OGG",
+           "MIX_INIT_FLUIDSYNTH", "Mix_Init", "Mix_Quit", "MIX_CHANNELS",
+           "MIX_DEFAULT_FREQUENCY" , "MIX_DEFAULT_FORMAT",
+           "MIX_DEFAULT_CHANNELS", "MIX_MAX_VOLUME", "Mix_Chunk", "Mix_Fading",
+           "MIX_NO_FADING", "MIX_FADING_OUT", "MIX_FADING_IN", "Mix_MusicType",
+           "MUS_NONE", "MUS_CMD", "MUS_WAV", "MUS_MOD", "MUS_MID", "MUS_OGG",
+           "MUS_MP3", "MUS_MP3_MAD", "MUS_FLAC", "MUS_MODPLUG", "Mix_Music",
+           "Mix_OpenAudio", "Mix_AllocateChannels", "Mix_QuerySpec",
+           "Mix_LoadWAV_RW", "Mix_LoadWAV", "Mix_LoadMUS", "Mix_LoadMUS_RW",
+           "Mix_LoadMUSType_RW", "Mix_QuickLoad_WAV", "Mix_QuickLoad_RAW",
+           "Mix_FreeChunk", "Mix_FreeMusic", "Mix_GetNumChunkDecoders",
+           "Mix_GetChunkDecoder", "Mix_GetNumMusicDecoders",
+           "Mix_GetMusicDecoder", "Mix_GetMusicType", "mix_func",
+           "Mix_SetPostMix", "Mix_HookMusic", "music_finished",
+           "Mix_HookMusicFinished", "Mix_GetMusicHookData", "channel_finished",
+           "Mix_ChannelFinished", "MIX_CHANNEL_POST", "Mix_EffectFunc_t",
+           "Mix_EffectDone_t", "Mix_RegisterEffect", "Mix_UnregisterEffect",
+           "Mix_UnregisterAllEffects", "MIX_EFFECTSMAXSPEED", "Mix_SetPanning",
+           "Mix_SetPosition", "Mix_SetDistance", "Mix_SetReverseStereo",
+           "Mix_ReserveChannels", "Mix_GroupChannel", "Mix_GroupChannels",
+           "Mix_GroupAvailable", "Mix_GroupCount", "Mix_GroupOldest",
+           "Mix_GroupNewer", "Mix_PlayChannel", "Mix_PlayChannelTimed",
+           "Mix_PlayMusic", "Mix_FadeInMusic", "Mix_FadeInMusicPos",
+           "Mix_FadeInChannel", "Mix_FadeInChannelTimed", "Mix_Volume",
+           "Mix_VolumeChunk", "Mix_VolumeMusic", "Mix_HaltChannel",
+           "Mix_HaltGroup", "Mix_HaltMusic", "Mix_ExpireChannel",
+           "Mix_FadeOutChannel", "Mix_FadeOutGroup", "Mix_FadeOutMusic",
+           "Mix_FadingMusic", "Mix_FadingChannel", "Mix_Pause", "Mix_Resume",
+           "Mix_Paused", "Mix_PauseMusic", "Mix_ResumeMusic", "Mix_RewindMusic",
+           "Mix_PausedMusic", "Mix_SetMusicPosition", "Mix_Playing",
+           "Mix_PlayingMusic", "Mix_SetMusicCMD", "Mix_SetSynchroValue",
+           "Mix_GetSynchroValue", "Mix_SetSoundFonts", "Mix_GetSoundFonts",
+           "soundfont_function", "Mix_EachSoundFont", "Mix_GetChunk",
+           "Mix_CloseAudio", "Mix_SetError", "Mix_GetError"
+          ]
+
+try:
+    dll = _DLL("SDL2_mixer", ["SDL2_mixer", "SDL2_mixer-2.0"],
+               os.getenv("PYSDL2_DLL_PATH"))
+except RuntimeError as exc:
+    raise ImportError(exc)
+
+
+def get_dll_file():
+    """Gets the file name of the loaded SDL2_mixer library."""
+    return dll.libfile
+
+_bind = dll.bind_function
+
+SDL_MIXER_MAJOR_VERSION = 2
+SDL_MIXER_MINOR_VERSION = 0
+SDL_MIXER_PATCHLEVEL = 0
+
+
+def SDL_MIXER_VERSION(x):
+    x.major = SDL_TTF_MAJOR_VERSION
+    x.minor = SDL_TTF_MINOR_VERSION
+    x.patch = SDL_TTF_PATCHLEVEL
+
+MIX_MAJOR_VERSION = SDL_MIXER_MAJOR_VERSION
+MIX_MINOR_VERSION = SDL_MIXER_MINOR_VERSION
+MIX_PATCHLEVEL = SDL_MIXER_PATCHLEVEL
+MIX_VERSION = SDL_MIXER_VERSION
+
+Mix_Linked_Version = _bind("Mix_Linked_Version", None, POINTER(SDL_version))
+MIX_InitFlags = c_int
+MIX_INIT_FLAC = 0x00000001
+MIX_INIT_MOD = 0x00000002
+MIX_INIT_MP3 = 0x00000004
+MIX_INIT_OGG = 0x00000008
+MIX_INIT_FLUIDSYNTH = 0x00000010
+
+Mix_Init = _bind("Mix_Init", [c_int], c_int)
+Mix_Quit = _bind("Mix_Quit")
+
+MIX_CHANNELS = 8
+MIX_DEFAULT_FREQUENCY = 22050
+if SDL_BYTEORDER == SDL_LIL_ENDIAN:
+    MIX_DEFAULT_FORMAT = AUDIO_S16LSB
+else:
+    MIX_DEFAULT_FORMAT = AUDIO_S16MSB
+MIX_DEFAULT_CHANNELS = 2
+MIX_MAX_VOLUME = 128
+
+class Mix_Chunk(Structure):
+    _fields_ = [("allocated", c_int),
+                ("abuf", POINTER(Uint8)),
+                ("alen", Uint32),
+                ("volume", Uint8)]
+
+Mix_Fading = c_int
+MIX_NO_FADING = 0
+MIX_FADING_OUT = 1
+MIX_FADING_IN = 2
+Mix_MusicType = c_int
+MUS_NONE = 0
+MUS_CMD = 1
+MUS_WAV = 2
+MUS_MOD = 3
+MUS_MID = 4
+MUS_OGG = 5
+MUS_MP3 = 6
+MUS_MP3_MAD = 7
+MUS_FLAC = 8
+MUS_MODPLUG = 9
+
+class Mix_Music(Structure):
+    pass
+
+Mix_OpenAudio = _bind("Mix_OpenAudio", [c_int, Uint16, c_int, c_int], c_int)
+Mix_AllocateChannels = _bind("Mix_AllocateChannels", [c_int], c_int)
+Mix_QuerySpec = _bind("Mix_QuerySpec", [POINTER(c_int), POINTER(Uint16), POINTER(c_int)], c_int)
+Mix_LoadWAV_RW = _bind("Mix_LoadWAV_RW", [POINTER(SDL_RWops), c_int], POINTER(Mix_Chunk))
+Mix_LoadWAV = lambda fname: Mix_LoadWAV_RW(SDL_RWFromFile(fname, b"rb"), 1)
+Mix_LoadMUS = _bind("Mix_LoadMUS", [c_char_p], POINTER(Mix_Music))
+Mix_LoadMUS_RW = _bind("Mix_LoadMUS_RW", [POINTER(SDL_RWops)], POINTER(Mix_Music))
+Mix_LoadMUSType_RW = _bind("Mix_LoadMUSType_RW", [POINTER(SDL_RWops), Mix_MusicType, c_int], POINTER(Mix_Music))
+Mix_QuickLoad_WAV = _bind("Mix_QuickLoad_WAV", [POINTER(Uint8)], POINTER(Mix_Chunk))
+Mix_QuickLoad_RAW = _bind("Mix_QuickLoad_RAW", [POINTER(Uint8), Uint32], POINTER(Mix_Chunk))
+Mix_FreeChunk = _bind("Mix_FreeChunk", [POINTER(Mix_Chunk)])
+Mix_FreeMusic = _bind("Mix_FreeMusic", [POINTER(Mix_Music)])
+Mix_GetNumChunkDecoders = _bind("Mix_GetNumChunkDecoders", None, c_int)
+Mix_GetChunkDecoder = _bind("Mix_GetChunkDecoder", [c_int], c_char_p)
+Mix_GetNumMusicDecoders = _bind("Mix_GetNumMusicDecoders", None, c_int)
+Mix_GetMusicDecoder = _bind("Mix_GetMusicDecoder", [c_int], c_char_p)
+Mix_GetMusicType = _bind("Mix_GetMusicType", [POINTER(Mix_Music)], Mix_MusicType)
+mix_func = CFUNCTYPE(None, c_void_p, POINTER(Uint8), c_int)
+Mix_SetPostMix = _bind("Mix_SetPostMix", [mix_func, c_void_p])
+Mix_HookMusic = _bind("Mix_HookMusic", [mix_func, c_void_p])
+music_finished = CFUNCTYPE(None)
+Mix_HookMusicFinished = _bind("Mix_HookMusicFinished", [music_finished])
+Mix_GetMusicHookData = _bind("Mix_GetMusicHookData", None, c_void_p)
+channel_finished = CFUNCTYPE(None, c_int)
+Mix_ChannelFinished = _bind("Mix_ChannelFinished", [channel_finished])
+MIX_CHANNEL_POST = -2
+Mix_EffectFunc_t = CFUNCTYPE(None, c_int, c_void_p, c_int, c_void_p)
+Mix_EffectDone_t = CFUNCTYPE(None, c_int, c_void_p)
+Mix_RegisterEffect = _bind("Mix_RegisterEffect", [c_int, Mix_EffectFunc_t, Mix_EffectDone_t, c_void_p], c_int)
+Mix_UnregisterEffect = _bind("Mix_UnregisterEffect", [c_int, Mix_EffectFunc_t], c_int)
+Mix_UnregisterAllEffects = _bind("Mix_UnregisterAllEffects", [c_int])
+MIX_EFFECTSMAXSPEED = "MIX_EFFECTSMAXSPEED"
+Mix_SetPanning = _bind("Mix_SetPanning", [c_int, Uint8, Uint8], c_int)
+Mix_SetPosition = _bind("Mix_SetPosition", [c_int, Sint16, Uint8], c_int)
+Mix_SetDistance = _bind("Mix_SetDistance", [c_int, Uint8])
+Mix_SetReverseStereo = _bind("Mix_SetReverseStereo", [c_int, c_int], c_int)
+Mix_ReserveChannels = _bind("Mix_ReserveChannels", [c_int], c_int)
+Mix_GroupChannel = _bind("Mix_GroupChannel", [c_int, c_int], c_int)
+Mix_GroupChannels = _bind("Mix_GroupChannels", [c_int, c_int, c_int], c_int)
+Mix_GroupAvailable = _bind("Mix_GroupAvailable", [c_int], c_int)
+Mix_GroupCount = _bind("Mix_GroupCount", [c_int], c_int)
+Mix_GroupOldest = _bind("Mix_GroupOldest", [c_int], c_int)
+Mix_GroupNewer = _bind("Mix_GroupNewer", [c_int], c_int)
+Mix_PlayChannel = lambda channel, chunk, loops: Mix_PlayChannelTimed(channel, chunk, loops, -1)
+Mix_PlayChannelTimed = _bind("Mix_PlayChannelTimed", [c_int, POINTER(Mix_Chunk), c_int, c_int], c_int)
+Mix_PlayMusic = _bind("Mix_PlayMusic", [POINTER(Mix_Music), c_int], c_int)
+Mix_FadeInMusic = _bind("Mix_FadeInMusic", [POINTER(Mix_Music), c_int, c_int], c_int)
+Mix_FadeInMusicPos = _bind("Mix_FadeInMusicPos", [POINTER(Mix_Music), c_int, c_int, c_double], c_int)
+Mix_FadeInChannel = lambda channel, chunk, loops, ms: Mix_FadeInChannelTimed(channel, chunk, loops, ms, -1)
+Mix_FadeInChannelTimed = _bind("Mix_FadeInChannelTimed", [c_int, POINTER(Mix_Chunk), c_int, c_int, c_int], c_int)
+Mix_Volume = _bind("Mix_Volume", [c_int, c_int], c_int)
+Mix_VolumeChunk = _bind("Mix_VolumeChunk", [POINTER(Mix_Chunk), c_int], c_int)
+Mix_VolumeMusic = _bind("Mix_VolumeMusic", [c_int], c_int)
+Mix_HaltChannel = _bind("Mix_HaltChannel", [c_int], c_int)
+Mix_HaltGroup = _bind("Mix_HaltGroup", [c_int], c_int)
+Mix_HaltMusic = _bind("Mix_HaltMusic", None, c_int)
+Mix_ExpireChannel = _bind("Mix_ExpireChannel", [c_int, c_int], c_int)
+Mix_FadeOutChannel = _bind("Mix_FadeOutChannel", [c_int, c_int], c_int)
+Mix_FadeOutGroup = _bind("Mix_FadeOutGroup", [c_int, c_int], c_int)
+Mix_FadeOutMusic = _bind("Mix_FadeOutMusic", [c_int], c_int)
+Mix_FadingMusic = _bind("Mix_FadingMusic", None, Mix_Fading)
+Mix_FadingChannel = _bind("Mix_FadingChannel", [c_int], Mix_Fading)
+Mix_Pause = _bind("Mix_Pause", [c_int])
+Mix_Resume = _bind("Mix_Resume", [c_int])
+Mix_Paused = _bind("Mix_Paused", [c_int], c_int)
+Mix_PauseMusic = _bind("Mix_PauseMusic")
+Mix_ResumeMusic = _bind("Mix_ResumeMusic")
+Mix_RewindMusic = _bind("Mix_RewindMusic")
+Mix_PausedMusic = _bind("Mix_PauseMusic", None, c_int)
+Mix_SetMusicPosition = _bind("Mix_SetMusicPosition", [c_double], c_int)
+Mix_Playing = _bind("Mix_Playing", [c_int], c_int)
+Mix_PlayingMusic = _bind("Mix_PlayingMusic", None, c_int)
+Mix_SetMusicCMD = _bind("Mix_SetMusicCMD", [c_char_p], c_int)
+Mix_SetSynchroValue = _bind("Mix_SetSynchroValue", [c_int], c_int)
+Mix_GetSynchroValue = _bind("Mix_GetSynchroValue", None, c_int)
+Mix_SetSoundFonts = _bind("Mix_SetSoundFonts", [c_char_p], c_int)
+Mix_GetSoundFonts = _bind("Mix_GetSoundFonts", None, c_char_p)
+soundfont_function = CFUNCTYPE(c_int, c_char_p, c_void_p)
+Mix_EachSoundFont = _bind("Mix_EachSoundFont", [soundfont_function, c_void_p], c_int)
+Mix_GetChunk = _bind("Mix_GetChunk", [c_int], POINTER(Mix_Chunk))
+Mix_CloseAudio = _bind("Mix_CloseAudio")
+Mix_SetError = SDL_SetError
+Mix_GetError = SDL_GetError
diff --git a/src/m64py/SDL2/sdlttf.py b/src/m64py/SDL2/sdlttf.py
new file mode 100644
index 0000000..495dd4b
--- /dev/null
+++ b/src/m64py/SDL2/sdlttf.py
@@ -0,0 +1,138 @@
+import os
+from ctypes import Structure, POINTER, c_int, c_long, c_char_p
+from .dll import _DLL
+from .version import SDL_version
+from .rwops import SDL_RWops
+from .stdinc import Uint16, Uint32
+from .pixels import SDL_Color
+from .surface import SDL_Surface
+from .error import SDL_GetError, SDL_SetError
+
+__all__ = ["get_dll_file", "SDL_TTF_MAJOR_VERSION", "SDL_TTF_MINOR_VERSION",
+          "SDL_TTF_PATCHLEVEL", "SDL_TTF_VERSION", "TTF_MAJOR_VERSION",
+          "TTF_MINOR_VERSION", "TTF_PATCHLEVEL", "TTF_VERSION",
+          "TTF_Linked_Version", "UNICODE_BOM_NATIVE", "UNICODE_BOM_SWAPPED",
+          "TTF_ByteSwappedUNICODE", "TTF_Font", "TTF_Init", "TTF_OpenFont",
+          "TTF_OpenFontIndex", "TTF_OpenFontRW", "TTF_OpenFontIndexRW",
+          "TTF_STYLE_NORMAL", "TTF_STYLE_BOLD", "TTF_STYLE_ITALIC",
+          "TTF_STYLE_UNDERLINE", "TTF_STYLE_STRIKETHROUGH", "TTF_GetFontStyle",
+          "TTF_SetFontStyle", "TTF_GetFontOutline", "TTF_SetFontOutline",
+          "TTF_HINTING_NORMAL", "TTF_HINTING_LIGHT", "TTF_HINTING_MONO",
+          "TTF_HINTING_NONE", "TTF_GetFontHinting", "TTF_SetFontHinting",
+          "TTF_FontHeight", "TTF_FontAscent", "TTF_FontDescent",
+          "TTF_FontLineSkip", "TTF_GetFontKerning", "TTF_SetFontKerning",
+          "TTF_FontFaces", "TTF_FontFaceIsFixedWidth", "TTF_FontFaceFamilyName",
+          "TTF_FontFaceStyleName", "TTF_GlyphIsProvided", "TTF_GlyphMetrics",
+          "TTF_SizeText", "TTF_SizeUTF8", "TTF_SizeUNICODE",
+          "TTF_RenderText_Solid", "TTF_RenderUTF8_Solid",
+          "TTF_RenderUNICODE_Solid", "TTF_RenderGlyph_Solid",
+          "TTF_RenderText_Shaded", "TTF_RenderUTF8_Shaded",
+          "TTF_RenderUNICODE_Shaded", "TTF_RenderGlyph_Shaded",
+          "TTF_RenderText_Blended", "TTF_RenderUTF8_Blended",
+          "TTF_RenderUNICODE_Blended", "TTF_RenderText_Blended_Wrapped",
+          "TTF_RenderUTF8_Blended_Wrapped", "TTF_RenderUNICODE_Blended_Wrapped",
+          "TTF_RenderGlyph_Blended", "TTF_RenderText", "TTF_RenderUTF",
+          "TTF_RenderUNICODE", "TTF_CloseFont", "TTF_Quit", "TTF_WasInit",
+          "TTF_GetFontKerningSize", "TTF_SetError", "TTF_GetError"
+          ]
+
+try:
+    dll = _DLL("SDL2_ttf", ["SDL2_ttf", "SDL2_ttf-2.0"],
+               os.getenv("PYSDL2_DLL_PATH"))
+except RuntimeError as exc:
+    raise ImportError(exc)
+
+def get_dll_file():
+    """Gets the file name of the loaded SDL2_ttf library."""
+    return dll.libfile
+
+_bind = dll.bind_function
+
+SDL_TTF_MAJOR_VERSION = 2
+SDL_TTF_MINOR_VERSION = 0
+SDL_TTF_PATCHLEVEL = 12
+
+
+def SDL_TTF_VERSION(x):
+    x.major = SDL_TTF_MAJOR_VERSION
+    x.minor = SDL_TTF_MINOR_VERSION
+    x.patch = SDL_TTF_PATCHLEVEL
+
+TTF_MAJOR_VERSION = SDL_TTF_MAJOR_VERSION
+TTF_MINOR_VERSION = SDL_TTF_MINOR_VERSION
+TTF_PATCHLEVEL = SDL_TTF_PATCHLEVEL
+TTF_VERSION = SDL_TTF_VERSION
+
+TTF_Linked_Version = _bind("TTF_Linked_Version", None, POINTER(SDL_version))
+UNICODE_BOM_NATIVE = 0xFEFF
+UNICODE_BOM_SWAPPED = 0xFFFE
+
+TTF_ByteSwappedUNICODE = _bind("TTF_ByteSwappedUNICODE", [c_int])
+
+
+class TTF_Font(Structure):
+    pass
+
+TTF_Init = _bind("TTF_Init", None, c_int)
+TTF_OpenFont = _bind("TTF_OpenFont", [c_char_p, c_int], POINTER(TTF_Font))
+TTF_OpenFontIndex = _bind("TTF_OpenFontIndex", [c_char_p, c_int, c_long], POINTER(TTF_Font))
+TTF_OpenFontRW = _bind("TTF_OpenFontRW", [POINTER(SDL_RWops), c_int, c_int], POINTER(TTF_Font))
+TTF_OpenFontIndexRW = _bind("TTF_OpenFontIndexRW", [POINTER(SDL_RWops), c_int, c_int, c_long], POINTER(TTF_Font))
+
+TTF_STYLE_NORMAL = 0x00
+TTF_STYLE_BOLD = 0x01
+TTF_STYLE_ITALIC = 0x02
+TTF_STYLE_UNDERLINE = 0x04
+TTF_STYLE_STRIKETHROUGH = 0x08
+TTF_GetFontStyle = _bind("TTF_GetFontStyle", [POINTER(TTF_Font)], c_int)
+TTF_SetFontStyle = _bind("TTF_SetFontStyle", [POINTER(TTF_Font), c_int])
+TTF_GetFontOutline = _bind("TTF_GetFontOutline", [POINTER(TTF_Font)], c_int)
+TTF_SetFontOutline = _bind("TTF_SetFontOutline", [POINTER(TTF_Font), c_int])
+
+TTF_HINTING_NORMAL = 0
+TTF_HINTING_LIGHT = 1
+TTF_HINTING_MONO = 2
+TTF_HINTING_NONE = 3
+TTF_GetFontHinting = _bind("TTF_GetFontHinting", [POINTER(TTF_Font)], c_int)
+TTF_SetFontHinting = _bind("TTF_SetFontHinting", [POINTER(TTF_Font), c_int])
+
+TTF_FontHeight = _bind("TTF_FontHeight", [POINTER(TTF_Font)], c_int)
+TTF_FontAscent = _bind("TTF_FontAscent", [POINTER(TTF_Font)], c_int)
+TTF_FontDescent = _bind("TTF_FontDescent", [POINTER(TTF_Font)], c_int)
+TTF_FontLineSkip = _bind("TTF_FontLineSkip", [POINTER(TTF_Font)], c_int)
+TTF_GetFontKerning = _bind("TTF_GetFontKerning", [POINTER(TTF_Font)], c_int)
+TTF_SetFontKerning = _bind("TTF_SetFontKerning", [POINTER(TTF_Font), c_int])
+TTF_FontFaces = _bind("TTF_FontFaces", [POINTER(TTF_Font)], c_long)
+TTF_FontFaceIsFixedWidth = _bind("TTF_FontFaceIsFixedWidth", [POINTER(TTF_Font)], c_int)
+TTF_FontFaceFamilyName = _bind("TTF_FontFaceFamilyName", [POINTER(TTF_Font)], c_char_p)
+TTF_FontFaceStyleName = _bind("TTF_FontFaceStyleName", [POINTER(TTF_Font)], c_char_p)
+TTF_GlyphIsProvided = _bind("TTF_GlyphIsProvided", [POINTER(TTF_Font), Uint16], c_int)
+TTF_GlyphMetrics = _bind("TTF_GlyphMetrics", [POINTER(TTF_Font), Uint16, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)], c_int)
+TTF_SizeText = _bind("TTF_SizeText", [POINTER(TTF_Font), c_char_p, POINTER(c_int), POINTER(c_int)], c_int)
+TTF_SizeUTF8 = _bind("TTF_SizeUTF8", [POINTER(TTF_Font), c_char_p, POINTER(c_int), POINTER(c_int)], c_int)
+TTF_SizeUNICODE = _bind("TTF_SizeUNICODE", [POINTER(TTF_Font), POINTER(Uint16), POINTER(c_int), POINTER(c_int)], c_int)
+TTF_RenderText_Solid = _bind("TTF_RenderText_Solid", [POINTER(TTF_Font), c_char_p, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderUTF8_Solid = _bind("TTF_RenderUTF8_Solid", [POINTER(TTF_Font), c_char_p, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderUNICODE_Solid = _bind("TTF_RenderUNICODE_Solid", [POINTER(TTF_Font), POINTER(Uint16), SDL_Color], POINTER(SDL_Surface))
+TTF_RenderGlyph_Solid = _bind("TTF_RenderGlyph_Solid", [POINTER(TTF_Font), Uint16, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderText_Shaded = _bind("TTF_RenderText_Shaded", [POINTER(TTF_Font), c_char_p, SDL_Color, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderUTF8_Shaded = _bind("TTF_RenderUTF8_Shaded", [POINTER(TTF_Font), c_char_p, SDL_Color, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderUNICODE_Shaded = _bind("TTF_RenderUNICODE_Shaded", [POINTER(TTF_Font), POINTER(Uint16), SDL_Color, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderGlyph_Shaded = _bind("TTF_RenderGlyph_Shaded", [POINTER(TTF_Font), Uint16, SDL_Color, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderText_Blended = _bind("TTF_RenderText_Blended", [POINTER(TTF_Font), c_char_p, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderUTF8_Blended = _bind("TTF_RenderUTF8_Blended", [POINTER(TTF_Font), c_char_p, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderUNICODE_Blended = _bind("TTF_RenderUNICODE_Blended", [POINTER(TTF_Font), POINTER(Uint16), SDL_Color], POINTER(SDL_Surface))
+TTF_RenderText_Blended_Wrapped = _bind("TTF_RenderText_Blended_Wrapped", [POINTER(TTF_Font), c_char_p, SDL_Color, Uint32], POINTER(SDL_Surface))
+TTF_RenderUTF8_Blended_Wrapped = _bind("TTF_RenderUTF8_Blended_Wrapped", [POINTER(TTF_Font), c_char_p, SDL_Color, Uint32], POINTER(SDL_Surface))
+TTF_RenderUNICODE_Blended_Wrapped = _bind("TTF_RenderUNICODE_Blended_Wrapped", [POINTER(TTF_Font), POINTER(Uint16), SDL_Color, Uint32], POINTER(SDL_Surface))
+TTF_RenderGlyph_Blended = _bind("TTF_RenderGlyph_Blended", [POINTER(TTF_Font), Uint16, SDL_Color], POINTER(SDL_Surface))
+TTF_RenderText = TTF_RenderText_Shaded
+TTF_RenderUTF = TTF_RenderUTF8_Shaded
+TTF_RenderUNICODE = TTF_RenderUNICODE_Shaded
+TTF_CloseFont = _bind("TTF_CloseFont", [POINTER(TTF_Font)])
+TTF_Quit = _bind("TTF_Quit") 
+TTF_WasInit = _bind("TTF_WasInit", None, c_int) 
+TTF_GetFontKerningSize = _bind("TTF_GetFontKerningSize", [POINTER(TTF_Font), c_int, c_int], c_int)
+TTF_SetError = SDL_SetError
+TTF_GetError = SDL_GetError
+
diff --git a/src/m64py/SDL2/shape.py b/src/m64py/SDL2/shape.py
new file mode 100644
index 0000000..ea16b14
--- /dev/null
+++ b/src/m64py/SDL2/shape.py
@@ -0,0 +1,42 @@
+from ctypes import Union, Structure, POINTER, c_char_p, c_uint, c_int
+from .dll import _bind
+from .stdinc import Uint8, Uint32, SDL_bool
+from .pixels import SDL_Color
+from .surface import SDL_Surface
+from .video import SDL_Window
+
+__all__ = ["SDL_NONSHAPEABLE_WINDOW", "SDL_INVALID_SHAPE_ARGUMENT",
+           "SDL_WINDOW_LACKS_SHAPE", "SDL_CreateShapedWindow",
+           "SDL_IsShapedWindow", "WindowShapeMode", "ShapeModeDefault",
+           "ShapeModeBinarizeAlpha", "ShapeModeReverseBinarizeAlpha",
+           "ShapeModeColorKey", "SDL_SHAPEMODEALPHA", "SDL_WindowShapeParams",
+           "SDL_WindowShapeMode", "SDL_SetWindowShape",
+           "SDL_GetShapedWindowMode"
+           ]
+
+SDL_NONSHAPEABLE_WINDOW = -1
+SDL_INVALID_SHAPE_ARGUMENT = -2
+SDL_WINDOW_LACKS_SHAPE = -3
+
+SDL_CreateShapedWindow = _bind("SDL_CreateShapedWindow", [c_char_p, c_uint, c_uint, c_uint, c_uint, Uint32], POINTER(SDL_Window))
+SDL_IsShapedWindow = _bind("SDL_IsShapedWindow", [POINTER(SDL_Window)], SDL_bool)
+
+WindowShapeMode = c_int
+ShapeModeDefault = 0
+ShapeModeBinarizeAlpha = 1
+ShapeModeReverseBinarizeAlpha = 2
+ShapeModeColorKey = 3
+
+SDL_SHAPEMODEALPHA = lambda mode: (mode == ShapeModeDefault or mode == ShapeModeBinarizeAlpha or mode == ShapeModeReverseBinarizeAlpha)
+
+class SDL_WindowShapeParams(Union):
+    _fields_ = [("binarizationCutoff", Uint8),
+                ("colorKey", SDL_Color)
+                ]
+class SDL_WindowShapeMode(Structure):
+    _fields_ = [("mode", WindowShapeMode),
+                ("parameters", SDL_WindowShapeParams)
+                ]
+
+SDL_SetWindowShape = _bind("SDL_SetWindowShape", [POINTER(SDL_Window), POINTER(SDL_Surface), POINTER(SDL_WindowShapeMode)], c_int)
+SDL_GetShapedWindowMode = _bind("SDL_GetShapedWindowMode", [POINTER(SDL_Window), POINTER(SDL_WindowShapeMode)], c_int)
diff --git a/src/m64py/SDL2/stdinc.py b/src/m64py/SDL2/stdinc.py
new file mode 100644
index 0000000..ca69657
--- /dev/null
+++ b/src/m64py/SDL2/stdinc.py
@@ -0,0 +1,37 @@
+import sys
+from .dll import _bind
+from ctypes import c_int, c_int8, c_uint8, c_int16, c_uint16, c_int32, \
+    c_uint32, c_int64, c_uint64, cdll, c_size_t, c_void_p, c_char_p
+from ctypes.util import find_library
+
+__all__ = ["SDL_FALSE", "SDL_TRUE", "SDL_bool", "Sint8", "Uint8", "Sint16",
+           "Uint16", "Sint32", "Uint32", "Sint64", "Uint64", "SDL_malloc",
+           "SDL_calloc", "SDL_realloc", "SDL_free", "SDL_getenv",
+           "SDL_setenv", "SDL_abs", "SDL_min", "SDL_max", "SDL_memset",
+           "SDL_memcpy"
+           ]
+
+SDL_FALSE = 0
+SDL_TRUE = 1
+
+SDL_bool = c_int
+Sint8 = c_int8
+Uint8 = c_uint8
+Sint16 = c_int16
+Uint16 = c_uint16
+Sint32 = c_int32
+Uint32 = c_uint32
+Sint64 = c_int64
+Uint64 = c_uint64
+
+SDL_malloc = _bind("SDL_malloc", [c_size_t], c_void_p)
+SDL_calloc = _bind("SDL_calloc", [c_size_t, c_size_t], c_void_p)
+SDL_realloc = _bind("SDL_realloc", [c_void_p, c_size_t], c_void_p)
+SDL_free = _bind("SDL_free", [c_void_p], None)
+SDL_getenv = _bind("SDL_getenv", [c_char_p], c_char_p)
+SDL_setenv = _bind("SDL_setenv", [c_char_p, c_char_p, c_int], c_int)
+SDL_abs = abs
+SDL_min = min
+SDL_max = max
+SDL_memset = _bind("SDL_memset", [c_void_p, c_int, c_size_t], c_void_p)
+SDL_memcpy = _bind("SDL_memcpy", [c_void_p, c_void_p, c_size_t], c_void_p)
diff --git a/src/m64py/SDL2/surface.py b/src/m64py/SDL2/surface.py
new file mode 100644
index 0000000..321d9e9
--- /dev/null
+++ b/src/m64py/SDL2/surface.py
@@ -0,0 +1,87 @@
+from ctypes import CFUNCTYPE, Structure, POINTER, c_int, c_void_p
+from .dll import _bind
+from .stdinc import Uint8, Uint32, SDL_bool
+from .blendmode import SDL_BlendMode
+from .rect import SDL_Rect
+from .pixels import SDL_PixelFormat, SDL_Palette
+from .rwops import SDL_RWops, SDL_RWFromFile
+
+__all__ = ["SDL_SWSURFACE", "SDL_PREALLOC", "SDL_RLEACCEL", "SDL_DONTFREE",
+           "SDL_MUSTLOCK", "SDL_BlitMap", "SDL_Surface", "SDL_Blit",
+           "SDL_CreateRGBSurface", "SDL_CreateRGBSurfaceFrom", "SDL_FreeSurface",
+           "SDL_SetSurfacePalette", "SDL_LockSurface", "SDL_UnlockSurface",
+           "SDL_LoadBMP_RW", "SDL_LoadBMP", "SDL_SaveBMP_RW", "SDL_SaveBMP",
+           "SDL_SetSurfaceRLE", "SDL_SetColorKey", "SDL_GetColorKey",
+           "SDL_SetSurfaceColorMod", "SDL_GetSurfaceColorMod",
+           "SDL_SetSurfaceAlphaMod", "SDL_GetSurfaceAlphaMod",
+           "SDL_SetSurfaceBlendMode", "SDL_GetSurfaceBlendMode",
+           "SDL_SetClipRect", "SDL_GetClipRect", "SDL_ConvertSurface",
+           "SDL_ConvertSurfaceFormat", "SDL_ConvertPixels", "SDL_FillRect",
+           "SDL_FillRects", "SDL_UpperBlit", "SDL_BlitSurface", "SDL_LowerBlit",
+           "SDL_SoftStretch", "SDL_UpperBlitScaled", "SDL_BlitScaled",
+           "SDL_LowerBlitScaled"
+           ]
+
+SDL_SWSURFACE = 0
+SDL_PREALLOC = 0x00000001
+SDL_RLEACCEL = 0x00000002
+SDL_DONTFREE = 0x00000004
+
+SDL_MUSTLOCK = lambda s: ((s.flags & SDL_RLEACCEL) != 0)
+
+class SDL_BlitMap(Structure):
+    pass
+
+class SDL_Surface(Structure):
+    _fields_ = [("flags", Uint32),
+                ("format", POINTER(SDL_PixelFormat)),
+                ("w", c_int), ("h", c_int),
+                ("pitch", c_int),
+                ("pixels", c_void_p),
+                ("userdata", c_void_p),
+                ("locked", c_int),
+                ("lock_data", c_void_p),
+                ("clip_rect", SDL_Rect),
+                ("map", POINTER(SDL_BlitMap)),
+                ("refcount", c_int)
+                ]
+
+SDL_Blit = CFUNCTYPE(c_int, POINTER(SDL_Surface), POINTER(SDL_Rect), POINTER(SDL_Surface), POINTER(SDL_Rect))
+
+SDL_CreateRGBSurface = _bind("SDL_CreateRGBSurface", [Uint32, c_int, c_int, c_int, Uint32, Uint32, Uint32, Uint32], POINTER(SDL_Surface))
+SDL_CreateRGBSurfaceFrom = _bind("SDL_CreateRGBSurfaceFrom", [c_void_p, c_int, c_int, c_int, c_int, Uint32, Uint32, Uint32, Uint32], POINTER(SDL_Surface))
+SDL_FreeSurface = _bind("SDL_FreeSurface", [POINTER(SDL_Surface)])
+SDL_SetSurfacePalette = _bind("SDL_SetSurfacePalette", [POINTER(SDL_Surface), POINTER(SDL_Palette)], c_int)
+SDL_LockSurface = _bind("SDL_LockSurface", [POINTER(SDL_Surface)], c_int)
+SDL_UnlockSurface = _bind("SDL_UnlockSurface", [POINTER(SDL_Surface)])
+
+SDL_LoadBMP_RW = _bind("SDL_LoadBMP_RW", [POINTER(SDL_RWops), c_int], POINTER(SDL_Surface))
+SDL_LoadBMP = lambda fname: SDL_LoadBMP_RW(SDL_RWFromFile(fname, b"rb"), 1)
+SDL_SaveBMP_RW = _bind("SDL_SaveBMP_RW", [POINTER(SDL_Surface), POINTER(SDL_RWops), c_int], c_int)
+SDL_SaveBMP = lambda surface, fname: SDL_SaveBMP_RW(surface, SDL_RWFromFile(fname, b"wb"), 1)
+
+SDL_SetSurfaceRLE = _bind("SDL_SetSurfaceRLE", [POINTER(SDL_Surface), c_int], c_int)
+SDL_SetColorKey = _bind("SDL_SetColorKey", [POINTER(SDL_Surface), c_int, Uint32], c_int)
+SDL_GetColorKey = _bind("SDL_GetColorKey", [POINTER(SDL_Surface), POINTER(Uint32)], c_int)
+SDL_SetSurfaceColorMod = _bind("SDL_SetSurfaceColorMod", [POINTER(SDL_Surface), Uint8, Uint8, Uint8], c_int)
+SDL_GetSurfaceColorMod = _bind("SDL_GetSurfaceColorMod", [POINTER(SDL_Surface), POINTER(Uint8), POINTER(Uint8), POINTER(Uint8)], c_int)
+SDL_SetSurfaceAlphaMod = _bind("SDL_SetSurfaceAlphaMod", [POINTER(SDL_Surface), Uint8], c_int)
+SDL_GetSurfaceAlphaMod = _bind("SDL_GetSurfaceAlphaMod", [POINTER(SDL_Surface), POINTER(Uint8)], c_int)
+SDL_SetSurfaceBlendMode = _bind("SDL_SetSurfaceBlendMode", [POINTER(SDL_Surface), SDL_BlendMode], c_int)
+SDL_GetSurfaceBlendMode = _bind("SDL_GetSurfaceBlendMode", [POINTER(SDL_Surface), POINTER(SDL_BlendMode)], c_int)
+SDL_SetClipRect = _bind("SDL_SetClipRect", [POINTER(SDL_Surface), POINTER(SDL_Rect)], SDL_bool)
+SDL_GetClipRect = _bind("SDL_GetClipRect", [POINTER(SDL_Surface), POINTER(SDL_Rect)])
+SDL_ConvertSurface = _bind("SDL_ConvertSurface", [POINTER(SDL_Surface), POINTER(SDL_PixelFormat), Uint32], POINTER(SDL_Surface))
+SDL_ConvertSurfaceFormat = _bind("SDL_ConvertSurfaceFormat", [POINTER(SDL_Surface), Uint32, Uint32], POINTER(SDL_Surface))
+SDL_ConvertPixels = _bind("SDL_ConvertPixels", [c_int, c_int, Uint32, c_void_p, c_int, Uint32, c_void_p, c_int], c_int)
+SDL_FillRect = _bind("SDL_FillRect", [POINTER(SDL_Surface), POINTER(SDL_Rect), Uint32], c_int)
+SDL_FillRects = _bind("SDL_FillRects", [POINTER(SDL_Surface), POINTER(SDL_Rect), c_int, Uint32], c_int)
+
+
+SDL_UpperBlit = _bind("SDL_UpperBlit", [POINTER(SDL_Surface), POINTER(SDL_Rect), POINTER(SDL_Surface), POINTER(SDL_Rect)], c_int)
+SDL_BlitSurface = SDL_UpperBlit
+SDL_LowerBlit = _bind("SDL_LowerBlit", [POINTER(SDL_Surface), POINTER(SDL_Rect), POINTER(SDL_Surface), POINTER(SDL_Rect)], c_int)
+SDL_SoftStretch = _bind("SDL_SoftStretch", [POINTER(SDL_Surface), POINTER(SDL_Rect), POINTER(SDL_Surface), POINTER(SDL_Rect)], c_int)
+SDL_UpperBlitScaled = _bind("SDL_UpperBlitScaled", [POINTER(SDL_Surface), POINTER(SDL_Rect), POINTER(SDL_Surface), POINTER(SDL_Rect)], c_int)
+SDL_BlitScaled = SDL_UpperBlitScaled
+SDL_LowerBlitScaled = _bind("SDL_LowerBlitScaled", [POINTER(SDL_Surface), POINTER(SDL_Rect), POINTER(SDL_Surface), POINTER(SDL_Rect)], c_int)
diff --git a/src/m64py/SDL2/syswm.py b/src/m64py/SDL2/syswm.py
new file mode 100644
index 0000000..a1cc080
--- /dev/null
+++ b/src/m64py/SDL2/syswm.py
@@ -0,0 +1,123 @@
+from ctypes import Union, Structure, c_int, c_void_p, c_long, c_ulong, \
+    c_longlong, c_ulonglong, c_uint, sizeof, POINTER
+from .dll import _bind
+from .stdinc import SDL_bool
+from .version import SDL_version
+from .video import SDL_Window
+
+__all__ = ["SDL_SYSWM_TYPE", "SDL_SYSWM_UNKNOWN", "SDL_SYSWM_WINDOWS",
+           "SDL_SYSWM_X11", "SDL_SYSWM_DIRECTFB", "SDL_SYSWM_COCOA",
+           "SDL_SYSWM_UIKIT", "SDL_SysWMmsg", "SDL_SysWMinfo",
+           "SDL_GetWindowWMInfo"
+           ]
+
+SDL_SYSWM_TYPE = c_int
+SDL_SYSWM_UNKNOWN = 0
+SDL_SYSWM_WINDOWS = 1
+SDL_SYSWM_X11 = 2
+SDL_SYSWM_DIRECTFB = 3
+SDL_SYSWM_COCOA = 4
+SDL_SYSWM_UIKIT = 5
+
+# FIXME: Hack around the ctypes "_type_ 'v' not supported" bug - remove
+# once this has been fixed properly in Python 2.7+
+HWND = c_void_p
+UINT = c_uint
+if sizeof(c_long) == sizeof(c_void_p):
+    WPARAM = c_ulong
+    LPARAM = c_long
+elif sizeof(c_longlong) == sizeof(c_void_p):
+    WPARAM = c_ulonglong
+    LPARAM = c_longlong
+# FIXME: end
+
+class _winmsg(Structure):
+    _fields_ = [("hwnd", HWND),
+                ("msg", UINT),
+                ("wParam", WPARAM),
+                ("lParam", LPARAM),
+                ]
+
+
+class _x11msg(Structure):
+    _fields_ = [("event", c_void_p)]
+
+
+class _dfbmsg(Structure):
+    _fields_ = [("event", c_void_p)]
+
+
+class _cocoamsg(Structure):
+    pass
+
+
+class _uikitmsg(Structure):
+    pass
+
+
+class _msg(Union):
+    _fields_ = [("win", _winmsg),
+                ("x11", _x11msg),
+                ("dfb", _dfbmsg),
+                ("cocoa", _cocoamsg),
+                ("uikit", _uikitmsg),
+                ("dummy", c_int)
+                ]
+
+
+class SDL_SysWMmsg(Structure):
+    _fields_ = [("version", SDL_version),
+                ("subsystem", SDL_SYSWM_TYPE),
+                ("msg", _msg)
+                ]
+
+
+class _wininfo(Structure):
+    _fields_ = [("window", HWND)]
+
+
+class _x11info(Structure):
+    """Window information for X11."""
+    _fields_ = [("display", c_void_p),
+                ("window", c_ulong)]
+
+
+class _dfbinfo(Structure):
+    """Window information for DirectFB."""
+    _fields_ = [("dfb", c_void_p),
+                ("window", c_void_p),
+                ("surface", c_void_p)]
+
+
+class _cocoainfo(Structure):
+    """Window information for MacOS X."""
+    _fields_ = [("window", c_void_p)]
+
+
+class _uikitinfo(Structure):
+    """Window information for iOS."""
+    _fields_ = [("window", c_void_p)]
+
+
+class _info(Union):
+    """The platform-specific information of a window."""
+    _fields_ = [("win", _wininfo),
+                ("x11", _x11info),
+                ("dfb", _dfbinfo),
+                ("cocoa", _cocoainfo),
+                ("uikit", _uikitinfo),
+                ("dummy", c_int)
+                ]
+
+
+class SDL_SysWMinfo(Structure):
+    """System-specific window manager information.
+
+    This holds the low-level information about the window.
+    """
+    _fields_ = [("version", SDL_version),
+                ("subsystem", SDL_SYSWM_TYPE),
+                ("info", _info)
+                ]
+
+SDL_GetWindowWMInfo = _bind("SDL_GetWindowWMInfo", [POINTER(SDL_Window), POINTER(SDL_SysWMinfo)], SDL_bool)
diff --git a/src/m64py/SDL2/timer.py b/src/m64py/SDL2/timer.py
new file mode 100644
index 0000000..db34ce0
--- /dev/null
+++ b/src/m64py/SDL2/timer.py
@@ -0,0 +1,19 @@
+from ctypes import CFUNCTYPE, c_void_p, c_int
+from .dll import _bind
+from .stdinc import Uint32, Uint64, SDL_bool
+
+__all__ = ["SDL_GetTicks", "SDL_GetPerformanceCounter",
+           "SDL_GetPerformanceFrequency", "SDL_Delay", "SDL_TimerCallback",
+           "SDL_TimerID", "SDL_AddTimer", "SDL_RemoveTimer"
+           ]
+
+SDL_GetTicks = _bind("SDL_GetTicks", None, Uint32)
+SDL_GetPerformanceCounter = _bind("SDL_GetPerformanceCounter", None, Uint64)
+SDL_GetPerformanceFrequency = _bind("SDL_GetPerformanceFrequency", None, Uint64)
+SDL_Delay = _bind("SDL_Delay", [Uint32])
+
+SDL_TimerCallback = CFUNCTYPE(Uint32, Uint32, c_void_p)
+SDL_TimerID = c_int
+
+SDL_AddTimer = _bind("SDL_AddTimer", [Uint32, SDL_TimerCallback, c_void_p], SDL_TimerID)
+SDL_RemoveTimer = _bind("SDL_RemoveTimer", [SDL_TimerID], SDL_bool)
diff --git a/src/m64py/SDL2/touch.py b/src/m64py/SDL2/touch.py
new file mode 100644
index 0000000..2f039d3
--- /dev/null
+++ b/src/m64py/SDL2/touch.py
@@ -0,0 +1,24 @@
+from ctypes import Structure, POINTER, c_float, c_int
+from .dll import _bind
+from .stdinc import Sint64
+
+__all__ = ["SDL_TouchID", "SDL_FingerID", "SDL_Finger", "SDL_GetNumTouchDevices",
+           "SDL_GetTouchDevice", "SDL_GetNumTouchFingers", "SDL_GetTouchFinger"
+           ]
+
+SDL_TouchID = Sint64
+SDL_FingerID = Sint64
+
+class SDL_Finger(Structure):
+    _fields_ = [("id", SDL_FingerID),
+                ("x", c_float),
+                ("y", c_float),
+                ("pressure", c_float)
+                ]
+
+# TODO: #define SDL_TOUCH_MOUSEID ((Uint32)-1)
+
+SDL_GetNumTouchDevices = _bind("SDL_GetNumTouchDevices", None, c_int)
+SDL_GetTouchDevice = _bind("SDL_GetTouchDevice", [c_int], SDL_TouchID)
+SDL_GetNumTouchFingers = _bind("SDL_GetNumTouchFingers", [SDL_TouchID], c_int)
+SDL_GetTouchFinger = _bind("SDL_GetTouchFinger", [SDL_TouchID, c_int], POINTER(SDL_Finger))
diff --git a/src/m64py/SDL2/version.py b/src/m64py/SDL2/version.py
new file mode 100644
index 0000000..032553f
--- /dev/null
+++ b/src/m64py/SDL2/version.py
@@ -0,0 +1,31 @@
+from ctypes import Structure, POINTER, c_char_p, c_int
+from .dll import _bind
+from .stdinc import Uint8
+
+__all__ = ["SDL_version", "SDL_MAJOR_VERSION", "SDL_MINOR_VERSION",
+           "SDL_PATCHLEVEL", "SDL_VERSION", "SDL_VERSIONNUM",
+           "SDL_COMPILEDVERSION", "SDL_VERSION_ATLEAST", "SDL_GetVersion",
+           "SDL_GetRevision", "SDL_GetRevisionNumber"
+           ]
+
+class SDL_version(Structure):
+    _fields_ = [("major", Uint8),
+                ("minor", Uint8),
+                ("patch", Uint8),
+                ]
+
+SDL_MAJOR_VERSION = 2
+SDL_MINOR_VERSION = 0
+SDL_PATCHLEVEL = 0
+
+def SDL_VERSION(x):
+    x.major = SDL_MAJOR_VERSION
+    x.minor = SDL_MINOR_VERSION
+    x.patch = SDL_PATCHLEVEL
+
+SDL_VERSIONNUM = lambda x, y, z: (x * 1000 + y * 100 + z)
+SDL_COMPILEDVERSION = SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL)
+SDL_VERSION_ATLEAST = lambda x, y, z: (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(x, y, z))
+SDL_GetVersion = _bind("SDL_GetVersion", [POINTER(SDL_version)])
+SDL_GetRevision = _bind("SDL_GetRevision", None, c_char_p)
+SDL_GetRevisionNumber = _bind("SDL_GetRevisionNumber", None, c_int)
diff --git a/src/m64py/SDL2/video.py b/src/m64py/SDL2/video.py
new file mode 100644
index 0000000..2fad6d2
--- /dev/null
+++ b/src/m64py/SDL2/video.py
@@ -0,0 +1,250 @@
+from ctypes import Structure, POINTER, c_int, c_void_p, c_char_p, c_float, \
+    py_object
+from .dll import _bind
+from .stdinc import Uint16, Uint32, SDL_bool
+from .rect import SDL_Rect
+from .surface import SDL_Surface
+
+__all__ = ["SDL_DisplayMode", "SDL_Window", "SDL_WindowFlags",
+           "SDL_WINDOW_FULLSCREEN", "SDL_WINDOW_OPENGL", "SDL_WINDOW_SHOWN",
+           "SDL_WINDOW_HIDDEN", "SDL_WINDOW_BORDERLESS", "SDL_WINDOW_RESIZABLE",
+           "SDL_WINDOW_MINIMIZED", "SDL_WINDOW_MAXIMIZED",
+           "SDL_WINDOW_INPUT_GRABBED", "SDL_WINDOW_INPUT_FOCUS",
+           "SDL_WINDOW_MOUSE_FOCUS", "SDL_WINDOW_FULLSCREEN_DESKTOP",
+           "SDL_WINDOW_FOREIGN", "SDL_WINDOWPOS_UNDEFINED_MASK",
+           "SDL_WINDOWPOS_UNDEFINED_DISPLAY", "SDL_WINDOWPOS_UNDEFINED",
+           "SDL_WINDOWPOS_ISUNDEFINED", "SDL_WINDOWPOS_CENTERED_MASK",
+           "SDL_WINDOWPOS_CENTERED_DISPLAY", "SDL_WINDOWPOS_CENTERED",
+           "SDL_WINDOWPOS_ISCENTERED", "SDL_WindowEventID",
+           "SDL_WINDOWEVENT_NONE", "SDL_WINDOWEVENT_SHOWN",
+           "SDL_WINDOWEVENT_HIDDEN", "SDL_WINDOWEVENT_EXPOSED",
+           "SDL_WINDOWEVENT_MOVED", "SDL_WINDOWEVENT_RESIZED",
+           "SDL_WINDOWEVENT_SIZE_CHANGED", "SDL_WINDOWEVENT_MINIMIZED",
+           "SDL_WINDOWEVENT_MAXIMIZED", "SDL_WINDOWEVENT_RESTORED",
+           "SDL_WINDOWEVENT_ENTER", "SDL_WINDOWEVENT_LEAVE",
+           "SDL_WINDOWEVENT_FOCUS_GAINED", "SDL_WINDOWEVENT_FOCUS_LOST",
+           "SDL_WINDOWEVENT_CLOSE", "SDL_GLContext", "SDL_GLattr",
+           "SDL_GL_RED_SIZE", "SDL_GL_GREEN_SIZE", "SDL_GL_BLUE_SIZE",
+           "SDL_GL_ALPHA_SIZE", "SDL_GL_BUFFER_SIZE", "SDL_GL_DOUBLEBUFFER",
+           "SDL_GL_DEPTH_SIZE", "SDL_GL_STENCIL_SIZE", "SDL_GL_ACCUM_RED_SIZE",
+           "SDL_GL_ACCUM_GREEN_SIZE", "SDL_GL_ACCUM_BLUE_SIZE",
+           "SDL_GL_ACCUM_ALPHA_SIZE", "SDL_GL_STEREO",
+           "SDL_GL_MULTISAMPLEBUFFERS", "SDL_GL_MULTISAMPLESAMPLES",
+           "SDL_GL_ACCELERATED_VISUAL", "SDL_GL_RETAINED_BACKING",
+           "SDL_GL_CONTEXT_MAJOR_VERSION", "SDL_GL_CONTEXT_MINOR_VERSION",
+           "SDL_GL_CONTEXT_EGL", "SDL_GL_CONTEXT_FLAGS",
+           "SDL_GL_CONTEXT_PROFILE_MASK", "SDL_GL_SHARE_WITH_CURRENT_CONTEXT",
+           "SDL_GLprofile", "SDL_GL_CONTEXT_PROFILE_CORE",
+           "SDL_GL_CONTEXT_PROFILE_COMPATIBILITY", "SDL_GL_CONTEXT_PROFILE_ES",
+           "SDL_GLcontextFlag", "SDL_GL_CONTEXT_DEBUG_FLAG",
+           "SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG",
+           "SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG",
+           "SDL_GL_CONTEXT_RESET_ISOLATION_FLAG", "SDL_GetNumVideoDrivers",
+           "SDL_GetVideoDriver", "SDL_VideoInit", "SDL_VideoQuit",
+           "SDL_GetCurrentVideoDriver", "SDL_GetNumVideoDisplays",
+           "SDL_GetDisplayName", "SDL_GetDisplayBounds",
+           "SDL_GetNumDisplayModes", "SDL_GetDisplayMode",
+           "SDL_GetDesktopDisplayMode", "SDL_GetCurrentDisplayMode",
+           "SDL_GetClosestDisplayMode", "SDL_GetWindowDisplayIndex",
+           "SDL_SetWindowDisplayMode", "SDL_GetWindowDisplayMode",
+           "SDL_GetWindowPixelFormat", "SDL_CreateWindow", "SDL_CreateWindowFrom",
+           "SDL_GetWindowID", "SDL_GetWindowFromID", "SDL_GetWindowFlags",
+           "SDL_SetWindowTitle", "SDL_GetWindowTitle", "SDL_SetWindowIcon",
+           "SDL_SetWindowData", "SDL_GetWindowData", "SDL_SetWindowPosition",
+           "SDL_GetWindowPosition", "SDL_SetWindowSize", "SDL_GetWindowSize",
+           "SDL_SetWindowMinimumSize", "SDL_GetWindowMinimumSize",
+           "SDL_SetWindowMaximumSize", "SDL_GetWindowMaximumSize",
+           "SDL_SetWindowBordered", "SDL_ShowWindow", "SDL_HideWindow",
+           "SDL_RaiseWindow", "SDL_MaximizeWindow", "SDL_MinimizeWindow",
+           "SDL_RestoreWindow", "SDL_SetWindowFullscreen", "SDL_GetWindowSurface",
+           "SDL_UpdateWindowSurface", "SDL_UpdateWindowSurfaceRects",
+           "SDL_SetWindowGrab", "SDL_GetWindowGrab", "SDL_SetWindowBrightness",
+           "SDL_GetWindowBrightness", "SDL_SetWindowGammaRamp",
+           "SDL_GetWindowGammaRamp", "SDL_DestroyWindow", "SDL_DisableScreenSaver",
+           "SDL_IsScreenSaverEnabled", "SDL_EnableScreenSaver",
+           "SDL_GL_LoadLibrary", "SDL_GL_GetProcAddress", "SDL_GL_UnloadLibrary",
+           "SDL_GL_ExtensionSupported", "SDL_GL_SetAttribute",
+           "SDL_GL_GetAttribute", "SDL_GL_CreateContext", "SDL_GL_MakeCurrent",
+           "SDL_GL_SetSwapInterval", "SDL_GL_GetSwapInterval",
+           "SDL_GL_SwapWindow", "SDL_GL_DeleteContext"
+           ]
+
+class SDL_DisplayMode(Structure):
+    _fields_ = [("format", Uint32),
+                ("w", c_int),
+                ("h", c_int),
+                ("refresh_rate", c_int),
+                ("driverdata", c_void_p)
+                ]
+    def __init__(self, format_=0, w=0, h=0, refresh_rate=0):
+        super(SDL_DisplayMode, self).__init__()
+        self.format = format_
+        self.w = w
+        self.h = h
+        self.refresh_rate = refresh_rate
+
+    def __repr__(self):
+        return "SDL_DisplayMode(format=%d, w=%d, h=%d, refresh_rate=%d)" % \
+            (self.format, self.w, self.h, self.refresh_rate)
+
+    def __eq__(self, mode):
+        return self.format == mode.format and self.w == mode.w and \
+            self.h == mode.h and self.refresh_rate == mode.refresh_rate
+
+    def __ne__(self, mode):
+        return self.format != mode.format or self.w != mode.w or \
+            self.h != mode.h or self.refresh_rate != mode.refresh_rate
+
+class SDL_Window(Structure):
+    pass
+
+SDL_WindowFlags = c_int
+SDL_WINDOW_FULLSCREEN = 0x00000001
+SDL_WINDOW_OPENGL = 0x00000002
+SDL_WINDOW_SHOWN = 0x00000004
+SDL_WINDOW_HIDDEN = 0x00000008
+SDL_WINDOW_BORDERLESS = 0x00000010
+SDL_WINDOW_RESIZABLE = 0x00000020
+SDL_WINDOW_MINIMIZED = 0x00000040
+SDL_WINDOW_MAXIMIZED = 0x00000080
+SDL_WINDOW_INPUT_GRABBED = 0x00000100
+SDL_WINDOW_INPUT_FOCUS = 0x00000200
+SDL_WINDOW_MOUSE_FOCUS = 0x00000400
+SDL_WINDOW_FULLSCREEN_DESKTOP = (SDL_WINDOW_FULLSCREEN | 0x00001000)
+SDL_WINDOW_FOREIGN = 0x00000800
+
+SDL_WINDOWPOS_UNDEFINED_MASK = 0x1FFF0000
+SDL_WINDOWPOS_UNDEFINED_DISPLAY = lambda x: (SDL_WINDOWPOS_UNDEFINED_MASK | x)
+SDL_WINDOWPOS_UNDEFINED = SDL_WINDOWPOS_UNDEFINED_DISPLAY(0)
+SDL_WINDOWPOS_ISUNDEFINED = lambda x: ((x & 0xFFFF0000) == SDL_WINDOWPOS_UNDEFINED_MASK)
+
+SDL_WINDOWPOS_CENTERED_MASK = 0x2FFF0000
+SDL_WINDOWPOS_CENTERED_DISPLAY = lambda x: (SDL_WINDOWPOS_CENTERED_MASK | x)
+SDL_WINDOWPOS_CENTERED = SDL_WINDOWPOS_CENTERED_DISPLAY(0)
+SDL_WINDOWPOS_ISCENTERED = lambda x: ((x & 0xFFFF0000) == SDL_WINDOWPOS_CENTERED_MASK)
+
+SDL_WindowEventID = c_int
+
+SDL_WINDOWEVENT_NONE = 0
+SDL_WINDOWEVENT_SHOWN = 1
+SDL_WINDOWEVENT_HIDDEN = 2
+SDL_WINDOWEVENT_EXPOSED = 3
+SDL_WINDOWEVENT_MOVED = 4
+SDL_WINDOWEVENT_RESIZED = 5
+SDL_WINDOWEVENT_SIZE_CHANGED = 6
+SDL_WINDOWEVENT_MINIMIZED = 7
+SDL_WINDOWEVENT_MAXIMIZED = 8
+SDL_WINDOWEVENT_RESTORED = 9
+SDL_WINDOWEVENT_ENTER = 10
+SDL_WINDOWEVENT_LEAVE = 11
+SDL_WINDOWEVENT_FOCUS_GAINED = 12
+SDL_WINDOWEVENT_FOCUS_LOST = 13
+SDL_WINDOWEVENT_CLOSE = 14
+
+SDL_GLContext = c_void_p
+SDL_GLattr = c_int
+SDL_GL_RED_SIZE = 0
+SDL_GL_GREEN_SIZE = 1
+SDL_GL_BLUE_SIZE = 2
+SDL_GL_ALPHA_SIZE = 3
+SDL_GL_BUFFER_SIZE = 4
+SDL_GL_DOUBLEBUFFER = 5
+SDL_GL_DEPTH_SIZE = 6
+SDL_GL_STENCIL_SIZE = 7
+SDL_GL_ACCUM_RED_SIZE = 8
+SDL_GL_ACCUM_GREEN_SIZE = 9
+SDL_GL_ACCUM_BLUE_SIZE = 10
+SDL_GL_ACCUM_ALPHA_SIZE = 11
+SDL_GL_STEREO = 12
+SDL_GL_MULTISAMPLEBUFFERS = 13
+SDL_GL_MULTISAMPLESAMPLES = 14
+SDL_GL_ACCELERATED_VISUAL = 15
+SDL_GL_RETAINED_BACKING = 16
+SDL_GL_CONTEXT_MAJOR_VERSION = 17
+SDL_GL_CONTEXT_MINOR_VERSION = 18
+SDL_GL_CONTEXT_EGL = 19
+SDL_GL_CONTEXT_FLAGS = 20
+SDL_GL_CONTEXT_PROFILE_MASK = 21
+SDL_GL_SHARE_WITH_CURRENT_CONTEXT = 22
+
+SDL_GLprofile = c_int
+SDL_GL_CONTEXT_PROFILE_CORE = 0x0001
+SDL_GL_CONTEXT_PROFILE_COMPATIBILITY = 0x0002
+SDL_GL_CONTEXT_PROFILE_ES = 0x0004
+
+SDL_GLcontextFlag = c_int
+SDL_GL_CONTEXT_DEBUG_FLAG = 0x0001
+SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = 0x0002
+SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG = 0x0004
+SDL_GL_CONTEXT_RESET_ISOLATION_FLAG = 0x0008
+
+
+SDL_GetNumVideoDrivers = _bind("SDL_GetNumVideoDrivers", None, c_int)
+SDL_GetVideoDriver = _bind("SDL_GetVideoDriver", [c_int], c_char_p)
+SDL_VideoInit = _bind("SDL_VideoInit", [c_char_p], c_int)
+SDL_VideoQuit = _bind("SDL_VideoQuit")
+SDL_GetCurrentVideoDriver = _bind("SDL_GetCurrentVideoDriver", None, c_char_p)
+SDL_GetNumVideoDisplays = _bind("SDL_GetNumVideoDisplays", None, c_int)
+SDL_GetDisplayName = _bind("SDL_GetDisplayName", [c_int], c_char_p)
+SDL_GetDisplayBounds = _bind("SDL_GetDisplayBounds", [c_int, POINTER(SDL_Rect)], c_int)
+SDL_GetNumDisplayModes = _bind("SDL_GetNumDisplayModes", [c_int], c_int)
+SDL_GetDisplayMode = _bind("SDL_GetDisplayMode", [c_int, c_int, POINTER(SDL_DisplayMode)], c_int)
+SDL_GetDesktopDisplayMode = _bind("SDL_GetDesktopDisplayMode", [c_int, POINTER(SDL_DisplayMode)], c_int)
+SDL_GetCurrentDisplayMode = _bind("SDL_GetCurrentDisplayMode", [c_int, POINTER(SDL_DisplayMode)], c_int)
+SDL_GetClosestDisplayMode = _bind("SDL_GetClosestDisplayMode", [c_int, POINTER(SDL_DisplayMode), POINTER(SDL_DisplayMode)], POINTER(SDL_DisplayMode))
+SDL_GetWindowDisplayIndex = _bind("SDL_GetWindowDisplayIndex", [POINTER(SDL_Window)], c_int)
+SDL_SetWindowDisplayMode = _bind("SDL_SetWindowDisplayMode", [POINTER(SDL_Window), POINTER(SDL_DisplayMode)], c_int)
+SDL_GetWindowDisplayMode = _bind("SDL_GetWindowDisplayMode", [POINTER(SDL_Window), POINTER(SDL_DisplayMode)], c_int)
+SDL_GetWindowPixelFormat = _bind("SDL_GetWindowPixelFormat", [POINTER(SDL_Window)], Uint32)
+SDL_CreateWindow = _bind("SDL_CreateWindow", [c_char_p, c_int, c_int, c_int, c_int, Uint32], POINTER(SDL_Window))
+SDL_CreateWindowFrom = _bind("SDL_CreateWindowFrom", [c_void_p], POINTER(SDL_Window))
+SDL_GetWindowID = _bind("SDL_GetWindowID", [POINTER(SDL_Window)], Uint32)
+SDL_GetWindowFromID = _bind("SDL_GetWindowFromID", [Uint32], POINTER(SDL_Window))
+SDL_GetWindowFlags = _bind("SDL_GetWindowFlags", [POINTER(SDL_Window)], Uint32)
+SDL_SetWindowTitle = _bind("SDL_SetWindowTitle", [POINTER(SDL_Window), c_char_p])
+SDL_GetWindowTitle = _bind("SDL_GetWindowTitle", [POINTER(SDL_Window)], c_char_p)
+SDL_SetWindowIcon = _bind("SDL_SetWindowIcon", [POINTER(SDL_Window), POINTER(SDL_Surface)])
+SDL_SetWindowData = _bind("SDL_SetWindowData", [POINTER(SDL_Window), c_char_p, POINTER(py_object)], POINTER(py_object))
+SDL_GetWindowData = _bind("SDL_GetWindowData", [POINTER(SDL_Window), c_char_p], POINTER(py_object))
+SDL_SetWindowPosition = _bind("SDL_SetWindowPosition", [POINTER(SDL_Window), c_int, c_int])
+SDL_GetWindowPosition = _bind("SDL_GetWindowPosition", [POINTER(SDL_Window), POINTER(c_int), POINTER(c_int)])
+SDL_SetWindowSize = _bind("SDL_SetWindowSize", [POINTER(SDL_Window), c_int, c_int])
+SDL_GetWindowSize = _bind("SDL_GetWindowSize", [POINTER(SDL_Window), POINTER(c_int), POINTER(c_int)])
+SDL_SetWindowMinimumSize = _bind("SDL_SetWindowMinimumSize", [POINTER(SDL_Window), c_int, c_int])
+SDL_GetWindowMinimumSize = _bind("SDL_GetWindowMinimumSize", [POINTER(SDL_Window), POINTER(c_int), POINTER(c_int)])
+SDL_SetWindowMaximumSize = _bind("SDL_SetWindowMaximumSize", [POINTER(SDL_Window), c_int, c_int])
+SDL_GetWindowMaximumSize = _bind("SDL_GetWindowMaximumSize", [POINTER(SDL_Window), POINTER(c_int), POINTER(c_int)])
+SDL_SetWindowBordered = _bind("SDL_SetWindowBordered", [POINTER(SDL_Window), SDL_bool])
+SDL_ShowWindow = _bind("SDL_ShowWindow", [POINTER(SDL_Window)])
+SDL_HideWindow = _bind("SDL_HideWindow", [POINTER(SDL_Window)])
+SDL_RaiseWindow = _bind("SDL_RaiseWindow", [POINTER(SDL_Window)])
+SDL_MaximizeWindow = _bind("SDL_MaximizeWindow", [POINTER(SDL_Window)])
+SDL_MinimizeWindow = _bind("SDL_MinimizeWindow", [POINTER(SDL_Window)])
+SDL_RestoreWindow = _bind("SDL_RestoreWindow", [POINTER(SDL_Window)])
+SDL_SetWindowFullscreen = _bind("SDL_SetWindowFullscreen", [POINTER(SDL_Window), Uint32], c_int)
+SDL_GetWindowSurface = _bind("SDL_GetWindowSurface", [POINTER(SDL_Window)], POINTER(SDL_Surface))
+SDL_UpdateWindowSurface = _bind("SDL_UpdateWindowSurface", [POINTER(SDL_Window)], c_int)
+SDL_UpdateWindowSurfaceRects = _bind("SDL_UpdateWindowSurfaceRects", [POINTER(SDL_Window), POINTER(SDL_Rect), c_int], c_int)
+SDL_SetWindowGrab = _bind("SDL_SetWindowGrab", [POINTER(SDL_Window), SDL_bool])
+SDL_GetWindowGrab = _bind("SDL_GetWindowGrab", [POINTER(SDL_Window)], SDL_bool)
+SDL_SetWindowBrightness = _bind("SDL_SetWindowBrightness", [POINTER(SDL_Window), c_float], c_int)
+SDL_GetWindowBrightness = _bind("SDL_GetWindowBrightness", [POINTER(SDL_Window)], c_float)
+SDL_SetWindowGammaRamp = _bind("SDL_SetWindowGammaRamp", [POINTER(SDL_Window), POINTER(Uint16), POINTER(Uint16), POINTER(Uint16)], c_int)
+SDL_GetWindowGammaRamp = _bind("SDL_GetWindowGammaRamp", [POINTER(SDL_Window), POINTER(Uint16), POINTER(Uint16), POINTER(Uint16)], c_int)
+SDL_DestroyWindow = _bind("SDL_DestroyWindow", [POINTER(SDL_Window)])
+SDL_IsScreenSaverEnabled = _bind("SDL_IsScreenSaverEnabled", None, SDL_bool)
+SDL_EnableScreenSaver = _bind("SDL_EnableScreenSaver")
+SDL_DisableScreenSaver = _bind("SDL_DisableScreenSaver")
+
+SDL_GL_LoadLibrary = _bind("SDL_GL_LoadLibrary", [c_char_p], c_int)
+SDL_GL_GetProcAddress = _bind("SDL_GL_GetProcAddress", [c_char_p], c_void_p)
+SDL_GL_UnloadLibrary = _bind("SDL_GL_UnloadLibrary")
+SDL_GL_ExtensionSupported = _bind("SDL_GL_ExtensionSupported", [c_char_p], SDL_bool)
+SDL_GL_SetAttribute = _bind("SDL_GL_SetAttribute", [SDL_GLattr, c_int], c_int)
+SDL_GL_GetAttribute = _bind("SDL_GL_GetAttribute", [SDL_GLattr, POINTER(c_int)], c_int)
+SDL_GL_CreateContext = _bind("SDL_GL_CreateContext", [POINTER(SDL_Window)], SDL_GLContext)
+SDL_GL_MakeCurrent = _bind("SDL_GL_MakeCurrent", [POINTER(SDL_Window), SDL_GLContext], c_int)
+SDL_GL_SetSwapInterval = _bind("SDL_GL_SetSwapInterval", [c_int], c_int)
+SDL_GL_GetSwapInterval = _bind("SDL_GL_GetSwapInterval", None, c_int)
+SDL_GL_SwapWindow = _bind("SDL_GL_SwapWindow", [POINTER(SDL_Window)])
+SDL_GL_DeleteContext = _bind("SDL_GL_DeleteContext", [SDL_GLContext])