import random
from PIL import Image

n0 = [
    [1,1,1],
    [1,0,1],
    [1,0,1],
    [1,0,1],
    [1,1,1]
]

n_x = [
    [0,0,0],
    [0,0,0],
    [1,0,1],
    [0,1,0],
    [1,0,1]
]

hexnumbers = [
    [  # 0
        [1,1,1],
        [1,0,1],
        [1,0,1],
        [1,0,1],
        [1,1,1]
    ],

    [  # 1
        [0,1,0],
        [1,1,0],
        [0,1,0],
        [0,1,0],
        [1,1,1]
    ],

    [  # 2
        [1,1,1],
        [0,0,1],
        [1,1,1],
        [1,0,0],
        [1,1,1]
    ],

    [  # 3
        [1,1,1],
        [0,0,1],
        [1,1,1],
        [0,0,1],
        [1,1,1]
    ],

    [  # 4
        [1,0,1],
        [1,0,1],
        [1,1,1],
        [0,0,1],
        [0,0,1]
    ],

    [  # 5
        [1,1,1],
        [1,0,0],
        [1,1,1],
        [0,0,1],
        [1,1,1]
    ],

    [  # 6
        [1,1,1],
        [1,0,0],
        [1,1,1],
        [1,0,1],
        [1,1,1]
    ],

    [  # 7
        [1,1,1],
        [0,0,1],
        [0,0,1],
        [0,0,1],
        [0,0,1]
    ],

    [  # 8
        [1,1,1],
        [1,0,1],
        [1,1,1],
        [1,0,1],
        [1,1,1]
    ],

    [  # 9
        [1,1,1],
        [1,0,1],
        [1,1,1],
        [0,0,1],
        [1,1,1]
    ],

    [  # A (10)
        [1,1,1],
        [1,0,1],
        [1,1,1],
        [1,0,1],
        [1,0,1]
    ],

    [  # B (11)
        [1,1,0],
        [1,0,1],
        [1,1,0],
        [1,0,1],
        [1,1,0]
    ],

    [  # C (12)
        [1,1,1],
        [1,0,0],
        [1,0,0],
        [1,0,0],
        [1,1,1]
    ],

    [  # D (13)
        [1,1,0],
        [1,0,1],
        [1,0,1],
        [1,0,1],
        [1,1,0]
    ],

    [  # E (14)
        [1,1,1],
        [1,0,0],
        [1,1,1],
        [1,0,0],
        [1,1,1]
    ],

    [  # F (15)
        [1,1,1],
        [1,0,0],
        [1,1,1],
        [1,0,0],
        [1,0,0]
    ]
]

### FONT: https://github.com/teryror/pixel-fonts/tree/master
a_p = [
    [1,1,1,1,1,0],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,1,1,1,0],
    [1,1,0,0,0,0],
    [1,1,0,0,0,0],
    [1,1,0,0,0,0]
]
a_1 = [
    [0,0,0,1,1,0],
    [0,0,1,1,1,0],
    [0,1,1,1,1,0],
    [1,1,0,1,1,0],
    [0,0,0,1,1,0],
    [0,0,0,1,1,0],
    [0,0,0,1,1,0],
    [0,0,0,1,1,0]
]
a_2 = [
    [0,1,1,1,1,0],
    [1,1,0,0,1,1],
    [0,0,0,0,1,1],
    [0,0,0,1,1,0],
    [0,0,1,1,0,0],
    [0,1,1,0,0,0],
    [1,1,0,0,0,0],
    [1,1,1,1,1,1]
]

a_s = [
    [0,1,1,1,1,0],
    [1,1,0,0,1,1],
    [1,1,0,0,0,0],
    [0,1,1,1,0,0],
    [0,0,1,1,1,0],
    [0,0,0,0,1,1],
    [1,1,0,0,1,1],
    [0,1,1,1,1,0]
]

a_h = [
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,1,1,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1]
]

a_w = [
    [1,1,0,0,1,0,0,1,1],
    [1,1,0,0,1,0,0,1,1],
    [1,1,0,1,1,1,0,1,1],
    [1,1,1,1,1,1,1,1,1],
    [0,1,1,1,0,1,1,1,0],
    [0,1,1,1,0,1,1,1,0],
    [0,1,1,0,0,0,1,1,0],
    [0,0,1,0,0,0,1,0,0]
]

a_c = [
    [0,1,1,1,1,0],
    [1,1,1,0,1,1],
    [1,1,0,0,0,0],
    [1,1,0,0,0,0],
    [1,1,0,0,0,0],
    [1,1,0,0,0,0],
    [1,1,1,0,1,1],
    [0,1,1,1,1,0]
]

a_o = [
    [0,1,1,1,1,0],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [0,1,1,1,1,0]
]

a_r = [
    [1,1,1,1,1,0],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1],
    [1,1,1,1,1,0],
    [1,1,0,1,1,1],
    [1,1,0,0,1,1],
    [1,1,0,0,1,1]
]

a_e = [
    [1,1,1,1,1,1],
    [1,1,0,0,0,0],
    [1,1,0,0,0,0],
    [1,1,1,1,1,1],
    [1,1,0,0,0,0],
    [1,1,0,0,0,0],
    [1,1,0,0,0,0],
    [1,1,1,1,1,1]
]

class color:
    def __init__(self, color=None, red=None, green=None, blue=None, alpha=255) -> None:
        # Allow hex string input like "#ff8800" or "ff8800"
        if isinstance(color, str):
            hexcode = color.lstrip("#")

            if len(hexcode) not in (6, 8):
                raise ValueError("Hex color must be 6 or 8 characters long")

            self.r = int(hexcode[0:2], 16)
            self.g = int(hexcode[2:4], 16)
            self.b = int(hexcode[4:6], 16)

            if len(hexcode) == 8:
                self.a = int(hexcode[6:8], 16)
            else:
                self.a = alpha

        else:
            # Regular RGB(A) input
            self.r = red
            self.g = green
            self.b = blue
            self.a = alpha
    def get(self) -> tuple[int, int, int]:
        return (self.r, self.g, self.b)
    def sub(self, n) -> tuple[int, int, int]:
        if self.r:
            r=self.r-n
        else:
            r=0
        if self.g:
            g=self.g-n
        else:
            g=0
        if self.b:
            b=self.b-n
        else:
            b=0
        return (r,g,b)
        
    def multiply(self, other) -> tuple[int, int, int]:
        r = other[0]
        g = other[1]
        b = other[2]
        return (((self.r * r) >> 8), ((self.g * g) >> 8), ((self.b * b)>>8))
    def shiftr(self, n):
        return ((self.r  >> n), (self.g  >> n), (self.b >>n))
    def mask(self, n):
        return ((self.r & n), (self.g & n), (self.b & n))

class coord:
    def __init__(self, x, y, width, height) -> None:
        self.x = x
        self.y = y
        self.width = width
        self.height = height
    
def make_next_board():
    next_board = [
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 1, 0, 0],
        [1, 1, 1, 0],
    ]
    return next_board

def make_board(n: int):
    board_height = 20
    board_width = 10

    board = []

    for _ in range(2):
        line = []

        for _ in range(board_width):
            line.append(0)

        board.append(line)

    board.append([0,1,2,3,4,5,6,7,0,0])

    for _ in range(board_height - 3):
        line = []

        for _ in range(board_width):
            line.append(random.randint(0, n-1))

        board.append(line)


    return board_height, board_width, board

def make_sprite():
    sprite = Image.open("img/bitmap.png")

    sprite_pixels = sprite.load()

    sprite_width, sprite_height = sprite.size

    return sprite_pixels, sprite_width, sprite_height

def make_score():
    score = random.randint(0, 999999999)
    return score

black    = color("#000000")
white    = color("#ffffff")

red      = color("#ff0000")
cyan     = color("#00ffff")

blue     = color("#0000ff")
yellow   = color("#fff200")

green    = color("#00ff00")
magenta  = color("#ff00ff")

orange   = color("#ff8000")
sky_blue = color("#0080ff")

purple   = color("#9d00ff")
lime     = color("#5fdf5f")

colors = [
    black,
    cyan,
    blue,
    orange,
    yellow,
    green,
    purple,
    red
]

colors2 = [
    black,
    color("#0086f3"),
    color("#3d4fdc"),
    color("#fdab01"),
    color("#abcb04"),
    color("#02bdcd"),
    color("#d20f63"),
    color("#fe4b0f"),
]


text_bg = black

next_board = make_next_board()
nb1 = coord(88, 104, 128, 128)
next_board1 = make_next_board()
nb2 = coord(1064, 104, 128, 128)

board_height, board_width, board = make_board(len(colors))
b1 = coord(304, 40, 320, 640)
board2_height, board2_width, board2 = make_board(len(colors2))
b2 = coord(656, 40, 320, 640)

score0 = make_score()
s1  = coord(84, 332, 136, 32)
sn1 = coord(74, 368, 156, 20)
score1 = make_score()
s2  = coord(1060, 332, 136, 32)
sn2 = coord(1050, 368, 156, 20)

mm0 = coord(576, 155, 128, 128)
mm1 = coord(576, 437, 128, 128)

lm0 = coord(120, 476, 58, 32)
lm1 = coord(120, 516, 58, 32)
lm2 = coord(120, 556, 64, 32)
lm3 = coord(120, 596, 64, 32)

rm0 = coord(1096, 476, 58, 32)
rm1 = coord(1096, 516, 58, 32)
rm2 = coord(1096, 556, 64, 32)
rm3 = coord(1096, 596, 64, 32)

width = 1280
height = 720

img = Image.new("RGB", (width, height))

pixels = img.load()

menu = 1

for y in range(height):
    for x in range(width):
        ### BG
        if (x+y)&1:
            pixels[x, y] = (0, 0, 255)
        else:
            pixels[x, y] = ((x+y)>>3, (((1280+720)>>3)-((x+y)>>3)), 0)
        ####################### MENU
        if menu and x >= mm0.x and x < (mm0.x + mm0.width) and y >= mm0.y and y < (mm0.y + mm0.height):
            xd = x-mm0.x
            yd = y-mm0.y
            xs = xd >> 3
            ys = yd >> 3
            if x > mm0.x+3 and y>mm0.y+3 and xd<mm0.width-4 and yd<mm0.height-4:
                if xs <ys*2 and xs<((mm0.width-8 >> 3)-ys)<<1 and xs >2:
                    pixels[x, y] = (255,255,255)
                elif (xs == ys*2 or xs==((mm0.width-8 >> 3)-ys)<<1) and xs >2 and xs <14:
                    pixels[x, y] = (32,32,32)
                else:
                    pixels[x, y] = black.get()
            else:
                pixels[x, y] = (128,128,128)

        elif menu and x >= mm1.x and x < (mm1.x + mm1.width) and y >= mm1.y and y < (mm1.y + mm1.height):
            xd = x-mm1.x-4
            yd = y-mm1.y-4
            xs = xd >> 3
            ys = yd >> 3
            if x > mm1.x+3 and y>mm1.y+3 and xd<mm1.width-8 and yd<mm1.height-8:
                # vert/horizontal
                if xs == 2 and ys < 10 and ys > 4: # left
                    pixels[x, y] = white.get()
                elif xs == 11 and ys < 8 and ys > 4: # right
                    pixels[x, y] = white.get()
                elif ys == 2 and xs < 10 and xs > 4: # top
                    pixels[x, y] = white.get()
                elif ys == 12 and xs < 10 and xs > 4: # bot
                    pixels[x, y] = white.get()
                # Orthogonal
                elif xs+ys == 7 and xs >1 and ys >1: # top left
                    pixels[x, y] = white.get()
                elif xs+ys == 21 and xs >8 and ys >9: # bot right
                    pixels[x, y] = white.get()
                elif ys-xs == 7 and xs < 6 and ys > 8: # bot left
                    pixels[x, y] = white.get()
                elif xs-ys == 7 and xs > 8 and ys < 5: # top right
                    pixels[x, y] = white.get()
                # Arrow Head
                elif xs-ys == 4 and xs > 8 and xs < 12: # left
                    pixels[x, y] = white.get()
                elif xs+ys == 18 and xs > 10 and xs <14: # right
                    pixels[x, y] = white.get()
                # Aliasing
                elif (xs==ys==11) or (xs==ys==3) or (xs==11 and ys==3) or (xs==3 and ys==11):
                    pixels[x, y] = (32,32,32)
                else:
                    pixels[x, y] = black.get()
            else:
                pixels[x, y] = (128,128,128)
        ####################### Left Side
        ### Board
        elif x>=b1.x and x<b1.x+b1.width and y>=b1.y and y<b1.y+b1.height:
            xd = x-b1.x
            yd = y-b1.y
            xs = xd&0x1F
            ys = yd&0x1F
            if (xs > 7 and xs < 24) and (ys > 7 and ys < 24): # middle
                pixels[x, y] = colors[board[yd>>5][xd>>5]].get()
            elif (xs > 5 and xs < 26) and (ys > 5 and ys < 26): # mid boarder
                pixels[x, y] = colors[board[yd>>5][xd>>5]].mask(0xFFFFFFB0)
            elif xs+ys<31: # top left edge
                if xs>ys:
                    pixels[x, y] = colors[board[yd>>5][xd>>5]].get()
                else:
                    pixels[x, y] = colors[board[yd>>5][xd>>5]].mask(0xFFFFFFEF)
            else:
                if xs>ys:
                    pixels[x, y] = colors[board[yd>>5][xd>>5]].mask(0xFFFFFFD7)
                else:
                    pixels[x, y] = colors[board[yd>>5][xd>>5]].mask(0xFFFFFFC0)
        ### Next Piece
        elif x>=nb1.x and x<nb1.x+nb1.width and y>=nb1.y and y<nb1.y+nb1.height:
            xd = x-nb1.x
            yd = y-nb1.y
            xs = xd&0x1F
            ys = yd&0x1F
            if (xs > 7 and xs < 24) and (ys > 7 and ys < 24): # middle
                pixels[x, y] = colors[next_board[yd>>5][xd>>5]].get()
            elif (xs > 5 and xs < 26) and (ys > 5 and ys < 26): # mid next_boarder
                pixels[x, y] = colors[next_board[yd>>5][xd>>5]].mask(0xFFFFFFB0)
            elif xs+ys<31: # top left edge
                if xs>ys:
                    pixels[x, y] = colors[next_board[yd>>5][xd>>5]].get()
                else:
                    pixels[x, y] = colors[next_board[yd>>5][xd>>5]].mask(0xFFFFFFEF)
            else:
                if xs>ys:
                    pixels[x, y] = colors[next_board[yd>>5][xd>>5]].mask(0xFFFFFFD7)
                else:
                    pixels[x, y] = colors[next_board[yd>>5][xd>>5]].mask(0xFFFFFFC0)
        ### Score text
        elif x>=s1.x and x<s1.x+s1.width and y>=s1.y and y<s1.y+s1.height:
            yd = y-s1.y
            if x < (24+s1.x) and a_s[yd>>2][(x-s1.x)>>2]:
                pixels[x, y] = white.get()
            elif x<(52+s1.x) and x > (28+s1.x) and a_c[yd>>2][(x-(28+s1.x))>>2]:
                pixels[x, y] = white.get()
            elif x<(80+s1.x) and x > (56+s1.x) and a_o[yd>>2][(x-(56+s1.x))>>2]:
                pixels[x, y] = white.get()
            elif x<(108+s1.x) and x > (84+s1.x) and a_r[yd>>2][(x-(84+s1.x))>>2]:
                pixels[x, y] = white.get()
            elif x > (112+s1.x) and a_e[yd>>2][(x-(112+s1.x))>>2]:
                pixels[x, y] = white.get()
        ### Score num
        elif x>=sn1.x and x<sn1.x+sn1.width and y>=sn1.y and y<sn1.y+sn1.height:
            yd = y-sn1.y
            if ((x >= 74  and x < 86)  and n0[yd>>2][(x -74)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 90  and x < 102) and n_x[yd>>2][(x -90)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 106 and x < 118) and hexnumbers[score0>>28&0b1111][yd>>2][(x -106)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 122 and x < 134) and hexnumbers[score0>>24&0b1111][yd>>2][(x -122)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 138 and x < 150) and hexnumbers[score0>>20&0b1111][yd>>2][(x -138)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 154 and x < 166) and hexnumbers[score0>>16&0b1111][yd>>2][(x -154)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 170 and x < 182) and hexnumbers[score0>>12&0b1111][yd>>2][(x -170)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 186 and x < 198) and hexnumbers[score0>>8&0b1111][yd>>2][(x -186)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 202 and x < 214) and hexnumbers[score0>>4&0b1111][yd>>2][(x -202)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 218 and x < 230) and hexnumbers[score0&0b1111][yd>>2][(x -218)>>2]):
                pixels[x, y] = white.get()
            else:
                pixels[x, y] = black.get()
            # pixels[x, y] = text_bg.get()
        ### Menu
        elif x >= lm0.x and x < (lm0.x + lm0.width) and y >= lm0.y and y < (lm0.y + lm0.height):
            xd = x-lm0.x
            yd = y-lm0.y
            xs = xd-34
            if xd < (24) and a_p[yd>>2][xd>>2]:
                pixels[x, y] = white.get()
            elif xd > (33) and a_1[yd>>2][xs>>2]:
                pixels[x, y] = white.get()
        elif x >= lm1.x and x < (lm1.x + lm1.width) and y >= lm1.y and y < (lm1.y + lm1.height):
            xd = x-lm1.x
            yd = y-lm1.y
            xs = xd-34
            if xd < (24) and a_p[yd>>2][xd>>2]:
                pixels[x, y] = white.get()
            elif xd > (33) and a_2[yd>>2][xs>>2]:
                pixels[x, y] = white.get()
        elif x >= lm2.x and x < (lm2.x + lm2.width) and y >= lm2.y and y < (lm2.y + lm2.height):
            xd = x-lm2.x
            yd = y-lm2.y
            xs = xd-28
            if xd < (24) and a_s[yd>>2][xd>>2]:
                pixels[x, y] = white.get()
            elif xd > (27) and a_w[yd>>2][xs>>2]:
                pixels[x, y] = white.get()
        elif x >= lm3.x and x < (lm3.x + lm3.width) and y >= lm3.y and y < (lm3.y + lm3.height):
            xd = x-lm3.x
            yd = y-lm3.y
            xs = xd-28
            if xd < (24) and a_h[yd>>2][xd>>2]:
                pixels[x, y] = white.get()
            elif xd > (27) and a_w[yd>>2][xs>>2]:
                pixels[x, y] = white.get()
        ####################### Right Board
        ### Board
        elif x>=b2.x and x<b2.x+b2.width and y>=b2.y and y<b2.y+b2.height:
            xd = x-b2.x
            yd = y-b2.y
            xs = xd&0x1F
            ys = yd&0x1F
            if (xs > 7 and xs < 24) and (ys > 7 and ys < 24): # middle
                pixels[x, y] = colors[board2[yd>>5][xd>>5]].get()
            elif (xs > 5 and xs < 26) and (ys > 5 and ys < 26): # mid boarder
                pixels[x, y] = colors[board2[yd>>5][xd>>5]].mask(0xFFFFFFB0)
            elif xs+ys<31: # top left edge
                if xs>ys:
                    pixels[x, y] = colors[board2[yd>>5][xd>>5]].get()
                else:
                    pixels[x, y] = colors[board2[yd>>5][xd>>5]].mask(0xFFFFFFEF)
            else:
                if xs>ys:
                    pixels[x, y] = colors[board2[yd>>5][xd>>5]].mask(0xFFFFFFD7)
                else:
                    pixels[x, y] = colors[board2[yd>>5][xd>>5]].mask(0xFFFFFFC0)
        ### Next Piece
        elif x>=nb2.x and x<nb2.x+nb2.width and y>=nb2.y and y<nb2.y+nb2.height:
            xd = x-nb2.x
            yd = y-nb2.y
            xs = xd&0x1F
            ys = yd&0x1F
            if (xs > 7 and xs < 24) and (ys > 7 and ys < 24): # middle
                pixels[x, y] = colors[next_board1[yd>>5][xd>>5]].get()
            elif (xs > 5 and xs < 26) and (ys > 5 and ys < 26): # mid next_boarder
                pixels[x, y] = colors[next_board1[yd>>5][xd>>5]].mask(0xFFFFFFB0)
            elif xs+ys<31: # top left edge
                if xs>ys:
                    pixels[x, y] = colors[next_board1[yd>>5][xd>>5]].get()
                else:
                    pixels[x, y] = colors[next_board1[yd>>5][xd>>5]].mask(0xFFFFFFEF)
            else:
                if xs>ys:
                    pixels[x, y] = colors[next_board1[yd>>5][xd>>5]].mask(0xFFFFFFD7)
                else:
                    pixels[x, y] = colors[next_board1[yd>>5][xd>>5]].mask(0xFFFFFFC0)
        ### Score Text
        elif x>=s2.x and x<s2.x+s2.width and y>=s2.y and y<s2.y+s2.height:
            yd = y-s2.y
            if x < (24+s2.x) and a_s[yd>>2][(x-s2.x)>>2]:
                pixels[x, y] = white.get()
            elif x<(52+s2.x) and x > (28+s2.x) and a_c[yd>>2][(x-(28+s2.x))>>2]:
                pixels[x, y] = white.get()
            elif x<(80+s2.x) and x > (56+s2.x) and a_o[yd>>2][(x-(56+s2.x))>>2]:
                pixels[x, y] = white.get()
            elif x<(108+s2.x) and x > (84+s2.x) and a_r[yd>>2][(x-(84+s2.x))>>2]:
                pixels[x, y] = white.get()
            elif x > (112+s2.x) and a_e[yd>>2][(x-(112+s2.x))>>2]:
                pixels[x, y] = white.get()
        ### Score Num
        elif x>=sn2.x and x<sn2.x+sn2.width and y>=sn2.y and y<sn2.y+sn2.height:
            yd = y-sn2.y
            if ((x >= 1050  and x < 1062)  and n0[yd>>2][(x -1050)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1066  and x < 1078) and n_x[yd>>2][(x -1066)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1082 and x < 1094) and hexnumbers[score1>>28&0b1111][yd>>2][(x -1082)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1098 and x < 1110) and hexnumbers[score1>>24&0b1111][yd>>2][(x -1098)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1114 and x < 1126) and hexnumbers[score1>>20&0b1111][yd>>2][(x -1114)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1130 and x < 1142) and hexnumbers[score1>>16&0b1111][yd>>2][(x -1130)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1146 and x < 1158) and hexnumbers[score1>>12&0b1111][yd>>2][(x -1146)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1162 and x < 1174) and hexnumbers[score1>>8&0b1111][yd>>2][(x -1162)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1178 and x < 1190) and hexnumbers[score1>>4&0b1111][yd>>2][(x -1178)>>2]):
                pixels[x, y] = white.get()
            elif ((x >= 1194 and x < 1206) and hexnumbers[score1&0b1111][yd>>2][(x -1194)>>2]):
                pixels[x, y] = white.get()
            else:
                pixels[x, y] = black.get()
        ### Menu
        elif x >= rm0.x and x < (rm0.x + rm0.width) and y >= rm0.y and y < (rm0.y + rm0.height):
            xd = x-rm0.x
            yd = y-rm0.y
            xs = xd-34
            if xd < (24) and a_p[yd>>2][xd>>2]:
                pixels[x, y] = white.get()
            elif xd > (33) and a_1[yd>>2][xs>>2]:
                pixels[x, y] = white.get()
        elif x >= rm1.x and x < (rm1.x + rm1.width) and y >= rm1.y and y < (rm1.y + rm1.height):
            xd = x-rm1.x
            yd = y-rm1.y
            xs = xd-34
            if xd < (24) and a_p[yd>>2][xd>>2]:
                pixels[x, y] = white.get()
            elif xd > (33) and a_2[yd>>2][xs>>2]:
                pixels[x, y] = white.get()
        elif x >= rm2.x and x < (rm2.x + rm2.width) and y >= rm2.y and y < (rm2.y + rm2.height):
            xd = x-rm2.x
            yd = y-rm2.y
            xs = xd-28
            if xd < (24) and a_s[yd>>2][xd>>2]:
                pixels[x, y] = white.get()
            elif xd > (27) and a_w[yd>>2][xs>>2]:
                pixels[x, y] = white.get()
        elif x >= rm3.x and x < (rm3.x + rm3.width) and y >= rm3.y and y < (rm3.y + rm3.height):
            xd = x-rm3.x
            yd = y-rm3.y
            xs = xd-28
            if xd < (24) and a_h[yd>>2][xd>>2]:
                pixels[x, y] = white.get()
            elif xd > (27) and a_w[yd>>2][xs>>2]:
                pixels[x, y] = white.get()

img.save("output/alpha.png")
img.show()