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

PHP Decode

{ "html": "PGxpbmsgbXBkaXN1cmwgaHJlZj0iY3NzL2Jvb3RzdHJhcC5taW4uY3NzIiByZWw9InN0eWxlc..

Decoded Output download

<?    { 
  	"html": "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" 
  } ?>

Did this file decode correctly?

Original Code

  {
  	"html": "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"
  }

Function Calls

None

Variables

None

Stats

MD5	e740057b302dbfbfa27dccb1df96226d
Eval Count	0
Decode Time	1620 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