gen/php/Preprocessor_Hash.cpp

   1
   2 #include <php/Parser.h>
   3 #include <php/Preprocessor.h>
   4 #include <php/Preprocessor_DOM.h>
   5 #include <php/Preprocessor_Hash.h>
   6 #include <cpp/ext/ext.h>
   7
   8 namespace HPHP {
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 /* preface starts */
  12 /* preface finishes */
  13 /* SRC: Preprocessor_Hash.php line 666 */
  14 Variant c_ppdstack_hash::os_get(const char *s, int64 hash) {
  15   return c_ppdstack::os_get(s, hash);
  16 }
  17 Variant &c_ppdstack_hash::os_lval(const char *s, int64 hash) {
  18   return c_ppdstack::os_lval(s, hash);
  19 }
  20 void c_ppdstack_hash::o_get(ArrayElementVec &props) const {
  21   c_ppdstack::o_get(props);
  22 }
  23 bool c_ppdstack_hash::o_exists(CStrRef s, int64 hash) const {
  24   return c_ppdstack::o_exists(s, hash);
  25 }
  26 Variant c_ppdstack_hash::o_get(CStrRef s, int64 hash) {
  27   return c_ppdstack::o_get(s, hash);
  28 }
  29 Variant c_ppdstack_hash::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
  30   return c_ppdstack::o_set(s, hash, v, forInit);
  31 }
  32 Variant &c_ppdstack_hash::o_lval(CStrRef s, int64 hash) {
  33   return c_ppdstack::o_lval(s, hash);
  34 }
  35 Variant c_ppdstack_hash::os_constant(const char *s) {
  36   return c_ppdstack::os_constant(s);
  37 }
  38 IMPLEMENT_CLASS(ppdstack_hash)
  39 ObjectData *c_ppdstack_hash::create() {
  40   init();
  41   t___construct();
  42   return this;
  43 }
  44 ObjectData *c_ppdstack_hash::dynCreate(CArrRef params, bool init /* = true */) {
  45   if (init) {
  46     return (create());
  47   } else return this;
  48 }
  49 void c_ppdstack_hash::dynConstruct(CArrRef params) {
  50   (t___construct());
  51 }
  52 ObjectData *c_ppdstack_hash::cloneImpl() {
  53   c_ppdstack_hash *obj = NEW(c_ppdstack_hash)();
  54   cloneSet(obj);
  55   return obj;
  56 }
  57 void c_ppdstack_hash::cloneSet(c_ppdstack_hash *clone) {
  58   c_ppdstack::cloneSet(clone);
  59 }
  60 Variant c_ppdstack_hash::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
  61   if (hash < 0) hash = hash_string_i(s);
  62   switch (hash & 15) {
  63     case 0:
  64       HASH_GUARD(0x5CEFA5A265104D10LL, count) {
  65         return (t_count());
  66       }
  67       break;
  68     case 1:
  69       HASH_GUARD(0x27E7DBA875AD17E1LL, getflags) {
  70         return (t_getflags());
  71       }
  72       break;
  73     case 2:
  74       HASH_GUARD(0x499E72B719A4CAC2LL, addpart) {
  75         int count = params.size();
  76         if (count <= 0) return (t_addpart(), null);
  77         return (t_addpart(params.rvalAt(0)), null);
  78       }
  79       break;
  80     case 3:
  81       HASH_GUARD(0x773C5A963CD2AC13LL, pop) {
  82         return (t_pop());
  83       }
  84       break;
  85     case 6:
  86       HASH_GUARD(0x1A5F5A2CB292E516LL, getaccum) {
  87         return ref(t_getaccum());
  88       }
  89       break;
  90     case 8:
  91       HASH_GUARD(0x321E2BF5D878AA38LL, push) {
  92         return (t_push(params.rvalAt(0)), null);
  93       }
  94       break;
  95     case 12:
  96       HASH_GUARD(0x1726802D706D7BECLL, getcurrentpart) {
  97         return (t_getcurrentpart());
  98       }
  99       break;
 100     case 15:
 101       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
 102         return (t___construct(), null);
 103       }
 104       break;
 105     default:
 106       break;
 107   }
 108   return c_ppdstack::o_invoke(s, params, hash, fatal);
 109 }
 110 Variant c_ppdstack_hash::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
 111   if (hash < 0) hash = hash_string_i(s);
 112   switch (hash & 15) {
 113     case 0:
 114       HASH_GUARD(0x5CEFA5A265104D10LL, count) {
 115         return (t_count());
 116       }
 117       break;
 118     case 1:
 119       HASH_GUARD(0x27E7DBA875AD17E1LL, getflags) {
 120         return (t_getflags());
 121       }
 122       break;
 123     case 2:
 124       HASH_GUARD(0x499E72B719A4CAC2LL, addpart) {
 125         if (count <= 0) return (t_addpart(), null);
 126         return (t_addpart(a0), null);
 127       }
 128       break;
 129     case 3:
 130       HASH_GUARD(0x773C5A963CD2AC13LL, pop) {
 131         return (t_pop());
 132       }
 133       break;
 134     case 6:
 135       HASH_GUARD(0x1A5F5A2CB292E516LL, getaccum) {
 136         return ref(t_getaccum());
 137       }
 138       break;
 139     case 8:
 140       HASH_GUARD(0x321E2BF5D878AA38LL, push) {
 141         return (t_push(a0), null);
 142       }
 143       break;
 144     case 12:
 145       HASH_GUARD(0x1726802D706D7BECLL, getcurrentpart) {
 146         return (t_getcurrentpart());
 147       }
 148       break;
 149     case 15:
 150       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
 151         return (t___construct(), null);
 152       }
 153       break;
 154     default:
 155       break;
 156   }
 157   return c_ppdstack::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
 158 }
 159 Variant c_ppdstack_hash::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
 160   return c_ppdstack::os_invoke(c, s, params, hash, fatal);
 161 }
 162 Variant cw_ppdstack_hash$os_get(const char *s) {
 163   return c_ppdstack_hash::os_get(s, -1);
 164 }
 165 Variant &cw_ppdstack_hash$os_lval(const char *s) {
 166   return c_ppdstack_hash::os_lval(s, -1);
 167 }
 168 Variant cw_ppdstack_hash$os_constant(const char *s) {
 169   return c_ppdstack_hash::os_constant(s);
 170 }
 171 Variant cw_ppdstack_hash$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
 172   return c_ppdstack_hash::os_invoke(c, s, params, -1, fatal);
 173 }
 174 void c_ppdstack_hash::init() {
 175   c_ppdstack::init();
 176 }
 177 /* SRC: Preprocessor_Hash.php line 667 */
 178 void c_ppdstack_hash::t___construct() {
 179   INSTANCE_METHOD_INJECTION(PPDStack_Hash, PPDStack_Hash::__construct);
 180   bool oldInCtor = gasInCtor(true);
 181   (m_elementClass = "PPDStackElement_Hash");
 182   LINE(669,c_ppdstack::t___construct());
 183   (m_rootAccum = ((Object)(LINE(670,p_ppdaccum_hash(p_ppdaccum_hash(NEWOBJ(c_ppdaccum_hash)())->create())))));
 184   gasInCtor(oldInCtor);
 185 } /* function */
 186 /* SRC: Preprocessor_Hash.php line 1523 */
 187 Variant c_ppnode_hash_text::os_get(const char *s, int64 hash) {
 188   return c_ObjectData::os_get(s, hash);
 189 }
 190 Variant &c_ppnode_hash_text::os_lval(const char *s, int64 hash) {
 191   return c_ObjectData::os_lval(s, hash);
 192 }
 193 void c_ppnode_hash_text::o_get(ArrayElementVec &props) const {
 194   props.push_back(NEW(ArrayElement)("value", m_value.isReferenced() ? ref(m_value) : m_value));
 195   props.push_back(NEW(ArrayElement)("nextSibling", m_nextSibling.isReferenced() ? ref(m_nextSibling) : m_nextSibling));
 196   c_ObjectData::o_get(props);
 197 }
 198 bool c_ppnode_hash_text::o_exists(CStrRef s, int64 hash) const {
 199   if (hash < 0) hash = hash_string(s.data(), s.length());
 200   switch (hash & 3) {
 201     case 1:
 202       HASH_EXISTS_STRING(0x69E7413AE0C88471LL, value, 5);
 203       break;
 204     case 2:
 205       HASH_EXISTS_STRING(0x0B3EC7643EE81822LL, nextSibling, 11);
 206       break;
 207     default:
 208       break;
 209   }
 210   return c_ObjectData::o_exists(s, hash);
 211 }
 212 Variant c_ppnode_hash_text::o_get(CStrRef s, int64 hash) {
 213   if (hash < 0) hash = hash_string(s.data(), s.length());
 214   switch (hash & 3) {
 215     case 1:
 216       HASH_RETURN_STRING(0x69E7413AE0C88471LL, m_value,
 217                          value, 5);
 218       break;
 219     case 2:
 220       HASH_RETURN_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
 221                          nextSibling, 11);
 222       break;
 223     default:
 224       break;
 225   }
 226   return c_ObjectData::o_get(s, hash);
 227 }
 228 Variant c_ppnode_hash_text::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
 229   if (hash < 0) hash = hash_string(s.data(), s.length());
 230   switch (hash & 3) {
 231     case 1:
 232       HASH_SET_STRING(0x69E7413AE0C88471LL, m_value,
 233                       value, 5);
 234       break;
 235     case 2:
 236       HASH_SET_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
 237                       nextSibling, 11);
 238       break;
 239     default:
 240       break;
 241   }
 242   return c_ObjectData::o_set(s, hash, v, forInit);
 243 }
 244 Variant &c_ppnode_hash_text::o_lval(CStrRef s, int64 hash) {
 245   if (hash < 0) hash = hash_string(s.data(), s.length());
 246   switch (hash & 3) {
 247     case 1:
 248       HASH_RETURN_STRING(0x69E7413AE0C88471LL, m_value,
 249                          value, 5);
 250       break;
 251     case 2:
 252       HASH_RETURN_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
 253                          nextSibling, 11);
 254       break;
 255     default:
 256       break;
 257   }
 258   return c_ObjectData::o_lval(s, hash);
 259 }
 260 Variant c_ppnode_hash_text::os_constant(const char *s) {
 261   return c_ObjectData::os_constant(s);
 262 }
 263 IMPLEMENT_CLASS(ppnode_hash_text)
 264 ObjectData *c_ppnode_hash_text::create(Variant v_value) {
 265   init();
 266   t___construct(v_value);
 267   return this;
 268 }
 269 ObjectData *c_ppnode_hash_text::dynCreate(CArrRef params, bool init /* = true */) {
 270   if (init) {
 271     return (create(params.rvalAt(0)));
 272   } else return this;
 273 }
 274 void c_ppnode_hash_text::dynConstruct(CArrRef params) {
 275   (t___construct(params.rvalAt(0)));
 276 }
 277 ObjectData *c_ppnode_hash_text::cloneImpl() {
 278   c_ppnode_hash_text *obj = NEW(c_ppnode_hash_text)();
 279   cloneSet(obj);
 280   return obj;
 281 }
 282 void c_ppnode_hash_text::cloneSet(c_ppnode_hash_text *clone) {
 283   clone->m_value = m_value.isReferenced() ? ref(m_value) : m_value;
 284   clone->m_nextSibling = m_nextSibling.isReferenced() ? ref(m_nextSibling) : m_nextSibling;
 285   ObjectData::cloneSet(clone);
 286 }
 287 Variant c_ppnode_hash_text::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
 288   if (hash < 0) hash = hash_string_i(s);
 289   switch (hash & 31) {
 290     case 0:
 291       HASH_GUARD(0x73E7C3304C0C5360LL, splitarg) {
 292         return (t_splitarg(), null);
 293       }
 294       break;
 295     case 5:
 296       HASH_GUARD(0x23F51CDECC198965LL, getname) {
 297         return (t_getname());
 298       }
 299       break;
 300     case 6:
 301       HASH_GUARD(0x0A41DBE0830902C6LL, item) {
 302         return (t_item(params.rvalAt(0)));
 303       }
 304       break;
 305     case 9:
 306       HASH_GUARD(0x050681239965E069LL, getfirstchild) {
 307         return (t_getfirstchild());
 308       }
 309       break;
 310     case 12:
 311       HASH_GUARD(0x47D4EE3CB3EB696CLL, splitext) {
 312         return (t_splitext(), null);
 313       }
 314       break;
 315     case 13:
 316       HASH_GUARD(0x0621AE2D22A1922DLL, splitheading) {
 317         return (t_splitheading(), null);
 318       }
 319       break;
 320     case 14:
 321       HASH_GUARD(0x5ABDC66291F1CA2ELL, getchildrenoftype) {
 322         return (t_getchildrenoftype(params.rvalAt(0)));
 323       }
 324       break;
 325     case 15:
 326       HASH_GUARD(0x732EC1BDA8EC520FLL, getchildren) {
 327         return (t_getchildren());
 328       }
 329       break;
 330     case 19:
 331       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
 332         return (t___tostring());
 333       }
 334       break;
 335     case 20:
 336       HASH_GUARD(0x41EB078EF92C44D4LL, getlength) {
 337         return (t_getlength());
 338       }
 339       break;
 340     case 25:
 341       HASH_GUARD(0x4CB333CF2D880119LL, getnextsibling) {
 342         return (t_getnextsibling());
 343       }
 344       break;
 345     case 31:
 346       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
 347         return (t___construct(params.rvalAt(0)), null);
 348       }
 349       break;
 350     default:
 351       break;
 352   }
 353   return c_ObjectData::o_invoke(s, params, hash, fatal);
 354 }
 355 Variant c_ppnode_hash_text::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
 356   if (hash < 0) hash = hash_string_i(s);
 357   switch (hash & 31) {
 358     case 0:
 359       HASH_GUARD(0x73E7C3304C0C5360LL, splitarg) {
 360         return (t_splitarg(), null);
 361       }
 362       break;
 363     case 5:
 364       HASH_GUARD(0x23F51CDECC198965LL, getname) {
 365         return (t_getname());
 366       }
 367       break;
 368     case 6:
 369       HASH_GUARD(0x0A41DBE0830902C6LL, item) {
 370         return (t_item(a0));
 371       }
 372       break;
 373     case 9:
 374       HASH_GUARD(0x050681239965E069LL, getfirstchild) {
 375         return (t_getfirstchild());
 376       }
 377       break;
 378     case 12:
 379       HASH_GUARD(0x47D4EE3CB3EB696CLL, splitext) {
 380         return (t_splitext(), null);
 381       }
 382       break;
 383     case 13:
 384       HASH_GUARD(0x0621AE2D22A1922DLL, splitheading) {
 385         return (t_splitheading(), null);
 386       }
 387       break;
 388     case 14:
 389       HASH_GUARD(0x5ABDC66291F1CA2ELL, getchildrenoftype) {
 390         return (t_getchildrenoftype(a0));
 391       }
 392       break;
 393     case 15:
 394       HASH_GUARD(0x732EC1BDA8EC520FLL, getchildren) {
 395         return (t_getchildren());
 396       }
 397       break;
 398     case 19:
 399       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
 400         return (t___tostring());
 401       }
 402       break;
 403     case 20:
 404       HASH_GUARD(0x41EB078EF92C44D4LL, getlength) {
 405         return (t_getlength());
 406       }
 407       break;
 408     case 25:
 409       HASH_GUARD(0x4CB333CF2D880119LL, getnextsibling) {
 410         return (t_getnextsibling());
 411       }
 412       break;
 413     case 31:
 414       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
 415         return (t___construct(a0), null);
 416       }
 417       break;
 418     default:
 419       break;
 420   }
 421   return c_ObjectData::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
 422 }
 423 Variant c_ppnode_hash_text::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
 424   return c_ObjectData::os_invoke(c, s, params, hash, fatal);
 425 }
 426 Variant cw_ppnode_hash_text$os_get(const char *s) {
 427   return c_ppnode_hash_text::os_get(s, -1);
 428 }
 429 Variant &cw_ppnode_hash_text$os_lval(const char *s) {
 430   return c_ppnode_hash_text::os_lval(s, -1);
 431 }
 432 Variant cw_ppnode_hash_text$os_constant(const char *s) {
 433   return c_ppnode_hash_text::os_constant(s);
 434 }
 435 Variant cw_ppnode_hash_text$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
 436   return c_ppnode_hash_text::os_invoke(c, s, params, -1, fatal);
 437 }
 438 void c_ppnode_hash_text::init() {
 439   m_value = null;
 440   m_nextSibling = null;
 441 }
 442 /* SRC: Preprocessor_Hash.php line 1526 */
 443 void c_ppnode_hash_text::t___construct(Variant v_value) {
 444   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::__construct);
 445   bool oldInCtor = gasInCtor(true);
 446   if (LINE(1527,x_is_object(v_value))) {
 447     throw_exception(LINE(1528,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Text given object instead of string").create()))));
 448   }
 449   (m_value = v_value);
 450   gasInCtor(oldInCtor);
 451 } /* function */
 452 /* SRC: Preprocessor_Hash.php line 1533 */
 453 String c_ppnode_hash_text::t___tostring() {
 454   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::__toString);
 455   return LINE(1534,x_htmlspecialchars(toString(m_value)));
 456 } /* function */
 457 /* SRC: Preprocessor_Hash.php line 1537 */
 458 Variant c_ppnode_hash_text::t_getnextsibling() {
 459   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::getNextSibling);
 460   return m_nextSibling;
 461 } /* function */
 462 /* SRC: Preprocessor_Hash.php line 1541 */
 463 bool c_ppnode_hash_text::t_getchildren() {
 464   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::getChildren);
 465   return false;
 466 } /* function */
 467 /* SRC: Preprocessor_Hash.php line 1542 */
 468 bool c_ppnode_hash_text::t_getfirstchild() {
 469   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::getFirstChild);
 470   return false;
 471 } /* function */
 472 /* SRC: Preprocessor_Hash.php line 1543 */
 473 bool c_ppnode_hash_text::t_getchildrenoftype(CVarRef v_name) {
 474   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::getChildrenOfType);
 475   return false;
 476 } /* function */
 477 /* SRC: Preprocessor_Hash.php line 1544 */
 478 bool c_ppnode_hash_text::t_getlength() {
 479   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::getLength);
 480   return false;
 481 } /* function */
 482 /* SRC: Preprocessor_Hash.php line 1545 */
 483 bool c_ppnode_hash_text::t_item(CVarRef v_i) {
 484   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::item);
 485   return false;
 486 } /* function */
 487 /* SRC: Preprocessor_Hash.php line 1546 */
 488 String c_ppnode_hash_text::t_getname() {
 489   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::getName);
 490   return "#text";
 491 } /* function */
 492 /* SRC: Preprocessor_Hash.php line 1547 */
 493 void c_ppnode_hash_text::t_splitarg() {
 494   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::splitArg);
 495   throw_exception(LINE(1547,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Text::splitArg: not supported").create()))));
 496 } /* function */
 497 /* SRC: Preprocessor_Hash.php line 1548 */
 498 void c_ppnode_hash_text::t_splitext() {
 499   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::splitExt);
 500   throw_exception(LINE(1548,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Text::splitExt: not supported").create()))));
 501 } /* function */
 502 /* SRC: Preprocessor_Hash.php line 1549 */
 503 void c_ppnode_hash_text::t_splitheading() {
 504   INSTANCE_METHOD_INJECTION(PPNode_Hash_Text, PPNode_Hash_Text::splitHeading);
 505   throw_exception(LINE(1549,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Text::splitHeading: not supported").create()))));
 506 } /* function */
 507 /* SRC: Preprocessor_Hash.php line 725 */
 508 Variant c_ppdaccum_hash::os_get(const char *s, int64 hash) {
 509   return c_ObjectData::os_get(s, hash);
 510 }
 511 Variant &c_ppdaccum_hash::os_lval(const char *s, int64 hash) {
 512   return c_ObjectData::os_lval(s, hash);
 513 }
 514 void c_ppdaccum_hash::o_get(ArrayElementVec &props) const {
 515   props.push_back(NEW(ArrayElement)("firstNode", m_firstNode.isReferenced() ? ref(m_firstNode) : m_firstNode));
 516   props.push_back(NEW(ArrayElement)("lastNode", m_lastNode.isReferenced() ? ref(m_lastNode) : m_lastNode));
 517   c_ObjectData::o_get(props);
 518 }
 519 bool c_ppdaccum_hash::o_exists(CStrRef s, int64 hash) const {
 520   if (hash < 0) hash = hash_string(s.data(), s.length());
 521   switch (hash & 3) {
 522     case 1:
 523       HASH_EXISTS_STRING(0x6B446EEF03FAE201LL, lastNode, 8);
 524       break;
 525     case 2:
 526       HASH_EXISTS_STRING(0x4296B55256FA0986LL, firstNode, 9);
 527       break;
 528     default:
 529       break;
 530   }
 531   return c_ObjectData::o_exists(s, hash);
 532 }
 533 Variant c_ppdaccum_hash::o_get(CStrRef s, int64 hash) {
 534   if (hash < 0) hash = hash_string(s.data(), s.length());
 535   switch (hash & 3) {
 536     case 1:
 537       HASH_RETURN_STRING(0x6B446EEF03FAE201LL, m_lastNode,
 538                          lastNode, 8);
 539       break;
 540     case 2:
 541       HASH_RETURN_STRING(0x4296B55256FA0986LL, m_firstNode,
 542                          firstNode, 9);
 543       break;
 544     default:
 545       break;
 546   }
 547   return c_ObjectData::o_get(s, hash);
 548 }
 549 Variant c_ppdaccum_hash::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
 550   if (hash < 0) hash = hash_string(s.data(), s.length());
 551   switch (hash & 3) {
 552     case 1:
 553       HASH_SET_STRING(0x6B446EEF03FAE201LL, m_lastNode,
 554                       lastNode, 8);
 555       break;
 556     case 2:
 557       HASH_SET_STRING(0x4296B55256FA0986LL, m_firstNode,
 558                       firstNode, 9);
 559       break;
 560     default:
 561       break;
 562   }
 563   return c_ObjectData::o_set(s, hash, v, forInit);
 564 }
 565 Variant &c_ppdaccum_hash::o_lval(CStrRef s, int64 hash) {
 566   if (hash < 0) hash = hash_string(s.data(), s.length());
 567   switch (hash & 3) {
 568     case 1:
 569       HASH_RETURN_STRING(0x6B446EEF03FAE201LL, m_lastNode,
 570                          lastNode, 8);
 571       break;
 572     case 2:
 573       HASH_RETURN_STRING(0x4296B55256FA0986LL, m_firstNode,
 574                          firstNode, 9);
 575       break;
 576     default:
 577       break;
 578   }
 579   return c_ObjectData::o_lval(s, hash);
 580 }
 581 Variant c_ppdaccum_hash::os_constant(const char *s) {
 582   return c_ObjectData::os_constant(s);
 583 }
 584 IMPLEMENT_CLASS(ppdaccum_hash)
 585 ObjectData *c_ppdaccum_hash::create() {
 586   init();
 587   t___construct();
 588   return this;
 589 }
 590 ObjectData *c_ppdaccum_hash::dynCreate(CArrRef params, bool init /* = true */) {
 591   if (init) {
 592     return (create());
 593   } else return this;
 594 }
 595 void c_ppdaccum_hash::dynConstruct(CArrRef params) {
 596   (t___construct());
 597 }
 598 ObjectData *c_ppdaccum_hash::cloneImpl() {
 599   c_ppdaccum_hash *obj = NEW(c_ppdaccum_hash)();
 600   cloneSet(obj);
 601   return obj;
 602 }
 603 void c_ppdaccum_hash::cloneSet(c_ppdaccum_hash *clone) {
 604   clone->m_firstNode = m_firstNode.isReferenced() ? ref(m_firstNode) : m_firstNode;
 605   clone->m_lastNode = m_lastNode.isReferenced() ? ref(m_lastNode) : m_lastNode;
 606   ObjectData::cloneSet(clone);
 607 }
 608 Variant c_ppdaccum_hash::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
 609   if (hash < 0) hash = hash_string_i(s);
 610   switch (hash & 15) {
 611     case 1:
 612       HASH_GUARD(0x0D8DDF05964C6A31LL, addnode) {
 613         return (t_addnode(params.rvalAt(0)), null);
 614       }
 615       break;
 616     case 6:
 617       HASH_GUARD(0x6992F0F690B37356LL, addnodewithtext) {
 618         return (t_addnodewithtext(params.rvalAt(0), params.rvalAt(1)), null);
 619       }
 620       break;
 621     case 9:
 622       HASH_GUARD(0x6A8DCEFA6345DAC9LL, addaccum) {
 623         return (t_addaccum(params.rvalAt(0)), null);
 624       }
 625       break;
 626     case 14:
 627       HASH_GUARD(0x05AAC40C7DAD4ACELL, addliteral) {
 628         return (t_addliteral(params.rvalAt(0)), null);
 629       }
 630       break;
 631     case 15:
 632       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
 633         return (t___construct(), null);
 634       }
 635       break;
 636     default:
 637       break;
 638   }
 639   return c_ObjectData::o_invoke(s, params, hash, fatal);
 640 }
 641 Variant c_ppdaccum_hash::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
 642   if (hash < 0) hash = hash_string_i(s);
 643   switch (hash & 15) {
 644     case 1:
 645       HASH_GUARD(0x0D8DDF05964C6A31LL, addnode) {
 646         return (t_addnode(a0), null);
 647       }
 648       break;
 649     case 6:
 650       HASH_GUARD(0x6992F0F690B37356LL, addnodewithtext) {
 651         return (t_addnodewithtext(a0, a1), null);
 652       }
 653       break;
 654     case 9:
 655       HASH_GUARD(0x6A8DCEFA6345DAC9LL, addaccum) {
 656         return (t_addaccum(a0), null);
 657       }
 658       break;
 659     case 14:
 660       HASH_GUARD(0x05AAC40C7DAD4ACELL, addliteral) {
 661         return (t_addliteral(a0), null);
 662       }
 663       break;
 664     case 15:
 665       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
 666         return (t___construct(), null);
 667       }
 668       break;
 669     default:
 670       break;
 671   }
 672   return c_ObjectData::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
 673 }
 674 Variant c_ppdaccum_hash::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
 675   return c_ObjectData::os_invoke(c, s, params, hash, fatal);
 676 }
 677 Variant cw_ppdaccum_hash$os_get(const char *s) {
 678   return c_ppdaccum_hash::os_get(s, -1);
 679 }
 680 Variant &cw_ppdaccum_hash$os_lval(const char *s) {
 681   return c_ppdaccum_hash::os_lval(s, -1);
 682 }
 683 Variant cw_ppdaccum_hash$os_constant(const char *s) {
 684   return c_ppdaccum_hash::os_constant(s);
 685 }
 686 Variant cw_ppdaccum_hash$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
 687   return c_ppdaccum_hash::os_invoke(c, s, params, -1, fatal);
 688 }
 689 void c_ppdaccum_hash::init() {
 690   m_firstNode = null;
 691   m_lastNode = null;
 692 }
 693 /* SRC: Preprocessor_Hash.php line 728 */
 694 void c_ppdaccum_hash::t___construct() {
 695   INSTANCE_METHOD_INJECTION(PPDAccum_Hash, PPDAccum_Hash::__construct);
 696   bool oldInCtor = gasInCtor(true);
 697   (m_firstNode = (m_lastNode = false));
 698   gasInCtor(oldInCtor);
 699 } /* function */
 700 /* SRC: Preprocessor_Hash.php line 735 */
 701 void c_ppdaccum_hash::t_addliteral(CVarRef v_s) {
 702   INSTANCE_METHOD_INJECTION(PPDAccum_Hash, PPDAccum_Hash::addLiteral);
 703   if (same(m_lastNode, false)) {
 704     (m_firstNode = ((Object)((m_lastNode = ((Object)(LINE(737,p_ppnode_hash_text(p_ppnode_hash_text(NEWOBJ(c_ppnode_hash_text)())->create(v_s)))))))));
 705   }
 706   else if (instanceOf(m_lastNode, "PPNode_Hash_Text")) {
 707     concat_assign(m_lastNode.o_lval("value", 0x69E7413AE0C88471LL), toString(v_s));
 708   }
 709   else {
 710     (m_lastNode.o_lval("nextSibling", 0x0B3EC7643EE81822LL) = ((Object)(LINE(741,p_ppnode_hash_text(p_ppnode_hash_text(NEWOBJ(c_ppnode_hash_text)())->create(v_s))))));
 711     (m_lastNode = m_lastNode.o_get("nextSibling", 0x0B3EC7643EE81822LL));
 712   }
 713 } /* function */
 714 /* SRC: Preprocessor_Hash.php line 749 */
 715 void c_ppdaccum_hash::t_addnode(p_ppnode v_node) {
 716   INSTANCE_METHOD_INJECTION(PPDAccum_Hash, PPDAccum_Hash::addNode);
 717   if (same(m_lastNode, false)) {
 718     (m_firstNode = ((Object)((m_lastNode = ((Object)(v_node))))));
 719   }
 720   else {
 721     (m_lastNode.o_lval("nextSibling", 0x0B3EC7643EE81822LL) = ((Object)(v_node)));
 722     (m_lastNode = ((Object)(v_node)));
 723   }
 724 } /* function */
 725 /* SRC: Preprocessor_Hash.php line 761 */
 726 void c_ppdaccum_hash::t_addnodewithtext(CVarRef v_name, CVarRef v_value) {
 727   INSTANCE_METHOD_INJECTION(PPDAccum_Hash, PPDAccum_Hash::addNodeWithText);
 728   Object v_node;
 729
 730   (v_node = LINE(762,c_ppnode_hash_tree::t_newwithtext(v_name, v_value)));
 731   LINE(763,t_addnode(p_ppnode(v_node)));
 732 } /* function */
 733 /* SRC: Preprocessor_Hash.php line 771 */
 734 void c_ppdaccum_hash::t_addaccum(CVarRef v_accum) {
 735   INSTANCE_METHOD_INJECTION(PPDAccum_Hash, PPDAccum_Hash::addAccum);
 736   if (same(toObject(v_accum).o_get("lastNode", 0x6B446EEF03FAE201LL), false)) {
 737   }
 738   else if (same(m_lastNode, false)) {
 739     (m_firstNode = toObject(v_accum).o_get("firstNode", 0x4296B55256FA0986LL));
 740     (m_lastNode = toObject(v_accum).o_get("lastNode", 0x6B446EEF03FAE201LL));
 741   }
 742   else {
 743     (m_lastNode.o_lval("nextSibling", 0x0B3EC7643EE81822LL) = toObject(v_accum).o_get("firstNode", 0x4296B55256FA0986LL));
 744     (m_lastNode = toObject(v_accum).o_get("lastNode", 0x6B446EEF03FAE201LL));
 745   }
 746 } /* function */
 747 /* SRC: Preprocessor_Hash.php line 1336 */
 748 Variant c_ppnode_hash_tree::os_get(const char *s, int64 hash) {
 749   return c_ObjectData::os_get(s, hash);
 750 }
 751 Variant &c_ppnode_hash_tree::os_lval(const char *s, int64 hash) {
 752   return c_ObjectData::os_lval(s, hash);
 753 }
 754 void c_ppnode_hash_tree::o_get(ArrayElementVec &props) const {
 755   props.push_back(NEW(ArrayElement)("name", m_name.isReferenced() ? ref(m_name) : m_name));
 756   props.push_back(NEW(ArrayElement)("firstChild", m_firstChild.isReferenced() ? ref(m_firstChild) : m_firstChild));
 757   props.push_back(NEW(ArrayElement)("lastChild", m_lastChild.isReferenced() ? ref(m_lastChild) : m_lastChild));
 758   props.push_back(NEW(ArrayElement)("nextSibling", m_nextSibling.isReferenced() ? ref(m_nextSibling) : m_nextSibling));
 759   c_ObjectData::o_get(props);
 760 }
 761 bool c_ppnode_hash_tree::o_exists(CStrRef s, int64 hash) const {
 762   if (hash < 0) hash = hash_string(s.data(), s.length());
 763   switch (hash & 7) {
 764     case 0:
 765       HASH_EXISTS_STRING(0x22862CD26C0AAB50LL, firstChild, 10);
 766       break;
 767     case 2:
 768       HASH_EXISTS_STRING(0x29DD4C280399C7FALL, lastChild, 9);
 769       HASH_EXISTS_STRING(0x0B3EC7643EE81822LL, nextSibling, 11);
 770       break;
 771     case 4:
 772       HASH_EXISTS_STRING(0x0BCDB293DC3CBDDCLL, name, 4);
 773       break;
 774     default:
 775       break;
 776   }
 777   return c_ObjectData::o_exists(s, hash);
 778 }
 779 Variant c_ppnode_hash_tree::o_get(CStrRef s, int64 hash) {
 780   if (hash < 0) hash = hash_string(s.data(), s.length());
 781   switch (hash & 7) {
 782     case 0:
 783       HASH_RETURN_STRING(0x22862CD26C0AAB50LL, m_firstChild,
 784                          firstChild, 10);
 785       break;
 786     case 2:
 787       HASH_RETURN_STRING(0x29DD4C280399C7FALL, m_lastChild,
 788                          lastChild, 9);
 789       HASH_RETURN_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
 790                          nextSibling, 11);
 791       break;
 792     case 4:
 793       HASH_RETURN_STRING(0x0BCDB293DC3CBDDCLL, m_name,
 794                          name, 4);
 795       break;
 796     default:
 797       break;
 798   }
 799   return c_ObjectData::o_get(s, hash);
 800 }
 801 Variant c_ppnode_hash_tree::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
 802   if (hash < 0) hash = hash_string(s.data(), s.length());
 803   switch (hash & 7) {
 804     case 0:
 805       HASH_SET_STRING(0x22862CD26C0AAB50LL, m_firstChild,
 806                       firstChild, 10);
 807       break;
 808     case 2:
 809       HASH_SET_STRING(0x29DD4C280399C7FALL, m_lastChild,
 810                       lastChild, 9);
 811       HASH_SET_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
 812                       nextSibling, 11);
 813       break;
 814     case 4:
 815       HASH_SET_STRING(0x0BCDB293DC3CBDDCLL, m_name,
 816                       name, 4);
 817       break;
 818     default:
 819       break;
 820   }
 821   return c_ObjectData::o_set(s, hash, v, forInit);
 822 }
 823 Variant &c_ppnode_hash_tree::o_lval(CStrRef s, int64 hash) {
 824   if (hash < 0) hash = hash_string(s.data(), s.length());
 825   switch (hash & 7) {
 826     case 0:
 827       HASH_RETURN_STRING(0x22862CD26C0AAB50LL, m_firstChild,
 828                          firstChild, 10);
 829       break;
 830     case 2:
 831       HASH_RETURN_STRING(0x29DD4C280399C7FALL, m_lastChild,
 832                          lastChild, 9);
 833       HASH_RETURN_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
 834                          nextSibling, 11);
 835       break;
 836     case 4:
 837       HASH_RETURN_STRING(0x0BCDB293DC3CBDDCLL, m_name,
 838                          name, 4);
 839       break;
 840     default:
 841       break;
 842   }
 843   return c_ObjectData::o_lval(s, hash);
 844 }
 845 Variant c_ppnode_hash_tree::os_constant(const char *s) {
 846   return c_ObjectData::os_constant(s);
 847 }
 848 IMPLEMENT_CLASS(ppnode_hash_tree)
 849 ObjectData *c_ppnode_hash_tree::create(Variant v_name) {
 850   init();
 851   t___construct(v_name);
 852   return this;
 853 }
 854 ObjectData *c_ppnode_hash_tree::dynCreate(CArrRef params, bool init /* = true */) {
 855   if (init) {
 856     return (create(params.rvalAt(0)));
 857   } else return this;
 858 }
 859 void c_ppnode_hash_tree::dynConstruct(CArrRef params) {
 860   (t___construct(params.rvalAt(0)));
 861 }
 862 ObjectData *c_ppnode_hash_tree::cloneImpl() {
 863   c_ppnode_hash_tree *obj = NEW(c_ppnode_hash_tree)();
 864   cloneSet(obj);
 865   return obj;
 866 }
 867 void c_ppnode_hash_tree::cloneSet(c_ppnode_hash_tree *clone) {
 868   clone->m_name = m_name.isReferenced() ? ref(m_name) : m_name;
 869   clone->m_firstChild = m_firstChild.isReferenced() ? ref(m_firstChild) : m_firstChild;
 870   clone->m_lastChild = m_lastChild.isReferenced() ? ref(m_lastChild) : m_lastChild;
 871   clone->m_nextSibling = m_nextSibling.isReferenced() ? ref(m_nextSibling) : m_nextSibling;
 872   ObjectData::cloneSet(clone);
 873 }
 874 Variant c_ppnode_hash_tree::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
 875   if (hash < 0) hash = hash_string_i(s);
 876   switch (hash & 31) {
 877     case 0:
 878       HASH_GUARD(0x73E7C3304C0C5360LL, splitarg) {
 879         return (t_splitarg());
 880       }
 881       break;
 882     case 5:
 883       HASH_GUARD(0x23F51CDECC198965LL, getname) {
 884         return (t_getname());
 885       }
 886       break;
 887     case 6:
 888       HASH_GUARD(0x0A41DBE0830902C6LL, item) {
 889         return (t_item(params.rvalAt(0)));
 890       }
 891       break;
 892     case 9:
 893       HASH_GUARD(0x050681239965E069LL, getfirstchild) {
 894         return (t_getfirstchild());
 895       }
 896       break;
 897     case 12:
 898       HASH_GUARD(0x47D4EE3CB3EB696CLL, splitext) {
 899         return (t_splitext());
 900       }
 901       break;
 902     case 13:
 903       HASH_GUARD(0x0621AE2D22A1922DLL, splitheading) {
 904         return (t_splitheading());
 905       }
 906       HASH_GUARD(0x5D6BF11378AA7D8DLL, splittemplate) {
 907         return (t_splittemplate());
 908       }
 909       break;
 910     case 14:
 911       HASH_GUARD(0x5ABDC66291F1CA2ELL, getchildrenoftype) {
 912         return (t_getchildrenoftype(params.rvalAt(0)));
 913       }
 914       break;
 915     case 15:
 916       HASH_GUARD(0x732EC1BDA8EC520FLL, getchildren) {
 917         return (t_getchildren());
 918       }
 919       break;
 920     case 19:
 921       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
 922         return (t___tostring());
 923       }
 924       break;
 925     case 20:
 926       HASH_GUARD(0x41EB078EF92C44D4LL, getlength) {
 927         return (t_getlength());
 928       }
 929       HASH_GUARD(0x2DDE12A9866FC794LL, addchild) {
 930         return (t_addchild(params.rvalAt(0)), null);
 931       }
 932       break;
 933     case 25:
 934       HASH_GUARD(0x4CB333CF2D880119LL, getnextsibling) {
 935         return (t_getnextsibling());
 936       }
 937       break;
 938     case 31:
 939       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
 940         return (t___construct(params.rvalAt(0)), null);
 941       }
 942       break;
 943     default:
 944       break;
 945   }
 946   return c_ObjectData::o_invoke(s, params, hash, fatal);
 947 }
 948 Variant c_ppnode_hash_tree::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
 949   if (hash < 0) hash = hash_string_i(s);
 950   switch (hash & 31) {
 951     case 0:
 952       HASH_GUARD(0x73E7C3304C0C5360LL, splitarg) {
 953         return (t_splitarg());
 954       }
 955       break;
 956     case 5:
 957       HASH_GUARD(0x23F51CDECC198965LL, getname) {
 958         return (t_getname());
 959       }
 960       break;
 961     case 6:
 962       HASH_GUARD(0x0A41DBE0830902C6LL, item) {
 963         return (t_item(a0));
 964       }
 965       break;
 966     case 9:
 967       HASH_GUARD(0x050681239965E069LL, getfirstchild) {
 968         return (t_getfirstchild());
 969       }
 970       break;
 971     case 12:
 972       HASH_GUARD(0x47D4EE3CB3EB696CLL, splitext) {
 973         return (t_splitext());
 974       }
 975       break;
 976     case 13:
 977       HASH_GUARD(0x0621AE2D22A1922DLL, splitheading) {
 978         return (t_splitheading());
 979       }
 980       HASH_GUARD(0x5D6BF11378AA7D8DLL, splittemplate) {
 981         return (t_splittemplate());
 982       }
 983       break;
 984     case 14:
 985       HASH_GUARD(0x5ABDC66291F1CA2ELL, getchildrenoftype) {
 986         return (t_getchildrenoftype(a0));
 987       }
 988       break;
 989     case 15:
 990       HASH_GUARD(0x732EC1BDA8EC520FLL, getchildren) {
 991         return (t_getchildren());
 992       }
 993       break;
 994     case 19:
 995       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
 996         return (t___tostring());
 997       }
 998       break;
 999     case 20:
1000       HASH_GUARD(0x41EB078EF92C44D4LL, getlength) {
1001         return (t_getlength());
1002       }
1003       HASH_GUARD(0x2DDE12A9866FC794LL, addchild) {
1004         return (t_addchild(a0), null);
1005       }
1006       break;
1007     case 25:
1008       HASH_GUARD(0x4CB333CF2D880119LL, getnextsibling) {
1009         return (t_getnextsibling());
1010       }
1011       break;
1012     case 31:
1013       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
1014         return (t___construct(a0), null);
1015       }
1016       break;
1017     default:
1018       break;
1019   }
1020   return c_ObjectData::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
1021 }
1022 Variant c_ppnode_hash_tree::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
1023   return c_ObjectData::os_invoke(c, s, params, hash, fatal);
1024 }
1025 Variant cw_ppnode_hash_tree$os_get(const char *s) {
1026   return c_ppnode_hash_tree::os_get(s, -1);
1027 }
1028 Variant &cw_ppnode_hash_tree$os_lval(const char *s) {
1029   return c_ppnode_hash_tree::os_lval(s, -1);
1030 }
1031 Variant cw_ppnode_hash_tree$os_constant(const char *s) {
1032   return c_ppnode_hash_tree::os_constant(s);
1033 }
1034 Variant cw_ppnode_hash_tree$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
1035   return c_ppnode_hash_tree::os_invoke(c, s, params, -1, fatal);
1036 }
1037 void c_ppnode_hash_tree::init() {
1038   m_name = null;
1039   m_firstChild = null;
1040   m_lastChild = null;
1041   m_nextSibling = null;
1042 }
1043 /* SRC: Preprocessor_Hash.php line 1339 */
1044 void c_ppnode_hash_tree::t___construct(Variant v_name) {
1045   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::__construct);
1046   bool oldInCtor = gasInCtor(true);
1047   (m_name = v_name);
1048   (m_firstChild = (m_lastChild = (m_nextSibling = false)));
1049   gasInCtor(oldInCtor);
1050 } /* function */
1051 /* SRC: Preprocessor_Hash.php line 1344 */
1052 String c_ppnode_hash_tree::t___tostring() {
1053   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::__toString);
1054   Variant eo_0;
1055   Variant eo_1;
1056   Variant eo_2;
1057   Variant eo_3;
1058   Variant eo_4;
1059   String v_inner;
1060   String v_attribs;
1061   Variant v_node;
1062
1063   (v_inner = "");
1064   (v_attribs = "");
1065   {
1066     LOOP_COUNTER(1);
1067     for ((v_node = m_firstChild); toBoolean(v_node); (v_node = v_node.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
1068       LOOP_COUNTER_CHECK(1);
1069       {
1070         if (instanceOf(v_node, "PPNode_Hash_Attr")) {
1071           concat_assign(v_attribs, LINE(1349,(assignCallTemp(eo_1, toString(v_node.o_get("name", 0x0BCDB293DC3CBDDCLL))),assignCallTemp(eo_3, x_htmlspecialchars(toString(v_node.o_get("value", 0x69E7413AE0C88471LL)))),concat5(" ", eo_1, "=\"", eo_3, "\""))));
1072         }
1073         else {
1074           concat_assign(v_inner, toString(LINE(1351,v_node.o_invoke_few_args("__toString", 0x642C2D2994B34A13LL, 0))));
1075         }
1076       }
1077     }
1078   }
1079   if (same(v_inner, "")) {
1080     return LINE(1355,concat4("<", toString(m_name), v_attribs, "/>"));
1081   }
1082   else {
1083     return LINE(1357,(assignCallTemp(eo_1, toString(m_name)),assignCallTemp(eo_2, concat6(v_attribs, ">", v_inner, "</", toString(m_name), ">")),concat3("<", eo_1, eo_2)));
1084   }
1085   return toString(null);
1086 } /* function */
1087 /* SRC: Preprocessor_Hash.php line 1361 */
1088 Object c_ppnode_hash_tree::ti_newwithtext(const char* cls, CVarRef v_name, CVarRef v_text) {
1089   STATIC_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::newWithText);
1090   Object v_obj;
1091
1092   (v_obj = LINE(1362,create_object("self", Array(ArrayInit(1).set(0, v_name).create()))));
1093   LINE(1363,v_obj->o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, p_ppnode_hash_text(p_ppnode_hash_text(NEWOBJ(c_ppnode_hash_text)())->create(v_text))));
1094   return v_obj;
1095 } /* function */
1096 /* SRC: Preprocessor_Hash.php line 1367 */
1097 void c_ppnode_hash_tree::t_addchild(CVarRef v_node) {
1098   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::addChild);
1099   if (same(m_lastChild, false)) {
1100     (m_firstChild = (m_lastChild = v_node));
1101   }
1102   else {
1103     (m_lastChild.o_lval("nextSibling", 0x0B3EC7643EE81822LL) = v_node);
1104     (m_lastChild = v_node);
1105   }
1106 } /* function */
1107 /* SRC: Preprocessor_Hash.php line 1376 */
1108 p_ppnode_hash_array c_ppnode_hash_tree::t_getchildren() {
1109   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::getChildren);
1110   Array v_children;
1111   Variant v_child;
1112
1113   (v_children = ScalarArrays::sa_[0]);
1114   {
1115     LOOP_COUNTER(2);
1116     for ((v_child = m_firstChild); toBoolean(v_child); (v_child = v_child.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
1117       LOOP_COUNTER_CHECK(2);
1118       {
1119         v_children.append((v_child));
1120       }
1121     }
1122   }
1123   return ((Object)(LINE(1381,p_ppnode_hash_array(p_ppnode_hash_array(NEWOBJ(c_ppnode_hash_array)())->create(v_children)))));
1124 } /* function */
1125 /* SRC: Preprocessor_Hash.php line 1384 */
1126 Variant c_ppnode_hash_tree::t_getfirstchild() {
1127   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::getFirstChild);
1128   return m_firstChild;
1129 } /* function */
1130 /* SRC: Preprocessor_Hash.php line 1388 */
1131 Variant c_ppnode_hash_tree::t_getnextsibling() {
1132   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::getNextSibling);
1133   return m_nextSibling;
1134 } /* function */
1135 /* SRC: Preprocessor_Hash.php line 1392 */
1136 Array c_ppnode_hash_tree::t_getchildrenoftype(CVarRef v_name) {
1137   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::getChildrenOfType);
1138   Array v_children;
1139   Variant v_child;
1140
1141   (v_children = ScalarArrays::sa_[0]);
1142   {
1143     LOOP_COUNTER(3);
1144     for ((v_child = m_firstChild); toBoolean(v_child); (v_child = v_child.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
1145       LOOP_COUNTER_CHECK(3);
1146       {
1147         if (toObject(v_child)->t___isset("name") && same(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), v_name)) {
1148           v_children.append((v_name));
1149         }
1150       }
1151     }
1152   }
1153   return v_children;
1154 } /* function */
1155 /* SRC: Preprocessor_Hash.php line 1402 */
1156 bool c_ppnode_hash_tree::t_getlength() {
1157   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::getLength);
1158   return false;
1159 } /* function */
1160 /* SRC: Preprocessor_Hash.php line 1403 */
1161 bool c_ppnode_hash_tree::t_item(CVarRef v_i) {
1162   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::item);
1163   return false;
1164 } /* function */
1165 /* SRC: Preprocessor_Hash.php line 1405 */
1166 Variant c_ppnode_hash_tree::t_getname() {
1167   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::getName);
1168   return m_name;
1169 } /* function */
1170 /* SRC: Preprocessor_Hash.php line 1415 */
1171 Variant c_ppnode_hash_tree::t_splitarg() {
1172   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::splitArg);
1173   Variant v_bits;
1174   Variant v_child;
1175
1176   (v_bits = ScalarArrays::sa_[0]);
1177   {
1178     LOOP_COUNTER(4);
1179     for ((v_child = m_firstChild); toBoolean(v_child); (v_child = v_child.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
1180       LOOP_COUNTER_CHECK(4);
1181       {
1182         if (!(toObject(v_child)->t___isset("name"))) {
1183           continue;
1184         }
1185         if (same(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "name")) {
1186           v_bits.set("name", (v_child), 0x0BCDB293DC3CBDDCLL);
1187           if (instanceOf(v_child.o_get("firstChild", 0x22862CD26C0AAB50LL), "PPNode_Hash_Attr") && same(v_child.o_get("firstChild", 0x22862CD26C0AAB50LL).o_get("name", 0x0BCDB293DC3CBDDCLL), "index")) {
1188             v_bits.set("index", (v_child.o_get("firstChild", 0x22862CD26C0AAB50LL).o_get("value", 0x69E7413AE0C88471LL)), 0x440D5888C0FF3081LL);
1189           }
1190         }
1191         else if (same(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "value")) {
1192           v_bits.set("value", (v_child), 0x69E7413AE0C88471LL);
1193         }
1194       }
1195     }
1196   }
1197   if (!(isset(v_bits, "name", 0x0BCDB293DC3CBDDCLL))) {
1198     throw_exception(LINE(1434,create_object("mwexception", Array(ArrayInit(1).set(0, "Invalid brace node passed to PPNode_Hash_Tree::splitArg").create()))));
1199   }
1200   if (!(isset(v_bits, "index", 0x440D5888C0FF3081LL))) {
1201     v_bits.set("index", (""), 0x440D5888C0FF3081LL);
1202   }
1203   return v_bits;
1204 } /* function */
1205 /* SRC: Preprocessor_Hash.php line 1446 */
1206 Variant c_ppnode_hash_tree::t_splitext() {
1207   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::splitExt);
1208   Variant v_bits;
1209   Variant v_child;
1210
1211   (v_bits = ScalarArrays::sa_[0]);
1212   {
1213     LOOP_COUNTER(5);
1214     for ((v_child = m_firstChild); toBoolean(v_child); (v_child = v_child.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
1215       LOOP_COUNTER_CHECK(5);
1216       {
1217         if (!(toObject(v_child)->t___isset("name"))) {
1218           continue;
1219         }
1220         if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "name")) {
1221           v_bits.set("name", (v_child), 0x0BCDB293DC3CBDDCLL);
1222         }
1223         else if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "attr")) {
1224           v_bits.set("attr", (v_child), 0x64311A2C8443755DLL);
1225         }
1226         else if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "inner")) {
1227           v_bits.set("inner", (v_child), 0x4F20D07BB803C1FELL);
1228         }
1229         else if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "close")) {
1230           v_bits.set("close", (v_child), 0x36B43082F052EC6BLL);
1231         }
1232       }
1233     }
1234   }
1235   if (!(isset(v_bits, "name", 0x0BCDB293DC3CBDDCLL))) {
1236     throw_exception(LINE(1463,create_object("mwexception", Array(ArrayInit(1).set(0, "Invalid ext node passed to PPNode_Hash_Tree::splitExt").create()))));
1237   }
1238   return v_bits;
1239 } /* function */
1240 /* SRC: Preprocessor_Hash.php line 1471 */
1241 Variant c_ppnode_hash_tree::t_splitheading() {
1242   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::splitHeading);
1243   Variant v_bits;
1244   Variant v_child;
1245
1246   if (!same(m_name, "h")) {
1247     throw_exception(LINE(1473,create_object("mwexception", Array(ArrayInit(1).set(0, "Invalid h node passed to PPNode_Hash_Tree::splitHeading").create()))));
1248   }
1249   (v_bits = ScalarArrays::sa_[0]);
1250   {
1251     LOOP_COUNTER(6);
1252     for ((v_child = m_firstChild); toBoolean(v_child); (v_child = v_child.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
1253       LOOP_COUNTER_CHECK(6);
1254       {
1255         if (!(toObject(v_child)->t___isset("name"))) {
1256           continue;
1257         }
1258         if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "i")) {
1259           v_bits.set("i", (v_child.o_get("value", 0x69E7413AE0C88471LL)), 0x0EB22EDA95766E98LL);
1260         }
1261         else if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "level")) {
1262           v_bits.set("level", (v_child.o_get("value", 0x69E7413AE0C88471LL)), 0x26B910814038EBA3LL);
1263         }
1264       }
1265     }
1266   }
1267   if (!(isset(v_bits, "i", 0x0EB22EDA95766E98LL))) {
1268     throw_exception(LINE(1487,create_object("mwexception", Array(ArrayInit(1).set(0, "Invalid h node passed to PPNode_Hash_Tree::splitHeading").create()))));
1269   }
1270   return v_bits;
1271 } /* function */
1272 /* SRC: Preprocessor_Hash.php line 1495 */
1273 Variant c_ppnode_hash_tree::t_splittemplate() {
1274   INSTANCE_METHOD_INJECTION(PPNode_Hash_Tree, PPNode_Hash_Tree::splitTemplate);
1275   Array v_parts;
1276   Variant v_bits;
1277   Variant v_child;
1278
1279   (v_parts = ScalarArrays::sa_[0]);
1280   (v_bits = ScalarArrays::sa_[13]);
1281   {
1282     LOOP_COUNTER(7);
1283     for ((v_child = m_firstChild); toBoolean(v_child); (v_child = v_child.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
1284       LOOP_COUNTER_CHECK(7);
1285       {
1286         if (!(toObject(v_child)->t___isset("name"))) {
1287           continue;
1288         }
1289         if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "title")) {
1290           v_bits.set("title", (v_child), 0x66AD900A2301E2FELL);
1291         }
1292         if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "part")) {
1293           v_parts.append((v_child));
1294         }
1295         if (equal(v_child.o_get("name", 0x0BCDB293DC3CBDDCLL), "lineStart")) {
1296           v_bits.set("lineStart", ("1"), 0x0F84CB175598D0A5LL);
1297         }
1298       }
1299     }
1300   }
1301   if (!(isset(v_bits, "title", 0x66AD900A2301E2FELL))) {
1302     throw_exception(LINE(1513,create_object("mwexception", Array(ArrayInit(1).set(0, "Invalid node passed to PPNode_Hash_Tree::splitTemplate").create()))));
1303   }
1304   v_bits.set("parts", (((Object)(LINE(1515,p_ppnode_hash_array(p_ppnode_hash_array(NEWOBJ(c_ppnode_hash_array)())->create(v_parts)))))), 0x2708FDA74562AD8DLL);
1305   return v_bits;
1306 } /* function */
1307 /* SRC: Preprocessor_Hash.php line 788 */
1308 Variant c_ppframe_hash::os_get(const char *s, int64 hash) {
1309   return c_ObjectData::os_get(s, hash);
1310 }
1311 Variant &c_ppframe_hash::os_lval(const char *s, int64 hash) {
1312   return c_ObjectData::os_lval(s, hash);
1313 }
1314 void c_ppframe_hash::o_get(ArrayElementVec &props) const {
1315   props.push_back(NEW(ArrayElement)("preprocessor", m_preprocessor.isReferenced() ? ref(m_preprocessor) : m_preprocessor));
1316   props.push_back(NEW(ArrayElement)("parser", m_parser.isReferenced() ? ref(m_parser) : m_parser));
1317   props.push_back(NEW(ArrayElement)("title", m_title.isReferenced() ? ref(m_title) : m_title));
1318   props.push_back(NEW(ArrayElement)("titleCache", m_titleCache.isReferenced() ? ref(m_titleCache) : m_titleCache));
1319   props.push_back(NEW(ArrayElement)("loopCheckHash", m_loopCheckHash.isReferenced() ? ref(m_loopCheckHash) : m_loopCheckHash));
1320   props.push_back(NEW(ArrayElement)("depth", m_depth.isReferenced() ? ref(m_depth) : m_depth));
1321   c_ObjectData::o_get(props);
1322 }
1323 bool c_ppframe_hash::o_exists(CStrRef s, int64 hash) const {
1324   if (hash < 0) hash = hash_string(s.data(), s.length());
1325   switch (hash & 15) {
1326     case 2:
1327       HASH_EXISTS_STRING(0x18A8B9D71D4F2D02LL, parser, 6);
1328       break;
1329     case 3:
1330       HASH_EXISTS_STRING(0x0CD4D2916BE2CE13LL, titleCache, 10);
1331       break;
1332     case 5:
1333       HASH_EXISTS_STRING(0x757439BA20184735LL, loopCheckHash, 13);
1334       break;
1335     case 7:
1336       HASH_EXISTS_STRING(0x1AE700EECE6274C7LL, depth, 5);
1337       break;
1338     case 14:
1339       HASH_EXISTS_STRING(0x2940E17D1F5401AELL, preprocessor, 12);
1340       HASH_EXISTS_STRING(0x66AD900A2301E2FELL, title, 5);
1341       break;
1342     default:
1343       break;
1344   }
1345   return c_ObjectData::o_exists(s, hash);
1346 }
1347 Variant c_ppframe_hash::o_get(CStrRef s, int64 hash) {
1348   if (hash < 0) hash = hash_string(s.data(), s.length());
1349   switch (hash & 15) {
1350     case 2:
1351       HASH_RETURN_STRING(0x18A8B9D71D4F2D02LL, m_parser,
1352                          parser, 6);
1353       break;
1354     case 3:
1355       HASH_RETURN_STRING(0x0CD4D2916BE2CE13LL, m_titleCache,
1356                          titleCache, 10);
1357       break;
1358     case 5:
1359       HASH_RETURN_STRING(0x757439BA20184735LL, m_loopCheckHash,
1360                          loopCheckHash, 13);
1361       break;
1362     case 7:
1363       HASH_RETURN_STRING(0x1AE700EECE6274C7LL, m_depth,
1364                          depth, 5);
1365       break;
1366     case 14:
1367       HASH_RETURN_STRING(0x2940E17D1F5401AELL, m_preprocessor,
1368                          preprocessor, 12);
1369       HASH_RETURN_STRING(0x66AD900A2301E2FELL, m_title,
1370                          title, 5);
1371       break;
1372     default:
1373       break;
1374   }
1375   return c_ObjectData::o_get(s, hash);
1376 }
1377 Variant c_ppframe_hash::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
1378   if (hash < 0) hash = hash_string(s.data(), s.length());
1379   switch (hash & 15) {
1380     case 2:
1381       HASH_SET_STRING(0x18A8B9D71D4F2D02LL, m_parser,
1382                       parser, 6);
1383       break;
1384     case 3:
1385       HASH_SET_STRING(0x0CD4D2916BE2CE13LL, m_titleCache,
1386                       titleCache, 10);
1387       break;
1388     case 5:
1389       HASH_SET_STRING(0x757439BA20184735LL, m_loopCheckHash,
1390                       loopCheckHash, 13);
1391       break;
1392     case 7:
1393       HASH_SET_STRING(0x1AE700EECE6274C7LL, m_depth,
1394                       depth, 5);
1395       break;
1396     case 14:
1397       HASH_SET_STRING(0x2940E17D1F5401AELL, m_preprocessor,
1398                       preprocessor, 12);
1399       HASH_SET_STRING(0x66AD900A2301E2FELL, m_title,
1400                       title, 5);
1401       break;
1402     default:
1403       break;
1404   }
1405   return c_ObjectData::o_set(s, hash, v, forInit);
1406 }
1407 Variant &c_ppframe_hash::o_lval(CStrRef s, int64 hash) {
1408   if (hash < 0) hash = hash_string(s.data(), s.length());
1409   switch (hash & 15) {
1410     case 2:
1411       HASH_RETURN_STRING(0x18A8B9D71D4F2D02LL, m_parser,
1412                          parser, 6);
1413       break;
1414     case 3:
1415       HASH_RETURN_STRING(0x0CD4D2916BE2CE13LL, m_titleCache,
1416                          titleCache, 10);
1417       break;
1418     case 5:
1419       HASH_RETURN_STRING(0x757439BA20184735LL, m_loopCheckHash,
1420                          loopCheckHash, 13);
1421       break;
1422     case 7:
1423       HASH_RETURN_STRING(0x1AE700EECE6274C7LL, m_depth,
1424                          depth, 5);
1425       break;
1426     case 14:
1427       HASH_RETURN_STRING(0x2940E17D1F5401AELL, m_preprocessor,
1428                          preprocessor, 12);
1429       HASH_RETURN_STRING(0x66AD900A2301E2FELL, m_title,
1430                          title, 5);
1431       break;
1432     default:
1433       break;
1434   }
1435   return c_ObjectData::o_lval(s, hash);
1436 }
1437 Variant c_ppframe_hash::os_constant(const char *s) {
1438   return c_ObjectData::os_constant(s);
1439 }
1440 IMPLEMENT_CLASS(ppframe_hash)
1441 ObjectData *c_ppframe_hash::create(Variant v_preprocessor) {
1442   init();
1443   t___construct(v_preprocessor);
1444   return this;
1445 }
1446 ObjectData *c_ppframe_hash::dynCreate(CArrRef params, bool init /* = true */) {
1447   if (init) {
1448     return (create(params.rvalAt(0)));
1449   } else return this;
1450 }
1451 void c_ppframe_hash::dynConstruct(CArrRef params) {
1452   (t___construct(params.rvalAt(0)));
1453 }
1454 ObjectData *c_ppframe_hash::cloneImpl() {
1455   c_ppframe_hash *obj = NEW(c_ppframe_hash)();
1456   cloneSet(obj);
1457   return obj;
1458 }
1459 void c_ppframe_hash::cloneSet(c_ppframe_hash *clone) {
1460   clone->m_preprocessor = m_preprocessor.isReferenced() ? ref(m_preprocessor) : m_preprocessor;
1461   clone->m_parser = m_parser.isReferenced() ? ref(m_parser) : m_parser;
1462   clone->m_title = m_title.isReferenced() ? ref(m_title) : m_title;
1463   clone->m_titleCache = m_titleCache.isReferenced() ? ref(m_titleCache) : m_titleCache;
1464   clone->m_loopCheckHash = m_loopCheckHash.isReferenced() ? ref(m_loopCheckHash) : m_loopCheckHash;
1465   clone->m_depth = m_depth.isReferenced() ? ref(m_depth) : m_depth;
1466   ObjectData::cloneSet(clone);
1467 }
1468 Variant c_ppframe_hash::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
1469   if (hash < 0) hash = hash_string_i(s);
1470   switch (hash & 31) {
1471     case 8:
1472       HASH_GUARD(0x6359F42D5FC265E8LL, isempty) {
1473         return (t_isempty());
1474       }
1475       break;
1476     case 11:
1477       HASH_GUARD(0x409618A98590618BLL, virtualbracketedimplode) {
1478         int count = params.size();
1479         if (count <= 3) return (t_virtualbracketedimplode(count, params.rvalAt(0), params.rvalAt(1), params.rvalAt(2)));
1480         return (t_virtualbracketedimplode(count,params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.slice(3, count - 3, false)));
1481       }
1482       break;
1483     case 13:
1484       HASH_GUARD(0x39B7BB05F05A37CDLL, expand) {
1485         int count = params.size();
1486         if (count <= 1) return (t_expand(params.rvalAt(0)));
1487         return (t_expand(params.rvalAt(0), params.rvalAt(1)));
1488       }
1489       break;
1490     case 14:
1491       HASH_GUARD(0x5047BA794DE2746ELL, implodewithflags) {
1492         int count = params.size();
1493         if (count <= 2) return (t_implodewithflags(count, params.rvalAt(0), params.rvalAt(1)));
1494         return (t_implodewithflags(count,params.rvalAt(0), params.rvalAt(1), params.slice(2, count - 2, false)));
1495       }
1496       break;
1497     case 16:
1498       HASH_GUARD(0x7EF27F050E4E0390LL, getnamedarguments) {
1499         return (t_getnamedarguments());
1500       }
1501       break;
1502     case 17:
1503       HASH_GUARD(0x1E2D3AE762AF0AF1LL, virtualimplode) {
1504         int count = params.size();
1505         if (count <= 1) return (t_virtualimplode(count, params.rvalAt(0)));
1506         return (t_virtualimplode(count,params.rvalAt(0), params.slice(1, count - 1, false)));
1507       }
1508       break;
1509     case 19:
1510       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
1511         return (t___tostring());
1512       }
1513       break;
1514     case 23:
1515       HASH_GUARD(0x3685C90A1EB568B7LL, getarguments) {
1516         return (t_getarguments());
1517       }
1518       break;
1519     case 24:
1520       HASH_GUARD(0x0A95A4780D41F7B8LL, getargument) {
1521         return (t_getargument(params.rvalAt(0)));
1522       }
1523       break;
1524     case 25:
1525       HASH_GUARD(0x7CBE9654ADB6CFB9LL, istemplate) {
1526         return (t_istemplate());
1527       }
1528       break;
1529     case 28:
1530       HASH_GUARD(0x7F4AB942B9CDE1BCLL, newchild) {
1531         int count = params.size();
1532         if (count <= 0) return (t_newchild());
1533         if (count == 1) return (t_newchild(params.rvalAt(0)));
1534         return (t_newchild(params.rvalAt(0), params.rvalAt(1)));
1535       }
1536       break;
1537     case 29:
1538       HASH_GUARD(0x7F29FBB1CA49733DLL, getnumberedarguments) {
1539         return (t_getnumberedarguments());
1540       }
1541       break;
1542     case 30:
1543       HASH_GUARD(0x36A80B48E08B753ELL, implode) {
1544         int count = params.size();
1545         if (count <= 1) return (t_implode(count, params.rvalAt(0)));
1546         return (t_implode(count,params.rvalAt(0), params.slice(1, count - 1, false)));
1547       }
1548       break;
1549     case 31:
1550       HASH_GUARD(0x7BA9911BE4A4175FLL, loopcheck) {
1551         return (t_loopcheck(params.rvalAt(0)));
1552       }
1553       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
1554         return (t___construct(params.rvalAt(0)), null);
1555       }
1556       break;
1557     default:
1558       break;
1559   }
1560   return c_ObjectData::o_invoke(s, params, hash, fatal);
1561 }
1562 Variant c_ppframe_hash::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
1563   if (hash < 0) hash = hash_string_i(s);
1564   switch (hash & 31) {
1565     case 8:
1566       HASH_GUARD(0x6359F42D5FC265E8LL, isempty) {
1567         return (t_isempty());
1568       }
1569       break;
1570     case 11:
1571       HASH_GUARD(0x409618A98590618BLL, virtualbracketedimplode) {
1572         if (count <= 3) return (t_virtualbracketedimplode(count, a0, a1, a2));
1573         Array params;
1574         if (count >= 4) params.append(a3);
1575         if (count >= 5) params.append(a4);
1576         if (count >= 6) params.append(a5);
1577         return (t_virtualbracketedimplode(count,a0, a1, a2, params));
1578       }
1579       break;
1580     case 13:
1581       HASH_GUARD(0x39B7BB05F05A37CDLL, expand) {
1582         if (count <= 1) return (t_expand(a0));
1583         return (t_expand(a0, a1));
1584       }
1585       break;
1586     case 14:
1587       HASH_GUARD(0x5047BA794DE2746ELL, implodewithflags) {
1588         if (count <= 2) return (t_implodewithflags(count, a0, a1));
1589         Array params;
1590         if (count >= 3) params.append(a2);
1591         if (count >= 4) params.append(a3);
1592         if (count >= 5) params.append(a4);
1593         if (count >= 6) params.append(a5);
1594         return (t_implodewithflags(count,a0, a1, params));
1595       }
1596       break;
1597     case 16:
1598       HASH_GUARD(0x7EF27F050E4E0390LL, getnamedarguments) {
1599         return (t_getnamedarguments());
1600       }
1601       break;
1602     case 17:
1603       HASH_GUARD(0x1E2D3AE762AF0AF1LL, virtualimplode) {
1604         if (count <= 1) return (t_virtualimplode(count, a0));
1605         Array params;
1606         if (count >= 2) params.append(a1);
1607         if (count >= 3) params.append(a2);
1608         if (count >= 4) params.append(a3);
1609         if (count >= 5) params.append(a4);
1610         if (count >= 6) params.append(a5);
1611         return (t_virtualimplode(count,a0, params));
1612       }
1613       break;
1614     case 19:
1615       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
1616         return (t___tostring());
1617       }
1618       break;
1619     case 23:
1620       HASH_GUARD(0x3685C90A1EB568B7LL, getarguments) {
1621         return (t_getarguments());
1622       }
1623       break;
1624     case 24:
1625       HASH_GUARD(0x0A95A4780D41F7B8LL, getargument) {
1626         return (t_getargument(a0));
1627       }
1628       break;
1629     case 25:
1630       HASH_GUARD(0x7CBE9654ADB6CFB9LL, istemplate) {
1631         return (t_istemplate());
1632       }
1633       break;
1634     case 28:
1635       HASH_GUARD(0x7F4AB942B9CDE1BCLL, newchild) {
1636         if (count <= 0) return (t_newchild());
1637         if (count == 1) return (t_newchild(a0));
1638         return (t_newchild(a0, a1));
1639       }
1640       break;
1641     case 29:
1642       HASH_GUARD(0x7F29FBB1CA49733DLL, getnumberedarguments) {
1643         return (t_getnumberedarguments());
1644       }
1645       break;
1646     case 30:
1647       HASH_GUARD(0x36A80B48E08B753ELL, implode) {
1648         if (count <= 1) return (t_implode(count, a0));
1649         Array params;
1650         if (count >= 2) params.append(a1);
1651         if (count >= 3) params.append(a2);
1652         if (count >= 4) params.append(a3);
1653         if (count >= 5) params.append(a4);
1654         if (count >= 6) params.append(a5);
1655         return (t_implode(count,a0, params));
1656       }
1657       break;
1658     case 31:
1659       HASH_GUARD(0x7BA9911BE4A4175FLL, loopcheck) {
1660         return (t_loopcheck(a0));
1661       }
1662       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
1663         return (t___construct(a0), null);
1664       }
1665       break;
1666     default:
1667       break;
1668   }
1669   return c_ObjectData::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
1670 }
1671 Variant c_ppframe_hash::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
1672   return c_ObjectData::os_invoke(c, s, params, hash, fatal);
1673 }
1674 Variant cw_ppframe_hash$os_get(const char *s) {
1675   return c_ppframe_hash::os_get(s, -1);
1676 }
1677 Variant &cw_ppframe_hash$os_lval(const char *s) {
1678   return c_ppframe_hash::os_lval(s, -1);
1679 }
1680 Variant cw_ppframe_hash$os_constant(const char *s) {
1681   return c_ppframe_hash::os_constant(s);
1682 }
1683 Variant cw_ppframe_hash$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
1684   return c_ppframe_hash::os_invoke(c, s, params, -1, fatal);
1685 }
1686 void c_ppframe_hash::init() {
1687   m_preprocessor = null;
1688   m_parser = null;
1689   m_title = null;
1690   m_titleCache = null;
1691   m_loopCheckHash = null;
1692   m_depth = null;
1693 }
1694 /* SRC: Preprocessor_Hash.php line 809 */
1695 void c_ppframe_hash::t___construct(Variant v_preprocessor) {
1696   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::__construct);
1697   bool oldInCtor = gasInCtor(true);
1698   (m_preprocessor = v_preprocessor);
1699   (m_parser = v_preprocessor.o_get("parser", 0x18A8B9D71D4F2D02LL));
1700   (m_title = m_parser.o_get("mTitle", 0x4C804C46307BF0EALL));
1701   (m_titleCache = Array(ArrayInit(1).set(0, toBoolean(m_title) ? ((Variant)(LINE(813,m_title.o_invoke_few_args("getPrefixedDBkey", 0x3E327BDC66DECDABLL, 0)))) : ((Variant)(false))).create()));
1702   (m_loopCheckHash = ScalarArrays::sa_[0]);
1703   (m_depth = 0LL);
1704   gasInCtor(oldInCtor);
1705 } /* function */
1706 /* SRC: Preprocessor_Hash.php line 822 */
1707 p_pptemplateframe_hash c_ppframe_hash::t_newchild(Variant v_args //  = false
1708 , Variant v_title //  = false
1709 ) {
1710   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::newChild);
1711   DECLARE_GLOBAL_VARIABLES(g);
1712   Variant v_namedArgs;
1713   Variant v_numberedArgs;
1714   Variant v_arg;
1715   Variant v_bits;
1716   String v_name;
1717
1718   (v_namedArgs = ScalarArrays::sa_[0]);
1719   (v_numberedArgs = ScalarArrays::sa_[0]);
1720   if (same(v_title, false)) {
1721     (v_title = m_title);
1722   }
1723   if (!same(v_args, false)) {
1724     ;
1725     if (instanceOf(v_args, "PPNode_Hash_Array")) {
1726       (v_args = v_args.o_get("value", 0x69E7413AE0C88471LL));
1727     }
1728     else if (!(LINE(832,x_is_array(v_args)))) {
1729       throw_exception(LINE(833,create_object("mwexception", Array(ArrayInit(1).set(0, "PPFrame_Hash::newChild: $args must be array or PPNode_Hash_Array").create()))));
1730     }
1731     {
1732       LOOP_COUNTER(8);
1733       for (ArrayIterPtr iter10 = v_args.begin("ppframe_hash"); !iter10->end(); iter10->next()) {
1734         LOOP_COUNTER_CHECK(8);
1735         v_arg = iter10->second();
1736         {
1737           (v_bits = LINE(836,v_arg.o_invoke_few_args("splitArg", 0x73E7C3304C0C5360LL, 0)));
1738           if (!same(v_bits.rvalAt("index", 0x440D5888C0FF3081LL), "")) {
1739             v_numberedArgs.set(v_bits.rvalAt("index", 0x440D5888C0FF3081LL), (v_bits.rvalAt("value", 0x69E7413AE0C88471LL)));
1740             v_namedArgs.weakRemove(v_bits.rvalAt("index", 0x440D5888C0FF3081LL));
1741           }
1742           else {
1743             (v_name = LINE(843,x_trim(toString(o_root_invoke_few_args("expand", 0x39B7BB05F05A37CDLL, 2, v_bits.refvalAt("name", 0x0BCDB293DC3CBDDCLL), 4LL /* ppframe::STRIP_COMMENTS */)))));
1744             v_namedArgs.set(v_name, (v_bits.rvalAt("value", 0x69E7413AE0C88471LL)));
1745             v_numberedArgs.weakRemove(v_name);
1746           }
1747         }
1748       }
1749     }
1750   }
1751   return ((Object)(LINE(849,p_pptemplateframe_hash(p_pptemplateframe_hash(NEWOBJ(c_pptemplateframe_hash)())->create(m_preprocessor, ((Object)(this)), v_numberedArgs, v_namedArgs, v_title)))));
1752 } /* function */
1753 /* SRC: Preprocessor_Hash.php line 852 */
1754 Variant c_ppframe_hash::t_expand(CVarRef v_root, Variant v_flags //  = 0LL
1755 ) {
1756   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::expand);
1757   DECLARE_GLOBAL_VARIABLES(g);
1758   Variant &sv_expansionDepth __attribute__((__unused__)) = g->sv_ppframe_hash$$expand$$expansionDepth.lvalAt(this->o_getClassName());
1759   Variant &inited_sv_expansionDepth __attribute__((__unused__)) = g->inited_sv_ppframe_hash$$expand$$expansionDepth.lvalAt(this->o_getClassName());
1760   Variant v_outStack;
1761   Variant v_iteratorStack;
1762   Variant v_indexStack;
1763   int64 v_level = 0;
1764   Variant v_iteratorNode;
1765   Variant v_out;
1766   Variant v_index;
1767   Variant v_contextNode;
1768   Variant v_newIterator;
1769   Variant v_bits;
1770   Variant v_ret;
1771   Variant v_s;
1772   Variant v_node;
1773   Variant v_titleText;
1774   int64 v_serial = 0;
1775   Variant v_marker;
1776
1777   if (!inited_sv_expansionDepth) {
1778     (sv_expansionDepth = 0LL);
1779     inited_sv_expansionDepth = true;
1780   }
1781   if (LINE(854,x_is_string(v_root))) {
1782     return v_root;
1783   }
1784   if (more(++lval(m_parser.o_lval("mPPNodeCount", 0x17B591196693E481LL)), m_parser.o_get("mOptions", 0x79AC63B0E96DC6E9LL).o_get("mMaxPPNodeCount", 0x3DD526BE5013BD55LL))) {
1785     return "<span class=\"error\">Node-count limit exceeded</span>";
1786   }
1787   if (more(sv_expansionDepth, m_parser.o_get("mOptions", 0x79AC63B0E96DC6E9LL).o_get("mMaxPPExpandDepth", 0x2F1977A57AF7D6DELL))) {
1788     return "<span class=\"error\">Expansion depth limit exceeded</span>";
1789   }
1790   ++sv_expansionDepth;
1791   (v_outStack = ScalarArrays::sa_[9]);
1792   (v_iteratorStack = Array(ArrayInit(2).set(0, false).set(1, v_root).create()));
1793   (v_indexStack = ScalarArrays::sa_[10]);
1794   LOOP_COUNTER(11);
1795   {
1796     while (more(LINE(871,x_count(v_iteratorStack)), 1LL)) {
1797       LOOP_COUNTER_CHECK(11);
1798       {
1799         (v_level = LINE(872,x_count(v_outStack)) - 1LL);
1800         (v_iteratorNode = ref(lval(v_iteratorStack.lvalAt(v_level))));
1801         (v_out = ref(lval(v_outStack.lvalAt(v_level))));
1802         (v_index = ref(lval(v_indexStack.lvalAt(v_level))));
1803         if (LINE(877,x_is_array(v_iteratorNode))) {
1804           if (not_less(v_index, LINE(878,x_count(v_iteratorNode)))) {
1805             v_iteratorStack.set(v_level, (false));
1806             (v_contextNode = false);
1807           }
1808           else {
1809             (v_contextNode = v_iteratorNode.rvalAt(v_index));
1810             v_index++;
1811           }
1812         }
1813         else if (instanceOf(v_iteratorNode, "PPNode_Hash_Array")) {
1814           if (not_less(v_index, LINE(887,v_iteratorNode.o_invoke_few_args("getLength", 0x41EB078EF92C44D4LL, 0)))) {
1815             v_iteratorStack.set(v_level, (false));
1816             (v_contextNode = false);
1817           }
1818           else {
1819             (v_contextNode = LINE(892,v_iteratorNode.o_invoke_few_args("item", 0x0A41DBE0830902C6LL, 1, v_index)));
1820             v_index++;
1821           }
1822         }
1823         else {
1824           (v_contextNode = v_iteratorStack.rvalAt(v_level));
1825           v_iteratorStack.set(v_level, (false));
1826         }
1827         (v_newIterator = false);
1828         if (same(v_contextNode, false)) {
1829         }
1830         else if (LINE(906,x_is_string(v_contextNode))) {
1831           concat_assign(v_out, toString(v_contextNode));
1832         }
1833         else if (LINE(908,x_is_array(v_contextNode)) || instanceOf(v_contextNode, "PPNode_Hash_Array")) {
1834           (v_newIterator = v_contextNode);
1835         }
1836         else if (instanceOf(v_contextNode, "PPNode_Hash_Attr")) {
1837         }
1838         else if (instanceOf(v_contextNode, "PPNode_Hash_Text")) {
1839           concat_assign(v_out, toString(v_contextNode.o_get("value", 0x69E7413AE0C88471LL)));
1840         }
1841         else if (instanceOf(v_contextNode, "PPNode_Hash_Tree")) {
1842           if (equal(v_contextNode.o_get("name", 0x0BCDB293DC3CBDDCLL), "template")) {
1843             (v_bits = LINE(917,v_contextNode.o_invoke_few_args("splitTemplate", 0x5D6BF11378AA7D8DLL, 0)));
1844             if (toBoolean(bitwise_and(v_flags, throw_fatal("unknown class constant ppframe_hash::NO_TEMPLATES")))) {
1845               (v_newIterator = LINE(919,o_root_invoke_few_args("virtualBracketedImplode", 0x409618A98590618BLL, 5, "{{", "|", "}}", v_bits.refvalAt("title", 0x66AD900A2301E2FELL), v_bits.refvalAt("parts", 0x2708FDA74562AD8DLL))));
1846             }
1847             else {
1848               (v_ret = LINE(921,m_parser.o_invoke_few_args("braceSubstitution", 0x392E383BDD5B10F7LL, 2, v_bits, this)));
1849               if (isset(v_ret, "object", 0x7F30BC4E222B1861LL)) {
1850                 (v_newIterator = v_ret.rvalAt("object", 0x7F30BC4E222B1861LL));
1851               }
1852               else {
1853                 concat_assign(v_out, toString(v_ret.rvalAt("text", 0x2A28A0084DD3A743LL)));
1854               }
1855             }
1856           }
1857           else if (equal(v_contextNode.o_get("name", 0x0BCDB293DC3CBDDCLL), "tplarg")) {
1858             (v_bits = LINE(930,v_contextNode.o_invoke_few_args("splitTemplate", 0x5D6BF11378AA7D8DLL, 0)));
1859             if (toBoolean(bitwise_and(v_flags, throw_fatal("unknown class constant ppframe_hash::NO_ARGS")))) {
1860               (v_newIterator = LINE(932,o_root_invoke_few_args("virtualBracketedImplode", 0x409618A98590618BLL, 5, "{{{", "|", "}}}", v_bits.refvalAt("title", 0x66AD900A2301E2FELL), v_bits.refvalAt("parts", 0x2708FDA74562AD8DLL))));
1861             }
1862             else {
1863               (v_ret = LINE(934,m_parser.o_invoke_few_args("argSubstitution", 0x333DE406BD9436D1LL, 2, v_bits, this)));
1864               if (isset(v_ret, "object", 0x7F30BC4E222B1861LL)) {
1865                 (v_newIterator = v_ret.rvalAt("object", 0x7F30BC4E222B1861LL));
1866               }
1867               else {
1868                 concat_assign(v_out, toString(v_ret.rvalAt("text", 0x2A28A0084DD3A743LL)));
1869               }
1870             }
1871           }
1872           else if (equal(v_contextNode.o_get("name", 0x0BCDB293DC3CBDDCLL), "comment")) {
1873             if (toBoolean(m_parser.o_get("ot", 0x48663D83DD673D4DLL).rvalAt("html", 0x5CA91C812230855DLL)) || (toBoolean(m_parser.o_get("ot", 0x48663D83DD673D4DLL).rvalAt("pre", 0x633242EDD179FBACLL)) && toBoolean(LINE(945,m_parser.o_get("mOptions", 0x79AC63B0E96DC6E9LL).o_invoke_few_args("getRemoveComments", 0x4E73BF37061917D4LL, 0)))) || (toBoolean(bitwise_and(v_flags, throw_fatal("unknown class constant ppframe_hash::STRIP_COMMENTS"))))) {
1874               concat_assign(v_out, "");
1875             }
1876             else if (toBoolean(m_parser.o_get("ot", 0x48663D83DD673D4DLL).rvalAt("wiki", 0x24648D2BCD794D21LL)) && !((toBoolean(bitwise_and(v_flags, throw_fatal("unknown class constant ppframe_hash::RECOVER_COMMENTS")))))) {
1877               concat_assign(v_out, toString(LINE(953,m_parser.o_invoke_few_args("insertStripItem", 0x0A4CA37F020D70E2LL, 1, v_contextNode.o_get("firstChild", 0x22862CD26C0AAB50LL).o_lval("value", 0x69E7413AE0C88471LL)))));
1878             }
1879             else {
1880               concat_assign(v_out, toString(v_contextNode.o_get("firstChild", 0x22862CD26C0AAB50LL).o_get("value", 0x69E7413AE0C88471LL)));
1881             }
1882           }
1883           else if (equal(v_contextNode.o_get("name", 0x0BCDB293DC3CBDDCLL), "ignore")) {
1884             if ((!(t___isset("parent")) && toBoolean(m_parser.o_get("ot", 0x48663D83DD673D4DLL).rvalAt("wiki", 0x24648D2BCD794D21LL))) || (toBoolean(bitwise_and(v_flags, throw_fatal("unknown class constant ppframe_hash::NO_IGNORE"))))) {
1885               concat_assign(v_out, toString(v_contextNode.o_get("firstChild", 0x22862CD26C0AAB50LL).o_get("value", 0x69E7413AE0C88471LL)));
1886             }
1887           }
1888           else if (equal(v_contextNode.o_get("name", 0x0BCDB293DC3CBDDCLL), "ext")) {
1889             (v_bits = LINE(971,v_contextNode.o_invoke_few_args("splitExt", 0x47D4EE3CB3EB696CLL, 0)) + (Variant)(ScalarArrays::sa_[12]));
1890             concat_assign(v_out, toString(LINE(972,m_parser.o_invoke_few_args("extensionSubstitution", 0x7D371E851A4798E9LL, 2, v_bits, this))));
1891           }
1892           else if (equal(v_contextNode.o_get("name", 0x0BCDB293DC3CBDDCLL), "h")) {
1893             if (toBoolean(m_parser.o_get("ot", 0x48663D83DD673D4DLL).rvalAt("html", 0x5CA91C812230855DLL))) {
1894               (v_s = "");
1895               {
1896                 LOOP_COUNTER(12);
1897                 for ((v_node = v_contextNode.o_get("firstChild", 0x22862CD26C0AAB50LL)); toBoolean(v_node); (v_node = v_node.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
1898                   LOOP_COUNTER_CHECK(12);
1899                   {
1900                     concat_assign(v_s, toString(LINE(979,o_root_invoke_few_args("expand", 0x39B7BB05F05A37CDLL, 2, v_node, v_flags))));
1901                   }
1902                 }
1903               }
1904               (v_bits = LINE(982,v_contextNode.o_invoke_few_args("splitHeading", 0x0621AE2D22A1922DLL, 0)));
1905               (v_titleText = LINE(983,m_title.o_invoke_few_args("getPrefixedDBkey", 0x3E327BDC66DECDABLL, 0)));
1906               lval(m_parser.o_lval("mHeadings", 0x5EB895444FBC1E6BLL)).append((Array(ArrayInit(2).set(0, v_titleText).set(1, v_bits.rvalAt("i", 0x0EB22EDA95766E98LL)).create())));
1907               (v_serial = LINE(985,x_count(m_parser.o_get("mHeadings", 0x5EB895444FBC1E6BLL))) - 1LL);
1908               (v_marker = LINE(986,concat4(toString(m_parser.o_get("mUniqPrefix", 0x22D00FA247E8311DLL)), "-h-", toString(v_serial), "--QINU\177")));
1909               (v_s = concat_rev(toString(LINE(987,x_substr(toString(v_s), toInt32(v_bits.rvalAt("level", 0x26B910814038EBA3LL))))), concat(toString(x_substr(toString(v_s), toInt32(0LL), toInt32(v_bits.rvalAt("level", 0x26B910814038EBA3LL)))), toString(v_marker))));
1910               LINE(988,m_parser.o_get("mStripState", 0x7207EA9A5BBFBF69LL).o_get("general", 0x661B15A9C00F7127LL).o_invoke_few_args("setPair", 0x1CA93325C3BDD490LL, 2, v_marker, ""));
1911               concat_assign(v_out, toString(v_s));
1912             }
1913             else {
1914               (v_newIterator = LINE(992,v_contextNode.o_invoke_few_args("getChildren", 0x732EC1BDA8EC520FLL, 0)));
1915             }
1916           }
1917           else {
1918             (v_newIterator = LINE(996,v_contextNode.o_invoke_few_args("getChildren", 0x732EC1BDA8EC520FLL, 0)));
1919           }
1920         }
1921         else {
1922           throw_exception(LINE(999,create_object("mwexception", Array(ArrayInit(1).set(0, "PPFrame_Hash::expand: Invalid parameter type").create()))));
1923         }
1924         if (!same(v_newIterator, false)) {
1925           v_outStack.append((""));
1926           v_iteratorStack.append((v_newIterator));
1927           v_indexStack.append((0LL));
1928         }
1929         else if (same(v_iteratorStack.rvalAt(v_level), false)) {
1930           LOOP_COUNTER(13);
1931           {
1932             while (same(v_iteratorStack.rvalAt(v_level), false) && more(v_level, 0LL)) {
1933               LOOP_COUNTER_CHECK(13);
1934               {
1935                 concat_assign(lval(v_outStack.lvalAt(v_level - 1LL)), toString(v_out));
1936                 LINE(1011,x_array_pop(ref(v_outStack)));
1937                 LINE(1012,x_array_pop(ref(v_iteratorStack)));
1938                 LINE(1013,x_array_pop(ref(v_indexStack)));
1939                 v_level--;
1940               }
1941             }
1942           }
1943         }
1944       }
1945     }
1946   }
1947   --sv_expansionDepth;
1948   return v_outStack.rvalAt(0LL, 0x77CFA1EEF01BCA90LL);
1949 } /* function */
1950 /* SRC: Preprocessor_Hash.php line 1022 */
1951 Variant c_ppframe_hash::t_implodewithflags(int num_args, CVarRef v_sep, Variant v_flags, Array args /* = Array() */) {
1952   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::implodeWithFlags);
1953   Variant eo_0;
1954   Variant eo_1;
1955   Variant v_args;
1956   bool v_first = false;
1957   Variant v_s;
1958   Variant v_root;
1959   Variant v_node;
1960
1961   (v_args = LINE(1023,(assignCallTemp(eo_0, func_get_args(num_args, Array(ArrayInit(2).set(0, v_sep).set(1, v_flags).create()),args)),x_array_slice(eo_0, toInt32(2LL)))));
1962   (v_first = true);
1963   (v_s = "");
1964   {
1965     LOOP_COUNTER(14);
1966     for (ArrayIterPtr iter16 = v_args.begin("ppframe_hash"); !iter16->end(); iter16->next()) {
1967       LOOP_COUNTER_CHECK(14);
1968       v_root = iter16->second();
1969       {
1970         if (instanceOf(v_root, "PPNode_Hash_Array")) {
1971           (v_root = v_root.o_get("value", 0x69E7413AE0C88471LL));
1972         }
1973         if (!(LINE(1031,x_is_array(v_root)))) {
1974           (v_root = Array(ArrayInit(1).set(0, v_root).create()));
1975         }
1976         {
1977           LOOP_COUNTER(17);
1978           for (ArrayIterPtr iter19 = v_root.begin("ppframe_hash"); !iter19->end(); iter19->next()) {
1979             LOOP_COUNTER_CHECK(17);
1980             v_node = iter19->second();
1981             {
1982               if (v_first) {
1983                 (v_first = false);
1984               }
1985               else {
1986                 concat_assign(v_s, toString(v_sep));
1987               }
1988               concat_assign(v_s, toString(LINE(1040,o_root_invoke_few_args("expand", 0x39B7BB05F05A37CDLL, 2, v_node, v_flags))));
1989             }
1990           }
1991         }
1992       }
1993     }
1994   }
1995   return v_s;
1996 } /* function */
1997 /* SRC: Preprocessor_Hash.php line 1050 */
1998 Variant c_ppframe_hash::t_implode(int num_args, CVarRef v_sep, Array args /* = Array() */) {
1999   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::implode);
2000   Variant eo_0;
2001   Variant eo_1;
2002   Variant v_args;
2003   bool v_first = false;
2004   Variant v_s;
2005   Variant v_root;
2006   Variant v_node;
2007
2008   (v_args = LINE(1051,(assignCallTemp(eo_0, func_get_args(num_args, Array(ArrayInit(1).set(0, v_sep).create()),args)),x_array_slice(eo_0, toInt32(1LL)))));
2009   (v_first = true);
2010   (v_s = "");
2011   {
2012     LOOP_COUNTER(20);
2013     for (ArrayIterPtr iter22 = v_args.begin("ppframe_hash"); !iter22->end(); iter22->next()) {
2014       LOOP_COUNTER_CHECK(20);
2015       v_root = iter22->second();
2016       {
2017         if (instanceOf(v_root, "PPNode_Hash_Array")) {
2018           (v_root = v_root.o_get("value", 0x69E7413AE0C88471LL));
2019         }
2020         if (!(LINE(1059,x_is_array(v_root)))) {
2021           (v_root = Array(ArrayInit(1).set(0, v_root).create()));
2022         }
2023         {
2024           LOOP_COUNTER(23);
2025           for (ArrayIterPtr iter25 = v_root.begin("ppframe_hash"); !iter25->end(); iter25->next()) {
2026             LOOP_COUNTER_CHECK(23);
2027             v_node = iter25->second();
2028             {
2029               if (v_first) {
2030                 (v_first = false);
2031               }
2032               else {
2033                 concat_assign(v_s, toString(v_sep));
2034               }
2035               concat_assign(v_s, toString(LINE(1068,o_root_invoke_few_args("expand", 0x39B7BB05F05A37CDLL, 1, v_node))));
2036             }
2037           }
2038         }
2039       }
2040     }
2041   }
2042   return v_s;
2043 } /* function */
2044 /* SRC: Preprocessor_Hash.php line 1078 */
2045 p_ppnode_hash_array c_ppframe_hash::t_virtualimplode(int num_args, CVarRef v_sep, Array args /* = Array() */) {
2046   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::virtualImplode);
2047   Variant eo_0;
2048   Variant eo_1;
2049   Variant v_args;
2050   Array v_out;
2051   bool v_first = false;
2052   Variant v_root;
2053   Variant v_node;
2054
2055   (v_args = LINE(1079,(assignCallTemp(eo_0, func_get_args(num_args, Array(ArrayInit(1).set(0, v_sep).create()),args)),x_array_slice(eo_0, toInt32(1LL)))));
2056   (v_out = ScalarArrays::sa_[0]);
2057   (v_first = true);
2058   {
2059     LOOP_COUNTER(26);
2060     for (ArrayIterPtr iter28 = v_args.begin("ppframe_hash"); !iter28->end(); iter28->next()) {
2061       LOOP_COUNTER_CHECK(26);
2062       v_root = iter28->second();
2063       {
2064         if (instanceOf(v_root, "PPNode_Hash_Array")) {
2065           (v_root = v_root.o_get("value", 0x69E7413AE0C88471LL));
2066         }
2067         if (!(LINE(1087,x_is_array(v_root)))) {
2068           (v_root = Array(ArrayInit(1).set(0, v_root).create()));
2069         }
2070         {
2071           LOOP_COUNTER(29);
2072           for (ArrayIterPtr iter31 = v_root.begin("ppframe_hash"); !iter31->end(); iter31->next()) {
2073             LOOP_COUNTER_CHECK(29);
2074             v_node = iter31->second();
2075             {
2076               if (v_first) {
2077                 (v_first = false);
2078               }
2079               else {
2080                 v_out.append((v_sep));
2081               }
2082               v_out.append((v_node));
2083             }
2084           }
2085         }
2086       }
2087     }
2088   }
2089   return ((Object)(LINE(1099,p_ppnode_hash_array(p_ppnode_hash_array(NEWOBJ(c_ppnode_hash_array)())->create(v_out)))));
2090 } /* function */
2091 /* SRC: Preprocessor_Hash.php line 1105 */
2092 p_ppnode_hash_array c_ppframe_hash::t_virtualbracketedimplode(int num_args, CVarRef v_start, CVarRef v_sep, CVarRef v_end, Array args /* = Array() */) {
2093   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::virtualBracketedImplode);
2094   Variant eo_0;
2095   Variant eo_1;
2096   Variant v_args;
2097   Array v_out;
2098   bool v_first = false;
2099   Variant v_root;
2100   Variant v_node;
2101
2102   (v_args = LINE(1106,(assignCallTemp(eo_0, func_get_args(num_args, Array(ArrayInit(3).set(0, v_start).set(1, v_sep).set(2, v_end).create()),args)),x_array_slice(eo_0, toInt32(3LL)))));
2103   (v_out = Array(ArrayInit(1).set(0, v_start).create()));
2104   (v_first = true);
2105   {
2106     LOOP_COUNTER(32);
2107     for (ArrayIterPtr iter34 = v_args.begin("ppframe_hash"); !iter34->end(); iter34->next()) {
2108       LOOP_COUNTER_CHECK(32);
2109       v_root = iter34->second();
2110       {
2111         if (instanceOf(v_root, "PPNode_Hash_Array")) {
2112           (v_root = v_root.o_get("value", 0x69E7413AE0C88471LL));
2113         }
2114         if (!(LINE(1114,x_is_array(v_root)))) {
2115           (v_root = Array(ArrayInit(1).set(0, v_root).create()));
2116         }
2117         {
2118           LOOP_COUNTER(35);
2119           for (ArrayIterPtr iter37 = v_root.begin("ppframe_hash"); !iter37->end(); iter37->next()) {
2120             LOOP_COUNTER_CHECK(35);
2121             v_node = iter37->second();
2122             {
2123               if (v_first) {
2124                 (v_first = false);
2125               }
2126               else {
2127                 v_out.append((v_sep));
2128               }
2129               v_out.append((v_node));
2130             }
2131           }
2132         }
2133       }
2134     }
2135   }
2136   v_out.append((v_end));
2137   return ((Object)(LINE(1127,p_ppnode_hash_array(p_ppnode_hash_array(NEWOBJ(c_ppnode_hash_array)())->create(v_out)))));
2138 } /* function */
2139 /* SRC: Preprocessor_Hash.php line 1130 */
2140 String c_ppframe_hash::t___tostring() {
2141   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::__toString);
2142   return "frame{}";
2143 } /* function */
2144 /* SRC: Preprocessor_Hash.php line 1134 */
2145 Variant c_ppframe_hash::t_getpdbk(bool v_level //  = false
2146 ) {
2147   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::getPDBK);
2148   if (same(v_level, false)) {
2149     return LINE(1136,m_title.o_invoke_few_args("getPrefixedDBkey", 0x3E327BDC66DECDABLL, 0));
2150   }
2151   else {
2152     return isset(m_titleCache, v_level) ? ((Variant)(m_titleCache.rvalAt(v_level))) : ((Variant)(false));
2153   }
2154   return null;
2155 } /* function */
2156 /* SRC: Preprocessor_Hash.php line 1142 */
2157 Array c_ppframe_hash::t_getarguments() {
2158   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::getArguments);
2159   return ScalarArrays::sa_[0];
2160 } /* function */
2161 /* SRC: Preprocessor_Hash.php line 1146 */
2162 Array c_ppframe_hash::t_getnumberedarguments() {
2163   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::getNumberedArguments);
2164   return ScalarArrays::sa_[0];
2165 } /* function */
2166 /* SRC: Preprocessor_Hash.php line 1150 */
2167 Array c_ppframe_hash::t_getnamedarguments() {
2168   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::getNamedArguments);
2169   return ScalarArrays::sa_[0];
2170 } /* function */
2171 /* SRC: Preprocessor_Hash.php line 1157 */
2172 bool c_ppframe_hash::t_isempty() {
2173   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::isEmpty);
2174   return true;
2175 } /* function */
2176 /* SRC: Preprocessor_Hash.php line 1161 */
2177 bool c_ppframe_hash::t_getargument(CVarRef v_name) {
2178   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::getArgument);
2179   return false;
2180 } /* function */
2181 /* SRC: Preprocessor_Hash.php line 1168 */
2182 bool c_ppframe_hash::t_loopcheck(CVarRef v_title) {
2183   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::loopCheck);
2184   return !(isset(m_loopCheckHash, LINE(1169,toObject(v_title)->o_invoke_few_args("getPrefixedDBkey", 0x3E327BDC66DECDABLL, 0))));
2185 } /* function */
2186 /* SRC: Preprocessor_Hash.php line 1175 */
2187 bool c_ppframe_hash::t_istemplate() {
2188   INSTANCE_METHOD_INJECTION(PPFrame_Hash, PPFrame_Hash::isTemplate);
2189   return false;
2190 } /* function */
2191 /* SRC: Preprocessor_Hash.php line 9 */
2192 const int64 q_preprocessor_hash_CACHE_VERSION = 1LL;
2193 Variant c_preprocessor_hash::os_get(const char *s, int64 hash) {
2194   return c_ObjectData::os_get(s, hash);
2195 }
2196 Variant &c_preprocessor_hash::os_lval(const char *s, int64 hash) {
2197   return c_ObjectData::os_lval(s, hash);
2198 }
2199 void c_preprocessor_hash::o_get(ArrayElementVec &props) const {
2200   props.push_back(NEW(ArrayElement)("parser", m_parser.isReferenced() ? ref(m_parser) : m_parser));
2201   c_ObjectData::o_get(props);
2202 }
2203 bool c_preprocessor_hash::o_exists(CStrRef s, int64 hash) const {
2204   if (hash < 0) hash = hash_string(s.data(), s.length());
2205   switch (hash & 1) {
2206     case 0:
2207       HASH_EXISTS_STRING(0x18A8B9D71D4F2D02LL, parser, 6);
2208       break;
2209     default:
2210       break;
2211   }
2212   return c_ObjectData::o_exists(s, hash);
2213 }
2214 Variant c_preprocessor_hash::o_get(CStrRef s, int64 hash) {
2215   if (hash < 0) hash = hash_string(s.data(), s.length());
2216   switch (hash & 1) {
2217     case 0:
2218       HASH_RETURN_STRING(0x18A8B9D71D4F2D02LL, m_parser,
2219                          parser, 6);
2220       break;
2221     default:
2222       break;
2223   }
2224   return c_ObjectData::o_get(s, hash);
2225 }
2226 Variant c_preprocessor_hash::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
2227   if (hash < 0) hash = hash_string(s.data(), s.length());
2228   switch (hash & 1) {
2229     case 0:
2230       HASH_SET_STRING(0x18A8B9D71D4F2D02LL, m_parser,
2231                       parser, 6);
2232       break;
2233     default:
2234       break;
2235   }
2236   return c_ObjectData::o_set(s, hash, v, forInit);
2237 }
2238 Variant &c_preprocessor_hash::o_lval(CStrRef s, int64 hash) {
2239   if (hash < 0) hash = hash_string(s.data(), s.length());
2240   switch (hash & 1) {
2241     case 0:
2242       HASH_RETURN_STRING(0x18A8B9D71D4F2D02LL, m_parser,
2243                          parser, 6);
2244       break;
2245     default:
2246       break;
2247   }
2248   return c_ObjectData::o_lval(s, hash);
2249 }
2250 Variant c_preprocessor_hash::os_constant(const char *s) {
2251   int64 hash = hash_string(s);
2252   switch (hash & 1) {
2253     case 1:
2254       HASH_RETURN(0x6AD33BF0C16EEC43LL, q_preprocessor_hash_CACHE_VERSION, CACHE_VERSION);
2255       break;
2256     default:
2257       break;
2258   }
2259   return c_ObjectData::os_constant(s);
2260 }
2261 IMPLEMENT_CLASS(preprocessor_hash)
2262 ObjectData *c_preprocessor_hash::create(Variant v_parser) {
2263   init();
2264   t___construct(v_parser);
2265   return this;
2266 }
2267 ObjectData *c_preprocessor_hash::dynCreate(CArrRef params, bool init /* = true */) {
2268   if (init) {
2269     return (create(params.rvalAt(0)));
2270   } else return this;
2271 }
2272 void c_preprocessor_hash::dynConstruct(CArrRef params) {
2273   (t___construct(params.rvalAt(0)));
2274 }
2275 ObjectData *c_preprocessor_hash::cloneImpl() {
2276   c_preprocessor_hash *obj = NEW(c_preprocessor_hash)();
2277   cloneSet(obj);
2278   return obj;
2279 }
2280 void c_preprocessor_hash::cloneSet(c_preprocessor_hash *clone) {
2281   clone->m_parser = m_parser.isReferenced() ? ref(m_parser) : m_parser;
2282   ObjectData::cloneSet(clone);
2283 }
2284 Variant c_preprocessor_hash::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
2285   if (hash < 0) hash = hash_string_i(s);
2286   switch (hash & 7) {
2287     case 0:
2288       HASH_GUARD(0x5A11FE5B629AF7A0LL, newcustomframe) {
2289         return (t_newcustomframe(params.rvalAt(0)));
2290       }
2291       break;
2292     case 3:
2293       HASH_GUARD(0x0BA55A9913645813LL, preprocesstoobj) {
2294         int count = params.size();
2295         if (count <= 1) return (t_preprocesstoobj(params.rvalAt(0)));
2296         return (t_preprocesstoobj(params.rvalAt(0), params.rvalAt(1)));
2297       }
2298       break;
2299     case 5:
2300       HASH_GUARD(0x787B6141D7721675LL, newframe) {
2301         return (t_newframe());
2302       }
2303       break;
2304     case 7:
2305       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
2306         return (t___construct(params.rvalAt(0)), null);
2307       }
2308       break;
2309     default:
2310       break;
2311   }
2312   return c_ObjectData::o_invoke(s, params, hash, fatal);
2313 }
2314 Variant c_preprocessor_hash::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
2315   if (hash < 0) hash = hash_string_i(s);
2316   switch (hash & 7) {
2317     case 0:
2318       HASH_GUARD(0x5A11FE5B629AF7A0LL, newcustomframe) {
2319         return (t_newcustomframe(a0));
2320       }
2321       break;
2322     case 3:
2323       HASH_GUARD(0x0BA55A9913645813LL, preprocesstoobj) {
2324         if (count <= 1) return (t_preprocesstoobj(a0));
2325         return (t_preprocesstoobj(a0, a1));
2326       }
2327       break;
2328     case 5:
2329       HASH_GUARD(0x787B6141D7721675LL, newframe) {
2330         return (t_newframe());
2331       }
2332       break;
2333     case 7:
2334       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
2335         return (t___construct(a0), null);
2336       }
2337       break;
2338     default:
2339       break;
2340   }
2341   return c_ObjectData::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
2342 }
2343 Variant c_preprocessor_hash::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
2344   return c_ObjectData::os_invoke(c, s, params, hash, fatal);
2345 }
2346 Variant cw_preprocessor_hash$os_get(const char *s) {
2347   return c_preprocessor_hash::os_get(s, -1);
2348 }
2349 Variant &cw_preprocessor_hash$os_lval(const char *s) {
2350   return c_preprocessor_hash::os_lval(s, -1);
2351 }
2352 Variant cw_preprocessor_hash$os_constant(const char *s) {
2353   return c_preprocessor_hash::os_constant(s);
2354 }
2355 Variant cw_preprocessor_hash$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
2356   return c_preprocessor_hash::os_invoke(c, s, params, -1, fatal);
2357 }
2358 void c_preprocessor_hash::init() {
2359   m_parser = null;
2360 }
2361 /* SRC: Preprocessor_Hash.php line 14 */
2362 void c_preprocessor_hash::t___construct(Variant v_parser) {
2363   INSTANCE_METHOD_INJECTION(Preprocessor_Hash, Preprocessor_Hash::__construct);
2364   bool oldInCtor = gasInCtor(true);
2365   (m_parser = v_parser);
2366   gasInCtor(oldInCtor);
2367 } /* function */
2368 /* SRC: Preprocessor_Hash.php line 18 */
2369 p_ppframe_hash c_preprocessor_hash::t_newframe() {
2370   INSTANCE_METHOD_INJECTION(Preprocessor_Hash, Preprocessor_Hash::newFrame);
2371   return ((Object)(LINE(19,p_ppframe_hash(p_ppframe_hash(NEWOBJ(c_ppframe_hash)())->create(((Object)(this)))))));
2372 } /* function */
2373 /* SRC: Preprocessor_Hash.php line 22 */
2374 p_ppcustomframe_hash c_preprocessor_hash::t_newcustomframe(CVarRef v_args) {
2375   INSTANCE_METHOD_INJECTION(Preprocessor_Hash, Preprocessor_Hash::newCustomFrame);
2376   return ((Object)(LINE(23,p_ppcustomframe_hash(p_ppcustomframe_hash(NEWOBJ(c_ppcustomframe_hash)())->create(((Object)(this)), v_args)))));
2377 } /* function */
2378 /* SRC: Preprocessor_Hash.php line 48 */
2379 Variant c_preprocessor_hash::t_preprocesstoobj(Variant v_text, Variant v_flags //  = 0LL
2380 ) {
2381   INSTANCE_METHOD_INJECTION(Preprocessor_Hash, Preprocessor_Hash::preprocessToObj);
2382   Variant eo_0;
2383   Variant eo_1;
2384   Variant eo_2;
2385   Variant eo_3;
2386   Variant eo_4;
2387   Variant eo_5;
2388   Variant eo_6;
2389   Variant eo_7;
2390   DECLARE_GLOBAL_VARIABLES(g);
2391   Variant &gv_wgMemc __attribute__((__unused__)) = g->GV(wgMemc);
2392   Variant v_wgMemc;
2393   Variant &gv_wgPreprocessorCacheThreshold __attribute__((__unused__)) = g->GV(wgPreprocessorCacheThreshold);
2394   Variant v_wgPreprocessorCacheThreshold;
2395   Variant v_cacheable;
2396   Variant v_cacheKey;
2397   Variant v_cacheValue;
2398   Variant v_version;
2399   Variant v_hash;
2400   Variant v_rules;
2401   Variant v_forInclusion;
2402   Variant v_xmlishElements;
2403   Variant v_enableOnlyinclude;
2404   Variant v_ignoredTags;
2405   Variant v_ignoredElements;
2406   Variant v_xmlishRegex;
2407   Variant v_elementsRegex;
2408   Variant v_stack;
2409   Variant v_searchBase;
2410   Variant v_revText;
2411   Variant v_i;
2412   Variant v_accum;
2413   Variant v_findEquals;
2414   Variant v_findPipe;
2415   Variant v_headingIndex;
2416   Variant v_inHeading;
2417   Variant v_noMoreGT;
2418   Variant v_findOnlyinclude;
2419   Variant v_fakeLineStart;
2420   Variant v_startPos;
2421   Variant v_tagEndPos;
2422   Variant v_found;
2423   Variant v_curChar;
2424   Variant v_search;
2425   Variant v_currentClosing;
2426   Variant v_rule;
2427   Variant v_literalLength;
2428   Variant v_matches;
2429   Variant v_endPos;
2430   Variant v_inner;
2431   Variant v_wsStart;
2432   Variant v_wsEnd;
2433   Variant v_wsLength;
2434   Variant v_part;
2435   Variant v_name;
2436   Variant v_lowerName;
2437   Variant v_attrStart;
2438   Variant v_tagStartPos;
2439   Variant v_attrEnd;
2440   Variant v_close;
2441   Variant v_attr;
2442   Variant v_extNode;
2443   Variant v_count;
2444   Variant v_piece;
2445   Variant v_searchStart;
2446   Variant v_equalsLength;
2447   Variant v_element;
2448   Variant v_maxCount;
2449   Variant v_matchingCount;
2450   Variant v_parts;
2451   Variant v_titleAccum;
2452   Variant v_titleNode;
2453   Variant v_argIndex;
2454   Variant v_partIndex;
2455   Variant v_lastNode;
2456   Variant v_node;
2457   Variant v_equalsNode;
2458   Variant v_nameNode;
2459   Variant v_valueNode;
2460   Variant v_partNode;
2461   Variant v_names;
2462   Variant v_skippedBraces;
2463   Variant v_enclosingAccum;
2464   Variant v_rootNode;
2465
2466
2467   class VariableTable : public LVariableTable {
2468   public:
2469     Variant &v_text; Variant &v_flags; Variant &v_wgMemc; Variant &v_wgPreprocessorCacheThreshold; Variant &v_cacheable; Variant &v_cacheKey; Variant &v_cacheValue; Variant &v_version; Variant &v_hash; Variant &v_rules; Variant &v_forInclusion; Variant &v_xmlishElements; Variant &v_enableOnlyinclude; Variant &v_ignoredTags; Variant &v_ignoredElements; Variant &v_xmlishRegex; Variant &v_elementsRegex; Variant &v_stack; Variant &v_searchBase; Variant &v_revText; Variant &v_i; Variant &v_accum; Variant &v_findEquals; Variant &v_findPipe; Variant &v_headingIndex; Variant &v_inHeading; Variant &v_noMoreGT; Variant &v_findOnlyinclude; Variant &v_fakeLineStart; Variant &v_startPos; Variant &v_tagEndPos; Variant &v_found; Variant &v_curChar; Variant &v_search; Variant &v_currentClosing; Variant &v_rule; Variant &v_literalLength; Variant &v_matches; Variant &v_endPos; Variant &v_inner; Variant &v_wsStart; Variant &v_wsEnd; Variant &v_wsLength; Variant &v_part; Variant &v_name; Variant &v_lowerName; Variant &v_attrStart; Variant &v_tagStartPos; Variant &v_attrEnd; Variant &v_close; Variant &v_attr; Variant &v_extNode; Variant &v_count; Variant &v_piece; Variant &v_searchStart; Variant &v_equalsLength; Variant &v_element; Variant &v_maxCount; Variant &v_matchingCount; Variant &v_parts; Variant &v_titleAccum; Variant &v_titleNode; Variant &v_argIndex; Variant &v_partIndex; Variant &v_lastNode; Variant &v_node; Variant &v_equalsNode; Variant &v_nameNode; Variant &v_valueNode; Variant &v_partNode; Variant &v_names; Variant &v_skippedBraces; Variant &v_enclosingAccum; Variant &v_rootNode;
2470     VariableTable(Variant &r_text, Variant &r_flags, Variant &r_wgMemc, Variant &r_wgPreprocessorCacheThreshold, Variant &r_cacheable, Variant &r_cacheKey, Variant &r_cacheValue, Variant &r_version, Variant &r_hash, Variant &r_rules, Variant &r_forInclusion, Variant &r_xmlishElements, Variant &r_enableOnlyinclude, Variant &r_ignoredTags, Variant &r_ignoredElements, Variant &r_xmlishRegex, Variant &r_elementsRegex, Variant &r_stack, Variant &r_searchBase, Variant &r_revText, Variant &r_i, Variant &r_accum, Variant &r_findEquals, Variant &r_findPipe, Variant &r_headingIndex, Variant &r_inHeading, Variant &r_noMoreGT, Variant &r_findOnlyinclude, Variant &r_fakeLineStart, Variant &r_startPos, Variant &r_tagEndPos, Variant &r_found, Variant &r_curChar, Variant &r_search, Variant &r_currentClosing, Variant &r_rule, Variant &r_literalLength, Variant &r_matches, Variant &r_endPos, Variant &r_inner, Variant &r_wsStart, Variant &r_wsEnd, Variant &r_wsLength, Variant &r_part, Variant &r_name, Variant &r_lowerName, Variant &r_attrStart, Variant &r_tagStartPos, Variant &r_attrEnd, Variant &r_close, Variant &r_attr, Variant &r_extNode, Variant &r_count, Variant &r_piece, Variant &r_searchStart, Variant &r_equalsLength, Variant &r_element, Variant &r_maxCount, Variant &r_matchingCount, Variant &r_parts, Variant &r_titleAccum, Variant &r_titleNode, Variant &r_argIndex, Variant &r_partIndex, Variant &r_lastNode, Variant &r_node, Variant &r_equalsNode, Variant &r_nameNode, Variant &r_valueNode, Variant &r_partNode, Variant &r_names, Variant &r_skippedBraces, Variant &r_enclosingAccum, Variant &r_rootNode) : v_text(r_text), v_flags(r_flags), v_wgMemc(r_wgMemc), v_wgPreprocessorCacheThreshold(r_wgPreprocessorCacheThreshold), v_cacheable(r_cacheable), v_cacheKey(r_cacheKey), v_cacheValue(r_cacheValue), v_version(r_version), v_hash(r_hash), v_rules(r_rules), v_forInclusion(r_forInclusion), v_xmlishElements(r_xmlishElements), v_enableOnlyinclude(r_enableOnlyinclude), v_ignoredTags(r_ignoredTags), v_ignoredElements(r_ignoredElements), v_xmlishRegex(r_xmlishRegex), v_elementsRegex(r_elementsRegex), v_stack(r_stack), v_searchBase(r_searchBase), v_revText(r_revText), v_i(r_i), v_accum(r_accum), v_findEquals(r_findEquals), v_findPipe(r_findPipe), v_headingIndex(r_headingIndex), v_inHeading(r_inHeading), v_noMoreGT(r_noMoreGT), v_findOnlyinclude(r_findOnlyinclude), v_fakeLineStart(r_fakeLineStart), v_startPos(r_startPos), v_tagEndPos(r_tagEndPos), v_found(r_found), v_curChar(r_curChar), v_search(r_search), v_currentClosing(r_currentClosing), v_rule(r_rule), v_literalLength(r_literalLength), v_matches(r_matches), v_endPos(r_endPos), v_inner(r_inner), v_wsStart(r_wsStart), v_wsEnd(r_wsEnd), v_wsLength(r_wsLength), v_part(r_part), v_name(r_name), v_lowerName(r_lowerName), v_attrStart(r_attrStart), v_tagStartPos(r_tagStartPos), v_attrEnd(r_attrEnd), v_close(r_close), v_attr(r_attr), v_extNode(r_extNode), v_count(r_count), v_piece(r_piece), v_searchStart(r_searchStart), v_equalsLength(r_equalsLength), v_element(r_element), v_maxCount(r_maxCount), v_matchingCount(r_matchingCount), v_parts(r_parts), v_titleAccum(r_titleAccum), v_titleNode(r_titleNode), v_argIndex(r_argIndex), v_partIndex(r_partIndex), v_lastNode(r_lastNode), v_node(r_node), v_equalsNode(r_equalsNode), v_nameNode(r_nameNode), v_valueNode(r_valueNode), v_partNode(r_partNode), v_names(r_names), v_skippedBraces(r_skippedBraces), v_enclosingAccum(r_enclosingAccum), v_rootNode(r_rootNode) {}
2471     virtual Variant &getImpl(CStrRef str, int64 hash) {
2472       const char *s __attribute__((__unused__)) = str.data();
2473       if (hash < 0) hash = hash_string(s);
2474       switch (hash & 255) {
2475         case 1:
2476           HASH_RETURN(0x6B446EEF03FAE201LL, v_lastNode,
2477                       lastNode);
2478           break;
2479         case 12:
2480           HASH_RETURN(0x24DE1F43AE321C0CLL, v_cacheKey,
2481                       cacheKey);
2482           break;
2483         case 13:
2484           HASH_RETURN(0x6AFDA85728FAE70DLL, v_flags,
2485                       flags);
2486           break;
2487         case 17:
2488           HASH_RETURN(0x3C17C0A51918EB11LL, v_cacheValue,
2489                       cacheValue);
2490           break;
2491         case 29:
2492           HASH_RETURN(0x749C3FAB1E74371DLL, v_startPos,
2493                       startPos);
2494           break;
2495         case 36:
2496           HASH_RETURN(0x07D9889BE123B524LL, v_searchBase,
2497                       searchBase);
2498           break;
2499         case 37:
2500           HASH_RETURN(0x78D6949B972CFD25LL, v_rules,
2501                       rules);
2502           break;
2503         case 40:
2504           HASH_RETURN(0x4761A194B0333B28LL, v_accum,
2505                       accum);
2506           break;
2507         case 43:
2508           HASH_RETURN(0x5084E637B870262BLL, v_stack,
2509                       stack);
2510           HASH_RETURN(0x0577FC17B4E8F92BLL, v_titleNode,
2511                       titleNode);
2512           break;
2513         case 45:
2514           HASH_RETURN(0x73F30E0F2D277D2DLL, v_inHeading,
2515                       inHeading);
2516           break;
2517         case 46:
2518           HASH_RETURN(0x7F0BF9704771F92ELL, v_literalLength,
2519                       literalLength);
2520           break;
2521         case 48:
2522           HASH_RETURN(0x6FD137A54D1BE930LL, v_wsStart,
2523                       wsStart);
2524           break;
2525         case 49:
2526           HASH_RETURN(0x3CFB4B7DE74B4931LL, v_nameNode,
2527                       nameNode);
2528           break;
2529         case 50:
2530           HASH_RETURN(0x485CF5F18ACB2632LL, v_endPos,
2531                       endPos);
2532           break;
2533         case 58:
2534           HASH_RETURN(0x706B04F63B7B2C3ALL, v_titleAccum,
2535                       titleAccum);
2536           break;
2537         case 67:
2538           HASH_RETURN(0x2A28A0084DD3A743LL, v_text,
2539                       text);
2540           HASH_RETURN(0x79E99297D9CF6243LL, v_search,
2541                       search);
2542           break;
2543         case 74:
2544           HASH_RETURN(0x120827A34A63694ALL, v_valueNode,
2545                       valueNode);
2546           break;
2547         case 75:
2548           HASH_RETURN(0x4D0B41A665B57E4BLL, v_searchStart,
2549                       searchStart);
2550           break;
2551         case 80:
2552           HASH_RETURN(0x30E66D49BBCCAD50LL, v_wgMemc,
2553                       wgMemc);
2554           break;
2555         case 81:
2556           HASH_RETURN(0x4436B8A58BF97C51LL, v_hash,
2557                       hash);
2558           break;
2559         case 86:
2560           HASH_RETURN(0x2C356137E4207156LL, v_tagStartPos,
2561                       tagStartPos);
2562           break;
2563         case 93:
2564           HASH_RETURN(0x64311A2C8443755DLL, v_attr,
2565                       attr);
2566           break;
2567         case 101:
2568           HASH_RETURN(0x0AE2F3887B84C665LL, v_tagEndPos,
2569                       tagEndPos);
2570           break;
2571         case 104:
2572           HASH_RETURN(0x5D2342E7226E4E68LL, v_skippedBraces,
2573                       skippedBraces);
2574           HASH_RETURN(0x6E17E55C72C97768LL, v_rootNode,
2575                       rootNode);
2576           break;
2577         case 105:
2578           HASH_RETURN(0x754D53FDE12A4569LL, v_equalsNode,
2579                       equalsNode);
2580           break;
2581         case 107:
2582           HASH_RETURN(0x36B43082F052EC6BLL, v_close,
2583                       close);
2584           break;
2585         case 108:
2586           HASH_RETURN(0x0FCC00A0960D4D6CLL, v_xmlishRegex,
2587                       xmlishRegex);
2588           break;
2589         case 117:
2590           HASH_RETURN(0x217F5FC11124CC75LL, v_wsLength,
2591                       wsLength);
2592           break;
2593         case 119:
2594           HASH_RETURN(0x5C804792579E2477LL, v_forInclusion,
2595                       forInclusion);
2596           break;
2597         case 121:
2598           HASH_RETURN(0x75E78845AE202B79LL, v_enclosingAccum,
2599                       enclosingAccum);
2600           break;
2601         case 125:
2602           HASH_RETURN(0x3179991995176C7DLL, v_partIndex,
2603                       partIndex);
2604           break;
2605         case 127:
2606           HASH_RETURN(0x41E37259D0CE717FLL, v_equalsLength,
2607                       equalsLength);
2608           break;
2609         case 128:
2610           HASH_RETURN(0x2FA2EA3BE4385180LL, v_ignoredElements,
2611                       ignoredElements);
2612           break;
2613         case 134:
2614           HASH_RETURN(0x1B3A1B4FC8E2BF86LL, v_findEquals,
2615                       findEquals);
2616           break;
2617         case 137:
2618           HASH_RETURN(0x1AFD3E7207DEC289LL, v_element,
2619                       element);
2620           break;
2621         case 141:
2622           HASH_RETURN(0x2708FDA74562AD8DLL, v_parts,
2623                       parts);
2624           break;
2625         case 144:
2626           HASH_RETURN(0x7A62DFE604197490LL, v_rule,
2627                       rule);
2628           break;
2629         case 152:
2630           HASH_RETURN(0x0EB22EDA95766E98LL, v_i,
2631                       i);
2632           break;
2633         case 155:
2634           HASH_RETURN(0x37961753510B769BLL, v_partNode,
2635                       partNode);
2636           break;
2637         case 157:
2638           HASH_RETURN(0x58F21C5E482FEE9DLL, v_extNode,
2639                       extNode);
2640           break;
2641         case 158:
2642           HASH_RETURN(0x1D7680FEEF32A39ELL, v_attrStart,
2643                       attrStart);
2644           HASH_RETURN(0x3ABE2A7FF197E79ELL, v_maxCount,
2645                       maxCount);
2646           break;
2647         case 162:
2648           HASH_RETURN(0x7985846879851FA2LL, v_revText,
2649                       revText);
2650           HASH_RETURN(0x6F571EAFB109D7A2LL, v_headingIndex,
2651                       headingIndex);
2652           break;
2653         case 169:
2654           HASH_RETURN(0x2DD17595E81D9BA9LL, v_xmlishElements,
2655                       xmlishElements);
2656           break;
2657         case 171:
2658           HASH_RETURN(0x4243E2C0D99B5EABLL, v_wgPreprocessorCacheThreshold,
2659                       wgPreprocessorCacheThreshold);
2660           break;
2661         case 174:
2662           HASH_RETURN(0x75716BF7E20AFAAELL, v_matchingCount,
2663                       matchingCount);
2664           break;
2665         case 175:
2666           HASH_RETURN(0x7451350C607F1BAFLL, v_noMoreGT,
2667                       noMoreGT);
2668           break;
2669         case 180:
2670           HASH_RETURN(0x2AF5F0847CD91DB4LL, v_version,
2671                       version);
2672           break;
2673         case 185:
2674           HASH_RETURN(0x61CFEEED54DD0AB9LL, v_matches,
2675                       matches);
2676           break;
2677         case 187:
2678           HASH_RETURN(0x3D66B5980D54BABBLL, v_count,
2679                       count);
2680           break;
2681         case 190:
2682           HASH_RETURN(0x4B89E9FF5DB696BELL, v_currentClosing,
2683                       currentClosing);
2684           break;
2685         case 193:
2686           HASH_RETURN(0x75AF6DCF22783AC1LL, v_node,
2687                       node);
2688           break;
2689         case 206:
2690           HASH_RETURN(0x41CC31743A0270CELL, v_found,
2691                       found);
2692           HASH_RETURN(0x5AE6844A0CCFE9CELL, v_attrEnd,
2693                       attrEnd);
2694           HASH_RETURN(0x0B812E4C8D98FBCELL, v_argIndex,
2695                       argIndex);
2696           break;
2697         case 209:
2698           HASH_RETURN(0x64DB35AFE8D7B1D1LL, v_cacheable,
2699                       cacheable);
2700           break;
2701         case 217:
2702           HASH_RETURN(0x3FB915AA8F8F8ED9LL, v_fakeLineStart,
2703                       fakeLineStart);
2704           break;
2705         case 219:
2706           HASH_RETURN(0x66866B45F7FF96DBLL, v_wsEnd,
2707                       wsEnd);
2708           HASH_RETURN(0x7132B63767EAFEDBLL, v_piece,
2709                       piece);
2710           break;
2711         case 220:
2712           HASH_RETURN(0x0BCDB293DC3CBDDCLL, v_name,
2713                       name);
2714           break;
2715         case 227:
2716           HASH_RETURN(0x40B8ADAF2E1FB7E3LL, v_elementsRegex,
2717                       elementsRegex);
2718           break;
2719         case 229:
2720           HASH_RETURN(0x7FE16A3727F18DE5LL, v_findOnlyinclude,
2721                       findOnlyinclude);
2722           break;
2723         case 236:
2724           HASH_RETURN(0x5DBFA1F0A183E9ECLL, v_curChar,
2725                       curChar);
2726           HASH_RETURN(0x7F144219D39BF1ECLL, v_part,
2727                       part);
2728           break;
2729         case 237:
2730           HASH_RETURN(0x669278D2AC3068EDLL, v_ignoredTags,
2731                       ignoredTags);
2732           break;
2733         case 242:
2734           HASH_RETURN(0x51A687446C1579F2LL, v_names,
2735                       names);
2736           break;
2737         case 248:
2738           HASH_RETURN(0x77F20E4209A12DF8LL, v_enableOnlyinclude,
2739                       enableOnlyinclude);
2740           break;
2741         case 249:
2742           HASH_RETURN(0x5AE3699687C882F9LL, v_findPipe,
2743                       findPipe);
2744           break;
2745         case 252:
2746           HASH_RETURN(0x35537723FE7928FCLL, v_lowerName,
2747                       lowerName);
2748           break;
2749         case 254:
2750           HASH_RETURN(0x4F20D07BB803C1FELL, v_inner,
2751                       inner);
2752           break;
2753         default:
2754           break;
2755       }
2756       return lvalAt(str, hash);
2757     }
2758     virtual bool exists(const char *s, int64 hash /* = -1 */) const {
2759       if (hash < 0) hash = hash_string(s);
2760       switch (hash & 255) {
2761         case 1:
2762           HASH_INITIALIZED(0x6B446EEF03FAE201LL, v_lastNode,
2763                            lastNode);
2764           break;
2765         case 12:
2766           HASH_INITIALIZED(0x24DE1F43AE321C0CLL, v_cacheKey,
2767                            cacheKey);
2768           break;
2769         case 13:
2770           HASH_INITIALIZED(0x6AFDA85728FAE70DLL, v_flags,
2771                            flags);
2772           break;
2773         case 17:
2774           HASH_INITIALIZED(0x3C17C0A51918EB11LL, v_cacheValue,
2775                            cacheValue);
2776           break;
2777         case 29:
2778           HASH_INITIALIZED(0x749C3FAB1E74371DLL, v_startPos,
2779                            startPos);
2780           break;
2781         case 36:
2782           HASH_INITIALIZED(0x07D9889BE123B524LL, v_searchBase,
2783                            searchBase);
2784           break;
2785         case 37:
2786           HASH_INITIALIZED(0x78D6949B972CFD25LL, v_rules,
2787                            rules);
2788           break;
2789         case 40:
2790           HASH_INITIALIZED(0x4761A194B0333B28LL, v_accum,
2791                            accum);
2792           break;
2793         case 43:
2794           HASH_INITIALIZED(0x5084E637B870262BLL, v_stack,
2795                            stack);
2796           HASH_INITIALIZED(0x0577FC17B4E8F92BLL, v_titleNode,
2797                            titleNode);
2798           break;
2799         case 45:
2800           HASH_INITIALIZED(0x73F30E0F2D277D2DLL, v_inHeading,
2801                            inHeading);
2802           break;
2803         case 46:
2804           HASH_INITIALIZED(0x7F0BF9704771F92ELL, v_literalLength,
2805                            literalLength);
2806           break;
2807         case 48:
2808           HASH_INITIALIZED(0x6FD137A54D1BE930LL, v_wsStart,
2809                            wsStart);
2810           break;
2811         case 49:
2812           HASH_INITIALIZED(0x3CFB4B7DE74B4931LL, v_nameNode,
2813                            nameNode);
2814           break;
2815         case 50:
2816           HASH_INITIALIZED(0x485CF5F18ACB2632LL, v_endPos,
2817                            endPos);
2818           break;
2819         case 58:
2820           HASH_INITIALIZED(0x706B04F63B7B2C3ALL, v_titleAccum,
2821                            titleAccum);
2822           break;
2823         case 67:
2824           HASH_INITIALIZED(0x2A28A0084DD3A743LL, v_text,
2825                            text);
2826           HASH_INITIALIZED(0x79E99297D9CF6243LL, v_search,
2827                            search);
2828           break;
2829         case 74:
2830           HASH_INITIALIZED(0x120827A34A63694ALL, v_valueNode,
2831                            valueNode);
2832           break;
2833         case 75:
2834           HASH_INITIALIZED(0x4D0B41A665B57E4BLL, v_searchStart,
2835                            searchStart);
2836           break;
2837         case 80:
2838           HASH_INITIALIZED(0x30E66D49BBCCAD50LL, v_wgMemc,
2839                            wgMemc);
2840           break;
2841         case 81:
2842           HASH_INITIALIZED(0x4436B8A58BF97C51LL, v_hash,
2843                            hash);
2844           break;
2845         case 86:
2846           HASH_INITIALIZED(0x2C356137E4207156LL, v_tagStartPos,
2847                            tagStartPos);
2848           break;
2849         case 93:
2850           HASH_INITIALIZED(0x64311A2C8443755DLL, v_attr,
2851                            attr);
2852           break;
2853         case 101:
2854           HASH_INITIALIZED(0x0AE2F3887B84C665LL, v_tagEndPos,
2855                            tagEndPos);
2856           break;
2857         case 104:
2858           HASH_INITIALIZED(0x5D2342E7226E4E68LL, v_skippedBraces,
2859                            skippedBraces);
2860           HASH_INITIALIZED(0x6E17E55C72C97768LL, v_rootNode,
2861                            rootNode);
2862           break;
2863         case 105:
2864           HASH_INITIALIZED(0x754D53FDE12A4569LL, v_equalsNode,
2865                            equalsNode);
2866           break;
2867         case 107:
2868           HASH_INITIALIZED(0x36B43082F052EC6BLL, v_close,
2869                            close);
2870           break;
2871         case 108:
2872           HASH_INITIALIZED(0x0FCC00A0960D4D6CLL, v_xmlishRegex,
2873                            xmlishRegex);
2874           break;
2875         case 117:
2876           HASH_INITIALIZED(0x217F5FC11124CC75LL, v_wsLength,
2877                            wsLength);
2878           break;
2879         case 119:
2880           HASH_INITIALIZED(0x5C804792579E2477LL, v_forInclusion,
2881                            forInclusion);
2882           break;
2883         case 121:
2884           HASH_INITIALIZED(0x75E78845AE202B79LL, v_enclosingAccum,
2885                            enclosingAccum);
2886           break;
2887         case 125:
2888           HASH_INITIALIZED(0x3179991995176C7DLL, v_partIndex,
2889                            partIndex);
2890           break;
2891         case 127:
2892           HASH_INITIALIZED(0x41E37259D0CE717FLL, v_equalsLength,
2893                            equalsLength);
2894           break;
2895         case 128:
2896           HASH_INITIALIZED(0x2FA2EA3BE4385180LL, v_ignoredElements,
2897                            ignoredElements);
2898           break;
2899         case 134:
2900           HASH_INITIALIZED(0x1B3A1B4FC8E2BF86LL, v_findEquals,
2901                            findEquals);
2902           break;
2903         case 137:
2904           HASH_INITIALIZED(0x1AFD3E7207DEC289LL, v_element,
2905                            element);
2906           break;
2907         case 141:
2908           HASH_INITIALIZED(0x2708FDA74562AD8DLL, v_parts,
2909                            parts);
2910           break;
2911         case 144:
2912           HASH_INITIALIZED(0x7A62DFE604197490LL, v_rule,
2913                            rule);
2914           break;
2915         case 152:
2916           HASH_INITIALIZED(0x0EB22EDA95766E98LL, v_i,
2917                            i);
2918           break;
2919         case 155:
2920           HASH_INITIALIZED(0x37961753510B769BLL, v_partNode,
2921                            partNode);
2922           break;
2923         case 157:
2924           HASH_INITIALIZED(0x58F21C5E482FEE9DLL, v_extNode,
2925                            extNode);
2926           break;
2927         case 158:
2928           HASH_INITIALIZED(0x1D7680FEEF32A39ELL, v_attrStart,
2929                            attrStart);
2930           HASH_INITIALIZED(0x3ABE2A7FF197E79ELL, v_maxCount,
2931                            maxCount);
2932           break;
2933         case 162:
2934           HASH_INITIALIZED(0x7985846879851FA2LL, v_revText,
2935                            revText);
2936           HASH_INITIALIZED(0x6F571EAFB109D7A2LL, v_headingIndex,
2937                            headingIndex);
2938           break;
2939         case 169:
2940           HASH_INITIALIZED(0x2DD17595E81D9BA9LL, v_xmlishElements,
2941                            xmlishElements);
2942           break;
2943         case 171:
2944           HASH_INITIALIZED(0x4243E2C0D99B5EABLL, v_wgPreprocessorCacheThreshold,
2945                            wgPreprocessorCacheThreshold);
2946           break;
2947         case 174:
2948           HASH_INITIALIZED(0x75716BF7E20AFAAELL, v_matchingCount,
2949                            matchingCount);
2950           break;
2951         case 175:
2952           HASH_INITIALIZED(0x7451350C607F1BAFLL, v_noMoreGT,
2953                            noMoreGT);
2954           break;
2955         case 180:
2956           HASH_INITIALIZED(0x2AF5F0847CD91DB4LL, v_version,
2957                            version);
2958           break;
2959         case 185:
2960           HASH_INITIALIZED(0x61CFEEED54DD0AB9LL, v_matches,
2961                            matches);
2962           break;
2963         case 187:
2964           HASH_INITIALIZED(0x3D66B5980D54BABBLL, v_count,
2965                            count);
2966           break;
2967         case 190:
2968           HASH_INITIALIZED(0x4B89E9FF5DB696BELL, v_currentClosing,
2969                            currentClosing);
2970           break;
2971         case 193:
2972           HASH_INITIALIZED(0x75AF6DCF22783AC1LL, v_node,
2973                            node);
2974           break;
2975         case 206:
2976           HASH_INITIALIZED(0x41CC31743A0270CELL, v_found,
2977                            found);
2978           HASH_INITIALIZED(0x5AE6844A0CCFE9CELL, v_attrEnd,
2979                            attrEnd);
2980           HASH_INITIALIZED(0x0B812E4C8D98FBCELL, v_argIndex,
2981                            argIndex);
2982           break;
2983         case 209:
2984           HASH_INITIALIZED(0x64DB35AFE8D7B1D1LL, v_cacheable,
2985                            cacheable);
2986           break;
2987         case 217:
2988           HASH_INITIALIZED(0x3FB915AA8F8F8ED9LL, v_fakeLineStart,
2989                            fakeLineStart);
2990           break;
2991         case 219:
2992           HASH_INITIALIZED(0x66866B45F7FF96DBLL, v_wsEnd,
2993                            wsEnd);
2994           HASH_INITIALIZED(0x7132B63767EAFEDBLL, v_piece,
2995                            piece);
2996           break;
2997         case 220:
2998           HASH_INITIALIZED(0x0BCDB293DC3CBDDCLL, v_name,
2999                            name);
3000           break;
3001         case 227:
3002           HASH_INITIALIZED(0x40B8ADAF2E1FB7E3LL, v_elementsRegex,
3003                            elementsRegex);
3004           break;
3005         case 229:
3006           HASH_INITIALIZED(0x7FE16A3727F18DE5LL, v_findOnlyinclude,
3007                            findOnlyinclude);
3008           break;
3009         case 236:
3010           HASH_INITIALIZED(0x5DBFA1F0A183E9ECLL, v_curChar,
3011                            curChar);
3012           HASH_INITIALIZED(0x7F144219D39BF1ECLL, v_part,
3013                            part);
3014           break;
3015         case 237:
3016           HASH_INITIALIZED(0x669278D2AC3068EDLL, v_ignoredTags,
3017                            ignoredTags);
3018           break;
3019         case 242:
3020           HASH_INITIALIZED(0x51A687446C1579F2LL, v_names,
3021                            names);
3022           break;
3023         case 248:
3024           HASH_INITIALIZED(0x77F20E4209A12DF8LL, v_enableOnlyinclude,
3025                            enableOnlyinclude);
3026           break;
3027         case 249:
3028           HASH_INITIALIZED(0x5AE3699687C882F9LL, v_findPipe,
3029                            findPipe);
3030           break;
3031         case 252:
3032           HASH_INITIALIZED(0x35537723FE7928FCLL, v_lowerName,
3033                            lowerName);
3034           break;
3035         case 254:
3036           HASH_INITIALIZED(0x4F20D07BB803C1FELL, v_inner,
3037                            inner);
3038           break;
3039         default:
3040           break;
3041       }
3042       return LVariableTable::exists(s, hash);
3043     }
3044   } variableTable(v_text, v_flags, v_wgMemc, v_wgPreprocessorCacheThreshold, v_cacheable, v_cacheKey, v_cacheValue, v_version, v_hash, v_rules, v_forInclusion, v_xmlishElements, v_enableOnlyinclude, v_ignoredTags, v_ignoredElements, v_xmlishRegex, v_elementsRegex, v_stack, v_searchBase, v_revText, v_i, v_accum, v_findEquals, v_findPipe, v_headingIndex, v_inHeading, v_noMoreGT, v_findOnlyinclude, v_fakeLineStart, v_startPos, v_tagEndPos, v_found, v_curChar, v_search, v_currentClosing, v_rule, v_literalLength, v_matches, v_endPos, v_inner, v_wsStart, v_wsEnd, v_wsLength, v_part, v_name, v_lowerName, v_attrStart, v_tagStartPos, v_attrEnd, v_close, v_attr, v_extNode, v_count, v_piece, v_searchStart, v_equalsLength, v_element, v_maxCount, v_matchingCount, v_parts, v_titleAccum, v_titleNode, v_argIndex, v_partIndex, v_lastNode, v_node, v_equalsNode, v_nameNode, v_valueNode, v_partNode, v_names, v_skippedBraces, v_enclosingAccum, v_rootNode);
3045   LVariableTable* __attribute__((__unused__)) variables = &variableTable;
3046   LINE(49,invoke_failed("wfprofilein", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj").create()), 0x0000000075359BAFLL));
3047   {
3048     v_wgMemc = ref(g->GV(wgMemc));
3049     v_wgPreprocessorCacheThreshold = ref(g->GV(wgPreprocessorCacheThreshold));
3050   }
3051   (v_cacheable = more(LINE(55,x_strlen(toString(v_text))), v_wgPreprocessorCacheThreshold));
3052   if (toBoolean(v_cacheable)) {
3053     LINE(57,invoke_failed("wfprofilein", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj-cacheable").create()), 0x0000000075359BAFLL));
3054     (v_cacheKey = LINE(59,(assignCallTemp(eo_1, ref(x_md5(toString(v_text)))),assignCallTemp(eo_2, ref(v_flags)),invoke_failed("wfmemckey", Array(ArrayInit(3).set(0, "preprocess-hash").set(1, eo_1).set(2, eo_2).create()), 0x0000000072AF623FLL))));
3055     (v_cacheValue = LINE(60,v_wgMemc.o_invoke_few_args("get", 0x25DCCC35D69AD828LL, 1, v_cacheKey)));
3056     if (toBoolean(v_cacheValue)) {
3057       (v_version = LINE(62,x_substr(toString(v_cacheValue), toInt32(0LL), toInt32(8LL))));
3058       if (equal(LINE(63,x_intval(v_version)), 1LL /* preprocessor_hash::CACHE_VERSION */)) {
3059         (v_hash = LINE(64,x_unserialize(toString(x_substr(toString(v_cacheValue), toInt32(8LL))))));
3060         LINE(67,(assignCallTemp(eo_1, concat3("Loaded preprocessor hash from memcached (key ", toString(v_cacheKey), ")")),invoke_failed("wfdebuglog", Array(ArrayInit(2).set(0, "Preprocessor").set(1, eo_1).create()), 0x00000000E6942489LL)));
3061         LINE(68,invoke_failed("wfprofileout", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj-cacheable").create()), 0x00000000B599F276LL));
3062         LINE(69,invoke_failed("wfprofileout", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj").create()), 0x00000000B599F276LL));
3063         return v_hash;
3064       }
3065     }
3066     LINE(73,invoke_failed("wfprofilein", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj-cache-miss").create()), 0x0000000075359BAFLL));
3067   }
3068   (v_rules = ScalarArrays::sa_[3]);
3069   (v_forInclusion = bitwise_and(v_flags, 1LL /* parser::PTD_FOR_INCLUSION */));
3070   (v_xmlishElements = LINE(96,m_parser.o_invoke_few_args("getStripList", 0x151B6C9D84BBC1F5LL, 0)));
3071   (v_enableOnlyinclude = false);
3072   if (toBoolean(v_forInclusion)) {
3073     (v_ignoredTags = ScalarArrays::sa_[4]);
3074     (v_ignoredElements = ScalarArrays::sa_[5]);
3075     v_xmlishElements.append(("noinclude"));
3076     if (!same(LINE(102,x_strpos(toString(v_text), "<onlyinclude>")), false) && !same(x_strpos(toString(v_text), "</onlyinclude>"), false)) {
3077       (v_enableOnlyinclude = true);
3078     }
3079   }
3080   else {
3081     (v_ignoredTags = ScalarArrays::sa_[6]);
3082     (v_ignoredElements = ScalarArrays::sa_[7]);
3083     v_xmlishElements.append(("includeonly"));
3084   }
3085   (v_xmlishRegex = LINE(110,(assignCallTemp(eo_1, x_array_merge(2, v_xmlishElements, Array(ArrayInit(1).set(0, v_ignoredTags).create()))),x_implode("|", eo_1))));
3086   (v_elementsRegex = LINE(113,concat3("~(", toString(v_xmlishRegex), ")(\?:\\s|\\/>|>)|(!--)~iA")));
3087   (v_stack = ((Object)(LINE(115,p_ppdstack_hash(p_ppdstack_hash(NEWOBJ(c_ppdstack_hash)())->create())))));
3088   (v_searchBase = "[{<\n");
3089   (v_revText = LINE(118,x_strrev(toString(v_text))));
3090   (v_i = 0LL);
3091   (v_accum = ref(LINE(121,v_stack.o_invoke_few_args("getAccum", 0x1A5F5A2CB292E516LL, 0))));
3092   (v_findEquals = false);
3093   (v_findPipe = false);
3094   (v_headingIndex = 1LL);
3095   (v_inHeading = false);
3096   (v_noMoreGT = false);
3097   (v_findOnlyinclude = v_enableOnlyinclude);
3098   (v_fakeLineStart = true);
3099   LOOP_COUNTER(38);
3100   {
3101     while (true) {
3102       LOOP_COUNTER_CHECK(38);
3103       {
3104         if (toBoolean(v_findOnlyinclude)) {
3105           (v_startPos = LINE(135,x_strpos(toString(v_text), "<onlyinclude>", toInt32(v_i))));
3106           if (same(v_startPos, false)) {
3107             (assignCallTemp(eo_1, ref(LINE(138,x_substr(toString(v_text), toInt32(v_i))))),v_accum.o_invoke("addNodeWithText", Array(ArrayInit(2).set(0, "ignore").set(1, eo_1).create()), 0x6992F0F690B37356LL));
3108             break;
3109           }
3110           (v_tagEndPos = v_startPos + LINE(141,x_strlen("<onlyinclude>")));
3111           (assignCallTemp(eo_1, ref(LINE(142,x_substr(toString(v_text), toInt32(v_i), toInt32(v_tagEndPos - v_i))))),v_accum.o_invoke("addNodeWithText", Array(ArrayInit(2).set(0, "ignore").set(1, eo_1).create()), 0x6992F0F690B37356LL));
3112           (v_i = v_tagEndPos);
3113           (v_findOnlyinclude = false);
3114         }
3115         if (toBoolean(v_fakeLineStart)) {
3116           (v_found = "line-start");
3117           (v_curChar = "");
3118         }
3119         else {
3120           (v_search = v_searchBase);
3121           if (same(v_stack.o_get("top", 0x1854FD73A00D89E8LL), false)) {
3122             (v_currentClosing = "");
3123           }
3124           else {
3125             (v_currentClosing = v_stack.o_get("top", 0x1854FD73A00D89E8LL).o_get("close", 0x36B43082F052EC6BLL));
3126             concat_assign(v_search, toString(v_currentClosing));
3127           }
3128           if (toBoolean(v_findPipe)) {
3129             concat_assign(v_search, "|");
3130           }
3131           if (toBoolean(v_findEquals)) {
3132             concat_assign(v_search, "=");
3133           }
3134           setNull(v_rule);
3135           (v_literalLength = LINE(168,x_strcspn(toString(v_text), toString(v_search), toInt32(v_i))));
3136           if (more(v_literalLength, 0LL)) {
3137             LINE(170,v_accum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, x_substr(toString(v_text), toInt32(v_i), toInt32(v_literalLength))));
3138             v_i += v_literalLength;
3139           }
3140           if (not_less(v_i, LINE(173,x_strlen(toString(v_text))))) {
3141             if (equal(v_currentClosing, "\n")) {
3142               (v_curChar = "");
3143               (v_found = "line-end");
3144             }
3145             else {
3146               break;
3147             }
3148           }
3149           else {
3150             (v_curChar = v_text.rvalAt(v_i));
3151             if (equal(v_curChar, "|")) {
3152               (v_found = "pipe");
3153             }
3154             else if (equal(v_curChar, "=")) {
3155               (v_found = "equals");
3156             }
3157             else if (equal(v_curChar, "<")) {
3158               (v_found = "angle");
3159             }
3160             else if (equal(v_curChar, "\n")) {
3161               if (toBoolean(v_inHeading)) {
3162                 (v_found = "line-end");
3163               }
3164               else {
3165                 (v_found = "line-start");
3166               }
3167             }
3168             else if (equal(v_curChar, v_currentClosing)) {
3169               (v_found = "close");
3170             }
3171             else if (isset(v_rules, v_curChar)) {
3172               (v_found = "open");
3173               (v_rule = v_rules.rvalAt(v_curChar));
3174             }
3175             else {
3176               ++v_i;
3177               continue;
3178             }
3179           }
3180         }
3181         if (equal(v_found, "angle")) {
3182           (v_matches = false);
3183           if (toBoolean(v_enableOnlyinclude) && equal(LINE(213,(assignCallTemp(eo_0, toString(v_text)),assignCallTemp(eo_1, toInt32(v_i)),assignCallTemp(eo_2, x_strlen("</onlyinclude>")),x_substr(eo_0, eo_1, eo_2))), "</onlyinclude>")) {
3184             (v_findOnlyinclude = true);
3185             continue;
3186           }
3187           if (!(toBoolean(LINE(219,x_preg_match(toString(v_elementsRegex), toString(v_text), ref(v_matches), toInt32(0LL), toInt32(v_i + 1LL)))))) {
3188             LINE(221,v_accum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, "<"));
3189             ++v_i;
3190             continue;
3191           }
3192           if (isset(v_matches, 2LL, 0x486AFCC090D5F98CLL) && equal(v_matches.rvalAt(2LL, 0x486AFCC090D5F98CLL), "!--")) {
3193             (v_endPos = LINE(232,x_strpos(toString(v_text), "-->", toInt32(v_i + 4LL))));
3194             if (same(v_endPos, false)) {
3195               (v_inner = LINE(235,x_substr(toString(v_text), toInt32(v_i))));
3196               LINE(236,v_accum.o_invoke_few_args("addNodeWithText", 0x6992F0F690B37356LL, 2, "comment", v_inner));
3197               (v_i = LINE(237,x_strlen(toString(v_text))));
3198             }
3199             else {
3200               (v_wsStart = toBoolean(v_i) ? ((Variant)((v_i - LINE(240,(assignCallTemp(eo_0, toString(v_revText)),assignCallTemp(eo_2, toInt32(x_strlen(toString(v_text)) - v_i)),x_strspn(eo_0, " ", eo_2)))))) : ((Variant)(0LL)));
3201               (v_wsEnd = v_endPos + 2LL + LINE(243,x_strspn(toString(v_text), " ", toInt32(v_endPos + 3LL))));
3202               if (more(v_wsStart, 0LL) && equal(LINE(248,x_substr(toString(v_text), toInt32(v_wsStart - 1LL), toInt32(1LL))), "\n") && equal(LINE(249,x_substr(toString(v_text), toInt32(v_wsEnd + 1LL), toInt32(1LL))), "\n")) {
3203                 (v_startPos = v_wsStart);
3204                 (v_endPos = v_wsEnd + 1LL);
3205                 (v_wsLength = v_i - v_wsStart);
3206                 if (more(v_wsLength, 0LL) && instanceOf(v_accum.o_get("lastNode", 0x6B446EEF03FAE201LL), "PPNode_Hash_Text") && same_rev(LINE(258,x_str_repeat(" ", toInt32(v_wsLength))), x_substr(toString(v_accum.o_get("lastNode", 0x6B446EEF03FAE201LL).o_get("value", 0x69E7413AE0C88471LL)), toInt32(negate(v_wsLength))))) {
3207                   (lval(v_accum.o_lval("lastNode", 0x6B446EEF03FAE201LL)).o_lval("value", 0x69E7413AE0C88471LL) = LINE(260,x_substr(toString(v_accum.o_get("lastNode", 0x6B446EEF03FAE201LL).o_get("value", 0x69E7413AE0C88471LL)), toInt32(0LL), toInt32(negate(v_wsLength)))));
3208                 }
3209                 (v_fakeLineStart = true);
3210               }
3211               else {
3212                 (v_startPos = v_i);
3213                 v_endPos += 2LL;
3214               }
3215               if (toBoolean(v_stack.o_get("top", 0x1854FD73A00D89E8LL))) {
3216                 (v_part = LINE(271,v_stack.o_get("top", 0x1854FD73A00D89E8LL).o_invoke_few_args("getCurrentPart", 0x1726802D706D7BECLL, 0)));
3217                 if (toObject(v_part)->t___isset("commentEnd") && equal(v_part.o_get("commentEnd", 0x5537E70C21E6C099LL), v_wsStart - 1LL)) {
3218                   (v_part.o_lval("commentEnd", 0x5537E70C21E6C099LL) = v_wsEnd);
3219                 }
3220                 else {
3221                   (v_part.o_lval("visualEnd", 0x101972FF17696EF2LL) = v_wsStart);
3222                   (v_part.o_lval("commentEnd", 0x5537E70C21E6C099LL) = v_endPos);
3223                 }
3224               }
3225               (v_i = v_endPos + 1LL);
3226               (v_inner = LINE(281,x_substr(toString(v_text), toInt32(v_startPos), toInt32(v_endPos - v_startPos + 1LL))));
3227               LINE(282,v_accum.o_invoke_few_args("addNodeWithText", 0x6992F0F690B37356LL, 2, "comment", v_inner));
3228             }
3229             continue;
3230           }
3231           (v_name = v_matches.rvalAt(1LL, 0x5BCA7C69B794F8CELL));
3232           (v_lowerName = LINE(287,x_strtolower(toString(v_name))));
3233           (v_attrStart = v_i + LINE(288,x_strlen(toString(v_name))) + 1LL);
3234           (v_tagEndPos = toBoolean(v_noMoreGT) ? ((Variant)(false)) : ((Variant)(LINE(291,x_strpos(toString(v_text), ">", toInt32(v_attrStart))))));
3235           if (same(v_tagEndPos, false)) {
3236             (v_noMoreGT = true);
3237             LINE(296,v_accum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, "<"));
3238             ++v_i;
3239             continue;
3240           }
3241           if (LINE(302,x_in_array(v_lowerName, v_ignoredTags))) {
3242             (assignCallTemp(eo_1, ref(LINE(303,x_substr(toString(v_text), toInt32(v_i), toInt32(v_tagEndPos - v_i + 1LL))))),v_accum.o_invoke("addNodeWithText", Array(ArrayInit(2).set(0, "ignore").set(1, eo_1).create()), 0x6992F0F690B37356LL));
3243             (v_i = v_tagEndPos + 1LL);
3244             continue;
3245           }
3246           (v_tagStartPos = v_i);
3247           if (equal(v_text.rvalAt(v_tagEndPos - 1LL), "/")) {
3248             (v_attrEnd = v_tagEndPos - 1LL);
3249             setNull(v_inner);
3250             (v_i = v_tagEndPos + 1LL);
3251             setNull(v_close);
3252           }
3253           else {
3254             (v_attrEnd = v_tagEndPos);
3255             if (toBoolean(LINE(319,(assignCallTemp(eo_0, LINE(318,(assignCallTemp(eo_6, x_preg_quote(toString(v_name), "/")),concat3("/<\\/", eo_6, "\\s*>/i")))),assignCallTemp(eo_1, toString(v_text)),assignCallTemp(eo_2, ref(v_matches)),assignCallTemp(eo_4, toInt32(v_tagEndPos + 1LL)),x_preg_match(eo_0, eo_1, eo_2, toInt32(256LL) /* PREG_OFFSET_CAPTURE */, eo_4))))) {
3256               (v_inner = LINE(321,x_substr(toString(v_text), toInt32(v_tagEndPos + 1LL), toInt32(v_matches.rvalAt(0LL, 0x77CFA1EEF01BCA90LL).rvalAt(1LL, 0x5BCA7C69B794F8CELL) - v_tagEndPos - 1LL))));
3257               (v_i = v_matches.rvalAt(0LL, 0x77CFA1EEF01BCA90LL).rvalAt(1LL, 0x5BCA7C69B794F8CELL) + LINE(322,x_strlen(toString(v_matches.rvalAt(0LL, 0x77CFA1EEF01BCA90LL).rvalAt(0LL, 0x77CFA1EEF01BCA90LL)))));
3258               (v_close = v_matches.rvalAt(0LL, 0x77CFA1EEF01BCA90LL).rvalAt(0LL, 0x77CFA1EEF01BCA90LL));
3259             }
3260             else {
3261               (v_inner = LINE(326,x_substr(toString(v_text), toInt32(v_tagEndPos + 1LL))));
3262               (v_i = LINE(327,x_strlen(toString(v_text))));
3263               setNull(v_close);
3264             }
3265           }
3266           if (LINE(332,x_in_array(v_lowerName, v_ignoredElements))) {
3267             (assignCallTemp(eo_1, ref(LINE(333,x_substr(toString(v_text), toInt32(v_tagStartPos), toInt32(v_i - v_tagStartPos))))),v_accum.o_invoke("addNodeWithText", Array(ArrayInit(2).set(0, "ignore").set(1, eo_1).create()), 0x6992F0F690B37356LL));
3268             continue;
3269           }
3270           if (not_more(v_attrEnd, v_attrStart)) {
3271             (v_attr = "");
3272           }
3273           else {
3274             (v_attr = LINE(342,x_substr(toString(v_text), toInt32(v_attrStart), toInt32(v_attrEnd - v_attrStart))));
3275           }
3276           (v_extNode = ((Object)(LINE(345,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("ext"))))));
3277           LINE(346,v_extNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, c_ppnode_hash_tree::t_newwithtext("name", v_name)));
3278           LINE(347,v_extNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, c_ppnode_hash_tree::t_newwithtext("attr", v_attr)));
3279           if (!same(v_inner, null)) {
3280             LINE(349,v_extNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, c_ppnode_hash_tree::t_newwithtext("inner", v_inner)));
3281           }
3282           if (!same(v_close, null)) {
3283             LINE(352,v_extNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, c_ppnode_hash_tree::t_newwithtext("close", v_close)));
3284           }
3285           LINE(354,v_accum.o_invoke_few_args("addNode", 0x0D8DDF05964C6A31LL, 1, v_extNode));
3286         }
3287         else if (equal(v_found, "line-start")) {
3288           if (toBoolean(v_fakeLineStart)) {
3289             (v_fakeLineStart = false);
3290           }
3291           else {
3292             LINE(363,v_accum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, v_curChar));
3293             v_i++;
3294           }
3295           (v_count = LINE(367,x_strspn(toString(v_text), "=", toInt32(v_i), toInt32(6LL))));
3296           if (equal(v_count, 1LL) && toBoolean(v_findEquals)) {
3297           }
3298           else if (more(v_count, 0LL)) {
3299             (v_piece = Array(ArrayInit(5).set(0, "open", "\n", 0x6A760D2EC60228C6LL).set(1, "close", "\n", 0x36B43082F052EC6BLL).set(2, "parts", Array(ArrayInit(1).set(0, ((Object)(LINE(376,p_ppdpart_hash(p_ppdpart_hash(NEWOBJ(c_ppdpart_hash)())->create(x_str_repeat("=", toInt32(v_count)))))))).create()), 0x2708FDA74562AD8DLL).set(3, "startPos", v_i, 0x749C3FAB1E74371DLL).set(4, "count", v_count, 0x3D66B5980D54BABBLL).create()));
3300             LINE(379,v_stack.o_invoke_few_args("push", 0x321E2BF5D878AA38LL, 1, v_piece));
3301             (v_accum = ref(LINE(380,v_stack.o_invoke_few_args("getAccum", 0x1A5F5A2CB292E516LL, 0))));
3302             LINE(381,extract(variables, toArray(v_stack.o_invoke_few_args("getFlags", 0x27E7DBA875AD17E1LL, 0))));
3303             v_i += v_count;
3304           }
3305         }
3306         else if (equal(v_found, "line-end")) {
3307           (v_piece = v_stack.o_get("top", 0x1854FD73A00D89E8LL));
3308           LINE(389,x_assert(equal(v_piece.o_get("open", 0x6A760D2EC60228C6LL), "\n")));
3309           (v_part = LINE(390,v_piece.o_invoke_few_args("getCurrentPart", 0x1726802D706D7BECLL, 0)));
3310           (v_wsLength = LINE(393,(assignCallTemp(eo_0, toString(v_revText)),assignCallTemp(eo_2, toInt32(x_strlen(toString(v_text)) - v_i)),x_strspn(eo_0, " \t", eo_2))));
3311           (v_searchStart = v_i - v_wsLength);
3312           if (toObject(v_part)->t___isset("commentEnd") && equal(v_searchStart - 1LL, v_part.o_get("commentEnd", 0x5537E70C21E6C099LL))) {
3313             (v_searchStart = v_part.o_get("visualEnd", 0x101972FF17696EF2LL));
3314             v_searchStart -= LINE(399,(assignCallTemp(eo_0, toString(v_revText)),assignCallTemp(eo_2, toInt32(x_strlen(toString(v_text)) - v_searchStart)),x_strspn(eo_0, " \t", eo_2)));
3315           }
3316           (v_count = v_piece.o_get("count", 0x3D66B5980D54BABBLL));
3317           (v_equalsLength = LINE(402,(assignCallTemp(eo_0, toString(v_revText)),assignCallTemp(eo_2, toInt32(x_strlen(toString(v_text)) - v_searchStart)),x_strspn(eo_0, "=", eo_2))));
3318           if (more(v_equalsLength, 0LL)) {
3319             if (equal(v_i - v_equalsLength, v_piece.o_get("startPos", 0x749C3FAB1E74371DLL))) {
3320               (v_count = v_equalsLength);
3321               if (less(v_count, 3LL)) {
3322                 (v_count = 0LL);
3323               }
3324               else {
3325                 (v_count = LINE(412,(assignCallTemp(eo_1, x_intval(divide((v_count - 1LL), 2LL))),x_min(2, 6LL, Array(ArrayInit(1).set(0, eo_1).create())))));
3326               }
3327             }
3328             else {
3329               (v_count = LINE(415,x_min(2, v_equalsLength, Array(ArrayInit(1).set(0, v_count).create()))));
3330             }
3331             if (more(v_count, 0LL)) {
3332               (v_element = ((Object)(LINE(419,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("possible-h"))))));
3333               LINE(420,v_element.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, p_ppnode_hash_attr(p_ppnode_hash_attr(NEWOBJ(c_ppnode_hash_attr)())->create("level", v_count))));
3334               LINE(421,v_element.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, (assignCallTemp(eo_1, v_headingIndex++),p_ppnode_hash_attr(p_ppnode_hash_attr(NEWOBJ(c_ppnode_hash_attr)())->create("i", eo_1)))));
3335               (lval(v_element.o_lval("lastChild", 0x29DD4C280399C7FALL)).o_lval("nextSibling", 0x0B3EC7643EE81822LL) = v_accum.o_get("firstNode", 0x4296B55256FA0986LL));
3336               (v_element.o_lval("lastChild", 0x29DD4C280399C7FALL) = v_accum.o_get("lastNode", 0x6B446EEF03FAE201LL));
3337             }
3338             else {
3339               (v_element = v_accum);
3340             }
3341           }
3342           else {
3343             (v_element = v_accum);
3344           }
3345           LINE(433,v_stack.o_invoke_few_args("pop", 0x773C5A963CD2AC13LL, 0));
3346           (v_accum = ref(LINE(434,v_stack.o_invoke_few_args("getAccum", 0x1A5F5A2CB292E516LL, 0))));
3347           LINE(435,extract(variables, toArray(v_stack.o_invoke_few_args("getFlags", 0x27E7DBA875AD17E1LL, 0))));
3348           if (instanceOf(v_element, "PPNode")) {
3349             LINE(439,v_accum.o_invoke_few_args("addNode", 0x0D8DDF05964C6A31LL, 1, v_element));
3350           }
3351           else {
3352             LINE(441,v_accum.o_invoke_few_args("addAccum", 0x6A8DCEFA6345DAC9LL, 1, v_element));
3353           }
3354         }
3355         else if (equal(v_found, "open")) {
3356           (v_count = LINE(452,x_strspn(toString(v_text), toString(v_curChar), toInt32(v_i))));
3357           if (not_less(v_count, v_rule.rvalAt("min", 0x66FFC7365E2D00CALL))) {
3358             (v_piece = Array(ArrayInit(4).set(0, "open", v_curChar, 0x6A760D2EC60228C6LL).set(1, "close", v_rule.rvalAt("end", 0x6DE935C204DC3D01LL), 0x36B43082F052EC6BLL).set(2, "count", v_count, 0x3D66B5980D54BABBLL).set(3, "lineStart", (more(v_i, 0LL) && equal(v_text.rvalAt(v_i - 1LL), "\n")), 0x0F84CB175598D0A5LL).create()));
3359             LINE(464,v_stack.o_invoke_few_args("push", 0x321E2BF5D878AA38LL, 1, v_piece));
3360             (v_accum = ref(LINE(465,v_stack.o_invoke_few_args("getAccum", 0x1A5F5A2CB292E516LL, 0))));
3361             LINE(466,extract(variables, toArray(v_stack.o_invoke_few_args("getFlags", 0x27E7DBA875AD17E1LL, 0))));
3362           }
3363           else {
3364             LINE(469,v_accum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, x_str_repeat(toString(v_curChar), toInt32(v_count))));
3365           }
3366           v_i += v_count;
3367         }
3368         else if (equal(v_found, "close")) {
3369           (v_piece = v_stack.o_get("top", 0x1854FD73A00D89E8LL));
3370           (v_maxCount = v_piece.o_get("count", 0x3D66B5980D54BABBLL));
3371           (v_count = LINE(478,x_strspn(toString(v_text), toString(v_curChar), toInt32(v_i), toInt32(v_maxCount))));
3372           (v_matchingCount = 0LL);
3373           (v_rule = v_rules.rvalAt(v_piece.o_get("open", 0x6A760D2EC60228C6LL)));
3374           if (more(v_count, v_rule.rvalAt("max", 0x022BD5C706BD9850LL))) {
3375             (v_matchingCount = v_rule.rvalAt("max", 0x022BD5C706BD9850LL));
3376           }
3377           else {
3378             (v_matchingCount = v_count);
3379             LOOP_COUNTER(39);
3380             {
3381               while (more(v_matchingCount, 0LL) && !(LINE(493,x_array_key_exists(v_matchingCount, v_rule.rvalAt("names", 0x51A687446C1579F2LL))))) {
3382                 LOOP_COUNTER_CHECK(39);
3383                 {
3384                   --v_matchingCount;
3385                 }
3386               }
3387             }
3388           }
3389           if (not_more(v_matchingCount, 0LL)) {
3390             LINE(501,v_accum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, x_str_repeat(toString(v_curChar), toInt32(v_count))));
3391             v_i += v_count;
3392             continue;
3393           }
3394           (v_name = v_rule.rvalAt("names", 0x51A687446C1579F2LL).rvalAt(v_matchingCount));
3395           if (same(v_name, null)) {
3396             (v_element = LINE(508,v_piece.o_invoke_few_args("breakSyntax", 0x1CF88FA5EFC88C39LL, 1, v_matchingCount)));
3397             LINE(509,v_element.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, x_str_repeat(toString(v_rule.rvalAt("end", 0x6DE935C204DC3D01LL)), toInt32(v_matchingCount))));
3398           }
3399           else {
3400             (v_parts = v_piece.o_get("parts", 0x2708FDA74562AD8DLL));
3401             (v_titleAccum = v_parts.rvalAt(0LL, 0x77CFA1EEF01BCA90LL).o_get("out", 0x7C801AC012E9F722LL));
3402             v_parts.weakRemove(0LL, 0x77CFA1EEF01BCA90LL);
3403             (v_element = ((Object)(LINE(517,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create(v_name))))));
3404             if (equal(v_maxCount, v_matchingCount) && !(empty(toObject(v_piece).o_get("lineStart", 0x0F84CB175598D0A5LL)))) {
3405               LINE(522,v_element.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, p_ppnode_hash_attr(p_ppnode_hash_attr(NEWOBJ(c_ppnode_hash_attr)())->create("lineStart", 1LL))));
3406             }
3407             (v_titleNode = ((Object)(LINE(524,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("title"))))));
3408             (v_titleNode.o_lval("firstChild", 0x22862CD26C0AAB50LL) = v_titleAccum.o_get("firstNode", 0x4296B55256FA0986LL));
3409             (v_titleNode.o_lval("lastChild", 0x29DD4C280399C7FALL) = v_titleAccum.o_get("lastNode", 0x6B446EEF03FAE201LL));
3410             LINE(527,v_element.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, v_titleNode));
3411             (v_argIndex = 1LL);
3412             {
3413               LOOP_COUNTER(40);
3414               for (ArrayIterPtr iter42 = v_parts.begin("preprocessor_hash"); !iter42->end(); iter42->next()) {
3415                 LOOP_COUNTER_CHECK(40);
3416                 v_part = iter42->second();
3417                 v_partIndex = iter42->first();
3418                 {
3419                   if (toObject(v_part)->t___isset("eqpos")) {
3420                     (v_lastNode = false);
3421                     {
3422                       LOOP_COUNTER(43);
3423                       for ((v_node = v_part.o_get("out", 0x7C801AC012E9F722LL).o_get("firstNode", 0x4296B55256FA0986LL)); toBoolean(v_node); (v_node = v_node.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
3424                         LOOP_COUNTER_CHECK(43);
3425                         {
3426                           if (same(v_node, v_part.o_get("eqpos", 0x33437B517F4D41D7LL))) {
3427                             break;
3428                           }
3429                           (v_lastNode = v_node);
3430                         }
3431                       }
3432                     }
3433                     if (!(toBoolean(v_node))) {
3434                       throw_exception(LINE(540,create_object("mwexception", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj: eqpos not found").create()))));
3435                     }
3436                     if (!same(v_node.o_get("name", 0x0BCDB293DC3CBDDCLL), "equals")) {
3437                       throw_exception(LINE(543,create_object("mwexception", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj: eqpos is not equals").create()))));
3438                     }
3439                     (v_equalsNode = v_node);
3440                     (v_nameNode = ((Object)(LINE(548,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("name"))))));
3441                     if (!same(v_lastNode, false)) {
3442                       (v_lastNode.o_lval("nextSibling", 0x0B3EC7643EE81822LL) = false);
3443                       (v_nameNode.o_lval("firstChild", 0x22862CD26C0AAB50LL) = v_part.o_get("out", 0x7C801AC012E9F722LL).o_get("firstNode", 0x4296B55256FA0986LL));
3444                       (v_nameNode.o_lval("lastChild", 0x29DD4C280399C7FALL) = v_lastNode);
3445                     }
3446                     (v_valueNode = ((Object)(LINE(556,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("value"))))));
3447                     if (!same(v_equalsNode.o_get("nextSibling", 0x0B3EC7643EE81822LL), false)) {
3448                       (v_valueNode.o_lval("firstChild", 0x22862CD26C0AAB50LL) = v_equalsNode.o_get("nextSibling", 0x0B3EC7643EE81822LL));
3449                       (v_valueNode.o_lval("lastChild", 0x29DD4C280399C7FALL) = v_part.o_get("out", 0x7C801AC012E9F722LL).o_get("lastNode", 0x6B446EEF03FAE201LL));
3450                     }
3451                     (v_partNode = ((Object)(LINE(561,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("part"))))));
3452                     LINE(562,v_partNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, v_nameNode));
3453                     LINE(563,v_partNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, v_equalsNode.o_lval("firstChild", 0x22862CD26C0AAB50LL)));
3454                     LINE(564,v_partNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, v_valueNode));
3455                     LINE(565,v_element.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, v_partNode));
3456                   }
3457                   else {
3458                     (v_partNode = ((Object)(LINE(567,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("part"))))));
3459                     (v_nameNode = ((Object)(LINE(568,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("name"))))));
3460                     LINE(569,v_nameNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, (assignCallTemp(eo_1, v_argIndex++),p_ppnode_hash_attr(p_ppnode_hash_attr(NEWOBJ(c_ppnode_hash_attr)())->create("index", eo_1)))));
3461                     (v_valueNode = ((Object)(LINE(570,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("value"))))));
3462                     (v_valueNode.o_lval("firstChild", 0x22862CD26C0AAB50LL) = v_part.o_get("out", 0x7C801AC012E9F722LL).o_get("firstNode", 0x4296B55256FA0986LL));
3463                     (v_valueNode.o_lval("lastChild", 0x29DD4C280399C7FALL) = v_part.o_get("out", 0x7C801AC012E9F722LL).o_get("lastNode", 0x6B446EEF03FAE201LL));
3464                     LINE(573,v_partNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, v_nameNode));
3465                     LINE(574,v_partNode.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, v_valueNode));
3466                     LINE(575,v_element.o_invoke_few_args("addChild", 0x2DDE12A9866FC794LL, 1, v_partNode));
3467                   }
3468                 }
3469               }
3470             }
3471           }
3472           v_i += v_matchingCount;
3473           LINE(584,v_stack.o_invoke_few_args("pop", 0x773C5A963CD2AC13LL, 0));
3474           (v_accum = ref(LINE(585,v_stack.o_invoke_few_args("getAccum", 0x1A5F5A2CB292E516LL, 0))));
3475           if (less(v_matchingCount, v_piece.o_get("count", 0x3D66B5980D54BABBLL))) {
3476             (v_piece.o_lval("parts", 0x2708FDA74562AD8DLL) = Array(ArrayInit(1).set(0, ((Object)(LINE(589,p_ppdpart_hash(p_ppdpart_hash(NEWOBJ(c_ppdpart_hash)())->create()))))).create()));
3477             v_piece.o_lval("count", 0x3D66B5980D54BABBLL) -= v_matchingCount;
3478             (v_names = v_rules.rvalAt(v_piece.o_get("open", 0x6A760D2EC60228C6LL)).rvalAt("names", 0x51A687446C1579F2LL));
3479             (v_skippedBraces = 0LL);
3480             (v_enclosingAccum = ref(v_accum));
3481             LOOP_COUNTER(44);
3482             {
3483               while (toBoolean(v_piece.o_get("count", 0x3D66B5980D54BABBLL))) {
3484                 LOOP_COUNTER_CHECK(44);
3485                 {
3486                   if (LINE(596,x_array_key_exists(v_piece.o_get("count", 0x3D66B5980D54BABBLL), v_names))) {
3487                     LINE(597,v_stack.o_invoke_few_args("push", 0x321E2BF5D878AA38LL, 1, v_piece));
3488                     (v_accum = ref(LINE(598,v_stack.o_invoke_few_args("getAccum", 0x1A5F5A2CB292E516LL, 0))));
3489                     break;
3490                   }
3491                   --lval(v_piece.o_lval("count", 0x3D66B5980D54BABBLL));
3492                   v_skippedBraces++;
3493                 }
3494               }
3495             }
3496             LINE(604,v_enclosingAccum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, x_str_repeat(toString(v_piece.o_get("open", 0x6A760D2EC60228C6LL)), toInt32(v_skippedBraces))));
3497           }
3498           LINE(607,extract(variables, toArray(v_stack.o_invoke_few_args("getFlags", 0x27E7DBA875AD17E1LL, 0))));
3499           if (instanceOf(v_element, "PPNode")) {
3500             LINE(611,v_accum.o_invoke_few_args("addNode", 0x0D8DDF05964C6A31LL, 1, v_element));
3501           }
3502           else {
3503             LINE(613,v_accum.o_invoke_few_args("addAccum", 0x6A8DCEFA6345DAC9LL, 1, v_element));
3504           }
3505         }
3506         else if (equal(v_found, "pipe")) {
3507           (v_findEquals = true);
3508           LINE(619,v_stack.o_invoke_few_args("addPart", 0x499E72B719A4CAC2LL, 0));
3509           (v_accum = ref(LINE(620,v_stack.o_invoke_few_args("getAccum", 0x1A5F5A2CB292E516LL, 0))));
3510           ++v_i;
3511         }
3512         else if (equal(v_found, "equals")) {
3513           (v_findEquals = false);
3514           LINE(626,v_accum.o_invoke_few_args("addNodeWithText", 0x6992F0F690B37356LL, 2, "equals", "="));
3515           (LINE(627,v_stack.o_invoke_few_args("getCurrentPart", 0x1726802D706D7BECLL, 0)).o_lval("eqpos", 0x33437B517F4D41D7LL) = v_accum.o_get("lastNode", 0x6B446EEF03FAE201LL));
3516           ++v_i;
3517         }
3518       }
3519     }
3520   }
3521   {
3522     LOOP_COUNTER(45);
3523     Variant map46 = v_stack.o_get("stack", 0x5084E637B870262BLL);
3524     for (ArrayIterPtr iter47 = map46.begin("preprocessor_hash"); !iter47->end(); iter47->next()) {
3525       LOOP_COUNTER_CHECK(45);
3526       v_piece = iter47->second();
3527       {
3528         LINE(634,v_stack.o_get("rootAccum", 0x5F4D08F214717E0FLL).o_invoke_few_args("addAccum", 0x6A8DCEFA6345DAC9LL, 1, v_piece.o_invoke_few_args("breakSyntax", 0x1CF88FA5EFC88C39LL, 0)));
3529       }
3530     }
3531   }
3532   {
3533     LOOP_COUNTER(48);
3534     for ((v_node = v_stack.o_get("rootAccum", 0x5F4D08F214717E0FLL).o_get("firstNode", 0x4296B55256FA0986LL)); toBoolean(v_node); (v_node = v_node.o_get("nextSibling", 0x0B3EC7643EE81822LL))) {
3535       LOOP_COUNTER_CHECK(48);
3536       {
3537         if (toObject(v_node)->t___isset("name") && same(v_node.o_get("name", 0x0BCDB293DC3CBDDCLL), "possible-h")) {
3538           (v_node.o_lval("name", 0x0BCDB293DC3CBDDCLL) = "h");
3539         }
3540       }
3541     }
3542   }
3543   (v_rootNode = ((Object)(LINE(644,p_ppnode_hash_tree(p_ppnode_hash_tree(NEWOBJ(c_ppnode_hash_tree)())->create("root"))))));
3544   (v_rootNode.o_lval("firstChild", 0x22862CD26C0AAB50LL) = v_stack.o_get("rootAccum", 0x5F4D08F214717E0FLL).o_get("firstNode", 0x4296B55256FA0986LL));
3545   (v_rootNode.o_lval("lastChild", 0x29DD4C280399C7FALL) = v_stack.o_get("rootAccum", 0x5F4D08F214717E0FLL).o_get("lastNode", 0x6B446EEF03FAE201LL));
3546   if (toBoolean(v_cacheable)) {
3547     (v_cacheValue = concat_rev(LINE(650,x_serialize(v_rootNode)), x_sprintf(2, "%08d", ScalarArrays::sa_[2])));
3548     LINE(651,v_wgMemc.o_invoke_few_args("set", 0x399A6427C2185621LL, 3, v_cacheKey, v_cacheValue, 86400LL));
3549     LINE(652,invoke_failed("wfprofileout", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj-cache-miss").create()), 0x00000000B599F276LL));
3550     LINE(653,invoke_failed("wfprofileout", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj-cacheable").create()), 0x00000000B599F276LL));
3551     LINE(654,(assignCallTemp(eo_1, concat3("Saved preprocessor Hash to memcached (key ", toString(v_cacheKey), ")")),invoke_failed("wfdebuglog", Array(ArrayInit(2).set(0, "Preprocessor").set(1, eo_1).create()), 0x00000000E6942489LL)));
3552   }
3553   LINE(657,invoke_failed("wfprofileout", Array(ArrayInit(1).set(0, "Preprocessor_Hash::preprocessToObj").create()), 0x00000000B599F276LL));
3554   return v_rootNode;
3555 } /* function */
3556 /* SRC: Preprocessor_Hash.php line 712 */
3557 Variant c_ppdpart_hash::os_get(const char *s, int64 hash) {
3558   return c_ppdpart::os_get(s, hash);
3559 }
3560 Variant &c_ppdpart_hash::os_lval(const char *s, int64 hash) {
3561   return c_ppdpart::os_lval(s, hash);
3562 }
3563 void c_ppdpart_hash::o_get(ArrayElementVec &props) const {
3564   c_ppdpart::o_get(props);
3565 }
3566 bool c_ppdpart_hash::o_exists(CStrRef s, int64 hash) const {
3567   return c_ppdpart::o_exists(s, hash);
3568 }
3569 Variant c_ppdpart_hash::o_get(CStrRef s, int64 hash) {
3570   return c_ppdpart::o_get(s, hash);
3571 }
3572 Variant c_ppdpart_hash::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
3573   return c_ppdpart::o_set(s, hash, v, forInit);
3574 }
3575 Variant &c_ppdpart_hash::o_lval(CStrRef s, int64 hash) {
3576   return c_ppdpart::o_lval(s, hash);
3577 }
3578 Variant c_ppdpart_hash::os_constant(const char *s) {
3579   return c_ppdpart::os_constant(s);
3580 }
3581 IMPLEMENT_CLASS(ppdpart_hash)
3582 ObjectData *c_ppdpart_hash::create(Variant v_out //  = ""
3583 ) {
3584   init();
3585   t___construct(v_out);
3586   return this;
3587 }
3588 ObjectData *c_ppdpart_hash::dynCreate(CArrRef params, bool init /* = true */) {
3589   if (init) {
3590     int count = params.size();
3591     if (count <= 0) return (create());
3592     return (create(params.rvalAt(0)));
3593   } else return this;
3594 }
3595 void c_ppdpart_hash::dynConstruct(CArrRef params) {
3596   int count = params.size();
3597   if (count <= 0) (t___construct());
3598   (t___construct(params.rvalAt(0)));
3599 }
3600 ObjectData *c_ppdpart_hash::cloneImpl() {
3601   c_ppdpart_hash *obj = NEW(c_ppdpart_hash)();
3602   cloneSet(obj);
3603   return obj;
3604 }
3605 void c_ppdpart_hash::cloneSet(c_ppdpart_hash *clone) {
3606   c_ppdpart::cloneSet(clone);
3607 }
3608 Variant c_ppdpart_hash::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
3609   if (hash < 0) hash = hash_string_i(s);
3610   switch (hash & 1) {
3611     case 1:
3612       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
3613         int count = params.size();
3614         if (count <= 0) return (t___construct(), null);
3615         return (t___construct(params.rvalAt(0)), null);
3616       }
3617       break;
3618     default:
3619       break;
3620   }
3621   return c_ppdpart::o_invoke(s, params, hash, fatal);
3622 }
3623 Variant c_ppdpart_hash::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
3624   if (hash < 0) hash = hash_string_i(s);
3625   switch (hash & 1) {
3626     case 1:
3627       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
3628         if (count <= 0) return (t___construct(), null);
3629         return (t___construct(a0), null);
3630       }
3631       break;
3632     default:
3633       break;
3634   }
3635   return c_ppdpart::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
3636 }
3637 Variant c_ppdpart_hash::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
3638   return c_ppdpart::os_invoke(c, s, params, hash, fatal);
3639 }
3640 Variant cw_ppdpart_hash$os_get(const char *s) {
3641   return c_ppdpart_hash::os_get(s, -1);
3642 }
3643 Variant &cw_ppdpart_hash$os_lval(const char *s) {
3644   return c_ppdpart_hash::os_lval(s, -1);
3645 }
3646 Variant cw_ppdpart_hash$os_constant(const char *s) {
3647   return c_ppdpart_hash::os_constant(s);
3648 }
3649 Variant cw_ppdpart_hash$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
3650   return c_ppdpart_hash::os_invoke(c, s, params, -1, fatal);
3651 }
3652 void c_ppdpart_hash::init() {
3653   c_ppdpart::init();
3654 }
3655 /* SRC: Preprocessor_Hash.php line 713 */
3656 void c_ppdpart_hash::t___construct(Variant v_out //  = ""
3657 ) {
3658   INSTANCE_METHOD_INJECTION(PPDPart_Hash, PPDPart_Hash::__construct);
3659   bool oldInCtor = gasInCtor(true);
3660   p_ppdaccum_hash v_accum;
3661
3662   ((Object)((v_accum = ((Object)(LINE(714,p_ppdaccum_hash(p_ppdaccum_hash(NEWOBJ(c_ppdaccum_hash)())->create())))))));
3663   if (!same(v_out, "")) {
3664     LINE(716,v_accum->t_addliteral(v_out));
3665   }
3666   LINE(718,c_ppdpart::t___construct(((Object)(v_accum))));
3667   gasInCtor(oldInCtor);
3668 } /* function */
3669 /* SRC: Preprocessor_Hash.php line 1297 */
3670 Variant c_ppcustomframe_hash::os_get(const char *s, int64 hash) {
3671   return c_ppframe_hash::os_get(s, hash);
3672 }
3673 Variant &c_ppcustomframe_hash::os_lval(const char *s, int64 hash) {
3674   return c_ppframe_hash::os_lval(s, hash);
3675 }
3676 void c_ppcustomframe_hash::o_get(ArrayElementVec &props) const {
3677   props.push_back(NEW(ArrayElement)("args", m_args.isReferenced() ? ref(m_args) : m_args));
3678   c_ppframe_hash::o_get(props);
3679 }
3680 bool c_ppcustomframe_hash::o_exists(CStrRef s, int64 hash) const {
3681   if (hash < 0) hash = hash_string(s.data(), s.length());
3682   switch (hash & 1) {
3683     case 0:
3684       HASH_EXISTS_STRING(0x4AF7CD17F976719ELL, args, 4);
3685       break;
3686     default:
3687       break;
3688   }
3689   return c_ppframe_hash::o_exists(s, hash);
3690 }
3691 Variant c_ppcustomframe_hash::o_get(CStrRef s, int64 hash) {
3692   if (hash < 0) hash = hash_string(s.data(), s.length());
3693   switch (hash & 1) {
3694     case 0:
3695       HASH_RETURN_STRING(0x4AF7CD17F976719ELL, m_args,
3696                          args, 4);
3697       break;
3698     default:
3699       break;
3700   }
3701   return c_ppframe_hash::o_get(s, hash);
3702 }
3703 Variant c_ppcustomframe_hash::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
3704   if (hash < 0) hash = hash_string(s.data(), s.length());
3705   switch (hash & 1) {
3706     case 0:
3707       HASH_SET_STRING(0x4AF7CD17F976719ELL, m_args,
3708                       args, 4);
3709       break;
3710     default:
3711       break;
3712   }
3713   return c_ppframe_hash::o_set(s, hash, v, forInit);
3714 }
3715 Variant &c_ppcustomframe_hash::o_lval(CStrRef s, int64 hash) {
3716   if (hash < 0) hash = hash_string(s.data(), s.length());
3717   switch (hash & 1) {
3718     case 0:
3719       HASH_RETURN_STRING(0x4AF7CD17F976719ELL, m_args,
3720                          args, 4);
3721       break;
3722     default:
3723       break;
3724   }
3725   return c_ppframe_hash::o_lval(s, hash);
3726 }
3727 Variant c_ppcustomframe_hash::os_constant(const char *s) {
3728   return c_ppframe_hash::os_constant(s);
3729 }
3730 IMPLEMENT_CLASS(ppcustomframe_hash)
3731 ObjectData *c_ppcustomframe_hash::create(Variant v_preprocessor, Variant v_args) {
3732   init();
3733   t___construct(v_preprocessor, v_args);
3734   return this;
3735 }
3736 ObjectData *c_ppcustomframe_hash::dynCreate(CArrRef params, bool init /* = true */) {
3737   if (init) {
3738     return (create(params.rvalAt(0), params.rvalAt(1)));
3739   } else return this;
3740 }
3741 void c_ppcustomframe_hash::dynConstruct(CArrRef params) {
3742   (t___construct(params.rvalAt(0), params.rvalAt(1)));
3743 }
3744 ObjectData *c_ppcustomframe_hash::cloneImpl() {
3745   c_ppcustomframe_hash *obj = NEW(c_ppcustomframe_hash)();
3746   cloneSet(obj);
3747   return obj;
3748 }
3749 void c_ppcustomframe_hash::cloneSet(c_ppcustomframe_hash *clone) {
3750   clone->m_args = m_args.isReferenced() ? ref(m_args) : m_args;
3751   c_ppframe_hash::cloneSet(clone);
3752 }
3753 Variant c_ppcustomframe_hash::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
3754   if (hash < 0) hash = hash_string_i(s);
3755   switch (hash & 31) {
3756     case 8:
3757       HASH_GUARD(0x6359F42D5FC265E8LL, isempty) {
3758         return (t_isempty());
3759       }
3760       break;
3761     case 11:
3762       HASH_GUARD(0x409618A98590618BLL, virtualbracketedimplode) {
3763         int count = params.size();
3764         if (count <= 3) return (t_virtualbracketedimplode(count, params.rvalAt(0), params.rvalAt(1), params.rvalAt(2)));
3765         return (t_virtualbracketedimplode(count,params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.slice(3, count - 3, false)));
3766       }
3767       break;
3768     case 13:
3769       HASH_GUARD(0x39B7BB05F05A37CDLL, expand) {
3770         int count = params.size();
3771         if (count <= 1) return (t_expand(params.rvalAt(0)));
3772         return (t_expand(params.rvalAt(0), params.rvalAt(1)));
3773       }
3774       break;
3775     case 14:
3776       HASH_GUARD(0x5047BA794DE2746ELL, implodewithflags) {
3777         int count = params.size();
3778         if (count <= 2) return (t_implodewithflags(count, params.rvalAt(0), params.rvalAt(1)));
3779         return (t_implodewithflags(count,params.rvalAt(0), params.rvalAt(1), params.slice(2, count - 2, false)));
3780       }
3781       break;
3782     case 16:
3783       HASH_GUARD(0x7EF27F050E4E0390LL, getnamedarguments) {
3784         return (t_getnamedarguments());
3785       }
3786       break;
3787     case 17:
3788       HASH_GUARD(0x1E2D3AE762AF0AF1LL, virtualimplode) {
3789         int count = params.size();
3790         if (count <= 1) return (t_virtualimplode(count, params.rvalAt(0)));
3791         return (t_virtualimplode(count,params.rvalAt(0), params.slice(1, count - 1, false)));
3792       }
3793       break;
3794     case 19:
3795       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
3796         return (t___tostring());
3797       }
3798       break;
3799     case 23:
3800       HASH_GUARD(0x3685C90A1EB568B7LL, getarguments) {
3801         return (t_getarguments());
3802       }
3803       break;
3804     case 24:
3805       HASH_GUARD(0x0A95A4780D41F7B8LL, getargument) {
3806         return (t_getargument(params.rvalAt(0)));
3807       }
3808       break;
3809     case 25:
3810       HASH_GUARD(0x7CBE9654ADB6CFB9LL, istemplate) {
3811         return (t_istemplate());
3812       }
3813       break;
3814     case 28:
3815       HASH_GUARD(0x7F4AB942B9CDE1BCLL, newchild) {
3816         int count = params.size();
3817         if (count <= 0) return (t_newchild());
3818         if (count == 1) return (t_newchild(params.rvalAt(0)));
3819         return (t_newchild(params.rvalAt(0), params.rvalAt(1)));
3820       }
3821       break;
3822     case 29:
3823       HASH_GUARD(0x7F29FBB1CA49733DLL, getnumberedarguments) {
3824         return (t_getnumberedarguments());
3825       }
3826       break;
3827     case 30:
3828       HASH_GUARD(0x36A80B48E08B753ELL, implode) {
3829         int count = params.size();
3830         if (count <= 1) return (t_implode(count, params.rvalAt(0)));
3831         return (t_implode(count,params.rvalAt(0), params.slice(1, count - 1, false)));
3832       }
3833       break;
3834     case 31:
3835       HASH_GUARD(0x7BA9911BE4A4175FLL, loopcheck) {
3836         return (t_loopcheck(params.rvalAt(0)));
3837       }
3838       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
3839         return (t___construct(params.rvalAt(0), params.rvalAt(1)), null);
3840       }
3841       break;
3842     default:
3843       break;
3844   }
3845   return c_ppframe_hash::o_invoke(s, params, hash, fatal);
3846 }
3847 Variant c_ppcustomframe_hash::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
3848   if (hash < 0) hash = hash_string_i(s);
3849   switch (hash & 31) {
3850     case 8:
3851       HASH_GUARD(0x6359F42D5FC265E8LL, isempty) {
3852         return (t_isempty());
3853       }
3854       break;
3855     case 11:
3856       HASH_GUARD(0x409618A98590618BLL, virtualbracketedimplode) {
3857         if (count <= 3) return (t_virtualbracketedimplode(count, a0, a1, a2));
3858         Array params;
3859         if (count >= 4) params.append(a3);
3860         if (count >= 5) params.append(a4);
3861         if (count >= 6) params.append(a5);
3862         return (t_virtualbracketedimplode(count,a0, a1, a2, params));
3863       }
3864       break;
3865     case 13:
3866       HASH_GUARD(0x39B7BB05F05A37CDLL, expand) {
3867         if (count <= 1) return (t_expand(a0));
3868         return (t_expand(a0, a1));
3869       }
3870       break;
3871     case 14:
3872       HASH_GUARD(0x5047BA794DE2746ELL, implodewithflags) {
3873         if (count <= 2) return (t_implodewithflags(count, a0, a1));
3874         Array params;
3875         if (count >= 3) params.append(a2);
3876         if (count >= 4) params.append(a3);
3877         if (count >= 5) params.append(a4);
3878         if (count >= 6) params.append(a5);
3879         return (t_implodewithflags(count,a0, a1, params));
3880       }
3881       break;
3882     case 16:
3883       HASH_GUARD(0x7EF27F050E4E0390LL, getnamedarguments) {
3884         return (t_getnamedarguments());
3885       }
3886       break;
3887     case 17:
3888       HASH_GUARD(0x1E2D3AE762AF0AF1LL, virtualimplode) {
3889         if (count <= 1) return (t_virtualimplode(count, a0));
3890         Array params;
3891         if (count >= 2) params.append(a1);
3892         if (count >= 3) params.append(a2);
3893         if (count >= 4) params.append(a3);
3894         if (count >= 5) params.append(a4);
3895         if (count >= 6) params.append(a5);
3896         return (t_virtualimplode(count,a0, params));
3897       }
3898       break;
3899     case 19:
3900       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
3901         return (t___tostring());
3902       }
3903       break;
3904     case 23:
3905       HASH_GUARD(0x3685C90A1EB568B7LL, getarguments) {
3906         return (t_getarguments());
3907       }
3908       break;
3909     case 24:
3910       HASH_GUARD(0x0A95A4780D41F7B8LL, getargument) {
3911         return (t_getargument(a0));
3912       }
3913       break;
3914     case 25:
3915       HASH_GUARD(0x7CBE9654ADB6CFB9LL, istemplate) {
3916         return (t_istemplate());
3917       }
3918       break;
3919     case 28:
3920       HASH_GUARD(0x7F4AB942B9CDE1BCLL, newchild) {
3921         if (count <= 0) return (t_newchild());
3922         if (count == 1) return (t_newchild(a0));
3923         return (t_newchild(a0, a1));
3924       }
3925       break;
3926     case 29:
3927       HASH_GUARD(0x7F29FBB1CA49733DLL, getnumberedarguments) {
3928         return (t_getnumberedarguments());
3929       }
3930       break;
3931     case 30:
3932       HASH_GUARD(0x36A80B48E08B753ELL, implode) {
3933         if (count <= 1) return (t_implode(count, a0));
3934         Array params;
3935         if (count >= 2) params.append(a1);
3936         if (count >= 3) params.append(a2);
3937         if (count >= 4) params.append(a3);
3938         if (count >= 5) params.append(a4);
3939         if (count >= 6) params.append(a5);
3940         return (t_implode(count,a0, params));
3941       }
3942       break;
3943     case 31:
3944       HASH_GUARD(0x7BA9911BE4A4175FLL, loopcheck) {
3945         return (t_loopcheck(a0));
3946       }
3947       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
3948         return (t___construct(a0, a1), null);
3949       }
3950       break;
3951     default:
3952       break;
3953   }
3954   return c_ppframe_hash::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
3955 }
3956 Variant c_ppcustomframe_hash::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
3957   return c_ppframe_hash::os_invoke(c, s, params, hash, fatal);
3958 }
3959 Variant cw_ppcustomframe_hash$os_get(const char *s) {
3960   return c_ppcustomframe_hash::os_get(s, -1);
3961 }
3962 Variant &cw_ppcustomframe_hash$os_lval(const char *s) {
3963   return c_ppcustomframe_hash::os_lval(s, -1);
3964 }
3965 Variant cw_ppcustomframe_hash$os_constant(const char *s) {
3966   return c_ppcustomframe_hash::os_constant(s);
3967 }
3968 Variant cw_ppcustomframe_hash$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
3969   return c_ppcustomframe_hash::os_invoke(c, s, params, -1, fatal);
3970 }
3971 void c_ppcustomframe_hash::init() {
3972   c_ppframe_hash::init();
3973   m_args = null;
3974 }
3975 /* SRC: Preprocessor_Hash.php line 1300 */
3976 void c_ppcustomframe_hash::t___construct(Variant v_preprocessor, Variant v_args) {
3977   INSTANCE_METHOD_INJECTION(PPCustomFrame_Hash, PPCustomFrame_Hash::__construct);
3978   bool oldInCtor = gasInCtor(true);
3979   LINE(1301,c_ppframe_hash::t___construct(v_preprocessor));
3980   (m_args = v_args);
3981   gasInCtor(oldInCtor);
3982 } /* function */
3983 /* SRC: Preprocessor_Hash.php line 1305 */
3984 String c_ppcustomframe_hash::t___tostring() {
3985   INSTANCE_METHOD_INJECTION(PPCustomFrame_Hash, PPCustomFrame_Hash::__toString);
3986   Variant eo_0;
3987   Variant eo_1;
3988   Variant eo_2;
3989   Variant eo_3;
3990   Variant eo_4;
3991   Variant eo_5;
3992   Variant eo_6;
3993   Variant eo_7;
3994   String v_s;
3995   bool v_first = false;
3996   Primitive v_name = 0;
3997   Variant v_value;
3998
3999   (v_s = "cstmframe{");
4000   (v_first = true);
4001   {
4002     LOOP_COUNTER(49);
4003     Variant map50 = m_args;
4004     for (ArrayIterPtr iter51 = map50.begin("ppcustomframe_hash"); !iter51->end(); iter51->next()) {
4005       LOOP_COUNTER_CHECK(49);
4006       v_value = iter51->second();
4007       v_name = iter51->first();
4008       {
4009         if (v_first) {
4010           (v_first = false);
4011         }
4012         else {
4013           concat_assign(v_s, ", ");
4014         }
4015         concat_assign(v_s, LINE(1315,(assignCallTemp(eo_1, toString(v_name)),assignCallTemp(eo_3, toString((assignCallTemp(eo_7, v_value.o_invoke_few_args("__toString", 0x642C2D2994B34A13LL, 0)),x_str_replace("\"", "\\\"", eo_7)))),concat5("\"", eo_1, "\":\"", eo_3, "\""))));
4016       }
4017     }
4018   }
4019   concat_assign(v_s, "}");
4020   return v_s;
4021 } /* function */
4022 /* SRC: Preprocessor_Hash.php line 1321 */
4023 bool c_ppcustomframe_hash::t_isempty() {
4024   INSTANCE_METHOD_INJECTION(PPCustomFrame_Hash, PPCustomFrame_Hash::isEmpty);
4025   return !(toBoolean(LINE(1322,x_count(m_args))));
4026 } /* function */
4027 /* SRC: Preprocessor_Hash.php line 1325 */
4028 Variant c_ppcustomframe_hash::t_getargument(CVarRef v_index) {
4029   INSTANCE_METHOD_INJECTION(PPCustomFrame_Hash, PPCustomFrame_Hash::getArgument);
4030   if (!(isset(m_args, v_index))) {
4031     return false;
4032   }
4033   return m_args.rvalAt(v_index);
4034 } /* function */
4035 /* SRC: Preprocessor_Hash.php line 1591 */
4036 Variant c_ppnode_hash_attr::os_get(const char *s, int64 hash) {
4037   return c_ObjectData::os_get(s, hash);
4038 }
4039 Variant &c_ppnode_hash_attr::os_lval(const char *s, int64 hash) {
4040   return c_ObjectData::os_lval(s, hash);
4041 }
4042 void c_ppnode_hash_attr::o_get(ArrayElementVec &props) const {
4043   props.push_back(NEW(ArrayElement)("name", m_name.isReferenced() ? ref(m_name) : m_name));
4044   props.push_back(NEW(ArrayElement)("value", m_value.isReferenced() ? ref(m_value) : m_value));
4045   props.push_back(NEW(ArrayElement)("nextSibling", m_nextSibling.isReferenced() ? ref(m_nextSibling) : m_nextSibling));
4046   c_ObjectData::o_get(props);
4047 }
4048 bool c_ppnode_hash_attr::o_exists(CStrRef s, int64 hash) const {
4049   if (hash < 0) hash = hash_string(s.data(), s.length());
4050   switch (hash & 7) {
4051     case 1:
4052       HASH_EXISTS_STRING(0x69E7413AE0C88471LL, value, 5);
4053       break;
4054     case 2:
4055       HASH_EXISTS_STRING(0x0B3EC7643EE81822LL, nextSibling, 11);
4056       break;
4057     case 4:
4058       HASH_EXISTS_STRING(0x0BCDB293DC3CBDDCLL, name, 4);
4059       break;
4060     default:
4061       break;
4062   }
4063   return c_ObjectData::o_exists(s, hash);
4064 }
4065 Variant c_ppnode_hash_attr::o_get(CStrRef s, int64 hash) {
4066   if (hash < 0) hash = hash_string(s.data(), s.length());
4067   switch (hash & 7) {
4068     case 1:
4069       HASH_RETURN_STRING(0x69E7413AE0C88471LL, m_value,
4070                          value, 5);
4071       break;
4072     case 2:
4073       HASH_RETURN_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
4074                          nextSibling, 11);
4075       break;
4076     case 4:
4077       HASH_RETURN_STRING(0x0BCDB293DC3CBDDCLL, m_name,
4078                          name, 4);
4079       break;
4080     default:
4081       break;
4082   }
4083   return c_ObjectData::o_get(s, hash);
4084 }
4085 Variant c_ppnode_hash_attr::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
4086   if (hash < 0) hash = hash_string(s.data(), s.length());
4087   switch (hash & 7) {
4088     case 1:
4089       HASH_SET_STRING(0x69E7413AE0C88471LL, m_value,
4090                       value, 5);
4091       break;
4092     case 2:
4093       HASH_SET_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
4094                       nextSibling, 11);
4095       break;
4096     case 4:
4097       HASH_SET_STRING(0x0BCDB293DC3CBDDCLL, m_name,
4098                       name, 4);
4099       break;
4100     default:
4101       break;
4102   }
4103   return c_ObjectData::o_set(s, hash, v, forInit);
4104 }
4105 Variant &c_ppnode_hash_attr::o_lval(CStrRef s, int64 hash) {
4106   if (hash < 0) hash = hash_string(s.data(), s.length());
4107   switch (hash & 7) {
4108     case 1:
4109       HASH_RETURN_STRING(0x69E7413AE0C88471LL, m_value,
4110                          value, 5);
4111       break;
4112     case 2:
4113       HASH_RETURN_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
4114                          nextSibling, 11);
4115       break;
4116     case 4:
4117       HASH_RETURN_STRING(0x0BCDB293DC3CBDDCLL, m_name,
4118                          name, 4);
4119       break;
4120     default:
4121       break;
4122   }
4123   return c_ObjectData::o_lval(s, hash);
4124 }
4125 Variant c_ppnode_hash_attr::os_constant(const char *s) {
4126   return c_ObjectData::os_constant(s);
4127 }
4128 IMPLEMENT_CLASS(ppnode_hash_attr)
4129 ObjectData *c_ppnode_hash_attr::create(Variant v_name, Variant v_value) {
4130   init();
4131   t___construct(v_name, v_value);
4132   return this;
4133 }
4134 ObjectData *c_ppnode_hash_attr::dynCreate(CArrRef params, bool init /* = true */) {
4135   if (init) {
4136     return (create(params.rvalAt(0), params.rvalAt(1)));
4137   } else return this;
4138 }
4139 void c_ppnode_hash_attr::dynConstruct(CArrRef params) {
4140   (t___construct(params.rvalAt(0), params.rvalAt(1)));
4141 }
4142 ObjectData *c_ppnode_hash_attr::cloneImpl() {
4143   c_ppnode_hash_attr *obj = NEW(c_ppnode_hash_attr)();
4144   cloneSet(obj);
4145   return obj;
4146 }
4147 void c_ppnode_hash_attr::cloneSet(c_ppnode_hash_attr *clone) {
4148   clone->m_name = m_name.isReferenced() ? ref(m_name) : m_name;
4149   clone->m_value = m_value.isReferenced() ? ref(m_value) : m_value;
4150   clone->m_nextSibling = m_nextSibling.isReferenced() ? ref(m_nextSibling) : m_nextSibling;
4151   ObjectData::cloneSet(clone);
4152 }
4153 Variant c_ppnode_hash_attr::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
4154   if (hash < 0) hash = hash_string_i(s);
4155   switch (hash & 31) {
4156     case 0:
4157       HASH_GUARD(0x73E7C3304C0C5360LL, splitarg) {
4158         return (t_splitarg(), null);
4159       }
4160       break;
4161     case 5:
4162       HASH_GUARD(0x23F51CDECC198965LL, getname) {
4163         return (t_getname());
4164       }
4165       break;
4166     case 6:
4167       HASH_GUARD(0x0A41DBE0830902C6LL, item) {
4168         return (t_item(params.rvalAt(0)));
4169       }
4170       break;
4171     case 9:
4172       HASH_GUARD(0x050681239965E069LL, getfirstchild) {
4173         return (t_getfirstchild());
4174       }
4175       break;
4176     case 12:
4177       HASH_GUARD(0x47D4EE3CB3EB696CLL, splitext) {
4178         return (t_splitext(), null);
4179       }
4180       break;
4181     case 13:
4182       HASH_GUARD(0x0621AE2D22A1922DLL, splitheading) {
4183         return (t_splitheading(), null);
4184       }
4185       break;
4186     case 14:
4187       HASH_GUARD(0x5ABDC66291F1CA2ELL, getchildrenoftype) {
4188         return (t_getchildrenoftype(params.rvalAt(0)));
4189       }
4190       break;
4191     case 15:
4192       HASH_GUARD(0x732EC1BDA8EC520FLL, getchildren) {
4193         return (t_getchildren());
4194       }
4195       break;
4196     case 19:
4197       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
4198         return (t___tostring());
4199       }
4200       break;
4201     case 20:
4202       HASH_GUARD(0x41EB078EF92C44D4LL, getlength) {
4203         return (t_getlength());
4204       }
4205       break;
4206     case 25:
4207       HASH_GUARD(0x4CB333CF2D880119LL, getnextsibling) {
4208         return (t_getnextsibling());
4209       }
4210       break;
4211     case 31:
4212       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
4213         return (t___construct(params.rvalAt(0), params.rvalAt(1)), null);
4214       }
4215       break;
4216     default:
4217       break;
4218   }
4219   return c_ObjectData::o_invoke(s, params, hash, fatal);
4220 }
4221 Variant c_ppnode_hash_attr::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
4222   if (hash < 0) hash = hash_string_i(s);
4223   switch (hash & 31) {
4224     case 0:
4225       HASH_GUARD(0x73E7C3304C0C5360LL, splitarg) {
4226         return (t_splitarg(), null);
4227       }
4228       break;
4229     case 5:
4230       HASH_GUARD(0x23F51CDECC198965LL, getname) {
4231         return (t_getname());
4232       }
4233       break;
4234     case 6:
4235       HASH_GUARD(0x0A41DBE0830902C6LL, item) {
4236         return (t_item(a0));
4237       }
4238       break;
4239     case 9:
4240       HASH_GUARD(0x050681239965E069LL, getfirstchild) {
4241         return (t_getfirstchild());
4242       }
4243       break;
4244     case 12:
4245       HASH_GUARD(0x47D4EE3CB3EB696CLL, splitext) {
4246         return (t_splitext(), null);
4247       }
4248       break;
4249     case 13:
4250       HASH_GUARD(0x0621AE2D22A1922DLL, splitheading) {
4251         return (t_splitheading(), null);
4252       }
4253       break;
4254     case 14:
4255       HASH_GUARD(0x5ABDC66291F1CA2ELL, getchildrenoftype) {
4256         return (t_getchildrenoftype(a0));
4257       }
4258       break;
4259     case 15:
4260       HASH_GUARD(0x732EC1BDA8EC520FLL, getchildren) {
4261         return (t_getchildren());
4262       }
4263       break;
4264     case 19:
4265       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
4266         return (t___tostring());
4267       }
4268       break;
4269     case 20:
4270       HASH_GUARD(0x41EB078EF92C44D4LL, getlength) {
4271         return (t_getlength());
4272       }
4273       break;
4274     case 25:
4275       HASH_GUARD(0x4CB333CF2D880119LL, getnextsibling) {
4276         return (t_getnextsibling());
4277       }
4278       break;
4279     case 31:
4280       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
4281         return (t___construct(a0, a1), null);
4282       }
4283       break;
4284     default:
4285       break;
4286   }
4287   return c_ObjectData::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
4288 }
4289 Variant c_ppnode_hash_attr::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
4290   return c_ObjectData::os_invoke(c, s, params, hash, fatal);
4291 }
4292 Variant cw_ppnode_hash_attr$os_get(const char *s) {
4293   return c_ppnode_hash_attr::os_get(s, -1);
4294 }
4295 Variant &cw_ppnode_hash_attr$os_lval(const char *s) {
4296   return c_ppnode_hash_attr::os_lval(s, -1);
4297 }
4298 Variant cw_ppnode_hash_attr$os_constant(const char *s) {
4299   return c_ppnode_hash_attr::os_constant(s);
4300 }
4301 Variant cw_ppnode_hash_attr$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
4302   return c_ppnode_hash_attr::os_invoke(c, s, params, -1, fatal);
4303 }
4304 void c_ppnode_hash_attr::init() {
4305   m_name = null;
4306   m_value = null;
4307   m_nextSibling = null;
4308 }
4309 /* SRC: Preprocessor_Hash.php line 1594 */
4310 void c_ppnode_hash_attr::t___construct(Variant v_name, Variant v_value) {
4311   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::__construct);
4312   bool oldInCtor = gasInCtor(true);
4313   (m_name = v_name);
4314   (m_value = v_value);
4315   gasInCtor(oldInCtor);
4316 } /* function */
4317 /* SRC: Preprocessor_Hash.php line 1599 */
4318 String c_ppnode_hash_attr::t___tostring() {
4319   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::__toString);
4320   Variant eo_0;
4321   Variant eo_1;
4322   Variant eo_2;
4323   Variant eo_3;
4324   Variant eo_4;
4325   return LINE(1600,(assignCallTemp(eo_1, toString(m_name)),assignCallTemp(eo_3, x_htmlspecialchars(toString(m_value))),assignCallTemp(eo_4, concat3("</@", toString(m_name), ">")),concat5("<@", eo_1, ">", eo_3, eo_4)));
4326 } /* function */
4327 /* SRC: Preprocessor_Hash.php line 1603 */
4328 Variant c_ppnode_hash_attr::t_getname() {
4329   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::getName);
4330   return m_name;
4331 } /* function */
4332 /* SRC: Preprocessor_Hash.php line 1607 */
4333 Variant c_ppnode_hash_attr::t_getnextsibling() {
4334   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::getNextSibling);
4335   return m_nextSibling;
4336 } /* function */
4337 /* SRC: Preprocessor_Hash.php line 1611 */
4338 bool c_ppnode_hash_attr::t_getchildren() {
4339   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::getChildren);
4340   return false;
4341 } /* function */
4342 /* SRC: Preprocessor_Hash.php line 1612 */
4343 bool c_ppnode_hash_attr::t_getfirstchild() {
4344   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::getFirstChild);
4345   return false;
4346 } /* function */
4347 /* SRC: Preprocessor_Hash.php line 1613 */
4348 bool c_ppnode_hash_attr::t_getchildrenoftype(CVarRef v_name) {
4349   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::getChildrenOfType);
4350   return false;
4351 } /* function */
4352 /* SRC: Preprocessor_Hash.php line 1614 */
4353 bool c_ppnode_hash_attr::t_getlength() {
4354   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::getLength);
4355   return false;
4356 } /* function */
4357 /* SRC: Preprocessor_Hash.php line 1615 */
4358 bool c_ppnode_hash_attr::t_item(CVarRef v_i) {
4359   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::item);
4360   return false;
4361 } /* function */
4362 /* SRC: Preprocessor_Hash.php line 1616 */
4363 void c_ppnode_hash_attr::t_splitarg() {
4364   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::splitArg);
4365   throw_exception(LINE(1616,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Attr::splitArg: not supported").create()))));
4366 } /* function */
4367 /* SRC: Preprocessor_Hash.php line 1617 */
4368 void c_ppnode_hash_attr::t_splitext() {
4369   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::splitExt);
4370   throw_exception(LINE(1617,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Attr::splitExt: not supported").create()))));
4371 } /* function */
4372 /* SRC: Preprocessor_Hash.php line 1618 */
4373 void c_ppnode_hash_attr::t_splitheading() {
4374   INSTANCE_METHOD_INJECTION(PPNode_Hash_Attr, PPNode_Hash_Attr::splitHeading);
4375   throw_exception(LINE(1618,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Attr::splitHeading: not supported").create()))));
4376 } /* function */
4377 /* SRC: Preprocessor_Hash.php line 1184 */
4378 Variant c_pptemplateframe_hash::os_get(const char *s, int64 hash) {
4379   return c_ppframe_hash::os_get(s, hash);
4380 }
4381 Variant &c_pptemplateframe_hash::os_lval(const char *s, int64 hash) {
4382   return c_ppframe_hash::os_lval(s, hash);
4383 }
4384 void c_pptemplateframe_hash::o_get(ArrayElementVec &props) const {
4385   props.push_back(NEW(ArrayElement)("numberedArgs", m_numberedArgs.isReferenced() ? ref(m_numberedArgs) : m_numberedArgs));
4386   props.push_back(NEW(ArrayElement)("namedArgs", m_namedArgs.isReferenced() ? ref(m_namedArgs) : m_namedArgs));
4387   props.push_back(NEW(ArrayElement)("parent", m_parent.isReferenced() ? ref(m_parent) : m_parent));
4388   props.push_back(NEW(ArrayElement)("numberedExpansionCache", m_numberedExpansionCache.isReferenced() ? ref(m_numberedExpansionCache) : m_numberedExpansionCache));
4389   props.push_back(NEW(ArrayElement)("namedExpansionCache", m_namedExpansionCache.isReferenced() ? ref(m_namedExpansionCache) : m_namedExpansionCache));
4390   c_ppframe_hash::o_get(props);
4391 }
4392 bool c_pptemplateframe_hash::o_exists(CStrRef s, int64 hash) const {
4393   if (hash < 0) hash = hash_string(s.data(), s.length());
4394   switch (hash & 15) {
4395     case 5:
4396       HASH_EXISTS_STRING(0x21A0BD85B8757635LL, numberedExpansionCache, 22);
4397       break;
4398     case 8:
4399       HASH_EXISTS_STRING(0x4C84B2F1BC8BA768LL, namedExpansionCache, 19);
4400       break;
4401     case 9:
4402       HASH_EXISTS_STRING(0x00263ABC07EFFD29LL, numberedArgs, 12);
4403       break;
4404     case 10:
4405       HASH_EXISTS_STRING(0x3F849A2980280C0ALL, namedArgs, 9);
4406       break;
4407     case 12:
4408       HASH_EXISTS_STRING(0x16E2F26FFB10FD8CLL, parent, 6);
4409       break;
4410     default:
4411       break;
4412   }
4413   return c_ppframe_hash::o_exists(s, hash);
4414 }
4415 Variant c_pptemplateframe_hash::o_get(CStrRef s, int64 hash) {
4416   if (hash < 0) hash = hash_string(s.data(), s.length());
4417   switch (hash & 15) {
4418     case 5:
4419       HASH_RETURN_STRING(0x21A0BD85B8757635LL, m_numberedExpansionCache,
4420                          numberedExpansionCache, 22);
4421       break;
4422     case 8:
4423       HASH_RETURN_STRING(0x4C84B2F1BC8BA768LL, m_namedExpansionCache,
4424                          namedExpansionCache, 19);
4425       break;
4426     case 9:
4427       HASH_RETURN_STRING(0x00263ABC07EFFD29LL, m_numberedArgs,
4428                          numberedArgs, 12);
4429       break;
4430     case 10:
4431       HASH_RETURN_STRING(0x3F849A2980280C0ALL, m_namedArgs,
4432                          namedArgs, 9);
4433       break;
4434     case 12:
4435       HASH_RETURN_STRING(0x16E2F26FFB10FD8CLL, m_parent,
4436                          parent, 6);
4437       break;
4438     default:
4439       break;
4440   }
4441   return c_ppframe_hash::o_get(s, hash);
4442 }
4443 Variant c_pptemplateframe_hash::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
4444   if (hash < 0) hash = hash_string(s.data(), s.length());
4445   switch (hash & 15) {
4446     case 5:
4447       HASH_SET_STRING(0x21A0BD85B8757635LL, m_numberedExpansionCache,
4448                       numberedExpansionCache, 22);
4449       break;
4450     case 8:
4451       HASH_SET_STRING(0x4C84B2F1BC8BA768LL, m_namedExpansionCache,
4452                       namedExpansionCache, 19);
4453       break;
4454     case 9:
4455       HASH_SET_STRING(0x00263ABC07EFFD29LL, m_numberedArgs,
4456                       numberedArgs, 12);
4457       break;
4458     case 10:
4459       HASH_SET_STRING(0x3F849A2980280C0ALL, m_namedArgs,
4460                       namedArgs, 9);
4461       break;
4462     case 12:
4463       HASH_SET_STRING(0x16E2F26FFB10FD8CLL, m_parent,
4464                       parent, 6);
4465       break;
4466     default:
4467       break;
4468   }
4469   return c_ppframe_hash::o_set(s, hash, v, forInit);
4470 }
4471 Variant &c_pptemplateframe_hash::o_lval(CStrRef s, int64 hash) {
4472   if (hash < 0) hash = hash_string(s.data(), s.length());
4473   switch (hash & 15) {
4474     case 5:
4475       HASH_RETURN_STRING(0x21A0BD85B8757635LL, m_numberedExpansionCache,
4476                          numberedExpansionCache, 22);
4477       break;
4478     case 8:
4479       HASH_RETURN_STRING(0x4C84B2F1BC8BA768LL, m_namedExpansionCache,
4480                          namedExpansionCache, 19);
4481       break;
4482     case 9:
4483       HASH_RETURN_STRING(0x00263ABC07EFFD29LL, m_numberedArgs,
4484                          numberedArgs, 12);
4485       break;
4486     case 10:
4487       HASH_RETURN_STRING(0x3F849A2980280C0ALL, m_namedArgs,
4488                          namedArgs, 9);
4489       break;
4490     case 12:
4491       HASH_RETURN_STRING(0x16E2F26FFB10FD8CLL, m_parent,
4492                          parent, 6);
4493       break;
4494     default:
4495       break;
4496   }
4497   return c_ppframe_hash::o_lval(s, hash);
4498 }
4499 Variant c_pptemplateframe_hash::os_constant(const char *s) {
4500   return c_ppframe_hash::os_constant(s);
4501 }
4502 IMPLEMENT_CLASS(pptemplateframe_hash)
4503 ObjectData *c_pptemplateframe_hash::create(Variant v_preprocessor, Variant v_parent //  = false
4504 , Variant v_numberedArgs //  = ScalarArrays::sa_[0]
4505 , Variant v_namedArgs //  = ScalarArrays::sa_[0]
4506 , Variant v_title //  = false
4507 ) {
4508   init();
4509   t___construct(v_preprocessor, v_parent, v_numberedArgs, v_namedArgs, v_title);
4510   return this;
4511 }
4512 ObjectData *c_pptemplateframe_hash::dynCreate(CArrRef params, bool init /* = true */) {
4513   if (init) {
4514     int count = params.size();
4515     if (count <= 1) return (create(params.rvalAt(0)));
4516     if (count == 2) return (create(params.rvalAt(0), params.rvalAt(1)));
4517     if (count == 3) return (create(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2)));
4518     if (count == 4) return (create(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.rvalAt(3)));
4519     return (create(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.rvalAt(3), params.rvalAt(4)));
4520   } else return this;
4521 }
4522 void c_pptemplateframe_hash::dynConstruct(CArrRef params) {
4523   int count = params.size();
4524   if (count <= 1) (t___construct(params.rvalAt(0)));
4525   if (count == 2) (t___construct(params.rvalAt(0), params.rvalAt(1)));
4526   if (count == 3) (t___construct(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2)));
4527   if (count == 4) (t___construct(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.rvalAt(3)));
4528   (t___construct(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.rvalAt(3), params.rvalAt(4)));
4529 }
4530 ObjectData *c_pptemplateframe_hash::cloneImpl() {
4531   c_pptemplateframe_hash *obj = NEW(c_pptemplateframe_hash)();
4532   cloneSet(obj);
4533   return obj;
4534 }
4535 void c_pptemplateframe_hash::cloneSet(c_pptemplateframe_hash *clone) {
4536   clone->m_numberedArgs = m_numberedArgs.isReferenced() ? ref(m_numberedArgs) : m_numberedArgs;
4537   clone->m_namedArgs = m_namedArgs.isReferenced() ? ref(m_namedArgs) : m_namedArgs;
4538   clone->m_parent = m_parent.isReferenced() ? ref(m_parent) : m_parent;
4539   clone->m_numberedExpansionCache = m_numberedExpansionCache.isReferenced() ? ref(m_numberedExpansionCache) : m_numberedExpansionCache;
4540   clone->m_namedExpansionCache = m_namedExpansionCache.isReferenced() ? ref(m_namedExpansionCache) : m_namedExpansionCache;
4541   c_ppframe_hash::cloneSet(clone);
4542 }
4543 Variant c_pptemplateframe_hash::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
4544   if (hash < 0) hash = hash_string_i(s);
4545   switch (hash & 31) {
4546     case 8:
4547       HASH_GUARD(0x6359F42D5FC265E8LL, isempty) {
4548         return (t_isempty());
4549       }
4550       break;
4551     case 11:
4552       HASH_GUARD(0x409618A98590618BLL, virtualbracketedimplode) {
4553         int count = params.size();
4554         if (count <= 3) return (t_virtualbracketedimplode(count, params.rvalAt(0), params.rvalAt(1), params.rvalAt(2)));
4555         return (t_virtualbracketedimplode(count,params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.slice(3, count - 3, false)));
4556       }
4557       break;
4558     case 13:
4559       HASH_GUARD(0x39B7BB05F05A37CDLL, expand) {
4560         int count = params.size();
4561         if (count <= 1) return (t_expand(params.rvalAt(0)));
4562         return (t_expand(params.rvalAt(0), params.rvalAt(1)));
4563       }
4564       break;
4565     case 14:
4566       HASH_GUARD(0x5047BA794DE2746ELL, implodewithflags) {
4567         int count = params.size();
4568         if (count <= 2) return (t_implodewithflags(count, params.rvalAt(0), params.rvalAt(1)));
4569         return (t_implodewithflags(count,params.rvalAt(0), params.rvalAt(1), params.slice(2, count - 2, false)));
4570       }
4571       break;
4572     case 16:
4573       HASH_GUARD(0x7EF27F050E4E0390LL, getnamedarguments) {
4574         return (t_getnamedarguments());
4575       }
4576       break;
4577     case 17:
4578       HASH_GUARD(0x1E2D3AE762AF0AF1LL, virtualimplode) {
4579         int count = params.size();
4580         if (count <= 1) return (t_virtualimplode(count, params.rvalAt(0)));
4581         return (t_virtualimplode(count,params.rvalAt(0), params.slice(1, count - 1, false)));
4582       }
4583       break;
4584     case 19:
4585       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
4586         return (t___tostring());
4587       }
4588       break;
4589     case 23:
4590       HASH_GUARD(0x3685C90A1EB568B7LL, getarguments) {
4591         return (t_getarguments());
4592       }
4593       break;
4594     case 24:
4595       HASH_GUARD(0x0A95A4780D41F7B8LL, getargument) {
4596         return (t_getargument(params.rvalAt(0)));
4597       }
4598       break;
4599     case 25:
4600       HASH_GUARD(0x7CBE9654ADB6CFB9LL, istemplate) {
4601         return (t_istemplate());
4602       }
4603       break;
4604     case 28:
4605       HASH_GUARD(0x7F4AB942B9CDE1BCLL, newchild) {
4606         int count = params.size();
4607         if (count <= 0) return (t_newchild());
4608         if (count == 1) return (t_newchild(params.rvalAt(0)));
4609         return (t_newchild(params.rvalAt(0), params.rvalAt(1)));
4610       }
4611       break;
4612     case 29:
4613       HASH_GUARD(0x7F29FBB1CA49733DLL, getnumberedarguments) {
4614         return (t_getnumberedarguments());
4615       }
4616       break;
4617     case 30:
4618       HASH_GUARD(0x36A80B48E08B753ELL, implode) {
4619         int count = params.size();
4620         if (count <= 1) return (t_implode(count, params.rvalAt(0)));
4621         return (t_implode(count,params.rvalAt(0), params.slice(1, count - 1, false)));
4622       }
4623       break;
4624     case 31:
4625       HASH_GUARD(0x7BA9911BE4A4175FLL, loopcheck) {
4626         return (t_loopcheck(params.rvalAt(0)));
4627       }
4628       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
4629         int count = params.size();
4630         if (count <= 1) return (t___construct(params.rvalAt(0)), null);
4631         if (count == 2) return (t___construct(params.rvalAt(0), params.rvalAt(1)), null);
4632         if (count == 3) return (t___construct(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2)), null);
4633         if (count == 4) return (t___construct(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.rvalAt(3)), null);
4634         return (t___construct(params.rvalAt(0), params.rvalAt(1), params.rvalAt(2), params.rvalAt(3), params.rvalAt(4)), null);
4635       }
4636       break;
4637     default:
4638       break;
4639   }
4640   return c_ppframe_hash::o_invoke(s, params, hash, fatal);
4641 }
4642 Variant c_pptemplateframe_hash::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
4643   if (hash < 0) hash = hash_string_i(s);
4644   switch (hash & 31) {
4645     case 8:
4646       HASH_GUARD(0x6359F42D5FC265E8LL, isempty) {
4647         return (t_isempty());
4648       }
4649       break;
4650     case 11:
4651       HASH_GUARD(0x409618A98590618BLL, virtualbracketedimplode) {
4652         if (count <= 3) return (t_virtualbracketedimplode(count, a0, a1, a2));
4653         Array params;
4654         if (count >= 4) params.append(a3);
4655         if (count >= 5) params.append(a4);
4656         if (count >= 6) params.append(a5);
4657         return (t_virtualbracketedimplode(count,a0, a1, a2, params));
4658       }
4659       break;
4660     case 13:
4661       HASH_GUARD(0x39B7BB05F05A37CDLL, expand) {
4662         if (count <= 1) return (t_expand(a0));
4663         return (t_expand(a0, a1));
4664       }
4665       break;
4666     case 14:
4667       HASH_GUARD(0x5047BA794DE2746ELL, implodewithflags) {
4668         if (count <= 2) return (t_implodewithflags(count, a0, a1));
4669         Array params;
4670         if (count >= 3) params.append(a2);
4671         if (count >= 4) params.append(a3);
4672         if (count >= 5) params.append(a4);
4673         if (count >= 6) params.append(a5);
4674         return (t_implodewithflags(count,a0, a1, params));
4675       }
4676       break;
4677     case 16:
4678       HASH_GUARD(0x7EF27F050E4E0390LL, getnamedarguments) {
4679         return (t_getnamedarguments());
4680       }
4681       break;
4682     case 17:
4683       HASH_GUARD(0x1E2D3AE762AF0AF1LL, virtualimplode) {
4684         if (count <= 1) return (t_virtualimplode(count, a0));
4685         Array params;
4686         if (count >= 2) params.append(a1);
4687         if (count >= 3) params.append(a2);
4688         if (count >= 4) params.append(a3);
4689         if (count >= 5) params.append(a4);
4690         if (count >= 6) params.append(a5);
4691         return (t_virtualimplode(count,a0, params));
4692       }
4693       break;
4694     case 19:
4695       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
4696         return (t___tostring());
4697       }
4698       break;
4699     case 23:
4700       HASH_GUARD(0x3685C90A1EB568B7LL, getarguments) {
4701         return (t_getarguments());
4702       }
4703       break;
4704     case 24:
4705       HASH_GUARD(0x0A95A4780D41F7B8LL, getargument) {
4706         return (t_getargument(a0));
4707       }
4708       break;
4709     case 25:
4710       HASH_GUARD(0x7CBE9654ADB6CFB9LL, istemplate) {
4711         return (t_istemplate());
4712       }
4713       break;
4714     case 28:
4715       HASH_GUARD(0x7F4AB942B9CDE1BCLL, newchild) {
4716         if (count <= 0) return (t_newchild());
4717         if (count == 1) return (t_newchild(a0));
4718         return (t_newchild(a0, a1));
4719       }
4720       break;
4721     case 29:
4722       HASH_GUARD(0x7F29FBB1CA49733DLL, getnumberedarguments) {
4723         return (t_getnumberedarguments());
4724       }
4725       break;
4726     case 30:
4727       HASH_GUARD(0x36A80B48E08B753ELL, implode) {
4728         if (count <= 1) return (t_implode(count, a0));
4729         Array params;
4730         if (count >= 2) params.append(a1);
4731         if (count >= 3) params.append(a2);
4732         if (count >= 4) params.append(a3);
4733         if (count >= 5) params.append(a4);
4734         if (count >= 6) params.append(a5);
4735         return (t_implode(count,a0, params));
4736       }
4737       break;
4738     case 31:
4739       HASH_GUARD(0x7BA9911BE4A4175FLL, loopcheck) {
4740         return (t_loopcheck(a0));
4741       }
4742       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
4743         if (count <= 1) return (t___construct(a0), null);
4744         if (count == 2) return (t___construct(a0, a1), null);
4745         if (count == 3) return (t___construct(a0, a1, a2), null);
4746         if (count == 4) return (t___construct(a0, a1, a2, a3), null);
4747         return (t___construct(a0, a1, a2, a3, a4), null);
4748       }
4749       break;
4750     default:
4751       break;
4752   }
4753   return c_ppframe_hash::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
4754 }
4755 Variant c_pptemplateframe_hash::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
4756   return c_ppframe_hash::os_invoke(c, s, params, hash, fatal);
4757 }
4758 Variant cw_pptemplateframe_hash$os_get(const char *s) {
4759   return c_pptemplateframe_hash::os_get(s, -1);
4760 }
4761 Variant &cw_pptemplateframe_hash$os_lval(const char *s) {
4762   return c_pptemplateframe_hash::os_lval(s, -1);
4763 }
4764 Variant cw_pptemplateframe_hash$os_constant(const char *s) {
4765   return c_pptemplateframe_hash::os_constant(s);
4766 }
4767 Variant cw_pptemplateframe_hash$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
4768   return c_pptemplateframe_hash::os_invoke(c, s, params, -1, fatal);
4769 }
4770 void c_pptemplateframe_hash::init() {
4771   c_ppframe_hash::init();
4772   m_numberedArgs = null;
4773   m_namedArgs = null;
4774   m_parent = null;
4775   m_numberedExpansionCache = null;
4776   m_namedExpansionCache = null;
4777 }
4778 /* SRC: Preprocessor_Hash.php line 1188 */
4779 void c_pptemplateframe_hash::t___construct(Variant v_preprocessor, Variant v_parent //  = false
4780 , Variant v_numberedArgs //  = ScalarArrays::sa_[0]
4781 , Variant v_namedArgs //  = ScalarArrays::sa_[0]
4782 , Variant v_title //  = false
4783 ) {
4784   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::__construct);
4785   bool oldInCtor = gasInCtor(true);
4786   Variant v_pdbk;
4787
4788   LINE(1189,c_ppframe_hash::t___construct(v_preprocessor));
4789   (m_parent = v_parent);
4790   (m_numberedArgs = v_numberedArgs);
4791   (m_namedArgs = v_namedArgs);
4792   (m_title = v_title);
4793   (v_pdbk = toBoolean(v_title) ? ((Variant)(LINE(1194,v_title.o_invoke_few_args("getPrefixedDBkey", 0x3E327BDC66DECDABLL, 0)))) : ((Variant)(false)));
4794   (m_titleCache = v_parent.o_get("titleCache", 0x0CD4D2916BE2CE13LL));
4795   m_titleCache.append((v_pdbk));
4796   (m_loopCheckHash = v_parent.o_get("loopCheckHash", 0x757439BA20184735LL));
4797   if (!same(v_pdbk, false)) {
4798     m_loopCheckHash.set(v_pdbk, (true));
4799   }
4800   (m_depth = v_parent.o_get("depth", 0x1AE700EECE6274C7LL) + 1LL);
4801   (m_numberedExpansionCache = (m_namedExpansionCache = ScalarArrays::sa_[0]));
4802   gasInCtor(oldInCtor);
4803 } /* function */
4804 /* SRC: Preprocessor_Hash.php line 1205 */
4805 String c_pptemplateframe_hash::t___tostring() {
4806   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::__toString);
4807   Variant eo_0;
4808   Variant eo_1;
4809   Variant eo_2;
4810   Variant eo_3;
4811   Variant eo_4;
4812   Variant eo_5;
4813   Variant eo_6;
4814   Variant eo_7;
4815   String v_s;
4816   bool v_first = false;
4817   Variant v_args;
4818   Primitive v_name = 0;
4819   Variant v_value;
4820
4821   (v_s = "tplframe{");
4822   (v_first = true);
4823   (v_args = m_numberedArgs + m_namedArgs);
4824   {
4825     LOOP_COUNTER(52);
4826     for (ArrayIterPtr iter54 = v_args.begin("pptemplateframe_hash"); !iter54->end(); iter54->next()) {
4827       LOOP_COUNTER_CHECK(52);
4828       v_value = iter54->second();
4829       v_name = iter54->first();
4830       {
4831         if (v_first) {
4832           (v_first = false);
4833         }
4834         else {
4835           concat_assign(v_s, ", ");
4836         }
4837         concat_assign(v_s, LINE(1216,(assignCallTemp(eo_1, toString(v_name)),assignCallTemp(eo_3, toString((assignCallTemp(eo_7, v_value.o_invoke_few_args("__toString", 0x642C2D2994B34A13LL, 0)),x_str_replace("\"", "\\\"", eo_7)))),concat5("\"", eo_1, "\":\"", eo_3, "\""))));
4838       }
4839     }
4840   }
4841   concat_assign(v_s, "}");
4842   return v_s;
4843 } /* function */
4844 /* SRC: Preprocessor_Hash.php line 1224 */
4845 bool c_pptemplateframe_hash::t_isempty() {
4846   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::isEmpty);
4847   return !(toBoolean(LINE(1225,x_count(m_numberedArgs)))) && !(toBoolean(x_count(m_namedArgs)));
4848 } /* function */
4849 /* SRC: Preprocessor_Hash.php line 1228 */
4850 Variant c_pptemplateframe_hash::t_getarguments() {
4851   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::getArguments);
4852   Variant eo_0;
4853   Variant eo_1;
4854   Variant v_arguments;
4855   Variant v_key;
4856
4857   (v_arguments = ScalarArrays::sa_[0]);
4858   {
4859     LOOP_COUNTER(55);
4860     Variant map56 = LINE(1232,(assignCallTemp(eo_0, LINE(1231,x_array_keys(m_numberedArgs))),assignCallTemp(eo_1, LINE(1232,x_array_keys(m_namedArgs))),x_array_merge(2, eo_0, Array(ArrayInit(1).set(0, eo_1).create()))));
4861     for (ArrayIterPtr iter57 = map56.begin("pptemplateframe_hash"); !iter57->end(); iter57->next()) {
4862       LOOP_COUNTER_CHECK(55);
4863       v_key = iter57->second();
4864       {
4865         v_arguments.set(v_key, (LINE(1233,o_root_invoke_few_args("getArgument", 0x0A95A4780D41F7B8LL, 1, v_key))));
4866       }
4867     }
4868   }
4869   return v_arguments;
4870 } /* function */
4871 /* SRC: Preprocessor_Hash.php line 1238 */
4872 Variant c_pptemplateframe_hash::t_getnumberedarguments() {
4873   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::getNumberedArguments);
4874   Variant v_arguments;
4875   Variant v_key;
4876
4877   (v_arguments = ScalarArrays::sa_[0]);
4878   {
4879     LOOP_COUNTER(58);
4880     Variant map59 = LINE(1240,x_array_keys(m_numberedArgs));
4881     for (ArrayIterPtr iter60 = map59.begin("pptemplateframe_hash"); !iter60->end(); iter60->next()) {
4882       LOOP_COUNTER_CHECK(58);
4883       v_key = iter60->second();
4884       {
4885         v_arguments.set(v_key, (LINE(1241,o_root_invoke_few_args("getArgument", 0x0A95A4780D41F7B8LL, 1, v_key))));
4886       }
4887     }
4888   }
4889   return v_arguments;
4890 } /* function */
4891 /* SRC: Preprocessor_Hash.php line 1246 */
4892 Variant c_pptemplateframe_hash::t_getnamedarguments() {
4893   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::getNamedArguments);
4894   Variant v_arguments;
4895   Variant v_key;
4896
4897   (v_arguments = ScalarArrays::sa_[0]);
4898   {
4899     LOOP_COUNTER(61);
4900     Variant map62 = LINE(1248,x_array_keys(m_namedArgs));
4901     for (ArrayIterPtr iter63 = map62.begin("pptemplateframe_hash"); !iter63->end(); iter63->next()) {
4902       LOOP_COUNTER_CHECK(61);
4903       v_key = iter63->second();
4904       {
4905         v_arguments.set(v_key, (LINE(1249,o_root_invoke_few_args("getArgument", 0x0A95A4780D41F7B8LL, 1, v_key))));
4906       }
4907     }
4908   }
4909   return v_arguments;
4910 } /* function */
4911 /* SRC: Preprocessor_Hash.php line 1254 */
4912 Variant c_pptemplateframe_hash::t_getnumberedargument(CVarRef v_index) {
4913   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::getNumberedArgument);
4914   if (!(isset(m_numberedArgs, v_index))) {
4915     return false;
4916   }
4917   if (!(isset(m_numberedExpansionCache, v_index))) {
4918     m_numberedExpansionCache.set(v_index, (LINE(1260,m_parent.o_invoke_few_args("expand", 0x39B7BB05F05A37CDLL, 2, m_numberedArgs.refvalAt(v_index), throw_fatal("unknown class constant pptemplateframe_hash::STRIP_COMMENTS")))));
4919   }
4920   return m_numberedExpansionCache.rvalAt(v_index);
4921 } /* function */
4922 /* SRC: Preprocessor_Hash.php line 1265 */
4923 Variant c_pptemplateframe_hash::t_getnamedargument(CVarRef v_name) {
4924   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::getNamedArgument);
4925   if (!(isset(m_namedArgs, v_name))) {
4926     return false;
4927   }
4928   if (!(isset(m_namedExpansionCache, v_name))) {
4929     m_namedExpansionCache.set(v_name, (LINE(1272,x_trim(toString(m_parent.o_invoke_few_args("expand", 0x39B7BB05F05A37CDLL, 2, m_namedArgs.refvalAt(v_name), throw_fatal("unknown class constant pptemplateframe_hash::STRIP_COMMENTS")))))));
4930   }
4931   return m_namedExpansionCache.rvalAt(v_name);
4932 } /* function */
4933 /* SRC: Preprocessor_Hash.php line 1277 */
4934 Variant c_pptemplateframe_hash::t_getargument(CVarRef v_name) {
4935   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::getArgument);
4936   Variant v_text;
4937
4938   (v_text = LINE(1278,t_getnumberedargument(v_name)));
4939   if (same(v_text, false)) {
4940     (v_text = LINE(1280,t_getnamedargument(v_name)));
4941   }
4942   return v_text;
4943 } /* function */
4944 /* SRC: Preprocessor_Hash.php line 1288 */
4945 bool c_pptemplateframe_hash::t_istemplate() {
4946   INSTANCE_METHOD_INJECTION(PPTemplateFrame_Hash, PPTemplateFrame_Hash::isTemplate);
4947   return true;
4948 } /* function */
4949 /* SRC: Preprocessor_Hash.php line 1555 */
4950 Variant c_ppnode_hash_array::os_get(const char *s, int64 hash) {
4951   return c_ObjectData::os_get(s, hash);
4952 }
4953 Variant &c_ppnode_hash_array::os_lval(const char *s, int64 hash) {
4954   return c_ObjectData::os_lval(s, hash);
4955 }
4956 void c_ppnode_hash_array::o_get(ArrayElementVec &props) const {
4957   props.push_back(NEW(ArrayElement)("value", m_value.isReferenced() ? ref(m_value) : m_value));
4958   props.push_back(NEW(ArrayElement)("nextSibling", m_nextSibling.isReferenced() ? ref(m_nextSibling) : m_nextSibling));
4959   c_ObjectData::o_get(props);
4960 }
4961 bool c_ppnode_hash_array::o_exists(CStrRef s, int64 hash) const {
4962   if (hash < 0) hash = hash_string(s.data(), s.length());
4963   switch (hash & 3) {
4964     case 1:
4965       HASH_EXISTS_STRING(0x69E7413AE0C88471LL, value, 5);
4966       break;
4967     case 2:
4968       HASH_EXISTS_STRING(0x0B3EC7643EE81822LL, nextSibling, 11);
4969       break;
4970     default:
4971       break;
4972   }
4973   return c_ObjectData::o_exists(s, hash);
4974 }
4975 Variant c_ppnode_hash_array::o_get(CStrRef s, int64 hash) {
4976   if (hash < 0) hash = hash_string(s.data(), s.length());
4977   switch (hash & 3) {
4978     case 1:
4979       HASH_RETURN_STRING(0x69E7413AE0C88471LL, m_value,
4980                          value, 5);
4981       break;
4982     case 2:
4983       HASH_RETURN_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
4984                          nextSibling, 11);
4985       break;
4986     default:
4987       break;
4988   }
4989   return c_ObjectData::o_get(s, hash);
4990 }
4991 Variant c_ppnode_hash_array::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
4992   if (hash < 0) hash = hash_string(s.data(), s.length());
4993   switch (hash & 3) {
4994     case 1:
4995       HASH_SET_STRING(0x69E7413AE0C88471LL, m_value,
4996                       value, 5);
4997       break;
4998     case 2:
4999       HASH_SET_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
5000                       nextSibling, 11);
5001       break;
5002     default:
5003       break;
5004   }
5005   return c_ObjectData::o_set(s, hash, v, forInit);
5006 }
5007 Variant &c_ppnode_hash_array::o_lval(CStrRef s, int64 hash) {
5008   if (hash < 0) hash = hash_string(s.data(), s.length());
5009   switch (hash & 3) {
5010     case 1:
5011       HASH_RETURN_STRING(0x69E7413AE0C88471LL, m_value,
5012                          value, 5);
5013       break;
5014     case 2:
5015       HASH_RETURN_STRING(0x0B3EC7643EE81822LL, m_nextSibling,
5016                          nextSibling, 11);
5017       break;
5018     default:
5019       break;
5020   }
5021   return c_ObjectData::o_lval(s, hash);
5022 }
5023 Variant c_ppnode_hash_array::os_constant(const char *s) {
5024   return c_ObjectData::os_constant(s);
5025 }
5026 IMPLEMENT_CLASS(ppnode_hash_array)
5027 ObjectData *c_ppnode_hash_array::create(Variant v_value) {
5028   init();
5029   t___construct(v_value);
5030   return this;
5031 }
5032 ObjectData *c_ppnode_hash_array::dynCreate(CArrRef params, bool init /* = true */) {
5033   if (init) {
5034     return (create(params.rvalAt(0)));
5035   } else return this;
5036 }
5037 void c_ppnode_hash_array::dynConstruct(CArrRef params) {
5038   (t___construct(params.rvalAt(0)));
5039 }
5040 ObjectData *c_ppnode_hash_array::cloneImpl() {
5041   c_ppnode_hash_array *obj = NEW(c_ppnode_hash_array)();
5042   cloneSet(obj);
5043   return obj;
5044 }
5045 void c_ppnode_hash_array::cloneSet(c_ppnode_hash_array *clone) {
5046   clone->m_value = m_value.isReferenced() ? ref(m_value) : m_value;
5047   clone->m_nextSibling = m_nextSibling.isReferenced() ? ref(m_nextSibling) : m_nextSibling;
5048   ObjectData::cloneSet(clone);
5049 }
5050 Variant c_ppnode_hash_array::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
5051   if (hash < 0) hash = hash_string_i(s);
5052   switch (hash & 31) {
5053     case 0:
5054       HASH_GUARD(0x73E7C3304C0C5360LL, splitarg) {
5055         return (t_splitarg(), null);
5056       }
5057       break;
5058     case 5:
5059       HASH_GUARD(0x23F51CDECC198965LL, getname) {
5060         return (t_getname());
5061       }
5062       break;
5063     case 6:
5064       HASH_GUARD(0x0A41DBE0830902C6LL, item) {
5065         return (t_item(params.rvalAt(0)));
5066       }
5067       break;
5068     case 9:
5069       HASH_GUARD(0x050681239965E069LL, getfirstchild) {
5070         return (t_getfirstchild());
5071       }
5072       break;
5073     case 12:
5074       HASH_GUARD(0x47D4EE3CB3EB696CLL, splitext) {
5075         return (t_splitext(), null);
5076       }
5077       break;
5078     case 13:
5079       HASH_GUARD(0x0621AE2D22A1922DLL, splitheading) {
5080         return (t_splitheading(), null);
5081       }
5082       break;
5083     case 14:
5084       HASH_GUARD(0x5ABDC66291F1CA2ELL, getchildrenoftype) {
5085         return (t_getchildrenoftype(params.rvalAt(0)));
5086       }
5087       break;
5088     case 15:
5089       HASH_GUARD(0x732EC1BDA8EC520FLL, getchildren) {
5090         return (t_getchildren());
5091       }
5092       break;
5093     case 19:
5094       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
5095         return (t___tostring());
5096       }
5097       break;
5098     case 20:
5099       HASH_GUARD(0x41EB078EF92C44D4LL, getlength) {
5100         return (t_getlength());
5101       }
5102       break;
5103     case 25:
5104       HASH_GUARD(0x4CB333CF2D880119LL, getnextsibling) {
5105         return (t_getnextsibling());
5106       }
5107       break;
5108     case 31:
5109       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
5110         return (t___construct(params.rvalAt(0)), null);
5111       }
5112       break;
5113     default:
5114       break;
5115   }
5116   return c_ObjectData::o_invoke(s, params, hash, fatal);
5117 }
5118 Variant c_ppnode_hash_array::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
5119   if (hash < 0) hash = hash_string_i(s);
5120   switch (hash & 31) {
5121     case 0:
5122       HASH_GUARD(0x73E7C3304C0C5360LL, splitarg) {
5123         return (t_splitarg(), null);
5124       }
5125       break;
5126     case 5:
5127       HASH_GUARD(0x23F51CDECC198965LL, getname) {
5128         return (t_getname());
5129       }
5130       break;
5131     case 6:
5132       HASH_GUARD(0x0A41DBE0830902C6LL, item) {
5133         return (t_item(a0));
5134       }
5135       break;
5136     case 9:
5137       HASH_GUARD(0x050681239965E069LL, getfirstchild) {
5138         return (t_getfirstchild());
5139       }
5140       break;
5141     case 12:
5142       HASH_GUARD(0x47D4EE3CB3EB696CLL, splitext) {
5143         return (t_splitext(), null);
5144       }
5145       break;
5146     case 13:
5147       HASH_GUARD(0x0621AE2D22A1922DLL, splitheading) {
5148         return (t_splitheading(), null);
5149       }
5150       break;
5151     case 14:
5152       HASH_GUARD(0x5ABDC66291F1CA2ELL, getchildrenoftype) {
5153         return (t_getchildrenoftype(a0));
5154       }
5155       break;
5156     case 15:
5157       HASH_GUARD(0x732EC1BDA8EC520FLL, getchildren) {
5158         return (t_getchildren());
5159       }
5160       break;
5161     case 19:
5162       HASH_GUARD(0x642C2D2994B34A13LL, __tostring) {
5163         return (t___tostring());
5164       }
5165       break;
5166     case 20:
5167       HASH_GUARD(0x41EB078EF92C44D4LL, getlength) {
5168         return (t_getlength());
5169       }
5170       break;
5171     case 25:
5172       HASH_GUARD(0x4CB333CF2D880119LL, getnextsibling) {
5173         return (t_getnextsibling());
5174       }
5175       break;
5176     case 31:
5177       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
5178         return (t___construct(a0), null);
5179       }
5180       break;
5181     default:
5182       break;
5183   }
5184   return c_ObjectData::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
5185 }
5186 Variant c_ppnode_hash_array::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
5187   return c_ObjectData::os_invoke(c, s, params, hash, fatal);
5188 }
5189 Variant cw_ppnode_hash_array$os_get(const char *s) {
5190   return c_ppnode_hash_array::os_get(s, -1);
5191 }
5192 Variant &cw_ppnode_hash_array$os_lval(const char *s) {
5193   return c_ppnode_hash_array::os_lval(s, -1);
5194 }
5195 Variant cw_ppnode_hash_array$os_constant(const char *s) {
5196   return c_ppnode_hash_array::os_constant(s);
5197 }
5198 Variant cw_ppnode_hash_array$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
5199   return c_ppnode_hash_array::os_invoke(c, s, params, -1, fatal);
5200 }
5201 void c_ppnode_hash_array::init() {
5202   m_value = null;
5203   m_nextSibling = null;
5204 }
5205 /* SRC: Preprocessor_Hash.php line 1558 */
5206 void c_ppnode_hash_array::t___construct(Variant v_value) {
5207   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::__construct);
5208   bool oldInCtor = gasInCtor(true);
5209   (m_value = v_value);
5210   gasInCtor(oldInCtor);
5211 } /* function */
5212 /* SRC: Preprocessor_Hash.php line 1562 */
5213 String c_ppnode_hash_array::t___tostring() {
5214   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::__toString);
5215   return toString(LINE(1563,x_var_export(((Object)(this)), true)));
5216 } /* function */
5217 /* SRC: Preprocessor_Hash.php line 1566 */
5218 int c_ppnode_hash_array::t_getlength() {
5219   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::getLength);
5220   return LINE(1567,x_count(m_value));
5221 } /* function */
5222 /* SRC: Preprocessor_Hash.php line 1570 */
5223 Variant c_ppnode_hash_array::t_item(CVarRef v_i) {
5224   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::item);
5225   return m_value.rvalAt(v_i);
5226 } /* function */
5227 /* SRC: Preprocessor_Hash.php line 1574 */
5228 String c_ppnode_hash_array::t_getname() {
5229   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::getName);
5230   return "#nodelist";
5231 } /* function */
5232 /* SRC: Preprocessor_Hash.php line 1576 */
5233 Variant c_ppnode_hash_array::t_getnextsibling() {
5234   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::getNextSibling);
5235   return m_nextSibling;
5236 } /* function */
5237 /* SRC: Preprocessor_Hash.php line 1580 */
5238 bool c_ppnode_hash_array::t_getchildren() {
5239   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::getChildren);
5240   return false;
5241 } /* function */
5242 /* SRC: Preprocessor_Hash.php line 1581 */
5243 bool c_ppnode_hash_array::t_getfirstchild() {
5244   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::getFirstChild);
5245   return false;
5246 } /* function */
5247 /* SRC: Preprocessor_Hash.php line 1582 */
5248 bool c_ppnode_hash_array::t_getchildrenoftype(CVarRef v_name) {
5249   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::getChildrenOfType);
5250   return false;
5251 } /* function */
5252 /* SRC: Preprocessor_Hash.php line 1583 */
5253 void c_ppnode_hash_array::t_splitarg() {
5254   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::splitArg);
5255   throw_exception(LINE(1583,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Array::splitArg: not supported").create()))));
5256 } /* function */
5257 /* SRC: Preprocessor_Hash.php line 1584 */
5258 void c_ppnode_hash_array::t_splitext() {
5259   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::splitExt);
5260   throw_exception(LINE(1584,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Array::splitExt: not supported").create()))));
5261 } /* function */
5262 /* SRC: Preprocessor_Hash.php line 1585 */
5263 void c_ppnode_hash_array::t_splitheading() {
5264   INSTANCE_METHOD_INJECTION(PPNode_Hash_Array, PPNode_Hash_Array::splitHeading);
5265   throw_exception(LINE(1585,create_object("mwexception", Array(ArrayInit(1).set(0, "PPNode_Hash_Array::splitHeading: not supported").create()))));
5266 } /* function */
5267 /* SRC: Preprocessor_Hash.php line 677 */
5268 Variant c_ppdstackelement_hash::os_get(const char *s, int64 hash) {
5269   return c_ppdstackelement::os_get(s, hash);
5270 }
5271 Variant &c_ppdstackelement_hash::os_lval(const char *s, int64 hash) {
5272   return c_ppdstackelement::os_lval(s, hash);
5273 }
5274 void c_ppdstackelement_hash::o_get(ArrayElementVec &props) const {
5275   c_ppdstackelement::o_get(props);
5276 }
5277 bool c_ppdstackelement_hash::o_exists(CStrRef s, int64 hash) const {
5278   return c_ppdstackelement::o_exists(s, hash);
5279 }
5280 Variant c_ppdstackelement_hash::o_get(CStrRef s, int64 hash) {
5281   return c_ppdstackelement::o_get(s, hash);
5282 }
5283 Variant c_ppdstackelement_hash::o_set(CStrRef s, int64 hash, CVarRef v,bool forInit /* = false */) {
5284   return c_ppdstackelement::o_set(s, hash, v, forInit);
5285 }
5286 Variant &c_ppdstackelement_hash::o_lval(CStrRef s, int64 hash) {
5287   return c_ppdstackelement::o_lval(s, hash);
5288 }
5289 Variant c_ppdstackelement_hash::os_constant(const char *s) {
5290   return c_ppdstackelement::os_constant(s);
5291 }
5292 IMPLEMENT_CLASS(ppdstackelement_hash)
5293 ObjectData *c_ppdstackelement_hash::create(Variant v_data //  = ScalarArrays::sa_[0]
5294 ) {
5295   init();
5296   t___construct(v_data);
5297   return this;
5298 }
5299 ObjectData *c_ppdstackelement_hash::dynCreate(CArrRef params, bool init /* = true */) {
5300   if (init) {
5301     int count = params.size();
5302     if (count <= 0) return (create());
5303     return (create(params.rvalAt(0)));
5304   } else return this;
5305 }
5306 void c_ppdstackelement_hash::dynConstruct(CArrRef params) {
5307   int count = params.size();
5308   if (count <= 0) (t___construct());
5309   (t___construct(params.rvalAt(0)));
5310 }
5311 ObjectData *c_ppdstackelement_hash::cloneImpl() {
5312   c_ppdstackelement_hash *obj = NEW(c_ppdstackelement_hash)();
5313   cloneSet(obj);
5314   return obj;
5315 }
5316 void c_ppdstackelement_hash::cloneSet(c_ppdstackelement_hash *clone) {
5317   c_ppdstackelement::cloneSet(clone);
5318 }
5319 Variant c_ppdstackelement_hash::o_invoke(const char *s, CArrRef params, int64 hash, bool fatal) {
5320   if (hash < 0) hash = hash_string_i(s);
5321   switch (hash & 15) {
5322     case 1:
5323       HASH_GUARD(0x27E7DBA875AD17E1LL, getflags) {
5324         return (t_getflags());
5325       }
5326       break;
5327     case 2:
5328       HASH_GUARD(0x499E72B719A4CAC2LL, addpart) {
5329         int count = params.size();
5330         if (count <= 0) return (t_addpart(), null);
5331         return (t_addpart(params.rvalAt(0)), null);
5332       }
5333       break;
5334     case 6:
5335       HASH_GUARD(0x1A5F5A2CB292E516LL, getaccum) {
5336         return ref(t_getaccum());
5337       }
5338       break;
5339     case 9:
5340       HASH_GUARD(0x1CF88FA5EFC88C39LL, breaksyntax) {
5341         int count = params.size();
5342         if (count <= 0) return (t_breaksyntax());
5343         return (t_breaksyntax(params.rvalAt(0)));
5344       }
5345       break;
5346     case 12:
5347       HASH_GUARD(0x1726802D706D7BECLL, getcurrentpart) {
5348         return (t_getcurrentpart());
5349       }
5350       break;
5351     case 15:
5352       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
5353         int count = params.size();
5354         if (count <= 0) return (t___construct(), null);
5355         return (t___construct(params.rvalAt(0)), null);
5356       }
5357       break;
5358     default:
5359       break;
5360   }
5361   return c_ppdstackelement::o_invoke(s, params, hash, fatal);
5362 }
5363 Variant c_ppdstackelement_hash::o_invoke_few_args(const char *s, int64 hash, int count, CVarRef a0, CVarRef a1, CVarRef a2, CVarRef a3, CVarRef a4, CVarRef a5) {
5364   if (hash < 0) hash = hash_string_i(s);
5365   switch (hash & 15) {
5366     case 1:
5367       HASH_GUARD(0x27E7DBA875AD17E1LL, getflags) {
5368         return (t_getflags());
5369       }
5370       break;
5371     case 2:
5372       HASH_GUARD(0x499E72B719A4CAC2LL, addpart) {
5373         if (count <= 0) return (t_addpart(), null);
5374         return (t_addpart(a0), null);
5375       }
5376       break;
5377     case 6:
5378       HASH_GUARD(0x1A5F5A2CB292E516LL, getaccum) {
5379         return ref(t_getaccum());
5380       }
5381       break;
5382     case 9:
5383       HASH_GUARD(0x1CF88FA5EFC88C39LL, breaksyntax) {
5384         if (count <= 0) return (t_breaksyntax());
5385         return (t_breaksyntax(a0));
5386       }
5387       break;
5388     case 12:
5389       HASH_GUARD(0x1726802D706D7BECLL, getcurrentpart) {
5390         return (t_getcurrentpart());
5391       }
5392       break;
5393     case 15:
5394       HASH_GUARD(0x0D31D0AC229C615FLL, __construct) {
5395         if (count <= 0) return (t___construct(), null);
5396         return (t___construct(a0), null);
5397       }
5398       break;
5399     default:
5400       break;
5401   }
5402   return c_ppdstackelement::o_invoke_few_args(s, hash, count, a0, a1, a2, a3, a4, a5);
5403 }
5404 Variant c_ppdstackelement_hash::os_invoke(const char *c, const char *s, CArrRef params, int64 hash, bool fatal) {
5405   return c_ppdstackelement::os_invoke(c, s, params, hash, fatal);
5406 }
5407 Variant cw_ppdstackelement_hash$os_get(const char *s) {
5408   return c_ppdstackelement_hash::os_get(s, -1);
5409 }
5410 Variant &cw_ppdstackelement_hash$os_lval(const char *s) {
5411   return c_ppdstackelement_hash::os_lval(s, -1);
5412 }
5413 Variant cw_ppdstackelement_hash$os_constant(const char *s) {
5414   return c_ppdstackelement_hash::os_constant(s);
5415 }
5416 Variant cw_ppdstackelement_hash$os_invoke(const char *c, const char *s, CArrRef params, bool fatal /* = true */) {
5417   return c_ppdstackelement_hash::os_invoke(c, s, params, -1, fatal);
5418 }
5419 void c_ppdstackelement_hash::init() {
5420   c_ppdstackelement::init();
5421 }
5422 /* SRC: Preprocessor_Hash.php line 678 */
5423 void c_ppdstackelement_hash::t___construct(Variant v_data //  = ScalarArrays::sa_[0]
5424 ) {
5425   INSTANCE_METHOD_INJECTION(PPDStackElement_Hash, PPDStackElement_Hash::__construct);
5426   bool oldInCtor = gasInCtor(true);
5427   (m_partClass = "PPDPart_Hash");
5428   LINE(680,c_ppdstackelement::t___construct(v_data));
5429   gasInCtor(oldInCtor);
5430 } /* function */
5431 /* SRC: Preprocessor_Hash.php line 686 */
5432 Variant c_ppdstackelement_hash::t_breaksyntax(Variant v_openingCount //  = false
5433 ) {
5434   INSTANCE_METHOD_INJECTION(PPDStackElement_Hash, PPDStackElement_Hash::breakSyntax);
5435   Variant v_accum;
5436   bool v_first = false;
5437   Variant v_part;
5438
5439   if (equal(m_open, "\n")) {
5440     (v_accum = m_parts.rvalAt(0LL, 0x77CFA1EEF01BCA90LL).o_get("out", 0x7C801AC012E9F722LL));
5441   }
5442   else {
5443     if (same(v_openingCount, false)) {
5444       (v_openingCount = m_count);
5445     }
5446     (v_accum = ((Object)(LINE(693,p_ppdaccum_hash(p_ppdaccum_hash(NEWOBJ(c_ppdaccum_hash)())->create())))));
5447     LINE(694,v_accum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, x_str_repeat(toString(m_open), toInt32(v_openingCount))));
5448     (v_first = true);
5449     {
5450       LOOP_COUNTER(64);
5451       Variant map65 = m_parts;
5452       for (ArrayIterPtr iter66 = map65.begin("ppdstackelement_hash"); !iter66->end(); iter66->next()) {
5453         LOOP_COUNTER_CHECK(64);
5454         v_part = iter66->second();
5455         {
5456           if (v_first) {
5457             (v_first = false);
5458           }
5459           else {
5460             LINE(700,v_accum.o_invoke_few_args("addLiteral", 0x05AAC40C7DAD4ACELL, 1, "|"));
5461           }
5462           LINE(702,v_accum.o_invoke_few_args("addAccum", 0x6A8DCEFA6345DAC9LL, 1, v_part.o_lval("out", 0x7C801AC012E9F722LL)));
5463         }
5464       }
5465     }
5466   }
5467   return v_accum;
5468 } /* function */
5469 Object co_ppdstack_hash(CArrRef params, bool init /* = true */) {
5470   return Object(p_ppdstack_hash(NEW(c_ppdstack_hash)())->dynCreate(params, init));
5471 }
5472 Object co_ppnode_hash_text(CArrRef params, bool init /* = true */) {
5473   return Object(p_ppnode_hash_text(NEW(c_ppnode_hash_text)())->dynCreate(params, init));
5474 }
5475 Object co_ppdaccum_hash(CArrRef params, bool init /* = true */) {
5476   return Object(p_ppdaccum_hash(NEW(c_ppdaccum_hash)())->dynCreate(params, init));
5477 }
5478 Object co_ppnode_hash_tree(CArrRef params, bool init /* = true */) {
5479   return Object(p_ppnode_hash_tree(NEW(c_ppnode_hash_tree)())->dynCreate(params, init));
5480 }
5481 Object co_ppframe_hash(CArrRef params, bool init /* = true */) {
5482   return Object(p_ppframe_hash(NEW(c_ppframe_hash)())->dynCreate(params, init));
5483 }
5484 Object co_preprocessor_hash(CArrRef params, bool init /* = true */) {
5485   return Object(p_preprocessor_hash(NEW(c_preprocessor_hash)())->dynCreate(params, init));
5486 }
5487 Object co_ppdpart_hash(CArrRef params, bool init /* = true */) {
5488   return Object(p_ppdpart_hash(NEW(c_ppdpart_hash)())->dynCreate(params, init));
5489 }
5490 Object co_ppcustomframe_hash(CArrRef params, bool init /* = true */) {
5491   return Object(p_ppcustomframe_hash(NEW(c_ppcustomframe_hash)())->dynCreate(params, init));
5492 }
5493 Object co_ppnode_hash_attr(CArrRef params, bool init /* = true */) {
5494   return Object(p_ppnode_hash_attr(NEW(c_ppnode_hash_attr)())->dynCreate(params, init));
5495 }
5496 Object co_pptemplateframe_hash(CArrRef params, bool init /* = true */) {
5497   return Object(p_pptemplateframe_hash(NEW(c_pptemplateframe_hash)())->dynCreate(params, init));
5498 }
5499 Object co_ppnode_hash_array(CArrRef params, bool init /* = true */) {
5500   return Object(p_ppnode_hash_array(NEW(c_ppnode_hash_array)())->dynCreate(params, init));
5501 }
5502 Object co_ppdstackelement_hash(CArrRef params, bool init /* = true */) {
5503   return Object(p_ppdstackelement_hash(NEW(c_ppdstackelement_hash)())->dynCreate(params, init));
5504 }
5505 Variant pm_php$Preprocessor_Hash_php(bool incOnce /* = false */, LVariableTable* variables /* = NULL */) {
5506   FUNCTION_INJECTION(run_init::Preprocessor_Hash.php);
5507   {
5508     DECLARE_GLOBAL_VARIABLES(g);
5509     bool &alreadyRun = g->run_pm_php$Preprocessor_Hash_php;
5510     if (alreadyRun) { if (incOnce) return true;}
5511     else alreadyRun = true;
5512     if (!variables) variables = g;
5513   }
5514   DECLARE_GLOBAL_VARIABLES(g);
5515   LVariableTable *gVariables __attribute__((__unused__)) = get_variable_table();
5516   return true;
5517 } /* function */
5518
5519 ///////////////////////////////////////////////////////////////////////////////
5520 }