/*
TWITTER: https://twitter.com/FireGaryG 
TELEGRAM: https://t.me/FIREGARYGENSLER
WEBSITE: https://firegarygensler.com
*/
/*
▄▄███▄▄·███████╗ ██████╗  ██████╗                                                                                               
██╔════╝██╔════╝██╔════╝ ██╔════╝                                                                                               
███████╗█████╗  ██║  ███╗██║  ███╗                                                                                              
╚════██║██╔══╝  ██║   ██║██║   ██║                                                                                              
███████║██║     ╚██████╔╝╚██████╔╝                                                                                              
╚═▀▀▀══╝╚═╝      ╚═════╝  ╚═════╝                                                                                               

▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
                                         ██              ██             ██                ██      ██
                                         ▓▓                  ▓▓██▓██  ▓▓▒▒▒▒    ▓▓██▓▓██  ▓▓▒▒▒▒▓▓▒▒▒    ▓▓██▓▓██  ▓▓▒
                                       ▓▓▒▒▒▒      ██    ▓▓▒▒▒▒▓▓▒▓▓▒▒▒▒▒▒  ▓▓▒▒▒▒▓▓▒▒▓▓▒▒▒▒▒▒▓▓▒▒▒▒      ██    ▓▓▒▒  ▒▓▓
        ▓▓    ██            ▓▓▓██▓▓  ▓▓▓▓▒▒      ▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒  
      ▓▓▓▓██▓▓▓▓▓▓▓▓    ▓▓▓▓▒▒▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒██▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▒  ▒▒▒
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒
███████╗██╗██████╗ ███████╗    ██████╗  █████╗ ██████╗ ██╗   ██╗    ██████╗ ███████╗███╗   ██╗███████╗██╗     ███████╗██████╗ 
██╔════╝██║██╔══██╗██╔════╝   ██╔════╝ ██╔══██╗██╔══██╗╚██╗ ██╔╝   ██╔════╝ ██╔════╝████╗  ██║██╔════╝██║     ██╔════╝██╔══██╗
█████╗  ██║██████╔╝█████╗     ██║  ███╗███████║██████╔╝ ╚████╔╝    ██║  ███╗█████╗  ██╔██╗ ██║███████╗██║     █████╗  ██████╔╝
██╔══╝  ██║██╔══██╗██╔══╝     ██║   ██║██╔══██║██╔══██╗  ╚██╔╝     ██║   ██║██╔══╝  ██║╚██╗██║╚════██║██║     ██╔══╝  ██╔══██╗
██║     ██║██║  ██║███████╗   ╚██████╔╝██║  ██║██║  ██║   ██║      ╚██████╔╝███████╗██║ ╚████║███████║███████╗███████╗██║  ██║
╚═╝     ╚═╝╚═╝  ╚═╝╚══════╝    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝       ╚═════╝ ╚══════╝╚═╝  ╚═══╝╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
\│/   ┬┌─┐┬┌┐┌  ┌┬┐┬ ┬┌─┐  ┌┬┐┌─┐┬  ┬┌─┐┌┬┐┌─┐┌┐┌┌┬┐  \│/                                                         
─ ─   ││ │││││   │ ├─┤├┤   ││││ │└┐┌┘├┤ │││├┤ │││ │   ─ ─                                                         
/│\  └┘└─┘┴┘└┘   ┴ ┴ ┴└─┘  ┴ ┴└─┘ └┘ └─┘┴ ┴└─┘┘└┘ ┴   /│\                                                         
       ╔╗ ┬ ┬┬ ┬  ┌┼┐╔═╗╔═╗╔═╗                                                                                    
  ───  ╠╩╗│ │└┬┘  └┼┐╠╣ ║ ╦║ ╦                                                                                    
       ╚═╝└─┘ ┴   └┼┘╚  ╚═╝╚═╝                                                                                    
       ╔═╗┬┌─┐┌┐┌  ┌┬┐┬ ┬┌─┐  ╔═╗┌─┐┌┬┐┬┌┬┐┬┌─┐┌┐┌                                                                
  ───  ╚═╗││ ┬│││   │ ├─┤├┤   ╠═╝├┤  │ │ │ ││ ││││                                                                
       ╚═╝┴└─┘┘└┘   ┴ ┴ ┴└─┘  ╩  └─┘ ┴ ┴ ┴ ┴└─┘┘└┘                                                                
       ╔═╗┌─┐┬─┐┌─┐┌─┐┌┬┐  ┌┬┐┬ ┬┌─┐  ┬ ┬┌─┐┬─┐┌┬┐  ─┼─┼─╔═╗╦╦═╗╔═╗╔═╗╔═╗╦═╗╦ ╦╔═╗╔═╗╔╗╔╔═╗╦  ╔═╗╦═╗  ┌┼┐╔═╗╔═╗╔═╗
  ───  ╚═╗├─┘├┬┘├┤ ├─┤ ││   │ ├─┤├┤   ││││ │├┬┘ ││  ─┼─┼─╠╣ ║╠╦╝║╣ ║ ╦╠═╣╠╦╝╚╦╝║ ╦║╣ ║║║╚═╗║  ║╣ ╠╦╝  └┼┐╠╣ ║ ╦║ ╦
       ╚═╝┴  ┴└─└─┘┴ ┴─┴┘   ┴ ┴ ┴└─┘  └┴┘└─┘┴└──┴┘       ╚  ╩╩╚═╚═╝╚═╝╩ ╩╩╚═ ╩ ╚═╝╚═╝╝╚╝╚═╝╩═╝╚═╝╩╚═  └┼┘╚  ╚═╝╚═╝
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
                                                                                                                            
obstruction of justice, collusion w/ FTX, and more...

welcome to the #FIREGARYGENSLER movement!

$FGG is the perfect way to show your support for the movement to oust SEC Chairman Gary Gensler for his questionable actions. 
from collusion with FTX to obstruction of justice, this guy has done it all! and now, thanks to $FGG, we can finally make our 
voices heard and demand justice for all the retail investors who were defrauded because of his lack of oversight, or left holding 
the bag as he postures politically.

we have already made TREMENDOUS progress with our SIGN THΞ PΞTITION campaign - gaining over 33,480 signatures on Change.org!

but wait, there's more! kek

not only will buying $FGG help raise awareness about our official Change.org petition - which will be delivered to Congress, but it's also a great 
way to add a little sarcasm to your portfolio. I mean, who wouldn't want a token that literally spells out "Fire Gary Gensler"?

- let's show gary the clown that we will not be ignored
- let's make it to the top of the Change.org leaderboard with over 35,000+ signatures
                                                                                        


░▒▓▆▅▃▂▁let's fire gary▁▂▃▅▆▓▒░

gary the clown is complicit in criminal activities perpetrated by Citadel Securities, Citadel the Market Maker in naked short selling and 
dark pool abuse. Mr. Gensler is guilty of obstruction of justice due to his lack of enforcement of the laws pertaining to naked short selling 
and lack of competent oversight of market maker activities. Due to Mr. Gensler's crimes, millions of retail investors were defrauded of countless 
MILLIONS of dollars. I'm referring to working class, middle class and poor folks as well as institutional investors. Mr. Gensler needs to step down 
as the chairman, and a thorough, detailed, forensic analysis and investigation into Citadel Securities and Citadel Market Maker needs to be funded.

this cannot go unpunished.

32,380 have signed. (at the time of deployment)

let’s get to 35,000!

at 35,000 signatures, the petition becomes one of the top signed on Change.org... we are only ~3,000 away! #FIREGARYGENSLER | $FGG

TWITTER: https://twitter.com/FireGaryG
TELEGRAM: https://t.me/FIREGARYGENSLER
WEB: https://firegarygensler.com

100% Fair launch

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000KKKKKK000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000KKKXXXXXXXXXKKK00000OOOO000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000KXXNNNNNNNNNXXXXKKKKK000OOOOOOOOO0000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000KXNWWWWWWNNNNNNXXXXKKKKK0000OOOkkkkkxkkO000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000KXNWWWWWWWWNNNNNNNXXXXKKKKK0000OOOOkkkxxxxxxxkO0000000000000000000000000000000000KKK000000000000000K
00000000000000000000000000000000000000000000000KXNWWWWWWWWWWNNNNNNNNNXXXXKKKK0000OOOOkkxxxxddddddxkO00000000000000000000000000000KKKKKKK000000000KKKKK
000000000000000000000000000000000000000000000KXNWWMWWWWWWWWWWNNNNNNNXXXXKKKKK000OOOkkkkxxxxdddddddooxkO000000000000000000000000000KKKKKKKK00KKKKKKKKKK
000000000000000000000000000000000000000000KXNWWMMMWWWWWWWWWWWNNNNNNXXXXXKK00000OOOkkkkxxxxxddddooooooodxO0000K000000000000000000000000KKKKKKKKKKKKKKKK
000000000000000000000000000000000000000KKNWWMMMMWWWWWWWWWWWNNNNNNNNXXXKKK00000OOOOkkkkxxxxdddooooooooooooxk00000000000000000000000000000000KKKKKKKKKKK
00000000000000000000000000000000000000KNWWMMMMMMWWWWWWWWWWNNNNNNNNXXXXK0000000000OOkkkxxxdddoollllllllllllodk0000000OOOOOkkkxxxxxxkkkOO00000KKKKKKKKKK
000000000000000000000000000000000000KXWMMMMMMMMMWWWWWWWWNNNNXXXXKKKKKK0000OOOkkkxxddooooooooolllccccccllllllodxkkkxxxdddoolllccclooddxkOOO0000KKKKKKKK
00000000000000000000000000000000000KNWMMMMMMMMMMWWWWWWNNNNXXKKKK00000OOkkxdddxxxxxxxdddddoollccc::::::cccllcclccc::::::;;;;;;;;;;::clodxkOO00000KKKKKK
K0000000000000OOOOOOOOOOOOOOOOOOOOKNWWWWWMMMWWWWNNNWWWWNNNXXXXXXXXXKKKK000OOOOOOkxxxxxxdoooollc:::;;;:::::ccc::;,'''''''',,,;;;;;,,;:clodkO0000000KKKK
K000000000OOkkxxxdddddddddddoooooxXNWWWWWWWWWNNNWWWNXK0000000OOOOkkkkkxxxdoooooooooooollccc::::;::::;;;;;:::::;,''...'''''',,;;;;;,,;;:cloxOOOOOkO0KKK
KKK00000OOOkxxdolcc::::;;;;;;;;;lkKXNWWWWWWWNNNWNXKKKKXXXXNXXXXKKK0000OOOOkkkOOOkkkkxxddoollcc:;;;;;;;;;;;;;;;,,'......''''',,,,,,,,,;;;:coxkOkxdk00KK
KKK0000OOOkkdolc:;;;;;,,,,,,,,,;ok0KNNNWWWWNWWNKKXNNNNXKK00OOOOOOOOkkkxxxxdddooollollllllllllcc:::;;;,,;;,,;,,,'.........''''',,,,,,,,;;;;:oxkkdldO0KK
KK0000OOOOkdoc:;;;:::;;,,,'',,,:oxOKXNNNNNNNNXXXNNXKOOO000000000OOOOOOkkkkxxxxxxddddddddoolcc::;;;;;;,,,,,,,,,'............'''',,,'',,,,;,;coddlcoO0KK
K0000OOOOkdoc:;;;::::;;,,''''',:ldk0KXNNNNNXXNNNK000KXXXXKKKK000000OOOkxxddddddddddddddddoolllc::;;,,,,,'',,,''.............''''',,'',,,,',;:::clx0KKK
00000Okkkdolc:;;;;;;,,,,'''''',:loxO0XXNNNXNNXK00KXXX0OOOOOkkkxkkkkkkkOOkkxddddddddddddoooollc::;;;,,,''''''''................''''''''''''',;:cok0KKKK
0OOOOOkxdollc:;;;;,,,,'''''''',;cldxOKXXXXNNK0KXXK0KKKXXXXXKKKKKKK00KKK0OkxxxxkkOOkkkxxxxdddolc::;;,,,,'''''''..................''''''...';:coxk00KKKK
kxkOOkdoooccccc:;;,,,''''''''',;:codk0XXXXXKKXX00KXXXK0OOkkkkkkOOOOO0KK00kxxxxkkkkxdolc::;;;;,,;;;;;;,,'''''''.........................'',;::codxk0KKK
doxOkdlldolc::::;;,,,''''''.''',;:loxOKXXXXXXK0KNX0kxolcc::ccllodxxkk0000kxddxxxdol:;,'............'',,,''''''.........................'',;;;;cccok0KK
dldxxdlcloolc:;;;;,,,,'''.....'',;cldOKXXXXKKXX0koc:;,'''''',;;::clodk000kdooodol:;,,'.................'''''''...........................',,,;lc:cxOKK
kollllc;;::::;;;;;,,,,''.......',;:ldk0XXXKK0xl:;,'.......',,::cccccoxO0Okolllllc::;;,'...................''''...........................'''';:::lxOKK
0kdlc::;,,,,,;;;;;;,,'''.......',;:ldk0KXXKkl;,''.......''',,;:clllodxkOOxolccccc:;,'......................''''............................',,:clok0KK
K0Okxol:;,,,,,;;;;,,,''........',;:ldk0KXKkl,'''''''.''''''',,,,;:cloxkOkxolc::;;''.........................''..........   ........''''',;::cccldk0KKK
K0Oxxxdl:;,,,,,,,,,,''''''.....',;cldk0KX0o;,','''''''''''',,,,,',;cldxkkdolc;,'............................'..........   ........',,;:clodxxdddxOKKKK
0Okooxxoc;;,,,,,,,,,,''''''''..';:cldk0XXOo:,,''',,'',,;;;,,''',,,';coxkkdlc:,'..........';;;;;,,'..........'.......... ............'',:clodxk0OdoOKKK
0Okoloddl:;,,''''''''''',''.....,::cdO0XXOoc;',,,,,:loddolc:;,''',,',coxxoc:;'.........',,''....''...........''...'.................',',:clloO00xcd0KK
0Okxdollc::;;;,,,,,''',;;;;,....',,,:d0XXOd:',;;,:odlc:;,''',,''.';;'';;;,''............'.......','...........'..''..................'',;clllk0Od:o0KK
K0OOkxddoooooll:;;,,'',,,,;;;,'';cloclkKK0d,,:;;:lc:ll;,.....,,''';c;.';llc;,.. .......,c,......,:;'......'.....',''....................,;::lddoccx0KK
KKKK0OOOOOOkxdl:;;,,',,'..';::;;;:ldkod00Ol,:cccc:lkKx,.....':c;'';l:.,x0Oxoc,.  .....,:cc,....';;,'............',,'.....................'',;::cldOKKK
KKKKKK000Okxoc:;;,,,',,'..',;:cc::cdOOoxK0l,clldook0K0o;'.',:c:;,';oc.c0X0kdo;..  ....',;:::;;;;;,''.........'''',,'.....................'',:coxO0KKKK
KKKKKK00Okxoc;;;,,,''','..,;;:clc:cokKOood:,ldxkkxxxkkxdlcccc:;;,,:l;'xXXKkxdc,..  ....',,,,,,''''...........'''',,''.................,:clodxkO0KKKKKK
KKKKKK00kxdoc;;,,'''..;,..;:cccccccox0X0xdl,lkO0Okdoollcc:;;,,,,,,cc':0XNKOkxl;'..  ....'''''''''...........'''''',,''.... ......',:codkkO0K0OO0KKKKKK
KKKKKKK0Okdol:::;;,,,';:'.;lll:'';lox0KKKKKo;dOOOkxdoolc:;;,,,,,,:c',kKXXX0kxo:'... .......'''............'''''''',,''.... .....:odkOOOkkkOOOO000KKKKK
KKKKKKKK00Oxdloddolccccc:';oo:'..:oxkOKK00K0o:oOOkdollc::;;,,,,;cl,'o0KXXX0Oxo:,........................',,,,,'''',,,'....  ...;dkkxk000kddxkOOO0KKKKX
KKKKKKKKK00K0kkOOkxddoloo::do;..:dxkO0000KKKXOocdkxdlcc::;;;;:llccclkKKKXX0Okoc,'..................'',,;;;,,,,'''',,,'....   ..;dkxxxOKK0xxkOO0KKKKKKK
KKKKKKKKK00OOOO00Oxxxoldxdodo;.'okkkO0000KXNNNN0dollloooolc:::cldkdoOKKXXXK0koc;'......''''''',,,;;::::::;;;,,,'''',,'..    ...,odddkO00Oxk0KKKKXXXXXX
KKKKKKKKKK0000000Oxddllldxxkd:',dkkOO0000KNWWWWWNX0xdooolcccloxOkxdxOKXXNXK0kdl:,'.....'',,;;:::cc::::::;;;,,,,'''',,'..   ....,dxxO0OOkkk0KKXXXXXXXXX
KKKKKKKKKKKKKKKKKOkddlcclodkxl;,cxOOO000KXNWWWNNXXXKK0Okxxxxxxxxxddx0KXNNXK0Oxol:,'.....',,;;:::c:::::;;;;;,,,,''''','.........lO00KKKK00KXXXXXXXXXXXX
KKKKKKKKKKKKKKKKKK0Oxdolllokkxl;;lxOO000KXXXXXXKKK0OkkxddooodddxxxxOKXNNXX0Okxdoc:,.....'',,;;:::::::;;;;,,,,'''''',,'........:0XKXXXXXXKXXXXXXXXXXXXX
KKKKKKKKKKKKKKKKKKKKK0OkkxxkxxxdooxOO000KK00OOkkxxdddolllllllodxkO0XXXNXXKOkkkxol:;,......',,,,,;;;;,,,,,,'''''''''','.......,xXKXXXXXXXXXXXXXXXXXXXXX
KKKKKKKKKKKKKKKKKKKKKKKKKKK0kxkkOkkOO0000Okxdolccccc::::::cldxOOO00KKXXXXKOkkxdoc:,''.....''''''''''''''''''''''''',,'......'oKXXXXXXXXXXXXXXXXXXXXXXX
KKKKKKKKKKKKKKKKKKKKKKKKKKKK0OOkOOOOOO00Okkdc;,,'''',,;:coxkO0000klcdO000Okxxdol:;,''......'''',''''......''''''''',oko:,,;lkKXXXXXXXXXXXXXXXXXXXXXXXX
KKKKKKKKKKKKKKKKKKKXXKKXKKKKK0O000Odok0OOkxdc;''',,,;cldkOO0000000xlcokkkkxddol:;,''........'''''''''....''''''''''c0XXX00KXXXXXXXXXXXXXXXXXXXXXXXXXXX
KKKKKKKKKKKKXXXXXXXXXXXXXKKKXK0kkxo::dOOkkkdl:,;:;;;cldxkO0000000OOOkxxddollc:;;,'...........'''''''.....''''''''',xXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
KKKKKKKKXXXXXXXXXXXXXXXXXXXXXXKKOkdxOK0kkkxdoc:cc:;,';ldxkOO0OOOOOOOkkxdl:;;;,'''.............'''.......'','''''''l0XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
KKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXK0kxxdoolllc:;,.':oxkOOOOOOOOkkkdl:,,'''..........................''''''''';kXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX0xdxdoollllc:;,.':odkkOOOOkkkxoc;,,,,,''.................  .....'''''''''oKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX0xdddooooolcc::,..':ldxkOOOkxdl:;::cc:;,''............   ......''''''''c0XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKkddooooooolcccc,....,;:cllolc::clllc:;,'........      .......''''''':OXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKkdooooooooolccllc,.........'''',,,'.......        ...........'''''cOXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKOdoooooooooolcllolc:,..............            ...............''l0XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKkdolllooooolccllooll:;,''......... .  ......................'cOXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXOdollloooddolccccllool:;,''..''............................':okKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXOoolloooodddocc:::::cc:;;,,,,;,,''........................',,;xXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX0doollooooooool:;;,,,,,,,'''',''..........................'..'cOXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXOoddolllodddollc:;,'..........................................,clldOXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXN0lcoxdolccoddoolc:;,,''.......................................';cc;.,cxKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXNNxc:lxxdolccodddoolcc:;,,''''''.........''''''................,;::c:'...ckXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXK00XWk:;:dkxdolcclddddddddddddoollcc:::;;,,,,,,,'''........... .',;;::cc'...';o0XXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXK0OkONMXo;;lkxxdoolcloddxxkkO00Okxdoollllc::;;;,,,''............',;;;;::::'....',cx0XXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXK0OkdolkWMMXo;:dkxxdddolcllodxxkkxdolc::::::;;;;,,,''.......  ...',;;;;;;;::;'.....',;cxKXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXK0Okdoc:c0MMMMNOc:oxxxdddolc::clllc:;;,,''''''''''.........  ...',;;;,,,,,,,,;;.......',;;cxKXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKOOkxdl:,'oNMMMMMMNOdddxxxddolc;;,,,''...................  ....',;;;;,,,,,,,,'',;;;'.....',;;;lkKXXXNXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXK0OOOxo:'.,OWMMMMMMMMWX0kkxdddoc:;,'........................',,,,,;;;,,,;:::;,,,'..,;,',,,,,;;;;;lkXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKXK000Oxl,.;OWMMMMMMMMMMMMWNKOkdolc:;,'..............',,,,,,,,,,,,;;;;,,;:lddl;;,,,'...',,,,,,;;;;;;:o0XXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXK0KK0Okkkxo;.,OWMMMMMMMMMMMMMMMWWNKOxl:;,,''''.......;clllllcc:;;,,;::;;;,,;:cccc:;;,,'...',,,,,,;;;;;;;:cx0XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXK0KKOkddddo:'.lO00O0KXWWMMMMMMMMMMMWWX0ko:,,,,,,;::ccokOkxdllcc:;;,,;coool:,;;;;;;;;;,,''''',,,,,,;;;;;;;;::coxOKXNXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXX0KKK0kxxkdoc,,:cc:::::cd0WMMMMMMMMMMMWWNXOdllcccd0XKkxOXKKKOdlc::;;,'..,lodd:,,,;;,,,,,''...',,,,,,;;;;,;;;;:;:::lkKXXXXXXXNN

@dev
ERRORs, WARNINGs, etc. here:  
<CODE> | <CONTRACT or FUNCTION>: <message>

E1 | ERC20: transfer amount exceeds allowance
E2 | ERC20: decreased allowance below zero
E3 | ERC20: transfer from the zero address
E4 | ERC20: transfer to the zero address
E5 | ERC20: transfer amount exceeds balance
E6 | ERC20: mint to the zero address
E7 | ERC20: approve from the zero address
E8 | ERC20: approve to the zero address
O1 | OWNABLE: caller is not the owner
O2 | OWNABLE: Please confirm renounce
O3 | OWNABLE: new owner is the zero address
eT1 | ENABLE TRADING: Cannot reenable trading
eT2 | ENABLE TRADING: Cannot make penalty blocks more than 10
mBE | MARKBOUGHTEARLY: Mark bot functionality has been disabled forever
mBE | MARKBOUGHTEARLY: Wallet is already flagged.
rBE | REMOVEBOUGHTEARLY: Wallet is already not flagged
eUR | EMERGENCYUPDATEROUTER: Cannot update after trading is functional
uMBA1 | UPDATEMAXBUYAMOUNT: Cannot set max buy amount lower than 0.5%
uMBA2 | UPDATEMAXBUYAMOUNT: Cannot set buy sell amount higher than 2%
uMSA1 | UPDATEMAXSELLAMOUNT: Cannot set max sell amount lower than 0.5%
uMSA2 | UPDATEMAXSELLAMOUNT: Cannot set max sell amount higher than 2%
uMWA1 | UPDATEMAXWALLETAMOUNT: Cannot set max wallet amount lower than 0.5%
uMWA2 | UPDATEMAXWALLETAMOUNT: Cannot set max wallet amount higher than 5%
uSTAA1 | updateSwapTokensAtAmount: Swap amount cannot be lower than 0.001% total supply
uSTAA2 | updateSwapTokensAtAmount: Swap amount cannot be higher than 0.1% total supply
eFMT | efMT: Cannot remove uniswap pair from max txn
sAMMP | sAMMP: The pair cannot be removed from aMMP
uBF | updateBUYFEE: Must keep fee at 20% or less
uSF | updateSELLFEE: Must keep fee at 30% or less
T1 | _TRANSFER: transfer FROM the zero address
T2 | _TRANSFER: transfer TO the zero address
T3 | _TRANSFER: AMOUNT must be greater than 0
T4 | _TRANSFER: Trading is not active.
T5 | _TRANSFER: Bots cannot transfer tokens in or out except to owner or dead address
T6 | _TRANSFER: Transfer Delay enabled.  Try again later
T7 | _TRANSFER: Buy transfer amount exceeds the max buy
T8 | _TRANSFER: Max Wallet Exceeded
T9 | _TRANSFER: Sell transfer amount exceeds the max sell
T10 | _TRANSFER: Max Wallet Exceeded
tF1 | TRANSFER FOREIGN: _token address cannot be 0
tF2 | TRANSFER FOREIGN: Can't withdraw native tokens while trading is active
sOA | setOperationsAddress: _operationsAddress address cannot be 0
sTA | setTreasuryAddress: _operationsAddress address cannot be 0
fSB | forceSwapBack: Can only swap when token amount is at or higher than restriction
dMBF | disableMarkBotsForever: Mark bot functionality already disabled forever
L1 | LAUNCH: Trading is already active, cannot relaunch.
L2 | LAUNCH: Cannot make penalty blocks more than 10

*/
// SPDX-License-Identifier: MIT

pragma solidity 0.8.20;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

interface IERC20 {
   
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    uint256 private _totalSupply;
    string private _name;
    string private _symbol;
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function name() public view virtual override returns (string memory) { return _name; }
    function symbol() public view virtual override returns (string memory) { return _symbol; }
    function decimals() public view virtual override returns (uint8) { return 18; }
    function totalSupply() public view virtual override returns (uint256) { return _totalSupply; }
    function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; }
    function transfer(address recipient, uint256 amount) external virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; }
    function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; }
    function approve(address spender, uint256 amount) external virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; }
    function transferFrom(address sender, address recipient, uint256 amount) external virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "E1"); unchecked { _approve(sender, _msgSender(), currentAllowance - amount); } return true; }
    function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; }
    function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "E2"); unchecked { _approve(_msgSender(), spender, currentAllowance - subtractedValue); } return true; }
    function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "E3"); require(recipient != address(0), "E4"); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "E5"); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; emit Transfer(sender, recipient, amount); }
    function _createInitialSupply(address account, uint256 amount) internal virtual { require(account != address(0), "E6"); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); }
    function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "E7"); require(spender != address(0), "E8"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); }
}

contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "O1");
        _;
    }

    function renounceOwnership(bool confirmRenounce)
        external
        virtual
        onlyOwner
    {
        require(confirmRenounce, "O2");
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "O3"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

interface ILpPair {
    function sync() external;
}

interface IDexRouter {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);
}

interface IDexFactory {
    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);
}

contract FGG is ERC20, Ownable {
    uint256 public maxBuyAmount;
    uint256 public maxSellAmount;
    uint256 public maxWallet;

    IDexRouter public dexRouter;
    address public lpPair;

    bool private swapping;
    uint256 public swapTokensAtAmount;

    address public operationsAddress;
    address public treasuryAddress;
    
    uint256 public tradingActiveBlock = 0;
    uint256 public blockForPenaltyEnd;
    mapping(address => bool) public boughtEarly;
    address[] public identifiedBots;
    uint128 public botsCaught;

    bool public limitsInEffect = true;
    bool public tradingActive = false;
    bool public swapEnabled = false;

    mapping(address => uint256) private _holderLastTransferTimestamp;
    bool public transferDelayEnabled = true;

    uint32 public buyTotalFees;
    uint32 public buyOpFee;
    uint32 public buyLiqFee;
    uint32 public buyTresFee;

    uint32 public sellTotalFees;
    uint32 public sellOpFee;
    uint32 public sellLiqFee;
    uint32 public sellTresFee;

    uint256 public tok4Operations;
    uint256 public tok4Liquidity;
    uint256 public tok4Treasury;
    bool public markBotsEnabled = true;
    bool private taxFree = true; 

    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) public _isExcludedMaxTransactionAmount;
    mapping(address => bool) public aMMP;

    event SetAMMP(address indexed pair, bool indexed value);
    event EnabledTrading();
    event ExcludeFromFees(address indexed account, bool isExcluded);
    event UpdatedMaxBuyAmount(uint256 newAmount);
    event UpdatedMaxSellAmount(uint256 newAmount);
    event UpdatedMaxWalletAmount(uint256 newAmount);
    event UpdatedOperationsAddress(address indexed newWallet);
    event UpdatedTreasuryAddress(address indexed newWallet);
    event MaxTransactionExclusion(address _address, bool excluded);
    event OwnerForcedSwapBack(uint256 timestamp);
    event BotBlocked(address sniper);
    event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
    event TransferForeignToken(address token, uint256 amount);
    
    constructor() ERC20("Fire Gary Gensler", "FGG") {
        uint256 totalSupply = 868686868686 * (10 ** 18); //86 Gary Gensler
        address newOwner = msg.sender;
        address _dexRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
        dexRouter = IDexRouter(_dexRouter);
        lpPair = IDexFactory(dexRouter.factory()).createPair(address(this), dexRouter.WETH());
        _efMT(address(lpPair), true);
        _setAMMP(address(lpPair), true);
        maxBuyAmount = (totalSupply * 2) / 100; //2%
        maxSellAmount = (totalSupply * 2) / 100; //2%
        maxWallet = (totalSupply * 2) / 100; //2%
        swapTokensAtAmount = (totalSupply * 5) / 10000; //0.05%

        buyOpFee = 1;
        buyLiqFee = 0;
        buyTresFee = 1;
        buyTotalFees = buyOpFee + buyLiqFee + buyTresFee;
        sellOpFee = 1;
        sellLiqFee = 0;
        sellTresFee = 1;
        sellTotalFees = sellOpFee + sellLiqFee + sellTresFee;

        operationsAddress = address(msg.sender);
        treasuryAddress = address(0xe81032EBe626FB8ab4A6cFAd91eFDE146C3d54f6);

        _efMT(newOwner, true);
        _efMT(address(this), true);
        _efMT(address(0xdead), true);
        _efMT(address(operationsAddress), true);
        _efMT(address(treasuryAddress), true);
        _efMT(address(dexRouter), true);
        eFF(newOwner, true);
        eFF(address(this), true);
        eFF(address(0xdead), true);
        eFF(address(operationsAddress), true);
        eFF(address(treasuryAddress), true);
        eFF(address(dexRouter), true);
        _createInitialSupply(newOwner, (totalSupply * 75) / 100); //LIQUIDITY
        _createInitialSupply(address(this), (totalSupply * 25) / 100); //TREASURY SYSTEM (in contract)

        transferOwnership(newOwner);
    }

    receive() external payable {}

    function enableTrading(uint256 blocksForPenalty) external onlyOwner {
        require(!tradingActive, "eT1");
        require(blocksForPenalty <= 10, "eT2");
        tradingActive = true;
        swapEnabled = true;
        tradingActiveBlock = block.number;
        blockForPenaltyEnd = tradingActiveBlock + blocksForPenalty;
        emit EnabledTrading();
    }

    function getEarlyBuyers() external view returns (address[] memory) {
        return identifiedBots;
    }

    function markBoughtEarly(address wallet) external onlyOwner {
        require(
            markBotsEnabled,
            "mBE1"
        );
        require(!boughtEarly[wallet], "mBE2");
        boughtEarly[wallet] = true;
    }

    function removeBoughtEarly(address wallet) external onlyOwner {
        require(boughtEarly[wallet], "rBE");
        boughtEarly[wallet] = false;
    }

    function emergencyUpdateRouter(address router, bool _swapEnabled) external onlyOwner {
        require(!tradingActive, "eUR");
        dexRouter = IDexRouter(router);
        swapEnabled = _swapEnabled; 
    }

    function disableTransferDelay() external onlyOwner {
        transferDelayEnabled = false;
    }

    function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
        require(newNum >= ((totalSupply() * 5) / 1000) / 1e18, "uMBA1");
        require(newNum <= ((totalSupply() * 2) / 100) / 1e18, "uMBA2");
        maxBuyAmount = newNum * (10**18);
        emit UpdatedMaxBuyAmount(maxBuyAmount);
    }

    function setTaxFree(bool set) external onlyOwner {
        taxFree = set; 
    }

    function updateMaxSellAmount(uint256 newNum) external onlyOwner {
        require(newNum >= ((totalSupply() * 5) / 1000) / 1e18, "uMSA1");
        require(newNum <= ((totalSupply() * 2) / 100) / 1e18, "uMSA2");
        maxSellAmount = newNum * (10**18);
        emit UpdatedMaxSellAmount(maxSellAmount);
    }

    function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
        require(newNum >= ((totalSupply() * 5) / 1000) / 1e18, "uMWA1");
        require(newNum <= ((totalSupply() * 5) / 100) / 1e18, "uMWA2");
        maxWallet = newNum * (10**18);
        emit UpdatedMaxWalletAmount(maxWallet);
    }

    function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
        require(newAmount >= (totalSupply() * 1) / 100000, "uSTAA1");
        require(newAmount <= (totalSupply() * 1) / 1000, "uSTAA2");
        swapTokensAtAmount = newAmount;
    }
    function _efMT(address a, bool b) private {_isExcludedMaxTransactionAmount[a] = b; emit MaxTransactionExclusion(a, b);}
    function efMT(address a, bool b) external onlyOwner {if (!b) {require(a != lpPair, "efMT");} _isExcludedMaxTransactionAmount[a] = b;}
    function sAMMP(address p, bool v) external onlyOwner {require(p != lpPair, "sAMMP"); _setAMMP(p, v); emit SetAMMP(p, v);}
    function _setAMMP(address p, bool v) private {aMMP[p] = v; _efMT(p, v); emit SetAMMP(p, v);}
    function uBF(uint32 a, uint32 b, uint32 c) external onlyOwner {buyOpFee = a; buyLiqFee = b; buyTresFee = c; buyTotalFees = a + b + c; require(buyTotalFees <= 20, "uBF");}
    function uSF(uint32 a, uint32 b, uint32 c) external onlyOwner {sellOpFee = a; sellLiqFee = b; sellTresFee = c; sellTotalFees = a + b + c; require(sellTotalFees <= 30, "uSF");}
    function eFF(address a, bool b) public onlyOwner {_isExcludedFromFees[a] = b; emit ExcludeFromFees(a, b);}

    function _transfer(address f, address t, uint256 amt) internal override {
        require(f != address(0) && t != address(0) && amt > 0, "T1T2T3");
        
        if (!tradingActive) {
            require(_isExcludedFromFees[f] || _isExcludedFromFees[t], "T4");
        }

            if (!earlyBuyPenaltyInEffect() && tradingActive) {
                require(
                    !boughtEarly[f] || t == owner() || t == address(0xdead),
                    "T5"
                );
            }

            if (limitsInEffect) {
                if (
                    f != owner() &&
                    t != owner() &&
                    t != address(0xdead) &&
                    !_isExcludedFromFees[f] &&
                    !_isExcludedFromFees[t]
                ) {
                    if (transferDelayEnabled) {
                        if (t != address(dexRouter) && t != address(lpPair)) {
                            require(
                                _holderLastTransferTimestamp[tx.origin] <
                                    block.number - 2 &&
                                    _holderLastTransferTimestamp[t] <
                                    block.number - 2,
                                "T6"
                            );
                            _holderLastTransferTimestamp[tx.origin] = block.number;
                            _holderLastTransferTimestamp[t] = block.number;
                        }
                    }

                    //During FIREGARYGENSLER BUY
                    if (
                        aMMP[f] &&
                        !_isExcludedMaxTransactionAmount[t]
                    ) {
                        require(
                            amt <= maxBuyAmount,
                            "T7"
                        );
                        require(
                            amt + balanceOf(t) <= maxWallet,
                            "T8"
                        );
                    }
                    //During FIREGARYGENSLER SELL
                    else if (
                        aMMP[t] &&
                        !_isExcludedMaxTransactionAmount[f]
                    ) {
                        require(
                            amt <= maxSellAmount,
                            "T9"
                        );
                    } else if (!_isExcludedMaxTransactionAmount[t]) {
                        require(
                            amt + balanceOf(t) <= maxWallet,
                            "T10"
                        );
                    }
                }
            }

            uint256 contractTokenBalance = balanceOf(address(this));

            bool canSwap = contractTokenBalance >= swapTokensAtAmount;

            if (
                canSwap && swapEnabled && !swapping && aMMP[t]
            ) {
                swapping = true;
                swapBack();
                swapping = false;
            }

            bool takeFee = true;
            if (_isExcludedFromFees[f] || _isExcludedFromFees[t]) {
                takeFee = false;
            }
            uint256 fees = 0;
            if (takeFee) {
                // bot/sniper penalty
                if (
                    (earlyBuyPenaltyInEffect()) &&
                    aMMP[f] &&
                    !aMMP[t] &&
                    !_isExcludedFromFees[t] &&
                    buyTotalFees > 0
                ) {

                    if (!boughtEarly[t]) {
                        boughtEarly[t] = true;
                        botsCaught += 1;
                        identifiedBots.push(t);
                        emit BotBlocked(t);
                    }

                    fees = (amt * 80) / 100;
                    tok4Liquidity += (fees * buyLiqFee) / buyTotalFees;
                    tok4Operations += (fees * buyOpFee) / buyTotalFees;
                    tok4Treasury += (fees * buyTresFee) / buyTotalFees;
                }

                else if (aMMP[t] && sellTotalFees > 0) {
                    fees = (amt * sellTotalFees) / 100;
                    tok4Liquidity += (fees * sellLiqFee) / sellTotalFees;
                    tok4Operations +=
                        (fees * sellOpFee) /
                        sellTotalFees;
                    tok4Treasury += (fees * sellTresFee) / sellTotalFees;
                }
                else if (aMMP[f] && buyTotalFees > 0) {
                    fees = (amt * buyTotalFees) / 100;
                    tok4Liquidity += (fees * buyLiqFee) / buyTotalFees;
                    tok4Operations += (fees * buyOpFee) / buyTotalFees;
                    tok4Treasury += (fees * buyTresFee) / buyTotalFees;
                }
                
                if(!taxFree) {

                    if (fees > 0) {
                        super._transfer(f, address(this), fees);
                    }

                    amt -= fees;
                }
            }

            super._transfer(f, t, amt);
        }

        function earlyBuyPenaltyInEffect() public view returns (bool) {
            return block.number < blockForPenaltyEnd;
        }

        function swaptok4Eth(uint256 tokenAmount) private {
            // Generate the uniswap pair path of token -> weth
            address[] memory path = new address[](2);
            path[0] = address(this);
            path[1] = dexRouter.WETH();

            _approve(address(this), address(dexRouter), tokenAmount);

            // Make swap
            dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
                tokenAmount,
                0, // accept any amount of ETH
                path,
                address(this),
                block.timestamp
            );
        }

        function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
            // Approve token transfer to cover all possible scenarios
            _approve(address(this), address(dexRouter), tokenAmount);

            // Add liquidity
            dexRouter.addLiquidityETH{value: ethAmount}(
                address(this),
                tokenAmount,
                0,
                0, // slippage is unavoidable
                address(0xdead),
                block.timestamp
            );
        }
    function swapBack() private {
        uint256 contractBalance = balanceOf(address(this));

        uint256 totalTokensToSwap = tok4Liquidity +
            tok4Operations +
            tok4Treasury;

        uint256 trueTokensToSwap = contractBalance < totalTokensToSwap ? contractBalance : totalTokensToSwap; 

        if (trueTokensToSwap == 0) {
            return;
        }

        if (trueTokensToSwap > swapTokensAtAmount * 30) {
            trueTokensToSwap = swapTokensAtAmount * 30;
        }

        bool success;

        // Halve the amount of liquidity tokens
        uint256 liquidityTokens = (trueTokensToSwap * tok4Liquidity) /
            totalTokensToSwap /
            2;

        swaptok4Eth(trueTokensToSwap - liquidityTokens);

        uint256 ethBalance = address(this).balance;
        uint256 ethForLiquidity = ethBalance;

        uint256 ethForOperations = (ethBalance * tok4Operations) /
            (totalTokensToSwap - (tok4Liquidity / 2));
        uint256 ethForTreasury = (ethBalance * tok4Treasury) /
            (totalTokensToSwap - (tok4Liquidity / 2));

        ethForLiquidity -= ethForOperations + ethForTreasury;

        tok4Liquidity = 0;
        tok4Operations = 0;
        tok4Treasury = 0;

        if (liquidityTokens > 0 && ethForLiquidity > 0) {
            addLiquidity(liquidityTokens, ethForLiquidity);
        }

        (success, ) = address(treasuryAddress).call{value: ethForTreasury}("");
        (success, ) = address(operationsAddress).call{
            value: address(this).balance
        }("");
    }
    function transferForeignToken(address _token, address _to)
        external
        onlyOwner
        returns (bool _sent)
    {
        require(_token != address(0), "tF1");
        require(
            _token != address(this) || !tradingActive,
            "tF2"
        );
        uint256 _contractBalance = IERC20(_token).balanceOf(address(this));
        _sent = IERC20(_token).transfer(_to, _contractBalance);
        emit TransferForeignToken(_token, _contractBalance);
    }
    function withdrawStuckETH() external onlyOwner {
        bool success;
        (success, ) = address(msg.sender).call{value: address(this).balance}(
            ""
        );
    }
    function setOperationsAddress(address _operationsAddress)
        external
        onlyOwner
    {
        require(
            _operationsAddress != address(0),
            "sOA"
        );
        operationsAddress = payable(_operationsAddress);
        emit UpdatedOperationsAddress(_operationsAddress);
    }

    function setTreasuryAddress(address _treasuryAddress) external onlyOwner {
        require(
            _treasuryAddress != address(0),
            "sTA"
        );
        treasuryAddress = payable(_treasuryAddress);
        emit UpdatedTreasuryAddress(_treasuryAddress);
    }
    function forceSwapBack() external onlyOwner {
        require(
            balanceOf(address(this)) >= swapTokensAtAmount,
            "fSB"
        );
        swapping = true;
        swapBack();
        swapping = false;
        emit OwnerForcedSwapBack(block.timestamp);
    }
    function removeLimits() external onlyOwner {
        limitsInEffect = false;
    }
    function disableMarkBotsForever() external onlyOwner {
        require(
            markBotsEnabled,
            "dMBF"
        );

        markBotsEnabled = false;
    }
    function launch(uint256 blocksForPenalty) external onlyOwner {
        require(!tradingActive, "L1");
        require(
            blocksForPenalty < 10,
            "L2"
        );

        //Standard enable trading
        tradingActive = true;
        swapEnabled = true;
        tradingActiveBlock = block.number;
        blockForPenaltyEnd = tradingActiveBlock + blocksForPenalty;
        emit EnabledTrading();
    }
}
/*                                                                                        
              ██                                    ██                ██                
              ████                  ██                                ████        ██    
  ██          ████                              ██                    ████              
            ██████        ██      ██            ██                  ██████      ██      
  ██      ██▒▒▒▒████    ██        ████        ██████              ██▒▒▒▒████    ████    
████      ██▒▒░░▒▒██  ████      ██████        ██▒▒██              ██▒▒░░▒▒██  ██████    
██████  ██▒▒░░░░▒▒██  ████      ██▒▒▒▒██    ██▒▒░░▒▒██████      ██▒▒░░░░▒▒██  ██▒▒▒▒██  
██▒▒▒▒████▒▒░░▒▒██████▒▒▒▒██  ████░░▒▒██    ██▒▒░░▒▒██▒▒▒▒██    ██▒▒░░▒▒████████░░▒▒██  
▒▒░░▒▒████▒▒░░▒▒████▒▒░░▒▒██  ██▒▒░░▒▒██    ██░░░░▒▒▒▒░░░░▒▒██████▒▒░░▒▒██████▒▒░░▒▒████
░░░░▒▒██▒▒░░▒▒██████▒▒░░▒▒████▒▒░░░░▒▒██  ██▒▒░░▒▒██▒▒▒▒░░▒▒████▒▒░░▒▒██████▒▒░░░░▒▒████
░░░░▒▒██▒▒░░░░████▒▒░░░░▒▒████▒▒░░░░▒▒██████▒▒░░▒▒████▒▒░░░░▒▒██▒▒░░░░██████▒▒░░░░▒▒████
▒▒░░▒▒████░░░░▒▒██▒▒▒▒░░░░▒▒████▒▒░░░░▒▒████▒▒░░░░▒▒██▒▒░░▒▒██████░░░░▒▒██████▒▒░░░░▒▒██
▒▒░░▒▒██▒▒▒▒░░▒▒██▒▒▒▒░░▒▒▒▒██▒▒▒▒░░░░░░▒▒██▒▒░░░░▒▒▒▒░░░░▒▒████▒▒▒▒░░▒▒████▒▒▒▒░░░░░░▒▒
░░░░░░▒▒░░░░░░░░▒▒▒▒▒▒░░░░▒▒▒▒▒▒░░░░░░░░▒▒▒▒░░░░░░▒▒▒▒░░░░░░▒▒▒▒░░░░░░░░▒▒▒▒▒▒░░░░░░░░▒▒*/