Find this useful? Enter your email to receive occasional updates for securing PHP code.
Signing you up...
Thank you for signing up!
PHP Decode
<?php $_F=__FILE__;$_X='Pz48P3BocA0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi..
Decoded Output download
<?php $_F=__FILE__;$_X='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';eval(base64_decode('JF9YPWJhc2U2NF9kZWNvZGUoJF9YKTskX1g9c3RydHIoJF9YLCcxMjM0NTZhb3VpZScsJ2FvdWllMTIzNDU2Jyk7JF9SPWVyZWdfcmVwbGFjZSgnX19GSUxFX18nLCInIi4kX0YuIiciLCRfWCk7ZXZhbCgkX1IpOyRfUj0wOyRfWD0wOw=='));?>Did this file decode correctly?
Original Code
<?php $_F=__FILE__;$_X='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';eval(base64_decode('JF9YPWJhc2U2NF9kZWNvZGUoJF9YKTskX1g9c3RydHIoJF9YLCcxMjM0NTZhb3VpZScsJ2FvdWllMTIzNDU2Jyk7JF9SPWVyZWdfcmVwbGFjZSgnX19GSUxFX18nLCInIi4kX0YuIiciLCRfWCk7ZXZhbCgkX1IpOyRfUj0wOyRfWD0wOw=='));?>Function Calls
| base64_decode | 1 |
Stats
| MD5 | 6084fcbe9f99a9ee9f6a35360c4593c5 |
| Eval Count | 1 |
| Decode Time | 2532 ms |