Arcade GUI

 KEY_UNLOAD = .KeyCode.L
 KEY_TOGGLE_UI = .KeyCode.N


 Players = :()
 UIS = :()
 RunService = :()

 LP = Players.LocalPlayer
 PG = LP:()




 Runtime = { alive = , conns = {}, objs = {} }

  (c)
	.(Runtime.conns, c)
	 c


  (o)
	.(Runtime.objs, o)
	 o


  ()
	  Runtime.alive   
	Runtime.alive = 

	
	(()
		 saveClickerData 
			clickerData.lastTimestamp = .()
			()
		
	)

	 _, c  (Runtime.conns) 
		(() c:() )
	
	.(Runtime.conns)

	 _, o  (Runtime.objs) 
		(() o:() )
	
	.(Runtime.objs)



  
	 g = ()
	 g.__ATLAS_ARCADE_UNLOAD 
		(g.__ATLAS_ARCADE_UNLOAD)
	
	g.__ATLAS_ARCADE_UNLOAD = unload





  (className, props, parent)
	 inst = .(className)
	 k, v  (props  {}) 
		inst[k] = v
	
	inst.Parent = parent
	(inst)
	 inst


  (text, parent)
	 b = (, {
		Text = text,
		Font = .Font.GothamBold,
		TextSize = ,
		TextColor3 = .(,,),
		BackgroundColor3 = .(,,),
		BorderSizePixel = ,
		AutoButtonColor = ,
		Size = .(, -, , ),
	}, parent)

	(, { CornerRadius = .(, ) }, b)
	(, { Thickness = , Color = .(,,), Transparency =  }, b)
	 b





 HttpService = :()
 SAVE_FOLDER = 
 SAVE_FILE = 
 SAVE_PATH = SAVE_FOLDER ..  .. SAVE_FILE


 has_writefile   = (writefile) == 
 has_readfile    = (readfile) == 
 has_isfile      = (isfile) == 
 has_isfolder    = (isfolder) == 
 has_makefolder  = (makefolder) == 

 defaultClickerData = {
	score = ,
	clickPower = ,   
	cps = ,          
	autoClickers = , 
	rebirths = , 
	lastTimestamp = .()
}

 clickerData = .(defaultClickerData)
clickerData.rebirths = clickerData.rebirths  

  ()
	 has_makefolder  has_isfolder 
		  (SAVE_FOLDER) 
			(makefolder, SAVE_FOLDER)
		
	 has_makefolder   has_isfolder 
		
		(makefolder, SAVE_FOLDER)
	



  ()
    
    clickerData = .(defaultClickerData)

    
     has_readfile  has_isfile 
        ()
         (SAVE_PATH) 
             ok, content = (readfile, SAVE_PATH)
             ok  content 
                 ok2, decoded = (()  HttpService:(content) )
                 ok2  (decoded) ==  
                    
                     k, v  (decoded) 
                        clickerData[k] = v
                    
                
            
        
            
             has_writefile 
                (writefile, SAVE_PATH, HttpService:(clickerData))
            
        
    

    
    clickerData.rebirths = clickerData.rebirths  

    
     now = .()
     last = clickerData.lastTimestamp  now
     secondsPassed = .(, now - last)
     secondsPassed >  
         earned = (clickerData.cps  ) * secondsPassed
        clickerData.score = (clickerData.score  ) + earned
    
    clickerData.lastTimestamp = now



  ()
      has_writefile   
    ()
    
    clickerData.lastTimestamp = .()
     ok, encoded = (()  HttpService:(clickerData) )
     ok 
        (writefile, SAVE_PATH, encoded)
    




()




 gui = (, {
	Name = ,
	ResetOnSpawn = ,
	ZIndexBehavior = .ZIndexBehavior.Sibling,
}, PG)

 main = (, {
	AnchorPoint = .(, ),
	Position = .(, , , ),
	Size = .(, , , ),
	BackgroundColor3 = .(,,),
	BorderSizePixel = ,
}, gui)
(, { CornerRadius = .(, ) }, main)
(, { Thickness = , Color = .(,,), Transparency =  }, main)

 top = (, {
	Size = .(, , , ),
	BackgroundTransparency = ,
}, main)

 title = (, {
	BackgroundTransparency = ,
	Size = .(, -, , ),
	Position = .(, , , ),
	TextXAlignment = .TextXAlignment.Left,
	Text = ()
		:(KEY_TOGGLE_UI.Name, KEY_UNLOAD.Name),
	Font = .Font.GothamBold,
	TextSize = ,
	TextColor3 = .(,,),
}, top)

 closeBtn = (, {
	AnchorPoint = .(, ),
	Position = .(, -, , ),
	Size = .(, , , ),
	Text = ,
	Font = .Font.GothamBold,
	TextSize = ,
	TextColor3 = .(,,),
	BackgroundColor3 = .(, , ),
	BorderSizePixel = ,
}, top)
(, { CornerRadius = .(, ) }, closeBtn)

 body = (, {
	Position = .(, , , ),
	Size = .(, , , -),
	BackgroundTransparency = ,
}, main)

 sidebar = (, {
	Position = .(, , , ),
	Size = .(, , , -),
	BackgroundColor3 = .(,,),
	BorderSizePixel = ,
}, body)
(, { CornerRadius = .(, ) }, sidebar)
(, { Thickness = , Color = .(,,), Transparency =  }, sidebar)

 sideList = (, {
	Padding = .(, ),
	SortOrder = .SortOrder.LayoutOrder,
}, sidebar)
sideList.HorizontalAlignment = .HorizontalAlignment.Center

(, {
	PaddingTop = .(, ),
	PaddingBottom = .(, ),
	PaddingLeft = .(, ),
	PaddingRight = .(, ),
}, sidebar)

 stage = (, {
	Position = .(, , , ),
	Size = .(, -, , -),
	BackgroundColor3 = .(,,),
	BorderSizePixel = ,
}, body)
(, { CornerRadius = .(, ) }, stage)
(, { Thickness = , Color = .(,,), Transparency =  }, stage)

  (text)
	 (, {
		BackgroundTransparency = ,
		Position = .(, , , ),
		Size = .(, -, , ),
		TextXAlignment = .TextXAlignment.Left,
		Text = text,
		Font = .Font.GothamBold,
		TextSize = ,
		TextColor3 = .(,,),
	}, stage)


  (text)
	 (, {
		BackgroundTransparency = ,
		Position = .(, , , ),
		Size = .(, -, , ),
		TextXAlignment = .TextXAlignment.Left,
		Text = text,
		Font = .Font.Gotham,
		TextSize = ,
		TextColor3 = .(,,),
	}, stage)


  ()
	 _, child  (stage:()) 
		 child:()  child.Name ~=   child.Name ~=  
			child:()
		
	





 activeGame = { stop = ()  }
  ()
	(activeGame.stop)
	activeGame.stop = () 





  ()
	()
	()

	()
	()

	
	
	

	 IDLE_EXPONENT =  

	  (n)
		 suffix = {,,,,,,,,,,}
		 n <  
			 (.(n))
		

		 i = .(.(n)/)
		 scaled = n / (^(i*))

		 .(,scaled,suffix[i+]  )
	

	  (count)
		 .( * ( ^ count))
	

	  (level)
		 .( * ( ^ (level-)))
	

	  (rebirths)
		 .( * ( ^ rebirths))
	

	clickerData.rebirths = clickerData.rebirths  

	
	
	

	 displayScore = (, {
		BackgroundTransparency = ,
		Position = .(,,,),
		Size = .(,-,,),
		TextXAlignment = .TextXAlignment.Left,
		Text = ,
		Font = .Font.GothamBold,
		TextSize = ,
		TextColor3 = .(,,)
	}, stage)

	  ()
		displayScore.Text =
			..(clickerData.score).. 
			..clickerData.rebirths
	

	
	
	

	 btn = (,{
		AnchorPoint = .(,),
		Position = .(,,,),
		Size = .(,,,),
		Text = ,
		Font = .Font.GothamBlack,
		TextSize = ,
		TextColor3 = .(,,),
		BackgroundColor3 = .(,,),
		BorderSizePixel = 
	},stage)

	(,{CornerRadius=.(,)},btn)

	
	
	

	 rebirthBtn = (,{
		AnchorPoint = .(,),
		Position = .(,,,),
		Size = .(,,,),
		TextScaled = ,
		BackgroundColor3 = .(,,),
		TextColor3 = .(,,)
	},stage)

	(,{CornerRadius=.(,)},rebirthBtn)

	
	
	

	 upgradesPanel = (,{
		Position = .(,,,),
		Size = .(,,,),
		BackgroundTransparency = 
	},stage)

	 autoBtn = (,upgradesPanel)
	autoBtn.Size = .(,,,)

	 powerBtn = (,upgradesPanel)
	powerBtn.Size = .(,,,)
	powerBtn.Position = .(,,,)

	 cpsLabel = (,{
		BackgroundTransparency = ,
		Position = .(,,,),
		Size = .(,,,),
		TextColor3 = .(,,),
		Font = .Font.Gotham,
		TextSize = 
	},upgradesPanel)

	  ()
		autoBtn.Text =
			..((clickerData.autoClickers))..
			..clickerData.autoClickers

		powerBtn.Text =
			..((clickerData.clickPower))..
			..clickerData.clickPower

		rebirthBtn.Text =
			..((clickerData.rebirths))

		cpsLabel.Text = ..(clickerData.cps)
	

	
	
	

	(btn.MouseButton1Click:(()

		 multi =  + clickerData.rebirths
		clickerData.score += clickerData.clickPower * multi
		 has_writefile  () 

		()
		()
	))

	
	
	

	(autoBtn.MouseButton1Click:(()

		 price = (clickerData.autoClickers)

		 clickerData.score >= price 
			clickerData.score -= price
			clickerData.autoClickers += 
			clickerData.cps += 
			 has_writefile  () 
			()
			()
		

	))

	
	
	

	(powerBtn.MouseButton1Click:(()

		 price = (clickerData.clickPower)

		 clickerData.score >= price 
			clickerData.score -= price
			clickerData.clickPower += 
			 has_writefile  () 
			()
			()
		

	))

	
	
	

	(rebirthBtn.MouseButton1Click:(()

		 price = (clickerData.rebirths)

		 clickerData.score >= price 

			clickerData.score = 
			clickerData.autoClickers = 
			clickerData.cps = 
			clickerData.clickPower = 

			clickerData.rebirths += 
			 has_writefile  () 

			()
			()

		

	))

	
	
	

	 fractional = 

	(RunService.Heartbeat:((dt)

		 cps = clickerData.cps

		 cps >  

			 multi =  + clickerData.rebirths
			 gain = (cps ^ IDLE_EXPONENT) * multi

			fractional += gain * dt

			 fractional >=  
				 add = .(fractional)
				clickerData.score += add
				fractional -= add
				()
			

			 has_writefile  () 

		

	))

	()
	()

	activeGame.stop = () 





  ()
	()
	()

	()
	()

	 play = (, {
		Position = .(, , , ),
		Size = .(, -, , -),
		BackgroundColor3 = .(,,),
		BorderSizePixel = ,
	}, stage)
	(, { CornerRadius = .(, ) }, play)

	 bird = (, {
		Size = .(, , , ),
		Position = .(, , , ),
		BackgroundColor3 = .(, , ),
		BorderSizePixel = ,
	}, play)
	(, { CornerRadius = .(, ) }, bird)

	 score = 
	 scoreLabel = (, {
		BackgroundTransparency = ,
		Position = .(, , , ),
		Size = .(, , , ),
		Text = ,
		Font = .Font.GothamBold,
		TextSize = ,
		TextColor3 = .(,,),
	}, play)

	 y = play.AbsoluteSize.Y * 
	 vel = 
	 gravity = 
	 flap = -
	 speed = 

	 pipes = {}
	  ()
		 gap = 
		 w = 
		 px = play.AbsoluteSize.X + 
		 topH = .(, .(, play.AbsoluteSize.Y - gap - ))
		 bottomY = topH + gap

		 topPipe = (, {
			Size = .(, w, , topH),
			Position = .(, px, , ),
			BackgroundColor3 = .(, , ),
			BorderSizePixel = ,
		}, play)

		 bottomPipe = (, {
			Size = .(, w, , play.AbsoluteSize.Y - bottomY),
			Position = .(, px, , bottomY),
			BackgroundColor3 = .(, , ),
			BorderSizePixel = ,
		}, play)

		 passed = 
		.(pipes, { top = topPipe, bottom = bottomPipe, passed = ()  passed , setPassed = (v) passed=v  })
	

	  (aPos, aSize, bPos, bSize)
		 aPos.X < bPos.X + bSize.X 
			   aPos.X + aSize.X > bPos.X 
			   aPos.Y < bPos.Y + bSize.Y 
			   aPos.Y + aSize.Y > bPos.Y
	

	 running = 
	 lastSpawn = 
	 spawnEvery = 
	 focused = 

	 focusBtn = (, {
		BackgroundTransparency = ,
		Size = .(, , , ),
		Text = ,
	}, play)

	 keyConn = (UIS.InputBegan:((input, gp)
		 gp   
		  running   focused   
		 input.KeyCode == .KeyCode.Space 
			vel = flap
		
	))

	 clickConn = (focusBtn.MouseButton1Click:(()
		focused = 
	))

	  ()
		  running   
		running = 
		(, {
			BackgroundTransparency = ,
			AnchorPoint = .(, ),
			Position = .(, , , ),
			Size = .(, -, , ),
			Text = ():(score),
			Font = .Font.GothamBlack,
			TextSize = ,
			TextColor3 = .(,,),
			TextWrapped = ,
		}, play)
	

	 hbConn
	hbConn = (RunService.Heartbeat:((dt)
		  Runtime.alive   running   

		lastSpawn += dt
		 lastSpawn >= spawnEvery 
			lastSpawn = 
			()
		

		vel += gravity * dt
		y += vel * dt

		 y <   y = ; vel =  
		 y > play.AbsoluteSize.Y -  
			y = play.AbsoluteSize.Y - 
			()
		

		bird.Position = .(, , , .(y))

		 birdPos = .(bird.AbsolutePosition.X, bird.AbsolutePosition.Y)
		 birdSize = .(bird.AbsoluteSize.X, bird.AbsoluteSize.Y)

		 i = #pipes, , - 
			 p = pipes[i]
			 p.top.Parent ==   p.bottom.Parent ==  
				.(pipes, i)
				
			

			 xNow = p.top.Position.X.Offset - speed * dt
			p.top.Position = .(, xNow, , )
			p.bottom.Position = .(, xNow, , p.bottom.Position.Y.Offset)

			  p.()  (xNow + p.top.AbsoluteSize.X) <  
				p.()
				score += 
				scoreLabel.Text =  .. score
			

			 topPos = .(p.top.AbsolutePosition.X, p.top.AbsolutePosition.Y)
			 topSize = .(p.top.AbsoluteSize.X, p.top.AbsoluteSize.Y)
			 botPos = .(p.bottom.AbsolutePosition.X, p.bottom.AbsolutePosition.Y)
			 botSize = .(p.bottom.AbsoluteSize.X, p.bottom.AbsoluteSize.Y)

			 (birdPos, birdSize, topPos, topSize)  (birdPos, birdSize, botPos, botSize) 
				()
			

			 xNow < - 
				(() p.top:() )
				(() p.bottom:() )
				.(pipes, i)
			
		
	))

	activeGame.stop = ()
		running = 
		(() hbConn:() )
		(() keyConn:() )
		(() clickConn:() )
	





  ()
	()
	()

	()
	()

	 play = (, {
		Position = .(, , , ),
		Size = .(, -, , -),
		BackgroundColor3 = .(,,),
		BorderSizePixel = ,
	}, stage)
	(, { CornerRadius = .(, ) }, play)

	 scoreL, scoreR = , 
	 scoreLabel = (, {
		BackgroundTransparency = ,
		Position = .(, , , ),
		Size = .(, , , ),
		Text = ,
		Font = .Font.GothamBlack,
		TextSize = ,
		TextColor3 = .(,,),
	}, play)

	 paddleH = 
	 paddleW = 
	 p1y, p2y = , 
	 pSpeed = 

	 p1 = (, {
		Size = .(, paddleW, , paddleH),
		Position = .(, , , p1y),
		BackgroundColor3 = .(,,),
		BorderSizePixel = ,
	}, play)

	 p2 = (, {
		Size = .(, paddleW, , paddleH),
		Position = .(, - - paddleW, , p2y),
		BackgroundColor3 = .(,,),
		BorderSizePixel = ,
	}, play)

	 ball = (, {
		Size = .(, , , ),
		BackgroundColor3 = .(, , ),
		BorderSizePixel = ,
	}, play)
	(, { CornerRadius = .(, ) }, ball)

	  (dir)
		 cx = play.AbsoluteSize.X/
		 cy = play.AbsoluteSize.Y/
		ball.Position = .(, cx, , cy)
		 .(dir * , .(-,))
	

	 vel = (.(,)==    -)
	 running = 
	 keys = { W=, S=, Up=, Down= }

	 inConnBegan = (UIS.InputBegan:((i, gp)
		 gp   
		 i.KeyCode == .KeyCode.W  keys.W= 
		 i.KeyCode == .KeyCode.S  keys.S= 
		 i.KeyCode == .KeyCode.Up  keys.Up= 
		 i.KeyCode == .KeyCode.Down  keys.Down= 
	))
	 inConnEnd = (UIS.InputEnded:((i)
		 i.KeyCode == .KeyCode.W  keys.W= 
		 i.KeyCode == .KeyCode.S  keys.S= 
		 i.KeyCode == .KeyCode.Up  keys.Up= 
		 i.KeyCode == .KeyCode.Down  keys.Down= 
	))

	  (ax, ay, aw, ah, bx, by, bw, bh)
		 ax < bx + bw  ax + aw > bx  ay < by + bh  ay + ah > by
	

	 hbConn
	hbConn = (RunService.Heartbeat:((dt)
		  running   

		 keys.W  p1y -= pSpeed*dt 
		 keys.S  p1y += pSpeed*dt 
		 keys.Up  p2y -= pSpeed*dt 
		 keys.Down  p2y += pSpeed*dt 

		 maxY = play.AbsoluteSize.Y - paddleH
		p1y = .(p1y, , maxY)
		p2y = .(p2y, , maxY)

		p1.Position = .(, , , p1y)
		p2.Position = .(, - - paddleW, , p2y)

		 bx = ball.Position.X.Offset + vel.X * dt
		 by = ball.Position.Y.Offset + vel.Y * dt

		 by <   by = ; vel = .(vel.X, -vel.Y) 
		 by > play.AbsoluteSize.Y -   by = play.AbsoluteSize.Y - ; vel = .(vel.X, -vel.Y) 

		 p1x = 
		 p2x = play.AbsoluteSize.X -  - paddleW

		 (bx, by, , , p1x, p1y, paddleW, paddleH)  vel.X <  
			vel = .(-vel.X * , vel.Y + (by - (p1y + paddleH/)) * )
		
		 (bx, by, , , p2x, p2y, paddleW, paddleH)  vel.X >  
			vel = .(-vel.X * , vel.Y + (by - (p2y + paddleH/)) * )
		

		 bx < - 
			scoreR += 
			vel = ()
		 bx > play.AbsoluteSize.X +  
			scoreL += 
			vel = (-)
		

		scoreLabel.Text = ():(scoreL, scoreR)

		 scoreL >=   scoreR >=  
			running = 
			(, {
				BackgroundTransparency = ,
				AnchorPoint = .(, ),
				Position = .(, , , ),
				Size = .(, -, , ),
				Text = (scoreL > scoreR)    ,
				Font = .Font.GothamBlack,
				TextSize = ,
				TextColor3 = .(,,),
			}, play)
		

		ball.Position = .(, bx, , by)
	))

	activeGame.stop = ()
		running = 
		(() hbConn:() )
		(() inConnBegan:() )
		(() inConnEnd:() )
	





  ()
	()
	()

	()
	()

	 play = (, {
		Position = .(, , , ),
		Size = .(, -, , -),
		BackgroundColor3 = .(,,),
		BorderSizePixel = ,
	}, stage)
	(, { CornerRadius = .(, ) }, play)

	 cell = 
	 cols = .((play.AbsoluteSize.X) / cell)
	 rows = .((play.AbsoluteSize.Y) / cell)

	 score = 
	 scoreLabel = (, {
		BackgroundTransparency = ,
		Position = .(, , , ),
		Size = .(, , , ),
		Text = ,
		Font = .Font.GothamBold,
		TextSize = ,
		TextColor3 = .(,,),
	}, play)

	 dir = .(,)
	 pendingDir = dir
	 snake = { .(.(cols/), .(rows/)) }
	 grow = 
	 food = .(.(, cols-), .(, rows-))

	 cells = {}
	  (pos, color)
		 key = pos.X....pos.Y
		 f = cells[key]
		  f 
			f = (, {
				Size = .(, cell-, , cell-),
				BackgroundColor3 = color,
				BorderSizePixel = ,
			}, play)
			cells[key] = f
		
		f.BackgroundColor3 = color
		f.Position = .(, pos.X*cell, , pos.Y*cell)
		f.Visible = 
	

	  ()
		 _, f  (cells) 
			f.Visible = 
		
	

	  (p)
		 _, s  (snake) 
			 s.X == p.X  s.Y == p.Y    
		
		 
	

	  ()
		 p
		
			p = .(.(, cols-), .(, rows-))
		  (p)
		food = p
	

	 running = 
	 keyConn = (UIS.InputBegan:((i, gp)
		 gp   
		 i.KeyCode == .KeyCode.W  dir.Y ~=   pendingDir = .(,-) 
		 i.KeyCode == .KeyCode.S  dir.Y ~= -  pendingDir = .(,) 
		 i.KeyCode == .KeyCode.A  dir.X ~=   pendingDir = .(-,) 
		 i.KeyCode == .KeyCode.D  dir.X ~= -  pendingDir = .(,) 
	))

	 step = 
	 stepEvery = 

	 hbConn
	hbConn = (RunService.Heartbeat:((dt)
		  running   

		step += dt
		 step < stepEvery 
			()
			 _, s  (snake) 
				(s, .(, , ))
			
			(food, .(, , ))
			
		
		step = 

		dir = pendingDir
		 head = snake[]
		 nextHead = .(head.X + dir.X, head.Y + dir.Y)

		 nextHead.X <   nextHead.Y <   nextHead.X > cols-  nextHead.Y > rows- 
			running = 
		
		 running  (nextHead) 
			running = 
		

		  running 
			(, {
				BackgroundTransparency = ,
				AnchorPoint = .(,),
				Position = .(,,,),
				Size = .(,-,,),
				Text = ():(score),
				Font = .Font.GothamBlack,
				TextSize = ,
				TextColor3 = .(,,),
				TextWrapped = ,
			}, play)
			
		

		.(snake, , nextHead)

		 nextHead.X == food.X  nextHead.Y == food.Y 
			score += 
			scoreLabel.Text =  .. score
			grow += 
			()
		

		 grow >  
			grow -= 
		
			.(snake, #snake)
		
	))

	activeGame.stop = ()
		running = 
		(() hbConn:() )
		(() keyConn:() )
	





  ()
	()
	()

	()
	()

	 play = (, {
		Position = .(, , , ),
		Size = .(, -, , -),
		BackgroundColor3 = .(,,),
		BorderSizePixel = ,
	}, stage)
	(, { CornerRadius = .(, ) }, play)

	 emojis = { ,,, }
	 deck = {}
	 _, e  (emojis) 
		.(deck, e)
		.(deck, e)
	
	 i = #deck, , - 
		 j = .(, i)
		deck[i], deck[j] = deck[j], deck[i]
	

	 flips, matched = , 
	 lock = 
	 first = 

	 label = (, {
		BackgroundTransparency = ,
		Position = .(, , , ),
		Size = .(, -, , ),
		TextXAlignment = .TextXAlignment.Left,
		Text = ,
		Font = .Font.GothamBold,
		TextSize = ,
		TextColor3 = .(,,),
	}, play)

	 grid = (, {
		AnchorPoint = .(, ),
		Position = .(, , , ),
		Size = .(, , , ),
		BackgroundTransparency = ,
	}, play)
	(, {
		CellPadding = .(, , , ),
		CellSize = .(, , , ),
	}, grid)

	 cards = {}
	 idx = ,  
		 btn = (, {
			Text = ,
			Font = .Font.GothamBlack,
			TextSize = ,
			TextColor3 = .(,,),
			BackgroundColor3 = .(,,),
			BorderSizePixel = ,
			AutoButtonColor = ,
		}, grid)
		(, { CornerRadius = .(, ) }, btn)

		cards[idx] = { btn = btn, value = deck[idx], revealed = , done =  }

		(btn.MouseButton1Click:(()
			 lock   
			 c = cards[idx]
			 c.done  c.revealed   

			c.revealed = 
			c.btn.Text = c.value
			c.btn.BackgroundColor3 = .(, , )

			flips += 
			label.Text =  .. flips

			  first 
				first = idx
				
			

			lock = 
			 a = cards[first]
			 b = c

			.(, ()
				  Runtime.alive   

				 a.value == b.value 
					a.done = ; b.done = 
					a.btn.BackgroundColor3 = .(, , )
					b.btn.BackgroundColor3 = .(, , )
					matched += 
					 matched >=  
						(, {
							BackgroundTransparency = ,
							AnchorPoint = .(, ),
							Position = .(, , , ),
							Size = .(, -, , ),
							Text = ,
							Font = .Font.GothamBlack,
							TextSize = ,
							TextColor3 = .(,,),
						}, play)
					
				
					a.revealed = ; b.revealed = 
					a.btn.Text = 
					b.btn.Text = 
					a.btn.BackgroundColor3 = .(,,)
					b.btn.BackgroundColor3 = .(,,)
				

				first = 
				lock = 
			)
		))
	

	activeGame.stop = ()
		lock = 
	





 btnClicker = (, sidebar)
 btnFlappy  = (, sidebar)
 btnPong    = (, sidebar)
 btnSnake   = (, sidebar)
 btnMemory  = (, sidebar)

(, {
	BackgroundTransparency = ,
	Size = .(, -, , ),
	TextWrapped = ,
	TextYAlignment = .TextYAlignment.Top,
	TextXAlignment = .TextXAlignment.Left,
	Text = ()
		:(KEY_TOGGLE_UI.Name, KEY_UNLOAD.Name),
	Font = .Font.Gotham,
	TextSize = ,
	TextColor3 = .(,,),
}, sidebar)

(btnClicker.MouseButton1Click:(startClicker))
(btnFlappy.MouseButton1Click:(startFlappy))
(btnPong.MouseButton1Click:(startPong))
(btnSnake.MouseButton1Click:(startSnake))
(btnMemory.MouseButton1Click:(startMemory))


()




(closeBtn.MouseButton1Click:(unload))

(UIS.InputBegan:((input, gp)
	 gp   
	 input.KeyCode == KEY_UNLOAD 
		()
	 input.KeyCode == KEY_TOGGLE_UI 
		main.Visible =  main.Visible
	
))