hphp/hack/test/typecheck/intersect_huge.php

   1 <?hh
   2 /**
   3  * Copyright (c) 2014, Facebook, Inc.
   4  * All rights reserved.
   5  *
   6  * This source code is licensed under the BSD-style license found in the
   7  * LICENSE file in the "hack" directory of this source tree. An additional grant
   8  * of patent rights can be found in the PATENTS file in the same directory.
   9  *
  10  */
  11
  12 abstract class TType {
  13   const STOP   = 0;
  14   const VOID   = 1;
  15   const BOOL   = 2;
  16   const BYTE   = 3;
  17   const I08    = 3;
  18   const DOUBLE = 4;
  19   const I16    = 6;
  20   const I32    = 8;
  21   const I64    = 10;
  22   const STRING = 11;
  23   const UTF7   = 11;
  24   const STRUCT = 12;
  25   const MAP    = 13;
  26   const SET    = 14;
  27   const LST    = 15;
  28   const UTF8   = 16;
  29   const UTF16  = 17;
  30   const FLOAT  = 19;
  31 }
  32
  33 class C {
  34   public string $ivar1;
  35   public string $ivar2;
  36   public string $ivar3;
  37   public int $ivar4;
  38   public string $ivar5;
  39   public string $ivar6;
  40   public string $ivar7;
  41   public bool $ivar8;
  42   public ?Ty1 $ivar9;
  43   public Vector<string> $ivar10;
  44   public Vector<Ty2> $ivar11;
  45   public ?Ty2 $ivar12;
  46   public Vector<string> $ivar13;
  47   public Map<string, string> $ivar14;
  48   public int $ivar15;
  49   public bool $ivar16;
  50   public Map<string, string> $ivar17;
  51   public string $ivar18;
  52   public string $ivar19;
  53   public int $ivar20;
  54   public int $ivar21;
  55   public Vector<string> $ivar22;
  56   public Map<string, Ty3> $ivar23;
  57   public ?Ty4 $ivar24;
  58   public int $ivar25;
  59   public int $ivar26;
  60   public Vector<string> $ivar27;
  61   public Vector<string> $ivar28;
  62   public string $ivar29;
  63   public string $ivar30;
  64   public ?Ty5 $ivar31;
  65   public Vector<string> $ivar32;
  66   public Vector<Ty2> $ivar33;
  67   public int $ivar34;
  68   public bool $ivar35;
  69   public Vector<Ty2> $ivar36;
  70   public Vector<string> $ivar37;
  71   public string $ivar38;
  72   public string $ivar39;
  73   public string $ivar40;
  74   public string $ivar41;
  75   public ?Ty6 $ivar42;
  76   public int $ivar43;
  77   public ?Ty7 $ivar44;
  78   public string $ivar45;
  79   public Map<string, string> $ivar46;
  80   public Map<string, string> $ivar47;
  81   public Vector<Ty8> $ivar48;
  82   public int $ivar49;
  83   public ?Ty3 $ivar50;
  84   public Map<int, Ty9> $ivar51;
  85   public ?Ty10 $ivar52;
  86   public string $ivar53;
  87
  88   public function __construct(?Indexish<string, mixed> $vals = null) {
  89     $this->ivar1 = (string)untyped_idx($vals, 'ivar1', '');
  90     $this->ivar2 = (string)untyped_idx($vals, 'ivar2', '');
  91     $this->ivar3 = (string)untyped_idx($vals, 'ivar3', '');
  92     $this->ivar4 = (int)untyped_idx($vals, 'ivar4', 0);
  93     $this->ivar5 = (string)untyped_idx($vals, 'ivar5', '');
  94     $this->ivar6 = (string)untyped_idx($vals, 'ivar6', '');
  95     $this->ivar7 = (string)untyped_idx($vals, 'ivar7', '');
  96     $this->ivar8 = (bool)untyped_idx($vals, 'ivar8', false);
  97     $this->ivar9 = untyped_idx($vals, 'ivar9', null);
  98     $this->ivar10 = untyped_idx($vals, 'ivar10', Vector {});
  99     $this->ivar11 = untyped_idx($vals, 'ivar11', Vector {});
 100     $this->ivar12 = untyped_idx($vals, 'ivar12', null);
 101     $this->ivar13 = untyped_idx($vals, 'ivar13', Vector {});
 102     $this->ivar14 = untyped_idx($vals, 'ivar14', Map {});
 103     $this->ivar15 = (int)untyped_idx($vals, 'ivar15', 0);
 104     $this->ivar16 = (bool)untyped_idx($vals, 'ivar16', false);
 105     $this->ivar17 = untyped_idx($vals, 'ivar17', Map {});
 106     $this->ivar18 = (string)untyped_idx($vals, 'ivar18', '');
 107     $this->ivar19 = (string)untyped_idx($vals, 'ivar19', '');
 108     $this->ivar20 = (int)untyped_idx($vals, 'ivar20', 0);
 109     $this->ivar21 = (int)untyped_idx($vals, 'ivar21', 0);
 110     $this->ivar22 = untyped_idx($vals, 'ivar22', Vector {});
 111     $this->ivar23 = untyped_idx($vals, 'ivar23', Map {});
 112     $this->ivar24 = untyped_idx($vals, 'ivar24', null);
 113     $this->ivar25 = (int)untyped_idx($vals, 'ivar25', 0);
 114     $this->ivar26 = (int)untyped_idx($vals, 'ivar26', 0);
 115     $this->ivar27 = untyped_idx($vals, 'ivar27', Vector {});
 116     $this->ivar28 = untyped_idx($vals, 'ivar28', Vector {});
 117     $this->ivar29 = (string)untyped_idx($vals, 'ivar29', '');
 118     $this->ivar30 = (string)untyped_idx($vals, 'ivar30', '');
 119     $this->ivar31 = untyped_idx($vals, 'ivar31', null);
 120     $this->ivar32 = untyped_idx($vals, 'ivar32', Vector {});
 121     $this->ivar33 = untyped_idx($vals, 'ivar33', Vector {});
 122     $this->ivar34 = (int)untyped_idx($vals, 'ivar34', 0);
 123     $this->ivar35 = (bool)untyped_idx($vals, 'ivar35', false);
 124     $this->ivar36 = untyped_idx($vals, 'ivar36', Vector {});
 125     $this->ivar37 = untyped_idx($vals, 'ivar37', Vector {});
 126     $this->ivar38 = (string)untyped_idx($vals, 'ivar38', '');
 127     $this->ivar39 = (string)untyped_idx($vals, 'ivar39', '');
 128     $this->ivar40 = (string)untyped_idx($vals, 'ivar40', '');
 129     $this->ivar41 = (string)untyped_idx($vals, 'ivar41', '');
 130     $this->ivar42 = untyped_idx($vals, 'ivar42', null);
 131     $this->ivar43 = (int)untyped_idx($vals, 'ivar43', 0);
 132     $this->ivar44 = untyped_idx($vals, 'ivar44', null);
 133     $this->ivar45 = (string)untyped_idx($vals, 'ivar45', '');
 134     $this->ivar46 = untyped_idx($vals, 'ivar46', Map {});
 135     $this->ivar47 = untyped_idx($vals, 'ivar47', Map {});
 136     $this->ivar48 = untyped_idx($vals, 'ivar48', Vector {});
 137     $this->ivar49 = (int)untyped_idx($vals, 'ivar49', 0);
 138     $this->ivar50 = untyped_idx($vals, 'ivar50', null);
 139     $this->ivar51 = untyped_idx($vals, 'ivar51', Map {});
 140     $this->ivar52 = untyped_idx($vals, 'ivar52', null);
 141     $this->ivar53 = (string)untyped_idx($vals, 'ivar53', '');
 142   }
 143
 144   public function read(TProtocol $input) : int {
 145     $xfer = 0;
 146     $fname = null;
 147     $ftype = 0;
 148     $fid = 0;
 149     $xfer += $input->readStructBegin($fname);
 150     while (true)
 151     {
 152       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
 153       if ($ftype == TType::STOP) {
 154         break;
 155       }
 156       switch ($fid)
 157       {
 158         case 6:
 159           if ($ftype == TType::STRING) {
 160             $xfer += $input->readString($this->ivar1);
 161           } else {
 162             $xfer += $input->skip($ftype);
 163           }
 164           break;
 165         case 7:
 166           if ($ftype == TType::STRING) {
 167             $xfer += $input->readString($this->ivar2);
 168           } else {
 169             $xfer += $input->skip($ftype);
 170           }
 171           break;
 172         case 8:
 173           if ($ftype == TType::STRING) {
 174             $xfer += $input->readString($this->ivar3);
 175           } else {
 176             $xfer += $input->skip($ftype);
 177           }
 178           break;
 179         case 10:
 180           if ($ftype == TType::I64) {
 181             $xfer += $input->readI64($this->ivar4);
 182           } else {
 183             $xfer += $input->skip($ftype);
 184           }
 185           break;
 186         case 11:
 187           if ($ftype == TType::STRING) {
 188             $xfer += $input->readString($this->ivar5);
 189           } else {
 190             $xfer += $input->skip($ftype);
 191           }
 192           break;
 193         case 12:
 194           if ($ftype == TType::STRING) {
 195             $xfer += $input->readString($this->ivar6);
 196           } else {
 197             $xfer += $input->skip($ftype);
 198           }
 199           break;
 200         case 14:
 201           if ($ftype == TType::STRING) {
 202             $xfer += $input->readString($this->ivar7);
 203           } else {
 204             $xfer += $input->skip($ftype);
 205           }
 206           break;
 207         case 15:
 208           if ($ftype == TType::BOOL) {
 209             $xfer += $input->readBool($this->ivar8);
 210           } else {
 211             $xfer += $input->skip($ftype);
 212           }
 213           break;
 214         case 18:
 215           if ($ftype == TType::STRUCT) {
 216             $this->ivar9 = new Ty1();
 217             $xfer += $this->ivar9->read($input);
 218           } else {
 219             $xfer += $input->skip($ftype);
 220           }
 221           break;
 222         case 20:
 223           if ($ftype == TType::LST) {
 224             $_size443 = 0;
 225             $_val442 = Vector {};
 226             $_etype446 = 0;
 227             $xfer += $input->readListBegin($_etype446, $_size443);
 228             for ($_i447 = 0; $_i447 < $_size443; ++$_i447)
 229             {
 230               $elem448 = null;
 231               $xfer += $input->readString($elem448);
 232               if ($elem448 !== null) {
 233                 $_val442 []= $elem448;
 234               }
 235             }
 236             $xfer += $input->readListEnd();
 237             $this->ivar10 = $_val442;
 238           } else {
 239             $xfer += $input->skip($ftype);
 240           }
 241           break;
 242         case 21:
 243           if ($ftype == TType::LST) {
 244             $_size450 = 0;
 245             $_val449 = Vector {};
 246             $_etype453 = 0;
 247             $xfer += $input->readListBegin($_etype453, $_size450);
 248             for ($_i454 = 0; $_i454 < $_size450; ++$_i454)
 249             {
 250               $elem455 = null;
 251               $elem455 = new Ty2();
 252               $xfer += $elem455->read($input);
 253               if ($elem455 !== null) {
 254                 $_val449 []= $elem455;
 255               }
 256             }
 257             $xfer += $input->readListEnd();
 258             $this->ivar11 = $_val449;
 259           } else {
 260             $xfer += $input->skip($ftype);
 261           }
 262           break;
 263         case 22:
 264           if ($ftype == TType::STRUCT) {
 265             $this->ivar12 = new Ty2();
 266             $xfer += $this->ivar12->read($input);
 267           } else {
 268             $xfer += $input->skip($ftype);
 269           }
 270           break;
 271         case 23:
 272           if ($ftype == TType::LST) {
 273             $_size457 = 0;
 274             $_val456 = Vector {};
 275             $_etype460 = 0;
 276             $xfer += $input->readListBegin($_etype460, $_size457);
 277             for ($_i461 = 0; $_i461 < $_size457; ++$_i461)
 278             {
 279               $elem462 = null;
 280               $xfer += $input->readString($elem462);
 281               if ($elem462 !== null) {
 282                 $_val456 []= $elem462;
 283               }
 284             }
 285             $xfer += $input->readListEnd();
 286             $this->ivar13 = $_val456;
 287           } else {
 288             $xfer += $input->skip($ftype);
 289           }
 290           break;
 291         case 26:
 292           if ($ftype == TType::MAP) {
 293             $_size464 = 0;
 294             $_val463 = Map {};
 295             $_ktype465 = 0;
 296             $_vtype466 = 0;
 297             $xfer += $input->readMapBegin($_ktype465, $_vtype466, $_size464);
 298             for ($_i468 = 0; $_i468 < $_size464; ++$_i468)
 299             {
 300               $key469 = '';
 301               $val470 = '';
 302               $xfer += $input->readString($key469);
 303               $xfer += $input->readString($val470);
 304               if ($key469 !== null && $val470 !== null) {
 305                 $_val463[$key469] = $val470;
 306               }
 307             }
 308             $xfer += $input->readMapEnd();
 309             $this->ivar14 = $_val463;
 310           } else {
 311             $xfer += $input->skip($ftype);
 312           }
 313           break;
 314         case 27:
 315           if ($ftype == TType::I64) {
 316             $xfer += $input->readI64($this->ivar15);
 317           } else {
 318             $xfer += $input->skip($ftype);
 319           }
 320           break;
 321         case 32:
 322           if ($ftype == TType::BOOL) {
 323             $xfer += $input->readBool($this->ivar16);
 324           } else {
 325             $xfer += $input->skip($ftype);
 326           }
 327           break;
 328         case 33:
 329           if ($ftype == TType::MAP) {
 330             $_size472 = 0;
 331             $_val471 = Map {};
 332             $_ktype473 = 0;
 333             $_vtype474 = 0;
 334             $xfer += $input->readMapBegin($_ktype473, $_vtype474, $_size472);
 335             for ($_i476 = 0; $_i476 < $_size472; ++$_i476)
 336             {
 337               $key477 = '';
 338               $val478 = '';
 339               $xfer += $input->readString($key477);
 340               $xfer += $input->readString($val478);
 341               if ($key477 !== null && $val478 !== null) {
 342                 $_val471[$key477] = $val478;
 343               }
 344             }
 345             $xfer += $input->readMapEnd();
 346             $this->ivar17 = $_val471;
 347           } else {
 348             $xfer += $input->skip($ftype);
 349           }
 350           break;
 351         case 34:
 352           if ($ftype == TType::STRING) {
 353             $xfer += $input->readString($this->ivar18);
 354           } else {
 355             $xfer += $input->skip($ftype);
 356           }
 357           break;
 358         case 37:
 359           if ($ftype == TType::STRING) {
 360             $xfer += $input->readString($this->ivar19);
 361           } else {
 362             $xfer += $input->skip($ftype);
 363           }
 364           break;
 365         case 38:
 366           if ($ftype == TType::I64) {
 367             $xfer += $input->readI64($this->ivar20);
 368           } else {
 369             $xfer += $input->skip($ftype);
 370           }
 371           break;
 372         case 39:
 373           if ($ftype == TType::I64) {
 374             $xfer += $input->readI64($this->ivar21);
 375           } else {
 376             $xfer += $input->skip($ftype);
 377           }
 378           break;
 379         case 40:
 380           if ($ftype == TType::LST) {
 381             $_size480 = 0;
 382             $_val479 = Vector {};
 383             $_etype483 = 0;
 384             $xfer += $input->readListBegin($_etype483, $_size480);
 385             for ($_i484 = 0; $_i484 < $_size480; ++$_i484)
 386             {
 387               $elem485 = null;
 388               $xfer += $input->readString($elem485);
 389               if ($elem485 !== null) {
 390                 $_val479 []= $elem485;
 391               }
 392             }
 393             $xfer += $input->readListEnd();
 394             $this->ivar22 = $_val479;
 395           } else {
 396             $xfer += $input->skip($ftype);
 397           }
 398           break;
 399         case 41:
 400           if ($ftype == TType::MAP) {
 401             $_size487 = 0;
 402             $_val486 = Map {};
 403             $_ktype488 = 0;
 404             $_vtype489 = 0;
 405             $xfer += $input->readMapBegin($_ktype488, $_vtype489, $_size487);
 406             for ($_i491 = 0; $_i491 < $_size487; ++$_i491)
 407             {
 408               $key492 = '';
 409               $val493 = new Ty3();
 410               $xfer += $input->readString($key492);
 411               $val493 = new Ty3();
 412               $xfer += $val493->read($input);
 413               if ($key492 !== null && $val493 !== null) {
 414                 $_val486[$key492] = $val493;
 415               }
 416             }
 417             $xfer += $input->readMapEnd();
 418             $this->ivar23 = $_val486;
 419           } else {
 420             $xfer += $input->skip($ftype);
 421           }
 422           break;
 423         case 44:
 424           if ($ftype == TType::STRUCT) {
 425             $this->ivar24 = new Ty4();
 426             $xfer += $this->ivar24->read($input);
 427           } else {
 428             $xfer += $input->skip($ftype);
 429           }
 430           break;
 431         case 45:
 432           if ($ftype == TType::I64) {
 433             $xfer += $input->readI64($this->ivar25);
 434           } else {
 435             $xfer += $input->skip($ftype);
 436           }
 437           break;
 438         case 46:
 439           if ($ftype == TType::I32) {
 440             $xfer += $input->readI32($this->ivar26);
 441           } else {
 442             $xfer += $input->skip($ftype);
 443           }
 444           break;
 445         case 47:
 446           if ($ftype == TType::LST) {
 447             $_size495 = 0;
 448             $_val494 = Vector {};
 449             $_etype498 = 0;
 450             $xfer += $input->readListBegin($_etype498, $_size495);
 451             for ($_i499 = 0; $_i499 < $_size495; ++$_i499)
 452             {
 453               $elem500 = null;
 454               $xfer += $input->readString($elem500);
 455               if ($elem500 !== null) {
 456                 $_val494 []= $elem500;
 457               }
 458             }
 459             $xfer += $input->readListEnd();
 460             $this->ivar27 = $_val494;
 461           } else {
 462             $xfer += $input->skip($ftype);
 463           }
 464           break;
 465         case 48:
 466           if ($ftype == TType::LST) {
 467             $_size502 = 0;
 468             $_val501 = Vector {};
 469             $_etype505 = 0;
 470             $xfer += $input->readListBegin($_etype505, $_size502);
 471             for ($_i506 = 0; $_i506 < $_size502; ++$_i506)
 472             {
 473               $elem507 = null;
 474               $xfer += $input->readString($elem507);
 475               if ($elem507 !== null) {
 476                 $_val501 []= $elem507;
 477               }
 478             }
 479             $xfer += $input->readListEnd();
 480             $this->ivar28 = $_val501;
 481           } else {
 482             $xfer += $input->skip($ftype);
 483           }
 484           break;
 485         case 49:
 486           if ($ftype == TType::STRING) {
 487             $xfer += $input->readString($this->ivar29);
 488           } else {
 489             $xfer += $input->skip($ftype);
 490           }
 491           break;
 492         case 50:
 493           if ($ftype == TType::STRING) {
 494             $xfer += $input->readString($this->ivar30);
 495           } else {
 496             $xfer += $input->skip($ftype);
 497           }
 498           break;
 499         case 51:
 500           if ($ftype == TType::STRUCT) {
 501             $this->ivar31 = new Ty5();
 502             $xfer += $this->ivar31->read($input);
 503           } else {
 504             $xfer += $input->skip($ftype);
 505           }
 506           break;
 507         case 52:
 508           if ($ftype == TType::LST) {
 509             $_size509 = 0;
 510             $_val508 = Vector {};
 511             $_etype512 = 0;
 512             $xfer += $input->readListBegin($_etype512, $_size509);
 513             for ($_i513 = 0; $_i513 < $_size509; ++$_i513)
 514             {
 515               $elem514 = null;
 516               $xfer += $input->readString($elem514);
 517               if ($elem514 !== null) {
 518                 $_val508 []= $elem514;
 519               }
 520             }
 521             $xfer += $input->readListEnd();
 522             $this->ivar32 = $_val508;
 523           } else {
 524             $xfer += $input->skip($ftype);
 525           }
 526           break;
 527         case 53:
 528           if ($ftype == TType::LST) {
 529             $_size516 = 0;
 530             $_val515 = Vector {};
 531             $_etype519 = 0;
 532             $xfer += $input->readListBegin($_etype519, $_size516);
 533             for ($_i520 = 0; $_i520 < $_size516; ++$_i520)
 534             {
 535               $elem521 = null;
 536               $elem521 = new Ty2();
 537               $xfer += $elem521->read($input);
 538               if ($elem521 !== null) {
 539                 $_val515 []= $elem521;
 540               }
 541             }
 542             $xfer += $input->readListEnd();
 543             $this->ivar33 = $_val515;
 544           } else {
 545             $xfer += $input->skip($ftype);
 546           }
 547           break;
 548         case 54:
 549           if ($ftype == TType::I64) {
 550             $xfer += $input->readI64($this->ivar34);
 551           } else {
 552             $xfer += $input->skip($ftype);
 553           }
 554           break;
 555         case 55:
 556           if ($ftype == TType::BOOL) {
 557             $xfer += $input->readBool($this->ivar35);
 558           } else {
 559             $xfer += $input->skip($ftype);
 560           }
 561           break;
 562         case 56:
 563           if ($ftype == TType::LST) {
 564             $_size523 = 0;
 565             $_val522 = Vector {};
 566             $_etype526 = 0;
 567             $xfer += $input->readListBegin($_etype526, $_size523);
 568             for ($_i527 = 0; $_i527 < $_size523; ++$_i527)
 569             {
 570               $elem528 = null;
 571               $elem528 = new Ty2();
 572               $xfer += $elem528->read($input);
 573               if ($elem528 !== null) {
 574                 $_val522 []= $elem528;
 575               }
 576             }
 577             $xfer += $input->readListEnd();
 578             $this->ivar36 = $_val522;
 579           } else {
 580             $xfer += $input->skip($ftype);
 581           }
 582           break;
 583         case 57:
 584           if ($ftype == TType::LST) {
 585             $_size530 = 0;
 586             $_val529 = Vector {};
 587             $_etype533 = 0;
 588             $xfer += $input->readListBegin($_etype533, $_size530);
 589             for ($_i534 = 0; $_i534 < $_size530; ++$_i534)
 590             {
 591               $elem535 = null;
 592               $xfer += $input->readString($elem535);
 593               if ($elem535 !== null) {
 594                 $_val529 []= $elem535;
 595               }
 596             }
 597             $xfer += $input->readListEnd();
 598             $this->ivar37 = $_val529;
 599           } else {
 600             $xfer += $input->skip($ftype);
 601           }
 602           break;
 603         case 58:
 604           if ($ftype == TType::STRING) {
 605             $xfer += $input->readString($this->ivar38);
 606           } else {
 607             $xfer += $input->skip($ftype);
 608           }
 609           break;
 610         case 59:
 611           if ($ftype == TType::STRING) {
 612             $xfer += $input->readString($this->ivar39);
 613           } else {
 614             $xfer += $input->skip($ftype);
 615           }
 616           break;
 617         case 60:
 618           if ($ftype == TType::STRING) {
 619             $xfer += $input->readString($this->ivar40);
 620           } else {
 621             $xfer += $input->skip($ftype);
 622           }
 623           break;
 624         case 61:
 625           if ($ftype == TType::STRING) {
 626             $xfer += $input->readString($this->ivar41);
 627           } else {
 628             $xfer += $input->skip($ftype);
 629           }
 630           break;
 631         case 62:
 632           if ($ftype == TType::STRUCT) {
 633             $this->ivar42 = new Ty6();
 634             $xfer += $this->ivar42->read($input);
 635           } else {
 636             $xfer += $input->skip($ftype);
 637           }
 638           break;
 639         case 63:
 640           if ($ftype == TType::I64) {
 641             $xfer += $input->readI64($this->ivar43);
 642           } else {
 643             $xfer += $input->skip($ftype);
 644           }
 645           break;
 646         case 64:
 647           if ($ftype == TType::STRUCT) {
 648             $this->ivar44 = new Ty7();
 649             $xfer += $this->ivar44->read($input);
 650           } else {
 651             $xfer += $input->skip($ftype);
 652           }
 653           break;
 654         case 65:
 655           if ($ftype == TType::STRING) {
 656             $xfer += $input->readString($this->ivar45);
 657           } else {
 658             $xfer += $input->skip($ftype);
 659           }
 660           break;
 661         case 66:
 662           if ($ftype == TType::MAP) {
 663             $_size537 = 0;
 664             $_val536 = Map {};
 665             $_ktype538 = 0;
 666             $_vtype539 = 0;
 667             $xfer += $input->readMapBegin($_ktype538, $_vtype539, $_size537);
 668             for ($_i541 = 0; $_i541 < $_size537; ++$_i541)
 669             {
 670               $key542 = '';
 671               $val543 = '';
 672               $xfer += $input->readString($key542);
 673               $xfer += $input->readString($val543);
 674               if ($key542 !== null && $val543 !== null) {
 675                 $_val536[$key542] = $val543;
 676               }
 677             }
 678             $xfer += $input->readMapEnd();
 679             $this->ivar46 = $_val536;
 680           } else {
 681             $xfer += $input->skip($ftype);
 682           }
 683           break;
 684         case 67:
 685           if ($ftype == TType::MAP) {
 686             $_size545 = 0;
 687             $_val544 = Map {};
 688             $_ktype546 = 0;
 689             $_vtype547 = 0;
 690             $xfer += $input->readMapBegin($_ktype546, $_vtype547, $_size545);
 691             for ($_i549 = 0; $_i549 < $_size545; ++$_i549)
 692             {
 693               $key550 = '';
 694               $val551 = '';
 695               $xfer += $input->readString($key550);
 696               $xfer += $input->readString($val551);
 697               if ($key550 !== null && $val551 !== null) {
 698                 $_val544[$key550] = $val551;
 699               }
 700             }
 701             $xfer += $input->readMapEnd();
 702             $this->ivar47 = $_val544;
 703           } else {
 704             $xfer += $input->skip($ftype);
 705           }
 706           break;
 707         case 68:
 708           if ($ftype == TType::LST) {
 709             $_size553 = 0;
 710             $_val552 = Vector {};
 711             $_etype556 = 0;
 712             $xfer += $input->readListBegin($_etype556, $_size553);
 713             for ($_i557 = 0; $_i557 < $_size553; ++$_i557)
 714             {
 715               $elem558 = null;
 716               $elem558 = new Ty8();
 717               $xfer += $elem558->read($input);
 718               if ($elem558 !== null) {
 719                 $_val552 []= $elem558;
 720               }
 721             }
 722             $xfer += $input->readListEnd();
 723             $this->ivar48 = $_val552;
 724           } else {
 725             $xfer += $input->skip($ftype);
 726           }
 727           break;
 728         case 69:
 729           if ($ftype == TType::I64) {
 730             $xfer += $input->readI64($this->ivar49);
 731           } else {
 732             $xfer += $input->skip($ftype);
 733           }
 734           break;
 735         case 71:
 736           if ($ftype == TType::STRUCT) {
 737             $this->ivar50 = new Ty3();
 738             $xfer += $this->ivar50->read($input);
 739           } else {
 740             $xfer += $input->skip($ftype);
 741           }
 742           break;
 743         case 72:
 744           if ($ftype == TType::MAP) {
 745             $_size560 = 0;
 746             $_val559 = Map {};
 747             $_ktype561 = 0;
 748             $_vtype562 = 0;
 749             $xfer += $input->readMapBegin($_ktype561, $_vtype562, $_size560);
 750             for ($_i564 = 0; $_i564 < $_size560; ++$_i564)
 751             {
 752               $key565 = 0;
 753               $val566 = new Ty9();
 754               $xfer += $input->readI32($key565);
 755               $val566 = new Ty9();
 756               $xfer += $val566->read($input);
 757               if ($key565 !== null && $val566 !== null) {
 758                 $_val559[$key565] = $val566;
 759               }
 760             }
 761             $xfer += $input->readMapEnd();
 762             $this->ivar51 = $_val559;
 763           } else {
 764             $xfer += $input->skip($ftype);
 765           }
 766           break;
 767         case 73:
 768           if ($ftype == TType::STRUCT) {
 769             $this->ivar52 = new Ty10();
 770             $xfer += $this->ivar52->read($input);
 771           } else {
 772             $xfer += $input->skip($ftype);
 773           }
 774           break;
 775         case 74:
 776           if ($ftype == TType::STRING) {
 777             $xfer += $input->readString($this->ivar53);
 778           } else {
 779             $xfer += $input->skip($ftype);
 780           }
 781           break;
 782         default:
 783           $xfer += $input->skip($ftype);
 784           break;
 785       }
 786       $xfer += $input->readFieldEnd();
 787     }
 788     $xfer += $input->readStructEnd();
 789     return $xfer;
 790   }
 791
 792 }