serialize.go

   1 // Code generated by mkserialize.sh; DO NOT EDIT.
   2
   3 package mt
   4
   5 import (
   6         "bytes"
   7         "compress/zlib"
   8         "crypto/sha1"
   9         "errors"
  10         "fmt"
  11         "image/color"
  12         "io"
  13         "math"
  14         "sort"
  15         "unicode/utf16"
  16 )
  17
  18 func write8(w io.Writer, x uint8) {
  19         _, err := w.Write([]byte{x})
  20         chk(err)
  21 }
  22 func write16(w io.Writer, x uint16) {
  23         buf := make([]byte, 2)
  24         be.PutUint16(buf, x)
  25         _, err := w.Write(buf)
  26         chk(err)
  27 }
  28 func write32(w io.Writer, x uint32) {
  29         buf := make([]byte, 4)
  30         be.PutUint32(buf, x)
  31         _, err := w.Write(buf)
  32         chk(err)
  33 }
  34 func write64(w io.Writer, x uint64) {
  35         buf := make([]byte, 8)
  36         be.PutUint64(buf, x)
  37         _, err := w.Write(buf)
  38         chk(err)
  39 }
  40 func readBuf(r io.Reader, n int) []byte {
  41         buf := make([]byte, n)
  42         _, err := io.ReadFull(r, buf)
  43         chk(err)
  44         return buf
  45 }
  46 func read8(r io.Reader) uint8   { return readBuf(r, 1)[0] }
  47 func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  48 func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  49 func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  50
  51 func (obj *ToSrvNil) Serialize(w io.Writer) {
  52 }
  53
  54 func (obj *ToSrvNil) Deserialize(r io.Reader) {
  55 }
  56
  57 func (obj *ToSrvInit) Serialize(w io.Writer) {
  58         {
  59                 x := (*(*(struct {
  60                         SerializeVer             uint8
  61                         SupportedCompression     CompressionModes
  62                         MinProtoVer, MaxProtoVer uint16
  63                         PlayerName               string
  64
  65                         //mt:opt
  66                         SendFullItemMeta bool
  67                 }))(obj)).SerializeVer
  68                 write8(w, uint8(x))
  69         }
  70         if err := pcall(func() {
  71                 ((*(*(struct {
  72                         SerializeVer             uint8
  73                         SupportedCompression     CompressionModes
  74                         MinProtoVer, MaxProtoVer uint16
  75                         PlayerName               string
  76
  77                         //mt:opt
  78                         SendFullItemMeta bool
  79                 }))(obj)).SupportedCompression).Serialize(w)
  80         }); err != nil {
  81                 if err == io.EOF {
  82                         chk(io.EOF)
  83                 }
  84                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
  85         }
  86         {
  87                 x := (*(*(struct {
  88                         SerializeVer             uint8
  89                         SupportedCompression     CompressionModes
  90                         MinProtoVer, MaxProtoVer uint16
  91                         PlayerName               string
  92
  93                         //mt:opt
  94                         SendFullItemMeta bool
  95                 }))(obj)).MinProtoVer
  96                 write16(w, uint16(x))
  97         }
  98         {
  99                 x := (*(*(struct {
 100                         SerializeVer             uint8
 101                         SupportedCompression     CompressionModes
 102                         MinProtoVer, MaxProtoVer uint16
 103                         PlayerName               string
 104
 105                         //mt:opt
 106                         SendFullItemMeta bool
 107                 }))(obj)).MaxProtoVer
 108                 write16(w, uint16(x))
 109         }
 110         if len(([]byte((*(*(struct {
 111                 SerializeVer             uint8
 112                 SupportedCompression     CompressionModes
 113                 MinProtoVer, MaxProtoVer uint16
 114                 PlayerName               string
 115
 116                 //mt:opt
 117                 SendFullItemMeta bool
 118         }))(obj)).PlayerName))) > math.MaxUint16 {
 119                 chk(ErrTooLong)
 120         }
 121         {
 122                 x := uint16(len(([]byte((*(*(struct {
 123                         SerializeVer             uint8
 124                         SupportedCompression     CompressionModes
 125                         MinProtoVer, MaxProtoVer uint16
 126                         PlayerName               string
 127
 128                         //mt:opt
 129                         SendFullItemMeta bool
 130                 }))(obj)).PlayerName))))
 131                 write16(w, uint16(x))
 132         }
 133         {
 134                 _, err := w.Write(([]byte((*(*(struct {
 135                         SerializeVer             uint8
 136                         SupportedCompression     CompressionModes
 137                         MinProtoVer, MaxProtoVer uint16
 138                         PlayerName               string
 139
 140                         //mt:opt
 141                         SendFullItemMeta bool
 142                 }))(obj)).PlayerName))[:])
 143                 chk(err)
 144         }
 145         if err := pcall(func() {
 146                 {
 147                         x := (*(*(struct {
 148                                 SerializeVer             uint8
 149                                 SupportedCompression     CompressionModes
 150                                 MinProtoVer, MaxProtoVer uint16
 151                                 PlayerName               string
 152
 153                                 //mt:opt
 154                                 SendFullItemMeta bool
 155                         }))(obj)).SendFullItemMeta
 156                         if x {
 157                                 write8(w, 1)
 158                         } else {
 159                                 write8(w, 0)
 160                         }
 161                 }
 162         }); err != nil && err != io.EOF {
 163                 chk(err)
 164         }
 165 }
 166
 167 func (obj *ToSrvInit) Deserialize(r io.Reader) {
 168         {
 169                 p := &(*(*(struct {
 170                         SerializeVer             uint8
 171                         SupportedCompression     CompressionModes
 172                         MinProtoVer, MaxProtoVer uint16
 173                         PlayerName               string
 174
 175                         //mt:opt
 176                         SendFullItemMeta bool
 177                 }))(obj)).SerializeVer
 178                 *p = read8(r)
 179         }
 180         if err := pcall(func() {
 181                 ((*(*(struct {
 182                         SerializeVer             uint8
 183                         SupportedCompression     CompressionModes
 184                         MinProtoVer, MaxProtoVer uint16
 185                         PlayerName               string
 186
 187                         //mt:opt
 188                         SendFullItemMeta bool
 189                 }))(obj)).SupportedCompression).Deserialize(r)
 190         }); err != nil {
 191                 if err == io.EOF {
 192                         chk(io.EOF)
 193                 }
 194                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
 195         }
 196         {
 197                 p := &(*(*(struct {
 198                         SerializeVer             uint8
 199                         SupportedCompression     CompressionModes
 200                         MinProtoVer, MaxProtoVer uint16
 201                         PlayerName               string
 202
 203                         //mt:opt
 204                         SendFullItemMeta bool
 205                 }))(obj)).MinProtoVer
 206                 *p = read16(r)
 207         }
 208         {
 209                 p := &(*(*(struct {
 210                         SerializeVer             uint8
 211                         SupportedCompression     CompressionModes
 212                         MinProtoVer, MaxProtoVer uint16
 213                         PlayerName               string
 214
 215                         //mt:opt
 216                         SendFullItemMeta bool
 217                 }))(obj)).MaxProtoVer
 218                 *p = read16(r)
 219         }
 220         var local1 []uint8
 221         var local2 uint16
 222         {
 223                 p := &local2
 224                 *p = read16(r)
 225         }
 226         (local1) = make([]uint8, local2)
 227         {
 228                 _, err := io.ReadFull(r, (local1)[:])
 229                 chk(err)
 230         }
 231         ((*(*(struct {
 232                 SerializeVer             uint8
 233                 SupportedCompression     CompressionModes
 234                 MinProtoVer, MaxProtoVer uint16
 235                 PlayerName               string
 236
 237                 //mt:opt
 238                 SendFullItemMeta bool
 239         }))(obj)).PlayerName) = string(local1)
 240         if err := pcall(func() {
 241                 {
 242                         p := &(*(*(struct {
 243                                 SerializeVer             uint8
 244                                 SupportedCompression     CompressionModes
 245                                 MinProtoVer, MaxProtoVer uint16
 246                                 PlayerName               string
 247
 248                                 //mt:opt
 249                                 SendFullItemMeta bool
 250                         }))(obj)).SendFullItemMeta
 251                         switch n := read8(r); n {
 252                         case 0:
 253                                 *p = false
 254                         case 1:
 255                                 *p = true
 256                         default:
 257                                 chk(fmt.Errorf("invalid bool: %d", n))
 258                         }
 259                 }
 260         }); err != nil && err != io.EOF {
 261                 chk(err)
 262         }
 263 }
 264
 265 func (obj *ToSrvInit2) Serialize(w io.Writer) {
 266         if len(([]byte((*(*(struct {
 267                 Lang string
 268         }))(obj)).Lang))) > math.MaxUint16 {
 269                 chk(ErrTooLong)
 270         }
 271         {
 272                 x := uint16(len(([]byte((*(*(struct {
 273                         Lang string
 274                 }))(obj)).Lang))))
 275                 write16(w, uint16(x))
 276         }
 277         {
 278                 _, err := w.Write(([]byte((*(*(struct {
 279                         Lang string
 280                 }))(obj)).Lang))[:])
 281                 chk(err)
 282         }
 283 }
 284
 285 func (obj *ToSrvInit2) Deserialize(r io.Reader) {
 286         var local3 []uint8
 287         var local4 uint16
 288         {
 289                 p := &local4
 290                 *p = read16(r)
 291         }
 292         (local3) = make([]uint8, local4)
 293         {
 294                 _, err := io.ReadFull(r, (local3)[:])
 295                 chk(err)
 296         }
 297         ((*(*(struct {
 298                 Lang string
 299         }))(obj)).Lang) = string(local3)
 300 }
 301
 302 func (obj *ToSrvJoinModChan) Serialize(w io.Writer) {
 303         if len(([]byte((*(*(struct {
 304                 Channel string
 305         }))(obj)).Channel))) > math.MaxUint16 {
 306                 chk(ErrTooLong)
 307         }
 308         {
 309                 x := uint16(len(([]byte((*(*(struct {
 310                         Channel string
 311                 }))(obj)).Channel))))
 312                 write16(w, uint16(x))
 313         }
 314         {
 315                 _, err := w.Write(([]byte((*(*(struct {
 316                         Channel string
 317                 }))(obj)).Channel))[:])
 318                 chk(err)
 319         }
 320 }
 321
 322 func (obj *ToSrvJoinModChan) Deserialize(r io.Reader) {
 323         var local5 []uint8
 324         var local6 uint16
 325         {
 326                 p := &local6
 327                 *p = read16(r)
 328         }
 329         (local5) = make([]uint8, local6)
 330         {
 331                 _, err := io.ReadFull(r, (local5)[:])
 332                 chk(err)
 333         }
 334         ((*(*(struct {
 335                 Channel string
 336         }))(obj)).Channel) = string(local5)
 337 }
 338
 339 func (obj *ToSrvLeaveModChan) Serialize(w io.Writer) {
 340         if len(([]byte((*(*(struct {
 341                 Channel string
 342         }))(obj)).Channel))) > math.MaxUint16 {
 343                 chk(ErrTooLong)
 344         }
 345         {
 346                 x := uint16(len(([]byte((*(*(struct {
 347                         Channel string
 348                 }))(obj)).Channel))))
 349                 write16(w, uint16(x))
 350         }
 351         {
 352                 _, err := w.Write(([]byte((*(*(struct {
 353                         Channel string
 354                 }))(obj)).Channel))[:])
 355                 chk(err)
 356         }
 357 }
 358
 359 func (obj *ToSrvLeaveModChan) Deserialize(r io.Reader) {
 360         var local7 []uint8
 361         var local8 uint16
 362         {
 363                 p := &local8
 364                 *p = read16(r)
 365         }
 366         (local7) = make([]uint8, local8)
 367         {
 368                 _, err := io.ReadFull(r, (local7)[:])
 369                 chk(err)
 370         }
 371         ((*(*(struct {
 372                 Channel string
 373         }))(obj)).Channel) = string(local7)
 374 }
 375
 376 func (obj *ToSrvMsgModChan) Serialize(w io.Writer) {
 377         if len(([]byte((*(*(struct {
 378                 Channel string
 379                 Msg     string
 380         }))(obj)).Channel))) > math.MaxUint16 {
 381                 chk(ErrTooLong)
 382         }
 383         {
 384                 x := uint16(len(([]byte((*(*(struct {
 385                         Channel string
 386                         Msg     string
 387                 }))(obj)).Channel))))
 388                 write16(w, uint16(x))
 389         }
 390         {
 391                 _, err := w.Write(([]byte((*(*(struct {
 392                         Channel string
 393                         Msg     string
 394                 }))(obj)).Channel))[:])
 395                 chk(err)
 396         }
 397         if len(([]byte((*(*(struct {
 398                 Channel string
 399                 Msg     string
 400         }))(obj)).Msg))) > math.MaxUint16 {
 401                 chk(ErrTooLong)
 402         }
 403         {
 404                 x := uint16(len(([]byte((*(*(struct {
 405                         Channel string
 406                         Msg     string
 407                 }))(obj)).Msg))))
 408                 write16(w, uint16(x))
 409         }
 410         {
 411                 _, err := w.Write(([]byte((*(*(struct {
 412                         Channel string
 413                         Msg     string
 414                 }))(obj)).Msg))[:])
 415                 chk(err)
 416         }
 417 }
 418
 419 func (obj *ToSrvMsgModChan) Deserialize(r io.Reader) {
 420         var local9 []uint8
 421         var local10 uint16
 422         {
 423                 p := &local10
 424                 *p = read16(r)
 425         }
 426         (local9) = make([]uint8, local10)
 427         {
 428                 _, err := io.ReadFull(r, (local9)[:])
 429                 chk(err)
 430         }
 431         ((*(*(struct {
 432                 Channel string
 433                 Msg     string
 434         }))(obj)).Channel) = string(local9)
 435         var local11 []uint8
 436         var local12 uint16
 437         {
 438                 p := &local12
 439                 *p = read16(r)
 440         }
 441         (local11) = make([]uint8, local12)
 442         {
 443                 _, err := io.ReadFull(r, (local11)[:])
 444                 chk(err)
 445         }
 446         ((*(*(struct {
 447                 Channel string
 448                 Msg     string
 449         }))(obj)).Msg) = string(local11)
 450 }
 451
 452 func (obj *ToSrvPlayerPos) Serialize(w io.Writer) {
 453         if err := pcall(func() {
 454                 ((*(*(struct {
 455                         Pos PlayerPos
 456                 }))(obj)).Pos).Serialize(w)
 457         }); err != nil {
 458                 if err == io.EOF {
 459                         chk(io.EOF)
 460                 }
 461                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 462         }
 463 }
 464
 465 func (obj *ToSrvPlayerPos) Deserialize(r io.Reader) {
 466         if err := pcall(func() {
 467                 ((*(*(struct {
 468                         Pos PlayerPos
 469                 }))(obj)).Pos).Deserialize(r)
 470         }); err != nil {
 471                 if err == io.EOF {
 472                         chk(io.EOF)
 473                 }
 474                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 475         }
 476 }
 477
 478 func (obj *ToSrvGotBlks) Serialize(w io.Writer) {
 479         if len(((*(*(struct {
 480                 //mt:len8
 481                 Blks [][3]int16
 482         }))(obj)).Blks)) > math.MaxUint8 {
 483                 chk(ErrTooLong)
 484         }
 485         {
 486                 x := uint8(len(((*(*(struct {
 487                         //mt:len8
 488                         Blks [][3]int16
 489                 }))(obj)).Blks)))
 490                 write8(w, uint8(x))
 491         }
 492         for local13 := range (*(*(struct {
 493                 //mt:len8
 494                 Blks [][3]int16
 495         }))(obj)).Blks {
 496                 for local14 := range ((*(*(struct {
 497                         //mt:len8
 498                         Blks [][3]int16
 499                 }))(obj)).Blks)[local13] {
 500                         {
 501                                 x := (((*(*(struct {
 502                                         //mt:len8
 503                                         Blks [][3]int16
 504                                 }))(obj)).Blks)[local13])[local14]
 505                                 write16(w, uint16(x))
 506                         }
 507                 }
 508         }
 509 }
 510
 511 func (obj *ToSrvGotBlks) Deserialize(r io.Reader) {
 512         var local15 uint8
 513         {
 514                 p := &local15
 515                 *p = read8(r)
 516         }
 517         ((*(*(struct {
 518                 //mt:len8
 519                 Blks [][3]int16
 520         }))(obj)).Blks) = make([][3]int16, local15)
 521         for local16 := range (*(*(struct {
 522                 //mt:len8
 523                 Blks [][3]int16
 524         }))(obj)).Blks {
 525                 for local17 := range ((*(*(struct {
 526                         //mt:len8
 527                         Blks [][3]int16
 528                 }))(obj)).Blks)[local16] {
 529                         {
 530                                 p := &(((*(*(struct {
 531                                         //mt:len8
 532                                         Blks [][3]int16
 533                                 }))(obj)).Blks)[local16])[local17]
 534                                 *p = int16(read16(r))
 535                         }
 536                 }
 537         }
 538 }
 539
 540 func (obj *ToSrvDeletedBlks) Serialize(w io.Writer) {
 541         if len(((*(*(struct {
 542                 //mt:len8
 543                 Blks [][3]int16
 544         }))(obj)).Blks)) > math.MaxUint8 {
 545                 chk(ErrTooLong)
 546         }
 547         {
 548                 x := uint8(len(((*(*(struct {
 549                         //mt:len8
 550                         Blks [][3]int16
 551                 }))(obj)).Blks)))
 552                 write8(w, uint8(x))
 553         }
 554         for local18 := range (*(*(struct {
 555                 //mt:len8
 556                 Blks [][3]int16
 557         }))(obj)).Blks {
 558                 for local19 := range ((*(*(struct {
 559                         //mt:len8
 560                         Blks [][3]int16
 561                 }))(obj)).Blks)[local18] {
 562                         {
 563                                 x := (((*(*(struct {
 564                                         //mt:len8
 565                                         Blks [][3]int16
 566                                 }))(obj)).Blks)[local18])[local19]
 567                                 write16(w, uint16(x))
 568                         }
 569                 }
 570         }
 571 }
 572
 573 func (obj *ToSrvDeletedBlks) Deserialize(r io.Reader) {
 574         var local20 uint8
 575         {
 576                 p := &local20
 577                 *p = read8(r)
 578         }
 579         ((*(*(struct {
 580                 //mt:len8
 581                 Blks [][3]int16
 582         }))(obj)).Blks) = make([][3]int16, local20)
 583         for local21 := range (*(*(struct {
 584                 //mt:len8
 585                 Blks [][3]int16
 586         }))(obj)).Blks {
 587                 for local22 := range ((*(*(struct {
 588                         //mt:len8
 589                         Blks [][3]int16
 590                 }))(obj)).Blks)[local21] {
 591                         {
 592                                 p := &(((*(*(struct {
 593                                         //mt:len8
 594                                         Blks [][3]int16
 595                                 }))(obj)).Blks)[local21])[local22]
 596                                 *p = int16(read16(r))
 597                         }
 598                 }
 599         }
 600 }
 601
 602 func (obj *ToSrvInvAction) Serialize(w io.Writer) {
 603         {
 604                 _, err := w.Write(([]byte((*(*(struct {
 605                         //mt:raw
 606                         Action string
 607                 }))(obj)).Action))[:])
 608                 chk(err)
 609         }
 610 }
 611
 612 func (obj *ToSrvInvAction) Deserialize(r io.Reader) {
 613         var local23 []uint8
 614         {
 615                 var err error
 616                 (local23), err = io.ReadAll(r)
 617                 chk(err)
 618         }
 619         ((*(*(struct {
 620                 //mt:raw
 621                 Action string
 622         }))(obj)).Action) = string(local23)
 623 }
 624
 625 func (obj *ToSrvChatMsg) Serialize(w io.Writer) {
 626         local24 := utf16.Encode([]rune((*(*(struct {
 627                 //mt:utf16
 628                 Msg string
 629         }))(obj)).Msg))
 630         if len((local24)) > math.MaxUint16 {
 631                 chk(ErrTooLong)
 632         }
 633         {
 634                 x := uint16(len((local24)))
 635                 write16(w, uint16(x))
 636         }
 637         for local25 := range local24 {
 638                 {
 639                         x := (local24)[local25]
 640                         write16(w, uint16(x))
 641                 }
 642         }
 643 }
 644
 645 func (obj *ToSrvChatMsg) Deserialize(r io.Reader) {
 646         var local26 []uint16
 647         var local27 uint16
 648         {
 649                 p := &local27
 650                 *p = read16(r)
 651         }
 652         (local26) = make([]uint16, local27)
 653         for local28 := range local26 {
 654                 {
 655                         p := &(local26)[local28]
 656                         *p = read16(r)
 657                 }
 658         }
 659         (*(*(struct {
 660                 //mt:utf16
 661                 Msg string
 662         }))(obj)).Msg = string(utf16.Decode(local26))
 663 }
 664
 665 func (obj *ToSrvFallDmg) Serialize(w io.Writer) {
 666         {
 667                 x := (*(*(struct {
 668                         Amount uint16
 669                 }))(obj)).Amount
 670                 write16(w, uint16(x))
 671         }
 672 }
 673
 674 func (obj *ToSrvFallDmg) Deserialize(r io.Reader) {
 675         {
 676                 p := &(*(*(struct {
 677                         Amount uint16
 678                 }))(obj)).Amount
 679                 *p = read16(r)
 680         }
 681 }
 682
 683 func (obj *ToSrvSelectItem) Serialize(w io.Writer) {
 684         {
 685                 x := (*(*(struct {
 686                         Slot uint16
 687                 }))(obj)).Slot
 688                 write16(w, uint16(x))
 689         }
 690 }
 691
 692 func (obj *ToSrvSelectItem) Deserialize(r io.Reader) {
 693         {
 694                 p := &(*(*(struct {
 695                         Slot uint16
 696                 }))(obj)).Slot
 697                 *p = read16(r)
 698         }
 699 }
 700
 701 func (obj *ToSrvRespawn) Serialize(w io.Writer) {
 702 }
 703
 704 func (obj *ToSrvRespawn) Deserialize(r io.Reader) {
 705 }
 706
 707 func (obj *ToSrvInteract) Serialize(w io.Writer) {
 708         if err := pcall(func() {
 709                 ((*(*(struct {
 710                         Action   Interaction
 711                         ItemSlot uint16
 712                         //mt:lenhdr 32
 713                         Pointed PointedThing
 714                         //mt:end
 715                         Pos PlayerPos
 716                 }))(obj)).Action).Serialize(w)
 717         }); err != nil {
 718                 if err == io.EOF {
 719                         chk(io.EOF)
 720                 }
 721                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Interaction", err))
 722         }
 723         {
 724                 x := (*(*(struct {
 725                         Action   Interaction
 726                         ItemSlot uint16
 727                         //mt:lenhdr 32
 728                         Pointed PointedThing
 729                         //mt:end
 730                         Pos PlayerPos
 731                 }))(obj)).ItemSlot
 732                 write16(w, uint16(x))
 733         }
 734         {
 735                 ow := w
 736                 w := new(bytes.Buffer)
 737                 {
 738                         x := (*(*(struct {
 739                                 Action   Interaction
 740                                 ItemSlot uint16
 741                                 //mt:lenhdr 32
 742                                 Pointed PointedThing
 743                                 //mt:end
 744                                 Pos PlayerPos
 745                         }))(obj)).Pointed
 746                         chk(writePointedThing(w, x))
 747                 }
 748                 {
 749                         buf := w
 750                         w := ow
 751                         if len((buf.Bytes())) > math.MaxUint32 {
 752                                 chk(ErrTooLong)
 753                         }
 754                         {
 755                                 x := uint32(len((buf.Bytes())))
 756                                 write32(w, uint32(x))
 757                         }
 758                         {
 759                                 _, err := w.Write((buf.Bytes())[:])
 760                                 chk(err)
 761                         }
 762                 }
 763         }
 764         if err := pcall(func() {
 765                 ((*(*(struct {
 766                         Action   Interaction
 767                         ItemSlot uint16
 768                         //mt:lenhdr 32
 769                         Pointed PointedThing
 770                         //mt:end
 771                         Pos PlayerPos
 772                 }))(obj)).Pos).Serialize(w)
 773         }); err != nil {
 774                 if err == io.EOF {
 775                         chk(io.EOF)
 776                 }
 777                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 778         }
 779 }
 780
 781 func (obj *ToSrvInteract) Deserialize(r io.Reader) {
 782         if err := pcall(func() {
 783                 ((*(*(struct {
 784                         Action   Interaction
 785                         ItemSlot uint16
 786                         //mt:lenhdr 32
 787                         Pointed PointedThing
 788                         //mt:end
 789                         Pos PlayerPos
 790                 }))(obj)).Action).Deserialize(r)
 791         }); err != nil {
 792                 if err == io.EOF {
 793                         chk(io.EOF)
 794                 }
 795                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Interaction", err))
 796         }
 797         {
 798                 p := &(*(*(struct {
 799                         Action   Interaction
 800                         ItemSlot uint16
 801                         //mt:lenhdr 32
 802                         Pointed PointedThing
 803                         //mt:end
 804                         Pos PlayerPos
 805                 }))(obj)).ItemSlot
 806                 *p = read16(r)
 807         }
 808         {
 809                 var n uint32
 810                 {
 811                         p := &n
 812                         *p = read32(r)
 813                 }
 814                 r := &io.LimitedReader{R: r, N: int64(n)}
 815                 {
 816                         p := &(*(*(struct {
 817                                 Action   Interaction
 818                                 ItemSlot uint16
 819                                 //mt:lenhdr 32
 820                                 Pointed PointedThing
 821                                 //mt:end
 822                                 Pos PlayerPos
 823                         }))(obj)).Pointed
 824                         {
 825                                 var err error
 826                                 *p, err = readPointedThing(r)
 827                                 chk(err)
 828                         }
 829                 }
 830                 if r.N > 0 {
 831                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 832                 }
 833         }
 834         if err := pcall(func() {
 835                 ((*(*(struct {
 836                         Action   Interaction
 837                         ItemSlot uint16
 838                         //mt:lenhdr 32
 839                         Pointed PointedThing
 840                         //mt:end
 841                         Pos PlayerPos
 842                 }))(obj)).Pos).Deserialize(r)
 843         }); err != nil {
 844                 if err == io.EOF {
 845                         chk(io.EOF)
 846                 }
 847                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 848         }
 849 }
 850
 851 func (obj *ToSrvRemovedSounds) Serialize(w io.Writer) {
 852         if len(((*(*(struct {
 853                 IDs []SoundID
 854         }))(obj)).IDs)) > math.MaxUint16 {
 855                 chk(ErrTooLong)
 856         }
 857         {
 858                 x := uint16(len(((*(*(struct {
 859                         IDs []SoundID
 860                 }))(obj)).IDs)))
 861                 write16(w, uint16(x))
 862         }
 863         for local29 := range (*(*(struct {
 864                 IDs []SoundID
 865         }))(obj)).IDs {
 866                 if err := pcall(func() {
 867                         (((*(*(struct {
 868                                 IDs []SoundID
 869                         }))(obj)).IDs)[local29]).Serialize(w)
 870                 }); err != nil {
 871                         if err == io.EOF {
 872                                 chk(io.EOF)
 873                         }
 874                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
 875                 }
 876         }
 877 }
 878
 879 func (obj *ToSrvRemovedSounds) Deserialize(r io.Reader) {
 880         var local30 uint16
 881         {
 882                 p := &local30
 883                 *p = read16(r)
 884         }
 885         ((*(*(struct {
 886                 IDs []SoundID
 887         }))(obj)).IDs) = make([]SoundID, local30)
 888         for local31 := range (*(*(struct {
 889                 IDs []SoundID
 890         }))(obj)).IDs {
 891                 if err := pcall(func() {
 892                         (((*(*(struct {
 893                                 IDs []SoundID
 894                         }))(obj)).IDs)[local31]).Deserialize(r)
 895                 }); err != nil {
 896                         if err == io.EOF {
 897                                 chk(io.EOF)
 898                         }
 899                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
 900                 }
 901         }
 902 }
 903
 904 func (obj *ToSrvNodeMetaFields) Serialize(w io.Writer) {
 905         for local32 := range (*(*(struct {
 906                 Pos      [3]int16
 907                 Formname string
 908                 Fields   []Field
 909         }))(obj)).Pos {
 910                 {
 911                         x := ((*(*(struct {
 912                                 Pos      [3]int16
 913                                 Formname string
 914                                 Fields   []Field
 915                         }))(obj)).Pos)[local32]
 916                         write16(w, uint16(x))
 917                 }
 918         }
 919         if len(([]byte((*(*(struct {
 920                 Pos      [3]int16
 921                 Formname string
 922                 Fields   []Field
 923         }))(obj)).Formname))) > math.MaxUint16 {
 924                 chk(ErrTooLong)
 925         }
 926         {
 927                 x := uint16(len(([]byte((*(*(struct {
 928                         Pos      [3]int16
 929                         Formname string
 930                         Fields   []Field
 931                 }))(obj)).Formname))))
 932                 write16(w, uint16(x))
 933         }
 934         {
 935                 _, err := w.Write(([]byte((*(*(struct {
 936                         Pos      [3]int16
 937                         Formname string
 938                         Fields   []Field
 939                 }))(obj)).Formname))[:])
 940                 chk(err)
 941         }
 942         if len(((*(*(struct {
 943                 Pos      [3]int16
 944                 Formname string
 945                 Fields   []Field
 946         }))(obj)).Fields)) > math.MaxUint16 {
 947                 chk(ErrTooLong)
 948         }
 949         {
 950                 x := uint16(len(((*(*(struct {
 951                         Pos      [3]int16
 952                         Formname string
 953                         Fields   []Field
 954                 }))(obj)).Fields)))
 955                 write16(w, uint16(x))
 956         }
 957         for local33 := range (*(*(struct {
 958                 Pos      [3]int16
 959                 Formname string
 960                 Fields   []Field
 961         }))(obj)).Fields {
 962                 if err := pcall(func() {
 963                         (((*(*(struct {
 964                                 Pos      [3]int16
 965                                 Formname string
 966                                 Fields   []Field
 967                         }))(obj)).Fields)[local33]).Serialize(w)
 968                 }); err != nil {
 969                         if err == io.EOF {
 970                                 chk(io.EOF)
 971                         }
 972                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
 973                 }
 974         }
 975 }
 976
 977 func (obj *ToSrvNodeMetaFields) Deserialize(r io.Reader) {
 978         for local34 := range (*(*(struct {
 979                 Pos      [3]int16
 980                 Formname string
 981                 Fields   []Field
 982         }))(obj)).Pos {
 983                 {
 984                         p := &((*(*(struct {
 985                                 Pos      [3]int16
 986                                 Formname string
 987                                 Fields   []Field
 988                         }))(obj)).Pos)[local34]
 989                         *p = int16(read16(r))
 990                 }
 991         }
 992         var local35 []uint8
 993         var local36 uint16
 994         {
 995                 p := &local36
 996                 *p = read16(r)
 997         }
 998         (local35) = make([]uint8, local36)
 999         {
1000                 _, err := io.ReadFull(r, (local35)[:])
1001                 chk(err)
1002         }
1003         ((*(*(struct {
1004                 Pos      [3]int16
1005                 Formname string
1006                 Fields   []Field
1007         }))(obj)).Formname) = string(local35)
1008         var local37 uint16
1009         {
1010                 p := &local37
1011                 *p = read16(r)
1012         }
1013         ((*(*(struct {
1014                 Pos      [3]int16
1015                 Formname string
1016                 Fields   []Field
1017         }))(obj)).Fields) = make([]Field, local37)
1018         for local38 := range (*(*(struct {
1019                 Pos      [3]int16
1020                 Formname string
1021                 Fields   []Field
1022         }))(obj)).Fields {
1023                 if err := pcall(func() {
1024                         (((*(*(struct {
1025                                 Pos      [3]int16
1026                                 Formname string
1027                                 Fields   []Field
1028                         }))(obj)).Fields)[local38]).Deserialize(r)
1029                 }); err != nil {
1030                         if err == io.EOF {
1031                                 chk(io.EOF)
1032                         }
1033                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1034                 }
1035         }
1036 }
1037
1038 func (obj *ToSrvInvFields) Serialize(w io.Writer) {
1039         if len(([]byte((*(*(struct {
1040                 Formname string
1041                 Fields   []Field
1042         }))(obj)).Formname))) > math.MaxUint16 {
1043                 chk(ErrTooLong)
1044         }
1045         {
1046                 x := uint16(len(([]byte((*(*(struct {
1047                         Formname string
1048                         Fields   []Field
1049                 }))(obj)).Formname))))
1050                 write16(w, uint16(x))
1051         }
1052         {
1053                 _, err := w.Write(([]byte((*(*(struct {
1054                         Formname string
1055                         Fields   []Field
1056                 }))(obj)).Formname))[:])
1057                 chk(err)
1058         }
1059         if len(((*(*(struct {
1060                 Formname string
1061                 Fields   []Field
1062         }))(obj)).Fields)) > math.MaxUint16 {
1063                 chk(ErrTooLong)
1064         }
1065         {
1066                 x := uint16(len(((*(*(struct {
1067                         Formname string
1068                         Fields   []Field
1069                 }))(obj)).Fields)))
1070                 write16(w, uint16(x))
1071         }
1072         for local39 := range (*(*(struct {
1073                 Formname string
1074                 Fields   []Field
1075         }))(obj)).Fields {
1076                 if err := pcall(func() {
1077                         (((*(*(struct {
1078                                 Formname string
1079                                 Fields   []Field
1080                         }))(obj)).Fields)[local39]).Serialize(w)
1081                 }); err != nil {
1082                         if err == io.EOF {
1083                                 chk(io.EOF)
1084                         }
1085                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1086                 }
1087         }
1088 }
1089
1090 func (obj *ToSrvInvFields) Deserialize(r io.Reader) {
1091         var local40 []uint8
1092         var local41 uint16
1093         {
1094                 p := &local41
1095                 *p = read16(r)
1096         }
1097         (local40) = make([]uint8, local41)
1098         {
1099                 _, err := io.ReadFull(r, (local40)[:])
1100                 chk(err)
1101         }
1102         ((*(*(struct {
1103                 Formname string
1104                 Fields   []Field
1105         }))(obj)).Formname) = string(local40)
1106         var local42 uint16
1107         {
1108                 p := &local42
1109                 *p = read16(r)
1110         }
1111         ((*(*(struct {
1112                 Formname string
1113                 Fields   []Field
1114         }))(obj)).Fields) = make([]Field, local42)
1115         for local43 := range (*(*(struct {
1116                 Formname string
1117                 Fields   []Field
1118         }))(obj)).Fields {
1119                 if err := pcall(func() {
1120                         (((*(*(struct {
1121                                 Formname string
1122                                 Fields   []Field
1123                         }))(obj)).Fields)[local43]).Deserialize(r)
1124                 }); err != nil {
1125                         if err == io.EOF {
1126                                 chk(io.EOF)
1127                         }
1128                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1129                 }
1130         }
1131 }
1132
1133 func (obj *ToSrvReqMedia) Serialize(w io.Writer) {
1134         if len(((*(*(struct {
1135                 Filenames []string
1136         }))(obj)).Filenames)) > math.MaxUint16 {
1137                 chk(ErrTooLong)
1138         }
1139         {
1140                 x := uint16(len(((*(*(struct {
1141                         Filenames []string
1142                 }))(obj)).Filenames)))
1143                 write16(w, uint16(x))
1144         }
1145         for local44 := range (*(*(struct {
1146                 Filenames []string
1147         }))(obj)).Filenames {
1148                 if len(([]byte(((*(*(struct {
1149                         Filenames []string
1150                 }))(obj)).Filenames)[local44]))) > math.MaxUint16 {
1151                         chk(ErrTooLong)
1152                 }
1153                 {
1154                         x := uint16(len(([]byte(((*(*(struct {
1155                                 Filenames []string
1156                         }))(obj)).Filenames)[local44]))))
1157                         write16(w, uint16(x))
1158                 }
1159                 {
1160                         _, err := w.Write(([]byte(((*(*(struct {
1161                                 Filenames []string
1162                         }))(obj)).Filenames)[local44]))[:])
1163                         chk(err)
1164                 }
1165         }
1166 }
1167
1168 func (obj *ToSrvReqMedia) Deserialize(r io.Reader) {
1169         var local45 uint16
1170         {
1171                 p := &local45
1172                 *p = read16(r)
1173         }
1174         ((*(*(struct {
1175                 Filenames []string
1176         }))(obj)).Filenames) = make([]string, local45)
1177         for local46 := range (*(*(struct {
1178                 Filenames []string
1179         }))(obj)).Filenames {
1180                 var local47 []uint8
1181                 var local48 uint16
1182                 {
1183                         p := &local48
1184                         *p = read16(r)
1185                 }
1186                 (local47) = make([]uint8, local48)
1187                 {
1188                         _, err := io.ReadFull(r, (local47)[:])
1189                         chk(err)
1190                 }
1191                 (((*(*(struct {
1192                         Filenames []string
1193                 }))(obj)).Filenames)[local46]) = string(local47)
1194         }
1195 }
1196
1197 func (obj *ToSrvCltReady) Serialize(w io.Writer) {
1198         {
1199                 x := (*(*(struct {
1200                         // Version information.
1201                         Major, Minor, Patch uint8
1202                         Reserved            uint8
1203                         Version             string
1204                         Formspec            uint16
1205                 }))(obj)).Major
1206                 write8(w, uint8(x))
1207         }
1208         {
1209                 x := (*(*(struct {
1210                         // Version information.
1211                         Major, Minor, Patch uint8
1212                         Reserved            uint8
1213                         Version             string
1214                         Formspec            uint16
1215                 }))(obj)).Minor
1216                 write8(w, uint8(x))
1217         }
1218         {
1219                 x := (*(*(struct {
1220                         // Version information.
1221                         Major, Minor, Patch uint8
1222                         Reserved            uint8
1223                         Version             string
1224                         Formspec            uint16
1225                 }))(obj)).Patch
1226                 write8(w, uint8(x))
1227         }
1228         {
1229                 x := (*(*(struct {
1230                         // Version information.
1231                         Major, Minor, Patch uint8
1232                         Reserved            uint8
1233                         Version             string
1234                         Formspec            uint16
1235                 }))(obj)).Reserved
1236                 write8(w, uint8(x))
1237         }
1238         if len(([]byte((*(*(struct {
1239                 // Version information.
1240                 Major, Minor, Patch uint8
1241                 Reserved            uint8
1242                 Version             string
1243                 Formspec            uint16
1244         }))(obj)).Version))) > math.MaxUint16 {
1245                 chk(ErrTooLong)
1246         }
1247         {
1248                 x := uint16(len(([]byte((*(*(struct {
1249                         // Version information.
1250                         Major, Minor, Patch uint8
1251                         Reserved            uint8
1252                         Version             string
1253                         Formspec            uint16
1254                 }))(obj)).Version))))
1255                 write16(w, uint16(x))
1256         }
1257         {
1258                 _, err := w.Write(([]byte((*(*(struct {
1259                         // Version information.
1260                         Major, Minor, Patch uint8
1261                         Reserved            uint8
1262                         Version             string
1263                         Formspec            uint16
1264                 }))(obj)).Version))[:])
1265                 chk(err)
1266         }
1267         {
1268                 x := (*(*(struct {
1269                         // Version information.
1270                         Major, Minor, Patch uint8
1271                         Reserved            uint8
1272                         Version             string
1273                         Formspec            uint16
1274                 }))(obj)).Formspec
1275                 write16(w, uint16(x))
1276         }
1277 }
1278
1279 func (obj *ToSrvCltReady) Deserialize(r io.Reader) {
1280         {
1281                 p := &(*(*(struct {
1282                         // Version information.
1283                         Major, Minor, Patch uint8
1284                         Reserved            uint8
1285                         Version             string
1286                         Formspec            uint16
1287                 }))(obj)).Major
1288                 *p = read8(r)
1289         }
1290         {
1291                 p := &(*(*(struct {
1292                         // Version information.
1293                         Major, Minor, Patch uint8
1294                         Reserved            uint8
1295                         Version             string
1296                         Formspec            uint16
1297                 }))(obj)).Minor
1298                 *p = read8(r)
1299         }
1300         {
1301                 p := &(*(*(struct {
1302                         // Version information.
1303                         Major, Minor, Patch uint8
1304                         Reserved            uint8
1305                         Version             string
1306                         Formspec            uint16
1307                 }))(obj)).Patch
1308                 *p = read8(r)
1309         }
1310         {
1311                 p := &(*(*(struct {
1312                         // Version information.
1313                         Major, Minor, Patch uint8
1314                         Reserved            uint8
1315                         Version             string
1316                         Formspec            uint16
1317                 }))(obj)).Reserved
1318                 *p = read8(r)
1319         }
1320         var local49 []uint8
1321         var local50 uint16
1322         {
1323                 p := &local50
1324                 *p = read16(r)
1325         }
1326         (local49) = make([]uint8, local50)
1327         {
1328                 _, err := io.ReadFull(r, (local49)[:])
1329                 chk(err)
1330         }
1331         ((*(*(struct {
1332                 // Version information.
1333                 Major, Minor, Patch uint8
1334                 Reserved            uint8
1335                 Version             string
1336                 Formspec            uint16
1337         }))(obj)).Version) = string(local49)
1338         {
1339                 p := &(*(*(struct {
1340                         // Version information.
1341                         Major, Minor, Patch uint8
1342                         Reserved            uint8
1343                         Version             string
1344                         Formspec            uint16
1345                 }))(obj)).Formspec
1346                 *p = read16(r)
1347         }
1348 }
1349
1350 func (obj *ToSrvFirstSRP) Serialize(w io.Writer) {
1351         if len(((*(*(struct {
1352                 Salt        []byte
1353                 Verifier    []byte
1354                 EmptyPasswd bool
1355         }))(obj)).Salt)) > math.MaxUint16 {
1356                 chk(ErrTooLong)
1357         }
1358         {
1359                 x := uint16(len(((*(*(struct {
1360                         Salt        []byte
1361                         Verifier    []byte
1362                         EmptyPasswd bool
1363                 }))(obj)).Salt)))
1364                 write16(w, uint16(x))
1365         }
1366         {
1367                 _, err := w.Write(((*(*(struct {
1368                         Salt        []byte
1369                         Verifier    []byte
1370                         EmptyPasswd bool
1371                 }))(obj)).Salt)[:])
1372                 chk(err)
1373         }
1374         if len(((*(*(struct {
1375                 Salt        []byte
1376                 Verifier    []byte
1377                 EmptyPasswd bool
1378         }))(obj)).Verifier)) > math.MaxUint16 {
1379                 chk(ErrTooLong)
1380         }
1381         {
1382                 x := uint16(len(((*(*(struct {
1383                         Salt        []byte
1384                         Verifier    []byte
1385                         EmptyPasswd bool
1386                 }))(obj)).Verifier)))
1387                 write16(w, uint16(x))
1388         }
1389         {
1390                 _, err := w.Write(((*(*(struct {
1391                         Salt        []byte
1392                         Verifier    []byte
1393                         EmptyPasswd bool
1394                 }))(obj)).Verifier)[:])
1395                 chk(err)
1396         }
1397         {
1398                 x := (*(*(struct {
1399                         Salt        []byte
1400                         Verifier    []byte
1401                         EmptyPasswd bool
1402                 }))(obj)).EmptyPasswd
1403                 if x {
1404                         write8(w, 1)
1405                 } else {
1406                         write8(w, 0)
1407                 }
1408         }
1409 }
1410
1411 func (obj *ToSrvFirstSRP) Deserialize(r io.Reader) {
1412         var local51 uint16
1413         {
1414                 p := &local51
1415                 *p = read16(r)
1416         }
1417         ((*(*(struct {
1418                 Salt        []byte
1419                 Verifier    []byte
1420                 EmptyPasswd bool
1421         }))(obj)).Salt) = make([]byte, local51)
1422         {
1423                 _, err := io.ReadFull(r, ((*(*(struct {
1424                         Salt        []byte
1425                         Verifier    []byte
1426                         EmptyPasswd bool
1427                 }))(obj)).Salt)[:])
1428                 chk(err)
1429         }
1430         var local52 uint16
1431         {
1432                 p := &local52
1433                 *p = read16(r)
1434         }
1435         ((*(*(struct {
1436                 Salt        []byte
1437                 Verifier    []byte
1438                 EmptyPasswd bool
1439         }))(obj)).Verifier) = make([]byte, local52)
1440         {
1441                 _, err := io.ReadFull(r, ((*(*(struct {
1442                         Salt        []byte
1443                         Verifier    []byte
1444                         EmptyPasswd bool
1445                 }))(obj)).Verifier)[:])
1446                 chk(err)
1447         }
1448         {
1449                 p := &(*(*(struct {
1450                         Salt        []byte
1451                         Verifier    []byte
1452                         EmptyPasswd bool
1453                 }))(obj)).EmptyPasswd
1454                 switch n := read8(r); n {
1455                 case 0:
1456                         *p = false
1457                 case 1:
1458                         *p = true
1459                 default:
1460                         chk(fmt.Errorf("invalid bool: %d", n))
1461                 }
1462         }
1463 }
1464
1465 func (obj *ToSrvSRPBytesA) Serialize(w io.Writer) {
1466         if len(((*(*(struct {
1467                 A      []byte
1468                 NoSHA1 bool
1469         }))(obj)).A)) > math.MaxUint16 {
1470                 chk(ErrTooLong)
1471         }
1472         {
1473                 x := uint16(len(((*(*(struct {
1474                         A      []byte
1475                         NoSHA1 bool
1476                 }))(obj)).A)))
1477                 write16(w, uint16(x))
1478         }
1479         {
1480                 _, err := w.Write(((*(*(struct {
1481                         A      []byte
1482                         NoSHA1 bool
1483                 }))(obj)).A)[:])
1484                 chk(err)
1485         }
1486         {
1487                 x := (*(*(struct {
1488                         A      []byte
1489                         NoSHA1 bool
1490                 }))(obj)).NoSHA1
1491                 if x {
1492                         write8(w, 1)
1493                 } else {
1494                         write8(w, 0)
1495                 }
1496         }
1497 }
1498
1499 func (obj *ToSrvSRPBytesA) Deserialize(r io.Reader) {
1500         var local53 uint16
1501         {
1502                 p := &local53
1503                 *p = read16(r)
1504         }
1505         ((*(*(struct {
1506                 A      []byte
1507                 NoSHA1 bool
1508         }))(obj)).A) = make([]byte, local53)
1509         {
1510                 _, err := io.ReadFull(r, ((*(*(struct {
1511                         A      []byte
1512                         NoSHA1 bool
1513                 }))(obj)).A)[:])
1514                 chk(err)
1515         }
1516         {
1517                 p := &(*(*(struct {
1518                         A      []byte
1519                         NoSHA1 bool
1520                 }))(obj)).NoSHA1
1521                 switch n := read8(r); n {
1522                 case 0:
1523                         *p = false
1524                 case 1:
1525                         *p = true
1526                 default:
1527                         chk(fmt.Errorf("invalid bool: %d", n))
1528                 }
1529         }
1530 }
1531
1532 func (obj *ToSrvSRPBytesM) Serialize(w io.Writer) {
1533         if len(((*(*(struct {
1534                 M []byte
1535         }))(obj)).M)) > math.MaxUint16 {
1536                 chk(ErrTooLong)
1537         }
1538         {
1539                 x := uint16(len(((*(*(struct {
1540                         M []byte
1541                 }))(obj)).M)))
1542                 write16(w, uint16(x))
1543         }
1544         {
1545                 _, err := w.Write(((*(*(struct {
1546                         M []byte
1547                 }))(obj)).M)[:])
1548                 chk(err)
1549         }
1550 }
1551
1552 func (obj *ToSrvSRPBytesM) Deserialize(r io.Reader) {
1553         var local54 uint16
1554         {
1555                 p := &local54
1556                 *p = read16(r)
1557         }
1558         ((*(*(struct {
1559                 M []byte
1560         }))(obj)).M) = make([]byte, local54)
1561         {
1562                 _, err := io.ReadFull(r, ((*(*(struct {
1563                         M []byte
1564                 }))(obj)).M)[:])
1565                 chk(err)
1566         }
1567 }
1568
1569 func (obj *ToCltHello) Serialize(w io.Writer) {
1570         {
1571                 x := (*(*(struct {
1572                         SerializeVer uint8
1573                         Compression  CompressionModes
1574                         ProtoVer     uint16
1575                         AuthMethods
1576                         Username string
1577                 }))(obj)).SerializeVer
1578                 write8(w, uint8(x))
1579         }
1580         if err := pcall(func() {
1581                 ((*(*(struct {
1582                         SerializeVer uint8
1583                         Compression  CompressionModes
1584                         ProtoVer     uint16
1585                         AuthMethods
1586                         Username string
1587                 }))(obj)).Compression).Serialize(w)
1588         }); err != nil {
1589                 if err == io.EOF {
1590                         chk(io.EOF)
1591                 }
1592                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
1593         }
1594         {
1595                 x := (*(*(struct {
1596                         SerializeVer uint8
1597                         Compression  CompressionModes
1598                         ProtoVer     uint16
1599                         AuthMethods
1600                         Username string
1601                 }))(obj)).ProtoVer
1602                 write16(w, uint16(x))
1603         }
1604         if err := pcall(func() {
1605                 ((*(*(struct {
1606                         SerializeVer uint8
1607                         Compression  CompressionModes
1608                         ProtoVer     uint16
1609                         AuthMethods
1610                         Username string
1611                 }))(obj)).AuthMethods).Serialize(w)
1612         }); err != nil {
1613                 if err == io.EOF {
1614                         chk(io.EOF)
1615                 }
1616                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1617         }
1618         if len(([]byte((*(*(struct {
1619                 SerializeVer uint8
1620                 Compression  CompressionModes
1621                 ProtoVer     uint16
1622                 AuthMethods
1623                 Username string
1624         }))(obj)).Username))) > math.MaxUint16 {
1625                 chk(ErrTooLong)
1626         }
1627         {
1628                 x := uint16(len(([]byte((*(*(struct {
1629                         SerializeVer uint8
1630                         Compression  CompressionModes
1631                         ProtoVer     uint16
1632                         AuthMethods
1633                         Username string
1634                 }))(obj)).Username))))
1635                 write16(w, uint16(x))
1636         }
1637         {
1638                 _, err := w.Write(([]byte((*(*(struct {
1639                         SerializeVer uint8
1640                         Compression  CompressionModes
1641                         ProtoVer     uint16
1642                         AuthMethods
1643                         Username string
1644                 }))(obj)).Username))[:])
1645                 chk(err)
1646         }
1647 }
1648
1649 func (obj *ToCltHello) Deserialize(r io.Reader) {
1650         {
1651                 p := &(*(*(struct {
1652                         SerializeVer uint8
1653                         Compression  CompressionModes
1654                         ProtoVer     uint16
1655                         AuthMethods
1656                         Username string
1657                 }))(obj)).SerializeVer
1658                 *p = read8(r)
1659         }
1660         if err := pcall(func() {
1661                 ((*(*(struct {
1662                         SerializeVer uint8
1663                         Compression  CompressionModes
1664                         ProtoVer     uint16
1665                         AuthMethods
1666                         Username string
1667                 }))(obj)).Compression).Deserialize(r)
1668         }); err != nil {
1669                 if err == io.EOF {
1670                         chk(io.EOF)
1671                 }
1672                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
1673         }
1674         {
1675                 p := &(*(*(struct {
1676                         SerializeVer uint8
1677                         Compression  CompressionModes
1678                         ProtoVer     uint16
1679                         AuthMethods
1680                         Username string
1681                 }))(obj)).ProtoVer
1682                 *p = read16(r)
1683         }
1684         if err := pcall(func() {
1685                 ((*(*(struct {
1686                         SerializeVer uint8
1687                         Compression  CompressionModes
1688                         ProtoVer     uint16
1689                         AuthMethods
1690                         Username string
1691                 }))(obj)).AuthMethods).Deserialize(r)
1692         }); err != nil {
1693                 if err == io.EOF {
1694                         chk(io.EOF)
1695                 }
1696                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1697         }
1698         var local55 []uint8
1699         var local56 uint16
1700         {
1701                 p := &local56
1702                 *p = read16(r)
1703         }
1704         (local55) = make([]uint8, local56)
1705         {
1706                 _, err := io.ReadFull(r, (local55)[:])
1707                 chk(err)
1708         }
1709         ((*(*(struct {
1710                 SerializeVer uint8
1711                 Compression  CompressionModes
1712                 ProtoVer     uint16
1713                 AuthMethods
1714                 Username string
1715         }))(obj)).Username) = string(local55)
1716 }
1717
1718 func (obj *ToCltAcceptAuth) Serialize(w io.Writer) {
1719         if err := pcall(func() {
1720                 ((*(*(struct {
1721                         // The client does the equivalent of
1722                         //      PlayerPos[1] -= 5
1723                         // before using PlayerPos.
1724                         PlayerPos Pos
1725
1726                         MapSeed         uint64
1727                         SendInterval    float32
1728                         SudoAuthMethods AuthMethods
1729                 }))(obj)).PlayerPos).Serialize(w)
1730         }); err != nil {
1731                 if err == io.EOF {
1732                         chk(io.EOF)
1733                 }
1734                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
1735         }
1736         {
1737                 x := (*(*(struct {
1738                         // The client does the equivalent of
1739                         //      PlayerPos[1] -= 5
1740                         // before using PlayerPos.
1741                         PlayerPos Pos
1742
1743                         MapSeed         uint64
1744                         SendInterval    float32
1745                         SudoAuthMethods AuthMethods
1746                 }))(obj)).MapSeed
1747                 write64(w, uint64(x))
1748         }
1749         {
1750                 x := (*(*(struct {
1751                         // The client does the equivalent of
1752                         //      PlayerPos[1] -= 5
1753                         // before using PlayerPos.
1754                         PlayerPos Pos
1755
1756                         MapSeed         uint64
1757                         SendInterval    float32
1758                         SudoAuthMethods AuthMethods
1759                 }))(obj)).SendInterval
1760                 write32(w, math.Float32bits(x))
1761         }
1762         if err := pcall(func() {
1763                 ((*(*(struct {
1764                         // The client does the equivalent of
1765                         //      PlayerPos[1] -= 5
1766                         // before using PlayerPos.
1767                         PlayerPos Pos
1768
1769                         MapSeed         uint64
1770                         SendInterval    float32
1771                         SudoAuthMethods AuthMethods
1772                 }))(obj)).SudoAuthMethods).Serialize(w)
1773         }); err != nil {
1774                 if err == io.EOF {
1775                         chk(io.EOF)
1776                 }
1777                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1778         }
1779 }
1780
1781 func (obj *ToCltAcceptAuth) Deserialize(r io.Reader) {
1782         if err := pcall(func() {
1783                 ((*(*(struct {
1784                         // The client does the equivalent of
1785                         //      PlayerPos[1] -= 5
1786                         // before using PlayerPos.
1787                         PlayerPos Pos
1788
1789                         MapSeed         uint64
1790                         SendInterval    float32
1791                         SudoAuthMethods AuthMethods
1792                 }))(obj)).PlayerPos).Deserialize(r)
1793         }); err != nil {
1794                 if err == io.EOF {
1795                         chk(io.EOF)
1796                 }
1797                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
1798         }
1799         {
1800                 p := &(*(*(struct {
1801                         // The client does the equivalent of
1802                         //      PlayerPos[1] -= 5
1803                         // before using PlayerPos.
1804                         PlayerPos Pos
1805
1806                         MapSeed         uint64
1807                         SendInterval    float32
1808                         SudoAuthMethods AuthMethods
1809                 }))(obj)).MapSeed
1810                 *p = read64(r)
1811         }
1812         {
1813                 p := &(*(*(struct {
1814                         // The client does the equivalent of
1815                         //      PlayerPos[1] -= 5
1816                         // before using PlayerPos.
1817                         PlayerPos Pos
1818
1819                         MapSeed         uint64
1820                         SendInterval    float32
1821                         SudoAuthMethods AuthMethods
1822                 }))(obj)).SendInterval
1823                 *p = math.Float32frombits(read32(r))
1824         }
1825         if err := pcall(func() {
1826                 ((*(*(struct {
1827                         // The client does the equivalent of
1828                         //      PlayerPos[1] -= 5
1829                         // before using PlayerPos.
1830                         PlayerPos Pos
1831
1832                         MapSeed         uint64
1833                         SendInterval    float32
1834                         SudoAuthMethods AuthMethods
1835                 }))(obj)).SudoAuthMethods).Deserialize(r)
1836         }); err != nil {
1837                 if err == io.EOF {
1838                         chk(io.EOF)
1839                 }
1840                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1841         }
1842 }
1843
1844 func (obj *ToCltAcceptSudoMode) Serialize(w io.Writer) {
1845         if err := pcall(func() {
1846                 ((*(*(struct {
1847                         SudoAuthMethods AuthMethods
1848                 }))(obj)).SudoAuthMethods).Serialize(w)
1849         }); err != nil {
1850                 if err == io.EOF {
1851                         chk(io.EOF)
1852                 }
1853                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1854         }
1855         {
1856                 local57 := [15]byte{}
1857                 {
1858                         _, err := w.Write((local57)[:])
1859                         chk(err)
1860                 }
1861         }
1862 }
1863
1864 func (obj *ToCltAcceptSudoMode) Deserialize(r io.Reader) {
1865         if err := pcall(func() {
1866                 ((*(*(struct {
1867                         SudoAuthMethods AuthMethods
1868                 }))(obj)).SudoAuthMethods).Deserialize(r)
1869         }); err != nil {
1870                 if err == io.EOF {
1871                         chk(io.EOF)
1872                 }
1873                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1874         }
1875         {
1876                 var local58 [15]byte
1877                 local59 := [15]byte{}
1878                 {
1879                         _, err := io.ReadFull(r, (local58)[:])
1880                         chk(err)
1881                 }
1882                 if local58 != local59 {
1883                         chk(fmt.Errorf("const %v: %v", "[15]byte{}", local58))
1884                 }
1885         }
1886 }
1887
1888 func (obj *ToCltDenySudoMode) Serialize(w io.Writer) {
1889 }
1890
1891 func (obj *ToCltDenySudoMode) Deserialize(r io.Reader) {
1892 }
1893
1894 func (obj *ToCltKick) Serialize(w io.Writer) {
1895         if err := pcall(func() {
1896                 ((*(*(struct {
1897                         Reason KickReason
1898
1899                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1900                         Custom string
1901
1902                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1903                         Reconnect bool
1904                 }))(obj)).Reason).Serialize(w)
1905         }); err != nil {
1906                 if err == io.EOF {
1907                         chk(io.EOF)
1908                 }
1909                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.KickReason", err))
1910         }
1911         if !((*(*(struct {
1912                 Reason KickReason
1913
1914                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1915                 Custom string
1916
1917                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1918                 Reconnect bool
1919         }))(obj)).Reason < maxKickReason) {
1920                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
1921         }
1922         if dr := (*(*(struct {
1923                 Reason KickReason
1924
1925                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1926                 Custom string
1927
1928                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1929                 Reconnect bool
1930         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
1931                 if len(([]byte((*(*(struct {
1932                         Reason KickReason
1933
1934                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1935                         Custom string
1936
1937                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1938                         Reconnect bool
1939                 }))(obj)).Custom))) > math.MaxUint16 {
1940                         chk(ErrTooLong)
1941                 }
1942                 {
1943                         x := uint16(len(([]byte((*(*(struct {
1944                                 Reason KickReason
1945
1946                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1947                                 Custom string
1948
1949                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1950                                 Reconnect bool
1951                         }))(obj)).Custom))))
1952                         write16(w, uint16(x))
1953                 }
1954                 {
1955                         _, err := w.Write(([]byte((*(*(struct {
1956                                 Reason KickReason
1957
1958                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1959                                 Custom string
1960
1961                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1962                                 Reconnect bool
1963                         }))(obj)).Custom))[:])
1964                         chk(err)
1965                 }
1966         }
1967         if dr := (*(*(struct {
1968                 Reason KickReason
1969
1970                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1971                 Custom string
1972
1973                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1974                 Reconnect bool
1975         }))(obj)).Reason; dr == Shutdown || dr == Crash {
1976                 {
1977                         x := (*(*(struct {
1978                                 Reason KickReason
1979
1980                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1981                                 Custom string
1982
1983                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1984                                 Reconnect bool
1985                         }))(obj)).Reconnect
1986                         if x {
1987                                 write8(w, 1)
1988                         } else {
1989                                 write8(w, 0)
1990                         }
1991                 }
1992         }
1993 }
1994
1995 func (obj *ToCltKick) Deserialize(r io.Reader) {
1996         if err := pcall(func() {
1997                 ((*(*(struct {
1998                         Reason KickReason
1999
2000                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2001                         Custom string
2002
2003                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2004                         Reconnect bool
2005                 }))(obj)).Reason).Deserialize(r)
2006         }); err != nil {
2007                 if err == io.EOF {
2008                         chk(io.EOF)
2009                 }
2010                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.KickReason", err))
2011         }
2012         if !((*(*(struct {
2013                 Reason KickReason
2014
2015                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2016                 Custom string
2017
2018                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2019                 Reconnect bool
2020         }))(obj)).Reason < maxKickReason) {
2021                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
2022         }
2023         if dr := (*(*(struct {
2024                 Reason KickReason
2025
2026                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2027                 Custom string
2028
2029                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2030                 Reconnect bool
2031         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
2032                 var local60 []uint8
2033                 var local61 uint16
2034                 {
2035                         p := &local61
2036                         *p = read16(r)
2037                 }
2038                 (local60) = make([]uint8, local61)
2039                 {
2040                         _, err := io.ReadFull(r, (local60)[:])
2041                         chk(err)
2042                 }
2043                 ((*(*(struct {
2044                         Reason KickReason
2045
2046                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2047                         Custom string
2048
2049                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2050                         Reconnect bool
2051                 }))(obj)).Custom) = string(local60)
2052         }
2053         if dr := (*(*(struct {
2054                 Reason KickReason
2055
2056                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2057                 Custom string
2058
2059                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2060                 Reconnect bool
2061         }))(obj)).Reason; dr == Shutdown || dr == Crash {
2062                 {
2063                         p := &(*(*(struct {
2064                                 Reason KickReason
2065
2066                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2067                                 Custom string
2068
2069                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2070                                 Reconnect bool
2071                         }))(obj)).Reconnect
2072                         switch n := read8(r); n {
2073                         case 0:
2074                                 *p = false
2075                         case 1:
2076                                 *p = true
2077                         default:
2078                                 chk(fmt.Errorf("invalid bool: %d", n))
2079                         }
2080                 }
2081         }
2082 }
2083
2084 func (obj *ToCltBlkData) Serialize(w io.Writer) {
2085         for local62 := range (*(*(struct {
2086                 Blkpos [3]int16
2087                 Blk    MapBlk
2088         }))(obj)).Blkpos {
2089                 {
2090                         x := ((*(*(struct {
2091                                 Blkpos [3]int16
2092                                 Blk    MapBlk
2093                         }))(obj)).Blkpos)[local62]
2094                         write16(w, uint16(x))
2095                 }
2096         }
2097         if err := pcall(func() {
2098                 ((*(*(struct {
2099                         Blkpos [3]int16
2100                         Blk    MapBlk
2101                 }))(obj)).Blk).Serialize(w)
2102         }); err != nil {
2103                 if err == io.EOF {
2104                         chk(io.EOF)
2105                 }
2106                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlk", err))
2107         }
2108 }
2109
2110 func (obj *ToCltBlkData) Deserialize(r io.Reader) {
2111         for local63 := range (*(*(struct {
2112                 Blkpos [3]int16
2113                 Blk    MapBlk
2114         }))(obj)).Blkpos {
2115                 {
2116                         p := &((*(*(struct {
2117                                 Blkpos [3]int16
2118                                 Blk    MapBlk
2119                         }))(obj)).Blkpos)[local63]
2120                         *p = int16(read16(r))
2121                 }
2122         }
2123         if err := pcall(func() {
2124                 ((*(*(struct {
2125                         Blkpos [3]int16
2126                         Blk    MapBlk
2127                 }))(obj)).Blk).Deserialize(r)
2128         }); err != nil {
2129                 if err == io.EOF {
2130                         chk(io.EOF)
2131                 }
2132                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlk", err))
2133         }
2134 }
2135
2136 func (obj *ToCltAddNode) Serialize(w io.Writer) {
2137         for local64 := range (*(*(struct {
2138                 Pos [3]int16
2139                 Node
2140                 KeepMeta bool
2141         }))(obj)).Pos {
2142                 {
2143                         x := ((*(*(struct {
2144                                 Pos [3]int16
2145                                 Node
2146                                 KeepMeta bool
2147                         }))(obj)).Pos)[local64]
2148                         write16(w, uint16(x))
2149                 }
2150         }
2151         if err := pcall(func() {
2152                 ((*(*(struct {
2153                         Pos [3]int16
2154                         Node
2155                         KeepMeta bool
2156                 }))(obj)).Node).Serialize(w)
2157         }); err != nil {
2158                 if err == io.EOF {
2159                         chk(io.EOF)
2160                 }
2161                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Node", err))
2162         }
2163         {
2164                 x := (*(*(struct {
2165                         Pos [3]int16
2166                         Node
2167                         KeepMeta bool
2168                 }))(obj)).KeepMeta
2169                 if x {
2170                         write8(w, 1)
2171                 } else {
2172                         write8(w, 0)
2173                 }
2174         }
2175 }
2176
2177 func (obj *ToCltAddNode) Deserialize(r io.Reader) {
2178         for local65 := range (*(*(struct {
2179                 Pos [3]int16
2180                 Node
2181                 KeepMeta bool
2182         }))(obj)).Pos {
2183                 {
2184                         p := &((*(*(struct {
2185                                 Pos [3]int16
2186                                 Node
2187                                 KeepMeta bool
2188                         }))(obj)).Pos)[local65]
2189                         *p = int16(read16(r))
2190                 }
2191         }
2192         if err := pcall(func() {
2193                 ((*(*(struct {
2194                         Pos [3]int16
2195                         Node
2196                         KeepMeta bool
2197                 }))(obj)).Node).Deserialize(r)
2198         }); err != nil {
2199                 if err == io.EOF {
2200                         chk(io.EOF)
2201                 }
2202                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Node", err))
2203         }
2204         {
2205                 p := &(*(*(struct {
2206                         Pos [3]int16
2207                         Node
2208                         KeepMeta bool
2209                 }))(obj)).KeepMeta
2210                 switch n := read8(r); n {
2211                 case 0:
2212                         *p = false
2213                 case 1:
2214                         *p = true
2215                 default:
2216                         chk(fmt.Errorf("invalid bool: %d", n))
2217                 }
2218         }
2219 }
2220
2221 func (obj *ToCltRemoveNode) Serialize(w io.Writer) {
2222         for local66 := range (*(*(struct {
2223                 Pos [3]int16
2224         }))(obj)).Pos {
2225                 {
2226                         x := ((*(*(struct {
2227                                 Pos [3]int16
2228                         }))(obj)).Pos)[local66]
2229                         write16(w, uint16(x))
2230                 }
2231         }
2232 }
2233
2234 func (obj *ToCltRemoveNode) Deserialize(r io.Reader) {
2235         for local67 := range (*(*(struct {
2236                 Pos [3]int16
2237         }))(obj)).Pos {
2238                 {
2239                         p := &((*(*(struct {
2240                                 Pos [3]int16
2241                         }))(obj)).Pos)[local67]
2242                         *p = int16(read16(r))
2243                 }
2244         }
2245 }
2246
2247 func (obj *ToCltInv) Serialize(w io.Writer) {
2248         {
2249                 _, err := w.Write(([]byte((*(*(struct {
2250                         //mt:raw
2251                         Inv string
2252                 }))(obj)).Inv))[:])
2253                 chk(err)
2254         }
2255 }
2256
2257 func (obj *ToCltInv) Deserialize(r io.Reader) {
2258         var local68 []uint8
2259         {
2260                 var err error
2261                 (local68), err = io.ReadAll(r)
2262                 chk(err)
2263         }
2264         ((*(*(struct {
2265                 //mt:raw
2266                 Inv string
2267         }))(obj)).Inv) = string(local68)
2268 }
2269
2270 func (obj *ToCltTimeOfDay) Serialize(w io.Writer) {
2271         {
2272                 x := (*(*(struct {
2273                         Time  uint16  // %24000
2274                         Speed float32 // Speed times faster than real time
2275                 }))(obj)).Time
2276                 write16(w, uint16(x))
2277         }
2278         {
2279                 x := (*(*(struct {
2280                         Time  uint16  // %24000
2281                         Speed float32 // Speed times faster than real time
2282                 }))(obj)).Speed
2283                 write32(w, math.Float32bits(x))
2284         }
2285 }
2286
2287 func (obj *ToCltTimeOfDay) Deserialize(r io.Reader) {
2288         {
2289                 p := &(*(*(struct {
2290                         Time  uint16  // %24000
2291                         Speed float32 // Speed times faster than real time
2292                 }))(obj)).Time
2293                 *p = read16(r)
2294         }
2295         {
2296                 p := &(*(*(struct {
2297                         Time  uint16  // %24000
2298                         Speed float32 // Speed times faster than real time
2299                 }))(obj)).Speed
2300                 *p = math.Float32frombits(read32(r))
2301         }
2302 }
2303
2304 func (obj *ToCltCSMRestrictionFlags) Serialize(w io.Writer) {
2305         if err := pcall(func() {
2306                 ((*(*(struct {
2307                         Flags CSMRestrictionFlags
2308
2309                         // MapRange is the maximum distance from the player CSMs can read the map
2310                         // if Flags&LimitMapRange != 0.
2311                         MapRange uint32
2312                 }))(obj)).Flags).Serialize(w)
2313         }); err != nil {
2314                 if err == io.EOF {
2315                         chk(io.EOF)
2316                 }
2317                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CSMRestrictionFlags", err))
2318         }
2319         {
2320                 x := (*(*(struct {
2321                         Flags CSMRestrictionFlags
2322
2323                         // MapRange is the maximum distance from the player CSMs can read the map
2324                         // if Flags&LimitMapRange != 0.
2325                         MapRange uint32
2326                 }))(obj)).MapRange
2327                 write32(w, uint32(x))
2328         }
2329 }
2330
2331 func (obj *ToCltCSMRestrictionFlags) Deserialize(r io.Reader) {
2332         if err := pcall(func() {
2333                 ((*(*(struct {
2334                         Flags CSMRestrictionFlags
2335
2336                         // MapRange is the maximum distance from the player CSMs can read the map
2337                         // if Flags&LimitMapRange != 0.
2338                         MapRange uint32
2339                 }))(obj)).Flags).Deserialize(r)
2340         }); err != nil {
2341                 if err == io.EOF {
2342                         chk(io.EOF)
2343                 }
2344                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CSMRestrictionFlags", err))
2345         }
2346         {
2347                 p := &(*(*(struct {
2348                         Flags CSMRestrictionFlags
2349
2350                         // MapRange is the maximum distance from the player CSMs can read the map
2351                         // if Flags&LimitMapRange != 0.
2352                         MapRange uint32
2353                 }))(obj)).MapRange
2354                 *p = read32(r)
2355         }
2356 }
2357
2358 func (obj *ToCltAddPlayerVel) Serialize(w io.Writer) {
2359         if err := pcall(func() {
2360                 ((*(*(struct {
2361                         Vel Vec
2362                 }))(obj)).Vel).Serialize(w)
2363         }); err != nil {
2364                 if err == io.EOF {
2365                         chk(io.EOF)
2366                 }
2367                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
2368         }
2369 }
2370
2371 func (obj *ToCltAddPlayerVel) Deserialize(r io.Reader) {
2372         if err := pcall(func() {
2373                 ((*(*(struct {
2374                         Vel Vec
2375                 }))(obj)).Vel).Deserialize(r)
2376         }); err != nil {
2377                 if err == io.EOF {
2378                         chk(io.EOF)
2379                 }
2380                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
2381         }
2382 }
2383
2384 func (obj *ToCltMediaPush) Serialize(w io.Writer) {
2385         {
2386                 local69 := uint16(sha1.Size)
2387                 {
2388                         x := local69
2389                         write16(w, uint16(x))
2390                 }
2391         }
2392         {
2393                 _, err := w.Write(((*(*(struct {
2394                         //mt:const uint16(sha1.Size)
2395                         SHA1        [sha1.Size]byte
2396                         Filename    string
2397                         ShouldCache bool
2398
2399                         //mt:len32
2400                         Data []byte
2401                 }))(obj)).SHA1)[:])
2402                 chk(err)
2403         }
2404         if len(([]byte((*(*(struct {
2405                 //mt:const uint16(sha1.Size)
2406                 SHA1        [sha1.Size]byte
2407                 Filename    string
2408                 ShouldCache bool
2409
2410                 //mt:len32
2411                 Data []byte
2412         }))(obj)).Filename))) > math.MaxUint16 {
2413                 chk(ErrTooLong)
2414         }
2415         {
2416                 x := uint16(len(([]byte((*(*(struct {
2417                         //mt:const uint16(sha1.Size)
2418                         SHA1        [sha1.Size]byte
2419                         Filename    string
2420                         ShouldCache bool
2421
2422                         //mt:len32
2423                         Data []byte
2424                 }))(obj)).Filename))))
2425                 write16(w, uint16(x))
2426         }
2427         {
2428                 _, err := w.Write(([]byte((*(*(struct {
2429                         //mt:const uint16(sha1.Size)
2430                         SHA1        [sha1.Size]byte
2431                         Filename    string
2432                         ShouldCache bool
2433
2434                         //mt:len32
2435                         Data []byte
2436                 }))(obj)).Filename))[:])
2437                 chk(err)
2438         }
2439         {
2440                 x := (*(*(struct {
2441                         //mt:const uint16(sha1.Size)
2442                         SHA1        [sha1.Size]byte
2443                         Filename    string
2444                         ShouldCache bool
2445
2446                         //mt:len32
2447                         Data []byte
2448                 }))(obj)).ShouldCache
2449                 if x {
2450                         write8(w, 1)
2451                 } else {
2452                         write8(w, 0)
2453                 }
2454         }
2455         if len(((*(*(struct {
2456                 //mt:const uint16(sha1.Size)
2457                 SHA1        [sha1.Size]byte
2458                 Filename    string
2459                 ShouldCache bool
2460
2461                 //mt:len32
2462                 Data []byte
2463         }))(obj)).Data)) > math.MaxUint32 {
2464                 chk(ErrTooLong)
2465         }
2466         {
2467                 x := uint32(len(((*(*(struct {
2468                         //mt:const uint16(sha1.Size)
2469                         SHA1        [sha1.Size]byte
2470                         Filename    string
2471                         ShouldCache bool
2472
2473                         //mt:len32
2474                         Data []byte
2475                 }))(obj)).Data)))
2476                 write32(w, uint32(x))
2477         }
2478         {
2479                 _, err := w.Write(((*(*(struct {
2480                         //mt:const uint16(sha1.Size)
2481                         SHA1        [sha1.Size]byte
2482                         Filename    string
2483                         ShouldCache bool
2484
2485                         //mt:len32
2486                         Data []byte
2487                 }))(obj)).Data)[:])
2488                 chk(err)
2489         }
2490 }
2491
2492 func (obj *ToCltMediaPush) Deserialize(r io.Reader) {
2493         {
2494                 var local70 uint16
2495                 local71 := uint16(sha1.Size)
2496                 {
2497                         p := &local70
2498                         *p = read16(r)
2499                 }
2500                 if local70 != local71 {
2501                         chk(fmt.Errorf("const %v: %v", "uint16(sha1.Size)", local70))
2502                 }
2503         }
2504         {
2505                 _, err := io.ReadFull(r, ((*(*(struct {
2506                         //mt:const uint16(sha1.Size)
2507                         SHA1        [sha1.Size]byte
2508                         Filename    string
2509                         ShouldCache bool
2510
2511                         //mt:len32
2512                         Data []byte
2513                 }))(obj)).SHA1)[:])
2514                 chk(err)
2515         }
2516         var local72 []uint8
2517         var local73 uint16
2518         {
2519                 p := &local73
2520                 *p = read16(r)
2521         }
2522         (local72) = make([]uint8, local73)
2523         {
2524                 _, err := io.ReadFull(r, (local72)[:])
2525                 chk(err)
2526         }
2527         ((*(*(struct {
2528                 //mt:const uint16(sha1.Size)
2529                 SHA1        [sha1.Size]byte
2530                 Filename    string
2531                 ShouldCache bool
2532
2533                 //mt:len32
2534                 Data []byte
2535         }))(obj)).Filename) = string(local72)
2536         {
2537                 p := &(*(*(struct {
2538                         //mt:const uint16(sha1.Size)
2539                         SHA1        [sha1.Size]byte
2540                         Filename    string
2541                         ShouldCache bool
2542
2543                         //mt:len32
2544                         Data []byte
2545                 }))(obj)).ShouldCache
2546                 switch n := read8(r); n {
2547                 case 0:
2548                         *p = false
2549                 case 1:
2550                         *p = true
2551                 default:
2552                         chk(fmt.Errorf("invalid bool: %d", n))
2553                 }
2554         }
2555         var local74 uint32
2556         {
2557                 p := &local74
2558                 *p = read32(r)
2559         }
2560         ((*(*(struct {
2561                 //mt:const uint16(sha1.Size)
2562                 SHA1        [sha1.Size]byte
2563                 Filename    string
2564                 ShouldCache bool
2565
2566                 //mt:len32
2567                 Data []byte
2568         }))(obj)).Data) = make([]byte, local74)
2569         {
2570                 _, err := io.ReadFull(r, ((*(*(struct {
2571                         //mt:const uint16(sha1.Size)
2572                         SHA1        [sha1.Size]byte
2573                         Filename    string
2574                         ShouldCache bool
2575
2576                         //mt:len32
2577                         Data []byte
2578                 }))(obj)).Data)[:])
2579                 chk(err)
2580         }
2581 }
2582
2583 func (obj *ToCltChatMsg) Serialize(w io.Writer) {
2584         {
2585                 local75 := uint8(1)
2586                 {
2587                         x := local75
2588                         write8(w, uint8(x))
2589                 }
2590         }
2591         if err := pcall(func() {
2592                 ((*(*(struct {
2593                         Type ChatMsgType
2594
2595                         //mt:utf16
2596                         Sender, Text string
2597
2598                         Timestamp int64 // Unix time.
2599                 }))(obj)).Type).Serialize(w)
2600         }); err != nil {
2601                 if err == io.EOF {
2602                         chk(io.EOF)
2603                 }
2604                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
2605         }
2606         local76 := utf16.Encode([]rune((*(*(struct {
2607                 Type ChatMsgType
2608
2609                 //mt:utf16
2610                 Sender, Text string
2611
2612                 Timestamp int64 // Unix time.
2613         }))(obj)).Sender))
2614         if len((local76)) > math.MaxUint16 {
2615                 chk(ErrTooLong)
2616         }
2617         {
2618                 x := uint16(len((local76)))
2619                 write16(w, uint16(x))
2620         }
2621         for local77 := range local76 {
2622                 {
2623                         x := (local76)[local77]
2624                         write16(w, uint16(x))
2625                 }
2626         }
2627         local78 := utf16.Encode([]rune((*(*(struct {
2628                 Type ChatMsgType
2629
2630                 //mt:utf16
2631                 Sender, Text string
2632
2633                 Timestamp int64 // Unix time.
2634         }))(obj)).Text))
2635         if len((local78)) > math.MaxUint16 {
2636                 chk(ErrTooLong)
2637         }
2638         {
2639                 x := uint16(len((local78)))
2640                 write16(w, uint16(x))
2641         }
2642         for local79 := range local78 {
2643                 {
2644                         x := (local78)[local79]
2645                         write16(w, uint16(x))
2646                 }
2647         }
2648         {
2649                 x := (*(*(struct {
2650                         Type ChatMsgType
2651
2652                         //mt:utf16
2653                         Sender, Text string
2654
2655                         Timestamp int64 // Unix time.
2656                 }))(obj)).Timestamp
2657                 write64(w, uint64(x))
2658         }
2659 }
2660
2661 func (obj *ToCltChatMsg) Deserialize(r io.Reader) {
2662         {
2663                 var local80 uint8
2664                 local81 := uint8(1)
2665                 {
2666                         p := &local80
2667                         *p = read8(r)
2668                 }
2669                 if local80 != local81 {
2670                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local80))
2671                 }
2672         }
2673         if err := pcall(func() {
2674                 ((*(*(struct {
2675                         Type ChatMsgType
2676
2677                         //mt:utf16
2678                         Sender, Text string
2679
2680                         Timestamp int64 // Unix time.
2681                 }))(obj)).Type).Deserialize(r)
2682         }); err != nil {
2683                 if err == io.EOF {
2684                         chk(io.EOF)
2685                 }
2686                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
2687         }
2688         var local82 []uint16
2689         var local83 uint16
2690         {
2691                 p := &local83
2692                 *p = read16(r)
2693         }
2694         (local82) = make([]uint16, local83)
2695         for local84 := range local82 {
2696                 {
2697                         p := &(local82)[local84]
2698                         *p = read16(r)
2699                 }
2700         }
2701         (*(*(struct {
2702                 Type ChatMsgType
2703
2704                 //mt:utf16
2705                 Sender, Text string
2706
2707                 Timestamp int64 // Unix time.
2708         }))(obj)).Sender = string(utf16.Decode(local82))
2709         var local85 []uint16
2710         var local86 uint16
2711         {
2712                 p := &local86
2713                 *p = read16(r)
2714         }
2715         (local85) = make([]uint16, local86)
2716         for local87 := range local85 {
2717                 {
2718                         p := &(local85)[local87]
2719                         *p = read16(r)
2720                 }
2721         }
2722         (*(*(struct {
2723                 Type ChatMsgType
2724
2725                 //mt:utf16
2726                 Sender, Text string
2727
2728                 Timestamp int64 // Unix time.
2729         }))(obj)).Text = string(utf16.Decode(local85))
2730         {
2731                 p := &(*(*(struct {
2732                         Type ChatMsgType
2733
2734                         //mt:utf16
2735                         Sender, Text string
2736
2737                         Timestamp int64 // Unix time.
2738                 }))(obj)).Timestamp
2739                 *p = int64(read64(r))
2740         }
2741 }
2742
2743 func (obj *ToCltAORmAdd) Serialize(w io.Writer) {
2744         if len(((*(*(struct {
2745                 Remove []AOID
2746                 Add    []AOAdd
2747         }))(obj)).Remove)) > math.MaxUint16 {
2748                 chk(ErrTooLong)
2749         }
2750         {
2751                 x := uint16(len(((*(*(struct {
2752                         Remove []AOID
2753                         Add    []AOAdd
2754                 }))(obj)).Remove)))
2755                 write16(w, uint16(x))
2756         }
2757         for local88 := range (*(*(struct {
2758                 Remove []AOID
2759                 Add    []AOAdd
2760         }))(obj)).Remove {
2761                 if err := pcall(func() {
2762                         (((*(*(struct {
2763                                 Remove []AOID
2764                                 Add    []AOAdd
2765                         }))(obj)).Remove)[local88]).Serialize(w)
2766                 }); err != nil {
2767                         if err == io.EOF {
2768                                 chk(io.EOF)
2769                         }
2770                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2771                 }
2772         }
2773         if len(((*(*(struct {
2774                 Remove []AOID
2775                 Add    []AOAdd
2776         }))(obj)).Add)) > math.MaxUint16 {
2777                 chk(ErrTooLong)
2778         }
2779         {
2780                 x := uint16(len(((*(*(struct {
2781                         Remove []AOID
2782                         Add    []AOAdd
2783                 }))(obj)).Add)))
2784                 write16(w, uint16(x))
2785         }
2786         for local89 := range (*(*(struct {
2787                 Remove []AOID
2788                 Add    []AOAdd
2789         }))(obj)).Add {
2790                 if err := pcall(func() {
2791                         (((*(*(struct {
2792                                 Remove []AOID
2793                                 Add    []AOAdd
2794                         }))(obj)).Add)[local89]).Serialize(w)
2795                 }); err != nil {
2796                         if err == io.EOF {
2797                                 chk(io.EOF)
2798                         }
2799                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAdd", err))
2800                 }
2801         }
2802 }
2803
2804 func (obj *ToCltAORmAdd) Deserialize(r io.Reader) {
2805         var local90 uint16
2806         {
2807                 p := &local90
2808                 *p = read16(r)
2809         }
2810         ((*(*(struct {
2811                 Remove []AOID
2812                 Add    []AOAdd
2813         }))(obj)).Remove) = make([]AOID, local90)
2814         for local91 := range (*(*(struct {
2815                 Remove []AOID
2816                 Add    []AOAdd
2817         }))(obj)).Remove {
2818                 if err := pcall(func() {
2819                         (((*(*(struct {
2820                                 Remove []AOID
2821                                 Add    []AOAdd
2822                         }))(obj)).Remove)[local91]).Deserialize(r)
2823                 }); err != nil {
2824                         if err == io.EOF {
2825                                 chk(io.EOF)
2826                         }
2827                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2828                 }
2829         }
2830         var local92 uint16
2831         {
2832                 p := &local92
2833                 *p = read16(r)
2834         }
2835         ((*(*(struct {
2836                 Remove []AOID
2837                 Add    []AOAdd
2838         }))(obj)).Add) = make([]AOAdd, local92)
2839         for local93 := range (*(*(struct {
2840                 Remove []AOID
2841                 Add    []AOAdd
2842         }))(obj)).Add {
2843                 if err := pcall(func() {
2844                         (((*(*(struct {
2845                                 Remove []AOID
2846                                 Add    []AOAdd
2847                         }))(obj)).Add)[local93]).Deserialize(r)
2848                 }); err != nil {
2849                         if err == io.EOF {
2850                                 chk(io.EOF)
2851                         }
2852                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAdd", err))
2853                 }
2854         }
2855 }
2856
2857 func (obj *ToCltAOMsgs) Serialize(w io.Writer) {
2858         for local94 := range (*(*(struct {
2859                 //mt:raw
2860                 Msgs []IDAOMsg
2861         }))(obj)).Msgs {
2862                 if err := pcall(func() {
2863                         (((*(*(struct {
2864                                 //mt:raw
2865                                 Msgs []IDAOMsg
2866                         }))(obj)).Msgs)[local94]).Serialize(w)
2867                 }); err != nil {
2868                         if err == io.EOF {
2869                                 chk(io.EOF)
2870                         }
2871                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.IDAOMsg", err))
2872                 }
2873         }
2874 }
2875
2876 func (obj *ToCltAOMsgs) Deserialize(r io.Reader) {
2877         for {
2878                 var local95 IDAOMsg
2879                 err := pcall(func() {
2880                         if err := pcall(func() {
2881                                 (local95).Deserialize(r)
2882                         }); err != nil {
2883                                 if err == io.EOF {
2884                                         chk(io.EOF)
2885                                 }
2886                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.IDAOMsg", err))
2887                         }
2888                 })
2889                 if err == io.EOF {
2890                         break
2891                 }
2892                 ((*(*(struct {
2893                         //mt:raw
2894                         Msgs []IDAOMsg
2895                 }))(obj)).Msgs) = append(((*(*(struct {
2896                         //mt:raw
2897                         Msgs []IDAOMsg
2898                 }))(obj)).Msgs), local95)
2899                 chk(err)
2900         }
2901 }
2902
2903 func (obj *ToCltHP) Serialize(w io.Writer) {
2904         {
2905                 x := (*(*(struct {
2906                         HP uint16
2907                 }))(obj)).HP
2908                 write16(w, uint16(x))
2909         }
2910 }
2911
2912 func (obj *ToCltHP) Deserialize(r io.Reader) {
2913         {
2914                 p := &(*(*(struct {
2915                         HP uint16
2916                 }))(obj)).HP
2917                 *p = read16(r)
2918         }
2919 }
2920
2921 func (obj *ToCltMovePlayer) Serialize(w io.Writer) {
2922         if err := pcall(func() {
2923                 ((*(*(struct {
2924                         Pos
2925                         Pitch, Yaw float32
2926                 }))(obj)).Pos).Serialize(w)
2927         }); err != nil {
2928                 if err == io.EOF {
2929                         chk(io.EOF)
2930                 }
2931                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
2932         }
2933         {
2934                 x := (*(*(struct {
2935                         Pos
2936                         Pitch, Yaw float32
2937                 }))(obj)).Pitch
2938                 write32(w, math.Float32bits(x))
2939         }
2940         {
2941                 x := (*(*(struct {
2942                         Pos
2943                         Pitch, Yaw float32
2944                 }))(obj)).Yaw
2945                 write32(w, math.Float32bits(x))
2946         }
2947 }
2948
2949 func (obj *ToCltMovePlayer) Deserialize(r io.Reader) {
2950         if err := pcall(func() {
2951                 ((*(*(struct {
2952                         Pos
2953                         Pitch, Yaw float32
2954                 }))(obj)).Pos).Deserialize(r)
2955         }); err != nil {
2956                 if err == io.EOF {
2957                         chk(io.EOF)
2958                 }
2959                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
2960         }
2961         {
2962                 p := &(*(*(struct {
2963                         Pos
2964                         Pitch, Yaw float32
2965                 }))(obj)).Pitch
2966                 *p = math.Float32frombits(read32(r))
2967         }
2968         {
2969                 p := &(*(*(struct {
2970                         Pos
2971                         Pitch, Yaw float32
2972                 }))(obj)).Yaw
2973                 *p = math.Float32frombits(read32(r))
2974         }
2975 }
2976
2977 func (obj *ToCltLegacyKick) Serialize(w io.Writer) {
2978         local96 := utf16.Encode([]rune((*(*(struct {
2979                 //mt:utf16
2980                 Reason string
2981         }))(obj)).Reason))
2982         if len((local96)) > math.MaxUint16 {
2983                 chk(ErrTooLong)
2984         }
2985         {
2986                 x := uint16(len((local96)))
2987                 write16(w, uint16(x))
2988         }
2989         for local97 := range local96 {
2990                 {
2991                         x := (local96)[local97]
2992                         write16(w, uint16(x))
2993                 }
2994         }
2995 }
2996
2997 func (obj *ToCltLegacyKick) Deserialize(r io.Reader) {
2998         var local98 []uint16
2999         var local99 uint16
3000         {
3001                 p := &local99
3002                 *p = read16(r)
3003         }
3004         (local98) = make([]uint16, local99)
3005         for local100 := range local98 {
3006                 {
3007                         p := &(local98)[local100]
3008                         *p = read16(r)
3009                 }
3010         }
3011         (*(*(struct {
3012                 //mt:utf16
3013                 Reason string
3014         }))(obj)).Reason = string(utf16.Decode(local98))
3015 }
3016
3017 func (obj *ToCltFOV) Serialize(w io.Writer) {
3018         {
3019                 x := (*(*(struct {
3020                         FOV            float32
3021                         Multiplier     bool
3022                         TransitionTime float32
3023                 }))(obj)).FOV
3024                 write32(w, math.Float32bits(x))
3025         }
3026         {
3027                 x := (*(*(struct {
3028                         FOV            float32
3029                         Multiplier     bool
3030                         TransitionTime float32
3031                 }))(obj)).Multiplier
3032                 if x {
3033                         write8(w, 1)
3034                 } else {
3035                         write8(w, 0)
3036                 }
3037         }
3038         {
3039                 x := (*(*(struct {
3040                         FOV            float32
3041                         Multiplier     bool
3042                         TransitionTime float32
3043                 }))(obj)).TransitionTime
3044                 write32(w, math.Float32bits(x))
3045         }
3046 }
3047
3048 func (obj *ToCltFOV) Deserialize(r io.Reader) {
3049         {
3050                 p := &(*(*(struct {
3051                         FOV            float32
3052                         Multiplier     bool
3053                         TransitionTime float32
3054                 }))(obj)).FOV
3055                 *p = math.Float32frombits(read32(r))
3056         }
3057         {
3058                 p := &(*(*(struct {
3059                         FOV            float32
3060                         Multiplier     bool
3061                         TransitionTime float32
3062                 }))(obj)).Multiplier
3063                 switch n := read8(r); n {
3064                 case 0:
3065                         *p = false
3066                 case 1:
3067                         *p = true
3068                 default:
3069                         chk(fmt.Errorf("invalid bool: %d", n))
3070                 }
3071         }
3072         {
3073                 p := &(*(*(struct {
3074                         FOV            float32
3075                         Multiplier     bool
3076                         TransitionTime float32
3077                 }))(obj)).TransitionTime
3078                 *p = math.Float32frombits(read32(r))
3079         }
3080 }
3081
3082 func (obj *ToCltDeathScreen) Serialize(w io.Writer) {
3083         {
3084                 x := (*(*(struct {
3085                         PointCam bool
3086                         PointAt  Pos
3087                 }))(obj)).PointCam
3088                 if x {
3089                         write8(w, 1)
3090                 } else {
3091                         write8(w, 0)
3092                 }
3093         }
3094         if err := pcall(func() {
3095                 ((*(*(struct {
3096                         PointCam bool
3097                         PointAt  Pos
3098                 }))(obj)).PointAt).Serialize(w)
3099         }); err != nil {
3100                 if err == io.EOF {
3101                         chk(io.EOF)
3102                 }
3103                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3104         }
3105 }
3106
3107 func (obj *ToCltDeathScreen) Deserialize(r io.Reader) {
3108         {
3109                 p := &(*(*(struct {
3110                         PointCam bool
3111                         PointAt  Pos
3112                 }))(obj)).PointCam
3113                 switch n := read8(r); n {
3114                 case 0:
3115                         *p = false
3116                 case 1:
3117                         *p = true
3118                 default:
3119                         chk(fmt.Errorf("invalid bool: %d", n))
3120                 }
3121         }
3122         if err := pcall(func() {
3123                 ((*(*(struct {
3124                         PointCam bool
3125                         PointAt  Pos
3126                 }))(obj)).PointAt).Deserialize(r)
3127         }); err != nil {
3128                 if err == io.EOF {
3129                         chk(io.EOF)
3130                 }
3131                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3132         }
3133 }
3134
3135 func (obj *ToCltMedia) Serialize(w io.Writer) {
3136         {
3137                 x := (*(*(struct {
3138                         // N is the total number of ToCltMedia packets.
3139                         // I is the index of this packet.
3140                         N, I uint16
3141
3142                         //mt:len32
3143                         Files []struct {
3144                                 Name string
3145
3146                                 //mt:len32
3147                                 Data []byte
3148                         }
3149                 }))(obj)).N
3150                 write16(w, uint16(x))
3151         }
3152         {
3153                 x := (*(*(struct {
3154                         // N is the total number of ToCltMedia packets.
3155                         // I is the index of this packet.
3156                         N, I uint16
3157
3158                         //mt:len32
3159                         Files []struct {
3160                                 Name string
3161
3162                                 //mt:len32
3163                                 Data []byte
3164                         }
3165                 }))(obj)).I
3166                 write16(w, uint16(x))
3167         }
3168         if len(((*(*(struct {
3169                 // N is the total number of ToCltMedia packets.
3170                 // I is the index of this packet.
3171                 N, I uint16
3172
3173                 //mt:len32
3174                 Files []struct {
3175                         Name string
3176
3177                         //mt:len32
3178                         Data []byte
3179                 }
3180         }))(obj)).Files)) > math.MaxUint32 {
3181                 chk(ErrTooLong)
3182         }
3183         {
3184                 x := uint32(len(((*(*(struct {
3185                         // N is the total number of ToCltMedia packets.
3186                         // I is the index of this packet.
3187                         N, I uint16
3188
3189                         //mt:len32
3190                         Files []struct {
3191                                 Name string
3192
3193                                 //mt:len32
3194                                 Data []byte
3195                         }
3196                 }))(obj)).Files)))
3197                 write32(w, uint32(x))
3198         }
3199         for local101 := range (*(*(struct {
3200                 // N is the total number of ToCltMedia packets.
3201                 // I is the index of this packet.
3202                 N, I uint16
3203
3204                 //mt:len32
3205                 Files []struct {
3206                         Name string
3207
3208                         //mt:len32
3209                         Data []byte
3210                 }
3211         }))(obj)).Files {
3212                 if len(([]byte((((*(*(struct {
3213                         // N is the total number of ToCltMedia packets.
3214                         // I is the index of this packet.
3215                         N, I uint16
3216
3217                         //mt:len32
3218                         Files []struct {
3219                                 Name string
3220
3221                                 //mt:len32
3222                                 Data []byte
3223                         }
3224                 }))(obj)).Files)[local101]).Name))) > math.MaxUint16 {
3225                         chk(ErrTooLong)
3226                 }
3227                 {
3228                         x := uint16(len(([]byte((((*(*(struct {
3229                                 // N is the total number of ToCltMedia packets.
3230                                 // I is the index of this packet.
3231                                 N, I uint16
3232
3233                                 //mt:len32
3234                                 Files []struct {
3235                                         Name string
3236
3237                                         //mt:len32
3238                                         Data []byte
3239                                 }
3240                         }))(obj)).Files)[local101]).Name))))
3241                         write16(w, uint16(x))
3242                 }
3243                 {
3244                         _, err := w.Write(([]byte((((*(*(struct {
3245                                 // N is the total number of ToCltMedia packets.
3246                                 // I is the index of this packet.
3247                                 N, I uint16
3248
3249                                 //mt:len32
3250                                 Files []struct {
3251                                         Name string
3252
3253                                         //mt:len32
3254                                         Data []byte
3255                                 }
3256                         }))(obj)).Files)[local101]).Name))[:])
3257                         chk(err)
3258                 }
3259                 if len(((((*(*(struct {
3260                         // N is the total number of ToCltMedia packets.
3261                         // I is the index of this packet.
3262                         N, I uint16
3263
3264                         //mt:len32
3265                         Files []struct {
3266                                 Name string
3267
3268                                 //mt:len32
3269                                 Data []byte
3270                         }
3271                 }))(obj)).Files)[local101]).Data)) > math.MaxUint32 {
3272                         chk(ErrTooLong)
3273                 }
3274                 {
3275                         x := uint32(len(((((*(*(struct {
3276                                 // N is the total number of ToCltMedia packets.
3277                                 // I is the index of this packet.
3278                                 N, I uint16
3279
3280                                 //mt:len32
3281                                 Files []struct {
3282                                         Name string
3283
3284                                         //mt:len32
3285                                         Data []byte
3286                                 }
3287                         }))(obj)).Files)[local101]).Data)))
3288                         write32(w, uint32(x))
3289                 }
3290                 {
3291                         _, err := w.Write(((((*(*(struct {
3292                                 // N is the total number of ToCltMedia packets.
3293                                 // I is the index of this packet.
3294                                 N, I uint16
3295
3296                                 //mt:len32
3297                                 Files []struct {
3298                                         Name string
3299
3300                                         //mt:len32
3301                                         Data []byte
3302                                 }
3303                         }))(obj)).Files)[local101]).Data)[:])
3304                         chk(err)
3305                 }
3306         }
3307 }
3308
3309 func (obj *ToCltMedia) Deserialize(r io.Reader) {
3310         {
3311                 p := &(*(*(struct {
3312                         // N is the total number of ToCltMedia packets.
3313                         // I is the index of this packet.
3314                         N, I uint16
3315
3316                         //mt:len32
3317                         Files []struct {
3318                                 Name string
3319
3320                                 //mt:len32
3321                                 Data []byte
3322                         }
3323                 }))(obj)).N
3324                 *p = read16(r)
3325         }
3326         {
3327                 p := &(*(*(struct {
3328                         // N is the total number of ToCltMedia packets.
3329                         // I is the index of this packet.
3330                         N, I uint16
3331
3332                         //mt:len32
3333                         Files []struct {
3334                                 Name string
3335
3336                                 //mt:len32
3337                                 Data []byte
3338                         }
3339                 }))(obj)).I
3340                 *p = read16(r)
3341         }
3342         var local102 uint32
3343         {
3344                 p := &local102
3345                 *p = read32(r)
3346         }
3347         ((*(*(struct {
3348                 // N is the total number of ToCltMedia packets.
3349                 // I is the index of this packet.
3350                 N, I uint16
3351
3352                 //mt:len32
3353                 Files []struct {
3354                         Name string
3355
3356                         //mt:len32
3357                         Data []byte
3358                 }
3359         }))(obj)).Files) = make([]struct {
3360                 Name string
3361                 Data []byte
3362         }, local102)
3363         for local103 := range (*(*(struct {
3364                 // N is the total number of ToCltMedia packets.
3365                 // I is the index of this packet.
3366                 N, I uint16
3367
3368                 //mt:len32
3369                 Files []struct {
3370                         Name string
3371
3372                         //mt:len32
3373                         Data []byte
3374                 }
3375         }))(obj)).Files {
3376                 var local104 []uint8
3377                 var local105 uint16
3378                 {
3379                         p := &local105
3380                         *p = read16(r)
3381                 }
3382                 (local104) = make([]uint8, local105)
3383                 {
3384                         _, err := io.ReadFull(r, (local104)[:])
3385                         chk(err)
3386                 }
3387                 ((((*(*(struct {
3388                         // N is the total number of ToCltMedia packets.
3389                         // I is the index of this packet.
3390                         N, I uint16
3391
3392                         //mt:len32
3393                         Files []struct {
3394                                 Name string
3395
3396                                 //mt:len32
3397                                 Data []byte
3398                         }
3399                 }))(obj)).Files)[local103]).Name) = string(local104)
3400                 var local106 uint32
3401                 {
3402                         p := &local106
3403                         *p = read32(r)
3404                 }
3405                 ((((*(*(struct {
3406                         // N is the total number of ToCltMedia packets.
3407                         // I is the index of this packet.
3408                         N, I uint16
3409
3410                         //mt:len32
3411                         Files []struct {
3412                                 Name string
3413
3414                                 //mt:len32
3415                                 Data []byte
3416                         }
3417                 }))(obj)).Files)[local103]).Data) = make([]byte, local106)
3418                 {
3419                         _, err := io.ReadFull(r, ((((*(*(struct {
3420                                 // N is the total number of ToCltMedia packets.
3421                                 // I is the index of this packet.
3422                                 N, I uint16
3423
3424                                 //mt:len32
3425                                 Files []struct {
3426                                         Name string
3427
3428                                         //mt:len32
3429                                         Data []byte
3430                                 }
3431                         }))(obj)).Files)[local103]).Data)[:])
3432                         chk(err)
3433                 }
3434         }
3435 }
3436
3437 func (obj *ToCltNodeDefs) Serialize(w io.Writer) {
3438         {
3439                 ow := w
3440                 w := new(bytes.Buffer)
3441                 {
3442                         w := zlib.NewWriter(w)
3443                         {
3444                                 local107 := uint8(1)
3445                                 {
3446                                         x := local107
3447                                         write8(w, uint8(x))
3448                                 }
3449                         }
3450                         {
3451                                 x := (*(*(struct {
3452
3453                                         // See (de)serialize.fmt.
3454                                         Defs []NodeDef
3455                                 }))(obj)).Defs
3456                                 { // For ToCltNodeDefs.Defs.
3457                                         if len(x) > math.MaxUint16 {
3458                                                 chk(ErrTooLong)
3459                                         }
3460                                         write16(w, uint16(len(x)))
3461                                         var b bytes.Buffer
3462                                         for i := range x {
3463                                                 x[i].Serialize(&b)
3464                                         }
3465                                         if b.Len() > math.MaxUint32 {
3466                                                 chk(ErrTooLong)
3467                                         }
3468                                         write32(w, uint32(b.Len()))
3469                                         _, err := b.WriteTo(w)
3470                                         chk(err)
3471                                 }
3472                         }
3473                         chk(w.Close())
3474                 }
3475                 {
3476                         buf := w
3477                         w := ow
3478                         if len((buf.Bytes())) > math.MaxUint32 {
3479                                 chk(ErrTooLong)
3480                         }
3481                         {
3482                                 x := uint32(len((buf.Bytes())))
3483                                 write32(w, uint32(x))
3484                         }
3485                         {
3486                                 _, err := w.Write((buf.Bytes())[:])
3487                                 chk(err)
3488                         }
3489                 }
3490         }
3491 }
3492
3493 func (obj *ToCltNodeDefs) Deserialize(r io.Reader) {
3494         {
3495                 var n uint32
3496                 {
3497                         p := &n
3498                         *p = read32(r)
3499                 }
3500                 r := &io.LimitedReader{R: r, N: int64(n)}
3501                 {
3502                         r, err := zlib.NewReader(byteReader{r})
3503                         chk(err)
3504                         {
3505                                 var local108 uint8
3506                                 local109 := uint8(1)
3507                                 {
3508                                         p := &local108
3509                                         *p = read8(r)
3510                                 }
3511                                 if local108 != local109 {
3512                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local108))
3513                                 }
3514                         }
3515                         {
3516                                 p := &(*(*(struct {
3517
3518                                         // See (de)serialize.fmt.
3519                                         Defs []NodeDef
3520                                 }))(obj)).Defs
3521                                 { // For ToCltNodeDefs.Defs.
3522                                         *p = make([]NodeDef, read16(r))
3523                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3524                                         for i := range *p {
3525                                                 (*p)[i].Deserialize(r)
3526                                         }
3527                                         if r.N > 0 {
3528                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3529                                         }
3530                                 }
3531                         }
3532                         chk(r.Close())
3533                 }
3534                 if r.N > 0 {
3535                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3536                 }
3537         }
3538 }
3539
3540 func (obj *ToCltAnnounceMedia) Serialize(w io.Writer) {
3541         if len(((*(*(struct {
3542                 Files []struct {
3543                         Name       string
3544                         Base64SHA1 string
3545                 }
3546                 URL string
3547         }))(obj)).Files)) > math.MaxUint16 {
3548                 chk(ErrTooLong)
3549         }
3550         {
3551                 x := uint16(len(((*(*(struct {
3552                         Files []struct {
3553                                 Name       string
3554                                 Base64SHA1 string
3555                         }
3556                         URL string
3557                 }))(obj)).Files)))
3558                 write16(w, uint16(x))
3559         }
3560         for local110 := range (*(*(struct {
3561                 Files []struct {
3562                         Name       string
3563                         Base64SHA1 string
3564                 }
3565                 URL string
3566         }))(obj)).Files {
3567                 if len(([]byte((((*(*(struct {
3568                         Files []struct {
3569                                 Name       string
3570                                 Base64SHA1 string
3571                         }
3572                         URL string
3573                 }))(obj)).Files)[local110]).Name))) > math.MaxUint16 {
3574                         chk(ErrTooLong)
3575                 }
3576                 {
3577                         x := uint16(len(([]byte((((*(*(struct {
3578                                 Files []struct {
3579                                         Name       string
3580                                         Base64SHA1 string
3581                                 }
3582                                 URL string
3583                         }))(obj)).Files)[local110]).Name))))
3584                         write16(w, uint16(x))
3585                 }
3586                 {
3587                         _, err := w.Write(([]byte((((*(*(struct {
3588                                 Files []struct {
3589                                         Name       string
3590                                         Base64SHA1 string
3591                                 }
3592                                 URL string
3593                         }))(obj)).Files)[local110]).Name))[:])
3594                         chk(err)
3595                 }
3596                 if len(([]byte((((*(*(struct {
3597                         Files []struct {
3598                                 Name       string
3599                                 Base64SHA1 string
3600                         }
3601                         URL string
3602                 }))(obj)).Files)[local110]).Base64SHA1))) > math.MaxUint16 {
3603                         chk(ErrTooLong)
3604                 }
3605                 {
3606                         x := uint16(len(([]byte((((*(*(struct {
3607                                 Files []struct {
3608                                         Name       string
3609                                         Base64SHA1 string
3610                                 }
3611                                 URL string
3612                         }))(obj)).Files)[local110]).Base64SHA1))))
3613                         write16(w, uint16(x))
3614                 }
3615                 {
3616                         _, err := w.Write(([]byte((((*(*(struct {
3617                                 Files []struct {
3618                                         Name       string
3619                                         Base64SHA1 string
3620                                 }
3621                                 URL string
3622                         }))(obj)).Files)[local110]).Base64SHA1))[:])
3623                         chk(err)
3624                 }
3625         }
3626         if len(([]byte((*(*(struct {
3627                 Files []struct {
3628                         Name       string
3629                         Base64SHA1 string
3630                 }
3631                 URL string
3632         }))(obj)).URL))) > math.MaxUint16 {
3633                 chk(ErrTooLong)
3634         }
3635         {
3636                 x := uint16(len(([]byte((*(*(struct {
3637                         Files []struct {
3638                                 Name       string
3639                                 Base64SHA1 string
3640                         }
3641                         URL string
3642                 }))(obj)).URL))))
3643                 write16(w, uint16(x))
3644         }
3645         {
3646                 _, err := w.Write(([]byte((*(*(struct {
3647                         Files []struct {
3648                                 Name       string
3649                                 Base64SHA1 string
3650                         }
3651                         URL string
3652                 }))(obj)).URL))[:])
3653                 chk(err)
3654         }
3655 }
3656
3657 func (obj *ToCltAnnounceMedia) Deserialize(r io.Reader) {
3658         var local111 uint16
3659         {
3660                 p := &local111
3661                 *p = read16(r)
3662         }
3663         ((*(*(struct {
3664                 Files []struct {
3665                         Name       string
3666                         Base64SHA1 string
3667                 }
3668                 URL string
3669         }))(obj)).Files) = make([]struct {
3670                 Name       string
3671                 Base64SHA1 string
3672         }, local111)
3673         for local112 := range (*(*(struct {
3674                 Files []struct {
3675                         Name       string
3676                         Base64SHA1 string
3677                 }
3678                 URL string
3679         }))(obj)).Files {
3680                 var local113 []uint8
3681                 var local114 uint16
3682                 {
3683                         p := &local114
3684                         *p = read16(r)
3685                 }
3686                 (local113) = make([]uint8, local114)
3687                 {
3688                         _, err := io.ReadFull(r, (local113)[:])
3689                         chk(err)
3690                 }
3691                 ((((*(*(struct {
3692                         Files []struct {
3693                                 Name       string
3694                                 Base64SHA1 string
3695                         }
3696                         URL string
3697                 }))(obj)).Files)[local112]).Name) = string(local113)
3698                 var local115 []uint8
3699                 var local116 uint16
3700                 {
3701                         p := &local116
3702                         *p = read16(r)
3703                 }
3704                 (local115) = make([]uint8, local116)
3705                 {
3706                         _, err := io.ReadFull(r, (local115)[:])
3707                         chk(err)
3708                 }
3709                 ((((*(*(struct {
3710                         Files []struct {
3711                                 Name       string
3712                                 Base64SHA1 string
3713                         }
3714                         URL string
3715                 }))(obj)).Files)[local112]).Base64SHA1) = string(local115)
3716         }
3717         var local117 []uint8
3718         var local118 uint16
3719         {
3720                 p := &local118
3721                 *p = read16(r)
3722         }
3723         (local117) = make([]uint8, local118)
3724         {
3725                 _, err := io.ReadFull(r, (local117)[:])
3726                 chk(err)
3727         }
3728         ((*(*(struct {
3729                 Files []struct {
3730                         Name       string
3731                         Base64SHA1 string
3732                 }
3733                 URL string
3734         }))(obj)).URL) = string(local117)
3735 }
3736
3737 func (obj *ToCltItemDefs) Serialize(w io.Writer) {
3738         {
3739                 ow := w
3740                 w := new(bytes.Buffer)
3741                 {
3742                         w := zlib.NewWriter(w)
3743                         {
3744                                 local119 := uint8(0)
3745                                 {
3746                                         x := local119
3747                                         write8(w, uint8(x))
3748                                 }
3749                         }
3750                         if len(((*(*(struct {
3751                                 Defs    []ItemDef
3752                                 Aliases []struct{ Alias, Orig string }
3753                         }))(obj)).Defs)) > math.MaxUint16 {
3754                                 chk(ErrTooLong)
3755                         }
3756                         {
3757                                 x := uint16(len(((*(*(struct {
3758                                         Defs    []ItemDef
3759                                         Aliases []struct{ Alias, Orig string }
3760                                 }))(obj)).Defs)))
3761                                 write16(w, uint16(x))
3762                         }
3763                         for local120 := range (*(*(struct {
3764                                 Defs    []ItemDef
3765                                 Aliases []struct{ Alias, Orig string }
3766                         }))(obj)).Defs {
3767                                 if err := pcall(func() {
3768                                         (((*(*(struct {
3769                                                 Defs    []ItemDef
3770                                                 Aliases []struct{ Alias, Orig string }
3771                                         }))(obj)).Defs)[local120]).Serialize(w)
3772                                 }); err != nil {
3773                                         if err == io.EOF {
3774                                                 chk(io.EOF)
3775                                         }
3776                                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
3777                                 }
3778                         }
3779                         if len(((*(*(struct {
3780                                 Defs    []ItemDef
3781                                 Aliases []struct{ Alias, Orig string }
3782                         }))(obj)).Aliases)) > math.MaxUint16 {
3783                                 chk(ErrTooLong)
3784                         }
3785                         {
3786                                 x := uint16(len(((*(*(struct {
3787                                         Defs    []ItemDef
3788                                         Aliases []struct{ Alias, Orig string }
3789                                 }))(obj)).Aliases)))
3790                                 write16(w, uint16(x))
3791                         }
3792                         for local121 := range (*(*(struct {
3793                                 Defs    []ItemDef
3794                                 Aliases []struct{ Alias, Orig string }
3795                         }))(obj)).Aliases {
3796                                 if len(([]byte((((*(*(struct {
3797                                         Defs    []ItemDef
3798                                         Aliases []struct{ Alias, Orig string }
3799                                 }))(obj)).Aliases)[local121]).Alias))) > math.MaxUint16 {
3800                                         chk(ErrTooLong)
3801                                 }
3802                                 {
3803                                         x := uint16(len(([]byte((((*(*(struct {
3804                                                 Defs    []ItemDef
3805                                                 Aliases []struct{ Alias, Orig string }
3806                                         }))(obj)).Aliases)[local121]).Alias))))
3807                                         write16(w, uint16(x))
3808                                 }
3809                                 {
3810                                         _, err := w.Write(([]byte((((*(*(struct {
3811                                                 Defs    []ItemDef
3812                                                 Aliases []struct{ Alias, Orig string }
3813                                         }))(obj)).Aliases)[local121]).Alias))[:])
3814                                         chk(err)
3815                                 }
3816                                 if len(([]byte((((*(*(struct {
3817                                         Defs    []ItemDef
3818                                         Aliases []struct{ Alias, Orig string }
3819                                 }))(obj)).Aliases)[local121]).Orig))) > math.MaxUint16 {
3820                                         chk(ErrTooLong)
3821                                 }
3822                                 {
3823                                         x := uint16(len(([]byte((((*(*(struct {
3824                                                 Defs    []ItemDef
3825                                                 Aliases []struct{ Alias, Orig string }
3826                                         }))(obj)).Aliases)[local121]).Orig))))
3827                                         write16(w, uint16(x))
3828                                 }
3829                                 {
3830                                         _, err := w.Write(([]byte((((*(*(struct {
3831                                                 Defs    []ItemDef
3832                                                 Aliases []struct{ Alias, Orig string }
3833                                         }))(obj)).Aliases)[local121]).Orig))[:])
3834                                         chk(err)
3835                                 }
3836                         }
3837                         chk(w.Close())
3838                 }
3839                 {
3840                         buf := w
3841                         w := ow
3842                         if len((buf.Bytes())) > math.MaxUint32 {
3843                                 chk(ErrTooLong)
3844                         }
3845                         {
3846                                 x := uint32(len((buf.Bytes())))
3847                                 write32(w, uint32(x))
3848                         }
3849                         {
3850                                 _, err := w.Write((buf.Bytes())[:])
3851                                 chk(err)
3852                         }
3853                 }
3854         }
3855 }
3856
3857 func (obj *ToCltItemDefs) Deserialize(r io.Reader) {
3858         {
3859                 var n uint32
3860                 {
3861                         p := &n
3862                         *p = read32(r)
3863                 }
3864                 r := &io.LimitedReader{R: r, N: int64(n)}
3865                 {
3866                         r, err := zlib.NewReader(byteReader{r})
3867                         chk(err)
3868                         {
3869                                 var local122 uint8
3870                                 local123 := uint8(0)
3871                                 {
3872                                         p := &local122
3873                                         *p = read8(r)
3874                                 }
3875                                 if local122 != local123 {
3876                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local122))
3877                                 }
3878                         }
3879                         var local124 uint16
3880                         {
3881                                 p := &local124
3882                                 *p = read16(r)
3883                         }
3884                         ((*(*(struct {
3885                                 Defs    []ItemDef
3886                                 Aliases []struct{ Alias, Orig string }
3887                         }))(obj)).Defs) = make([]ItemDef, local124)
3888                         for local125 := range (*(*(struct {
3889                                 Defs    []ItemDef
3890                                 Aliases []struct{ Alias, Orig string }
3891                         }))(obj)).Defs {
3892                                 if err := pcall(func() {
3893                                         (((*(*(struct {
3894                                                 Defs    []ItemDef
3895                                                 Aliases []struct{ Alias, Orig string }
3896                                         }))(obj)).Defs)[local125]).Deserialize(r)
3897                                 }); err != nil {
3898                                         if err == io.EOF {
3899                                                 chk(io.EOF)
3900                                         }
3901                                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
3902                                 }
3903                         }
3904                         var local126 uint16
3905                         {
3906                                 p := &local126
3907                                 *p = read16(r)
3908                         }
3909                         ((*(*(struct {
3910                                 Defs    []ItemDef
3911                                 Aliases []struct{ Alias, Orig string }
3912                         }))(obj)).Aliases) = make([]struct {
3913                                 Alias string
3914                                 Orig  string
3915                         }, local126)
3916                         for local127 := range (*(*(struct {
3917                                 Defs    []ItemDef
3918                                 Aliases []struct{ Alias, Orig string }
3919                         }))(obj)).Aliases {
3920                                 var local128 []uint8
3921                                 var local129 uint16
3922                                 {
3923                                         p := &local129
3924                                         *p = read16(r)
3925                                 }
3926                                 (local128) = make([]uint8, local129)
3927                                 {
3928                                         _, err := io.ReadFull(r, (local128)[:])
3929                                         chk(err)
3930                                 }
3931                                 ((((*(*(struct {
3932                                         Defs    []ItemDef
3933                                         Aliases []struct{ Alias, Orig string }
3934                                 }))(obj)).Aliases)[local127]).Alias) = string(local128)
3935                                 var local130 []uint8
3936                                 var local131 uint16
3937                                 {
3938                                         p := &local131
3939                                         *p = read16(r)
3940                                 }
3941                                 (local130) = make([]uint8, local131)
3942                                 {
3943                                         _, err := io.ReadFull(r, (local130)[:])
3944                                         chk(err)
3945                                 }
3946                                 ((((*(*(struct {
3947                                         Defs    []ItemDef
3948                                         Aliases []struct{ Alias, Orig string }
3949                                 }))(obj)).Aliases)[local127]).Orig) = string(local130)
3950                         }
3951                         chk(r.Close())
3952                 }
3953                 if r.N > 0 {
3954                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3955                 }
3956         }
3957 }
3958
3959 func (obj *ToCltPlaySound) Serialize(w io.Writer) {
3960         if err := pcall(func() {
3961                 ((*(*(struct {
3962                         ID      SoundID
3963                         Name    string
3964                         Gain    float32
3965                         SrcType SoundSrcType
3966                         Pos
3967                         SrcAOID   AOID
3968                         Loop      bool
3969                         Fade      float32
3970                         Pitch     float32
3971                         Ephemeral bool
3972                 }))(obj)).ID).Serialize(w)
3973         }); err != nil {
3974                 if err == io.EOF {
3975                         chk(io.EOF)
3976                 }
3977                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
3978         }
3979         if len(([]byte((*(*(struct {
3980                 ID      SoundID
3981                 Name    string
3982                 Gain    float32
3983                 SrcType SoundSrcType
3984                 Pos
3985                 SrcAOID   AOID
3986                 Loop      bool
3987                 Fade      float32
3988                 Pitch     float32
3989                 Ephemeral bool
3990         }))(obj)).Name))) > math.MaxUint16 {
3991                 chk(ErrTooLong)
3992         }
3993         {
3994                 x := uint16(len(([]byte((*(*(struct {
3995                         ID      SoundID
3996                         Name    string
3997                         Gain    float32
3998                         SrcType SoundSrcType
3999                         Pos
4000                         SrcAOID   AOID
4001                         Loop      bool
4002                         Fade      float32
4003                         Pitch     float32
4004                         Ephemeral bool
4005                 }))(obj)).Name))))
4006                 write16(w, uint16(x))
4007         }
4008         {
4009                 _, err := w.Write(([]byte((*(*(struct {
4010                         ID      SoundID
4011                         Name    string
4012                         Gain    float32
4013                         SrcType SoundSrcType
4014                         Pos
4015                         SrcAOID   AOID
4016                         Loop      bool
4017                         Fade      float32
4018                         Pitch     float32
4019                         Ephemeral bool
4020                 }))(obj)).Name))[:])
4021                 chk(err)
4022         }
4023         {
4024                 x := (*(*(struct {
4025                         ID      SoundID
4026                         Name    string
4027                         Gain    float32
4028                         SrcType SoundSrcType
4029                         Pos
4030                         SrcAOID   AOID
4031                         Loop      bool
4032                         Fade      float32
4033                         Pitch     float32
4034                         Ephemeral bool
4035                 }))(obj)).Gain
4036                 write32(w, math.Float32bits(x))
4037         }
4038         if err := pcall(func() {
4039                 ((*(*(struct {
4040                         ID      SoundID
4041                         Name    string
4042                         Gain    float32
4043                         SrcType SoundSrcType
4044                         Pos
4045                         SrcAOID   AOID
4046                         Loop      bool
4047                         Fade      float32
4048                         Pitch     float32
4049                         Ephemeral bool
4050                 }))(obj)).SrcType).Serialize(w)
4051         }); err != nil {
4052                 if err == io.EOF {
4053                         chk(io.EOF)
4054                 }
4055                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundSrcType", err))
4056         }
4057         if err := pcall(func() {
4058                 ((*(*(struct {
4059                         ID      SoundID
4060                         Name    string
4061                         Gain    float32
4062                         SrcType SoundSrcType
4063                         Pos
4064                         SrcAOID   AOID
4065                         Loop      bool
4066                         Fade      float32
4067                         Pitch     float32
4068                         Ephemeral bool
4069                 }))(obj)).Pos).Serialize(w)
4070         }); err != nil {
4071                 if err == io.EOF {
4072                         chk(io.EOF)
4073                 }
4074                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
4075         }
4076         if err := pcall(func() {
4077                 ((*(*(struct {
4078                         ID      SoundID
4079                         Name    string
4080                         Gain    float32
4081                         SrcType SoundSrcType
4082                         Pos
4083                         SrcAOID   AOID
4084                         Loop      bool
4085                         Fade      float32
4086                         Pitch     float32
4087                         Ephemeral bool
4088                 }))(obj)).SrcAOID).Serialize(w)
4089         }); err != nil {
4090                 if err == io.EOF {
4091                         chk(io.EOF)
4092                 }
4093                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
4094         }
4095         {
4096                 x := (*(*(struct {
4097                         ID      SoundID
4098                         Name    string
4099                         Gain    float32
4100                         SrcType SoundSrcType
4101                         Pos
4102                         SrcAOID   AOID
4103                         Loop      bool
4104                         Fade      float32
4105                         Pitch     float32
4106                         Ephemeral bool
4107                 }))(obj)).Loop
4108                 if x {
4109                         write8(w, 1)
4110                 } else {
4111                         write8(w, 0)
4112                 }
4113         }
4114         {
4115                 x := (*(*(struct {
4116                         ID      SoundID
4117                         Name    string
4118                         Gain    float32
4119                         SrcType SoundSrcType
4120                         Pos
4121                         SrcAOID   AOID
4122                         Loop      bool
4123                         Fade      float32
4124                         Pitch     float32
4125                         Ephemeral bool
4126                 }))(obj)).Fade
4127                 write32(w, math.Float32bits(x))
4128         }
4129         {
4130                 x := (*(*(struct {
4131                         ID      SoundID
4132                         Name    string
4133                         Gain    float32
4134                         SrcType SoundSrcType
4135                         Pos
4136                         SrcAOID   AOID
4137                         Loop      bool
4138                         Fade      float32
4139                         Pitch     float32
4140                         Ephemeral bool
4141                 }))(obj)).Pitch
4142                 write32(w, math.Float32bits(x))
4143         }
4144         {
4145                 x := (*(*(struct {
4146                         ID      SoundID
4147                         Name    string
4148                         Gain    float32
4149                         SrcType SoundSrcType
4150                         Pos
4151                         SrcAOID   AOID
4152                         Loop      bool
4153                         Fade      float32
4154                         Pitch     float32
4155                         Ephemeral bool
4156                 }))(obj)).Ephemeral
4157                 if x {
4158                         write8(w, 1)
4159                 } else {
4160                         write8(w, 0)
4161                 }
4162         }
4163 }
4164
4165 func (obj *ToCltPlaySound) Deserialize(r io.Reader) {
4166         if err := pcall(func() {
4167                 ((*(*(struct {
4168                         ID      SoundID
4169                         Name    string
4170                         Gain    float32
4171                         SrcType SoundSrcType
4172                         Pos
4173                         SrcAOID   AOID
4174                         Loop      bool
4175                         Fade      float32
4176                         Pitch     float32
4177                         Ephemeral bool
4178                 }))(obj)).ID).Deserialize(r)
4179         }); err != nil {
4180                 if err == io.EOF {
4181                         chk(io.EOF)
4182                 }
4183                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4184         }
4185         var local132 []uint8
4186         var local133 uint16
4187         {
4188                 p := &local133
4189                 *p = read16(r)
4190         }
4191         (local132) = make([]uint8, local133)
4192         {
4193                 _, err := io.ReadFull(r, (local132)[:])
4194                 chk(err)
4195         }
4196         ((*(*(struct {
4197                 ID      SoundID
4198                 Name    string
4199                 Gain    float32
4200                 SrcType SoundSrcType
4201                 Pos
4202                 SrcAOID   AOID
4203                 Loop      bool
4204                 Fade      float32
4205                 Pitch     float32
4206                 Ephemeral bool
4207         }))(obj)).Name) = string(local132)
4208         {
4209                 p := &(*(*(struct {
4210                         ID      SoundID
4211                         Name    string
4212                         Gain    float32
4213                         SrcType SoundSrcType
4214                         Pos
4215                         SrcAOID   AOID
4216                         Loop      bool
4217                         Fade      float32
4218                         Pitch     float32
4219                         Ephemeral bool
4220                 }))(obj)).Gain
4221                 *p = math.Float32frombits(read32(r))
4222         }
4223         if err := pcall(func() {
4224                 ((*(*(struct {
4225                         ID      SoundID
4226                         Name    string
4227                         Gain    float32
4228                         SrcType SoundSrcType
4229                         Pos
4230                         SrcAOID   AOID
4231                         Loop      bool
4232                         Fade      float32
4233                         Pitch     float32
4234                         Ephemeral bool
4235                 }))(obj)).SrcType).Deserialize(r)
4236         }); err != nil {
4237                 if err == io.EOF {
4238                         chk(io.EOF)
4239                 }
4240                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundSrcType", err))
4241         }
4242         if err := pcall(func() {
4243                 ((*(*(struct {
4244                         ID      SoundID
4245                         Name    string
4246                         Gain    float32
4247                         SrcType SoundSrcType
4248                         Pos
4249                         SrcAOID   AOID
4250                         Loop      bool
4251                         Fade      float32
4252                         Pitch     float32
4253                         Ephemeral bool
4254                 }))(obj)).Pos).Deserialize(r)
4255         }); err != nil {
4256                 if err == io.EOF {
4257                         chk(io.EOF)
4258                 }
4259                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
4260         }
4261         if err := pcall(func() {
4262                 ((*(*(struct {
4263                         ID      SoundID
4264                         Name    string
4265                         Gain    float32
4266                         SrcType SoundSrcType
4267                         Pos
4268                         SrcAOID   AOID
4269                         Loop      bool
4270                         Fade      float32
4271                         Pitch     float32
4272                         Ephemeral bool
4273                 }))(obj)).SrcAOID).Deserialize(r)
4274         }); err != nil {
4275                 if err == io.EOF {
4276                         chk(io.EOF)
4277                 }
4278                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
4279         }
4280         {
4281                 p := &(*(*(struct {
4282                         ID      SoundID
4283                         Name    string
4284                         Gain    float32
4285                         SrcType SoundSrcType
4286                         Pos
4287                         SrcAOID   AOID
4288                         Loop      bool
4289                         Fade      float32
4290                         Pitch     float32
4291                         Ephemeral bool
4292                 }))(obj)).Loop
4293                 switch n := read8(r); n {
4294                 case 0:
4295                         *p = false
4296                 case 1:
4297                         *p = true
4298                 default:
4299                         chk(fmt.Errorf("invalid bool: %d", n))
4300                 }
4301         }
4302         {
4303                 p := &(*(*(struct {
4304                         ID      SoundID
4305                         Name    string
4306                         Gain    float32
4307                         SrcType SoundSrcType
4308                         Pos
4309                         SrcAOID   AOID
4310                         Loop      bool
4311                         Fade      float32
4312                         Pitch     float32
4313                         Ephemeral bool
4314                 }))(obj)).Fade
4315                 *p = math.Float32frombits(read32(r))
4316         }
4317         {
4318                 p := &(*(*(struct {
4319                         ID      SoundID
4320                         Name    string
4321                         Gain    float32
4322                         SrcType SoundSrcType
4323                         Pos
4324                         SrcAOID   AOID
4325                         Loop      bool
4326                         Fade      float32
4327                         Pitch     float32
4328                         Ephemeral bool
4329                 }))(obj)).Pitch
4330                 *p = math.Float32frombits(read32(r))
4331         }
4332         {
4333                 p := &(*(*(struct {
4334                         ID      SoundID
4335                         Name    string
4336                         Gain    float32
4337                         SrcType SoundSrcType
4338                         Pos
4339                         SrcAOID   AOID
4340                         Loop      bool
4341                         Fade      float32
4342                         Pitch     float32
4343                         Ephemeral bool
4344                 }))(obj)).Ephemeral
4345                 switch n := read8(r); n {
4346                 case 0:
4347                         *p = false
4348                 case 1:
4349                         *p = true
4350                 default:
4351                         chk(fmt.Errorf("invalid bool: %d", n))
4352                 }
4353         }
4354 }
4355
4356 func (obj *ToCltStopSound) Serialize(w io.Writer) {
4357         if err := pcall(func() {
4358                 ((*(*(struct {
4359                         ID SoundID
4360                 }))(obj)).ID).Serialize(w)
4361         }); err != nil {
4362                 if err == io.EOF {
4363                         chk(io.EOF)
4364                 }
4365                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4366         }
4367 }
4368
4369 func (obj *ToCltStopSound) Deserialize(r io.Reader) {
4370         if err := pcall(func() {
4371                 ((*(*(struct {
4372                         ID SoundID
4373                 }))(obj)).ID).Deserialize(r)
4374         }); err != nil {
4375                 if err == io.EOF {
4376                         chk(io.EOF)
4377                 }
4378                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4379         }
4380 }
4381
4382 func (obj *ToCltPrivs) Serialize(w io.Writer) {
4383         if len(((*(*(struct {
4384                 Privs []string
4385         }))(obj)).Privs)) > math.MaxUint16 {
4386                 chk(ErrTooLong)
4387         }
4388         {
4389                 x := uint16(len(((*(*(struct {
4390                         Privs []string
4391                 }))(obj)).Privs)))
4392                 write16(w, uint16(x))
4393         }
4394         for local134 := range (*(*(struct {
4395                 Privs []string
4396         }))(obj)).Privs {
4397                 if len(([]byte(((*(*(struct {
4398                         Privs []string
4399                 }))(obj)).Privs)[local134]))) > math.MaxUint16 {
4400                         chk(ErrTooLong)
4401                 }
4402                 {
4403                         x := uint16(len(([]byte(((*(*(struct {
4404                                 Privs []string
4405                         }))(obj)).Privs)[local134]))))
4406                         write16(w, uint16(x))
4407                 }
4408                 {
4409                         _, err := w.Write(([]byte(((*(*(struct {
4410                                 Privs []string
4411                         }))(obj)).Privs)[local134]))[:])
4412                         chk(err)
4413                 }
4414         }
4415 }
4416
4417 func (obj *ToCltPrivs) Deserialize(r io.Reader) {
4418         var local135 uint16
4419         {
4420                 p := &local135
4421                 *p = read16(r)
4422         }
4423         ((*(*(struct {
4424                 Privs []string
4425         }))(obj)).Privs) = make([]string, local135)
4426         for local136 := range (*(*(struct {
4427                 Privs []string
4428         }))(obj)).Privs {
4429                 var local137 []uint8
4430                 var local138 uint16
4431                 {
4432                         p := &local138
4433                         *p = read16(r)
4434                 }
4435                 (local137) = make([]uint8, local138)
4436                 {
4437                         _, err := io.ReadFull(r, (local137)[:])
4438                         chk(err)
4439                 }
4440                 (((*(*(struct {
4441                         Privs []string
4442                 }))(obj)).Privs)[local136]) = string(local137)
4443         }
4444 }
4445
4446 func (obj *ToCltInvFormspec) Serialize(w io.Writer) {
4447         if len(([]byte((*(*(struct {
4448                 //mt:len32
4449                 Formspec string
4450         }))(obj)).Formspec))) > math.MaxUint32 {
4451                 chk(ErrTooLong)
4452         }
4453         {
4454                 x := uint32(len(([]byte((*(*(struct {
4455                         //mt:len32
4456                         Formspec string
4457                 }))(obj)).Formspec))))
4458                 write32(w, uint32(x))
4459         }
4460         {
4461                 _, err := w.Write(([]byte((*(*(struct {
4462                         //mt:len32
4463                         Formspec string
4464                 }))(obj)).Formspec))[:])
4465                 chk(err)
4466         }
4467 }
4468
4469 func (obj *ToCltInvFormspec) Deserialize(r io.Reader) {
4470         var local139 []uint8
4471         var local140 uint32
4472         {
4473                 p := &local140
4474                 *p = read32(r)
4475         }
4476         (local139) = make([]uint8, local140)
4477         {
4478                 _, err := io.ReadFull(r, (local139)[:])
4479                 chk(err)
4480         }
4481         ((*(*(struct {
4482                 //mt:len32
4483                 Formspec string
4484         }))(obj)).Formspec) = string(local139)
4485 }
4486
4487 func (obj *ToCltDetachedInv) Serialize(w io.Writer) {
4488         if len(([]byte((*(*(struct {
4489                 Name string
4490                 Keep bool
4491                 Len  uint16 // deprecated
4492
4493                 //mt:raw
4494                 Inv string
4495         }))(obj)).Name))) > math.MaxUint16 {
4496                 chk(ErrTooLong)
4497         }
4498         {
4499                 x := uint16(len(([]byte((*(*(struct {
4500                         Name string
4501                         Keep bool
4502                         Len  uint16 // deprecated
4503
4504                         //mt:raw
4505                         Inv string
4506                 }))(obj)).Name))))
4507                 write16(w, uint16(x))
4508         }
4509         {
4510                 _, err := w.Write(([]byte((*(*(struct {
4511                         Name string
4512                         Keep bool
4513                         Len  uint16 // deprecated
4514
4515                         //mt:raw
4516                         Inv string
4517                 }))(obj)).Name))[:])
4518                 chk(err)
4519         }
4520         {
4521                 x := (*(*(struct {
4522                         Name string
4523                         Keep bool
4524                         Len  uint16 // deprecated
4525
4526                         //mt:raw
4527                         Inv string
4528                 }))(obj)).Keep
4529                 if x {
4530                         write8(w, 1)
4531                 } else {
4532                         write8(w, 0)
4533                 }
4534         }
4535         {
4536                 x := (*(*(struct {
4537                         Name string
4538                         Keep bool
4539                         Len  uint16 // deprecated
4540
4541                         //mt:raw
4542                         Inv string
4543                 }))(obj)).Len
4544                 write16(w, uint16(x))
4545         }
4546         {
4547                 _, err := w.Write(([]byte((*(*(struct {
4548                         Name string
4549                         Keep bool
4550                         Len  uint16 // deprecated
4551
4552                         //mt:raw
4553                         Inv string
4554                 }))(obj)).Inv))[:])
4555                 chk(err)
4556         }
4557 }
4558
4559 func (obj *ToCltDetachedInv) Deserialize(r io.Reader) {
4560         var local141 []uint8
4561         var local142 uint16
4562         {
4563                 p := &local142
4564                 *p = read16(r)
4565         }
4566         (local141) = make([]uint8, local142)
4567         {
4568                 _, err := io.ReadFull(r, (local141)[:])
4569                 chk(err)
4570         }
4571         ((*(*(struct {
4572                 Name string
4573                 Keep bool
4574                 Len  uint16 // deprecated
4575
4576                 //mt:raw
4577                 Inv string
4578         }))(obj)).Name) = string(local141)
4579         {
4580                 p := &(*(*(struct {
4581                         Name string
4582                         Keep bool
4583                         Len  uint16 // deprecated
4584
4585                         //mt:raw
4586                         Inv string
4587                 }))(obj)).Keep
4588                 switch n := read8(r); n {
4589                 case 0:
4590                         *p = false
4591                 case 1:
4592                         *p = true
4593                 default:
4594                         chk(fmt.Errorf("invalid bool: %d", n))
4595                 }
4596         }
4597         {
4598                 p := &(*(*(struct {
4599                         Name string
4600                         Keep bool
4601                         Len  uint16 // deprecated
4602
4603                         //mt:raw
4604                         Inv string
4605                 }))(obj)).Len
4606                 *p = read16(r)
4607         }
4608         var local143 []uint8
4609         {
4610                 var err error
4611                 (local143), err = io.ReadAll(r)
4612                 chk(err)
4613         }
4614         ((*(*(struct {
4615                 Name string
4616                 Keep bool
4617                 Len  uint16 // deprecated
4618
4619                 //mt:raw
4620                 Inv string
4621         }))(obj)).Inv) = string(local143)
4622 }
4623
4624 func (obj *ToCltShowFormspec) Serialize(w io.Writer) {
4625         if len(([]byte((*(*(struct {
4626                 //mt:len32
4627                 Formspec string
4628
4629                 Formname string
4630         }))(obj)).Formspec))) > math.MaxUint32 {
4631                 chk(ErrTooLong)
4632         }
4633         {
4634                 x := uint32(len(([]byte((*(*(struct {
4635                         //mt:len32
4636                         Formspec string
4637
4638                         Formname string
4639                 }))(obj)).Formspec))))
4640                 write32(w, uint32(x))
4641         }
4642         {
4643                 _, err := w.Write(([]byte((*(*(struct {
4644                         //mt:len32
4645                         Formspec string
4646
4647                         Formname string
4648                 }))(obj)).Formspec))[:])
4649                 chk(err)
4650         }
4651         if len(([]byte((*(*(struct {
4652                 //mt:len32
4653                 Formspec string
4654
4655                 Formname string
4656         }))(obj)).Formname))) > math.MaxUint16 {
4657                 chk(ErrTooLong)
4658         }
4659         {
4660                 x := uint16(len(([]byte((*(*(struct {
4661                         //mt:len32
4662                         Formspec string
4663
4664                         Formname string
4665                 }))(obj)).Formname))))
4666                 write16(w, uint16(x))
4667         }
4668         {
4669                 _, err := w.Write(([]byte((*(*(struct {
4670                         //mt:len32
4671                         Formspec string
4672
4673                         Formname string
4674                 }))(obj)).Formname))[:])
4675                 chk(err)
4676         }
4677 }
4678
4679 func (obj *ToCltShowFormspec) Deserialize(r io.Reader) {
4680         var local144 []uint8
4681         var local145 uint32
4682         {
4683                 p := &local145
4684                 *p = read32(r)
4685         }
4686         (local144) = make([]uint8, local145)
4687         {
4688                 _, err := io.ReadFull(r, (local144)[:])
4689                 chk(err)
4690         }
4691         ((*(*(struct {
4692                 //mt:len32
4693                 Formspec string
4694
4695                 Formname string
4696         }))(obj)).Formspec) = string(local144)
4697         var local146 []uint8
4698         var local147 uint16
4699         {
4700                 p := &local147
4701                 *p = read16(r)
4702         }
4703         (local146) = make([]uint8, local147)
4704         {
4705                 _, err := io.ReadFull(r, (local146)[:])
4706                 chk(err)
4707         }
4708         ((*(*(struct {
4709                 //mt:len32
4710                 Formspec string
4711
4712                 Formname string
4713         }))(obj)).Formname) = string(local146)
4714 }
4715
4716 func (obj *ToCltMovement) Serialize(w io.Writer) {
4717         {
4718                 x := (*(*(struct {
4719                         DefaultAccel, AirAccel, FastAccel,
4720                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4721                         Fluidity, Smoothing, Sink,
4722                         Gravity float32
4723                 }))(obj)).DefaultAccel
4724                 write32(w, math.Float32bits(x))
4725         }
4726         {
4727                 x := (*(*(struct {
4728                         DefaultAccel, AirAccel, FastAccel,
4729                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4730                         Fluidity, Smoothing, Sink,
4731                         Gravity float32
4732                 }))(obj)).AirAccel
4733                 write32(w, math.Float32bits(x))
4734         }
4735         {
4736                 x := (*(*(struct {
4737                         DefaultAccel, AirAccel, FastAccel,
4738                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4739                         Fluidity, Smoothing, Sink,
4740                         Gravity float32
4741                 }))(obj)).FastAccel
4742                 write32(w, math.Float32bits(x))
4743         }
4744         {
4745                 x := (*(*(struct {
4746                         DefaultAccel, AirAccel, FastAccel,
4747                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4748                         Fluidity, Smoothing, Sink,
4749                         Gravity float32
4750                 }))(obj)).WalkSpeed
4751                 write32(w, math.Float32bits(x))
4752         }
4753         {
4754                 x := (*(*(struct {
4755                         DefaultAccel, AirAccel, FastAccel,
4756                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4757                         Fluidity, Smoothing, Sink,
4758                         Gravity float32
4759                 }))(obj)).CrouchSpeed
4760                 write32(w, math.Float32bits(x))
4761         }
4762         {
4763                 x := (*(*(struct {
4764                         DefaultAccel, AirAccel, FastAccel,
4765                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4766                         Fluidity, Smoothing, Sink,
4767                         Gravity float32
4768                 }))(obj)).FastSpeed
4769                 write32(w, math.Float32bits(x))
4770         }
4771         {
4772                 x := (*(*(struct {
4773                         DefaultAccel, AirAccel, FastAccel,
4774                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4775                         Fluidity, Smoothing, Sink,
4776                         Gravity float32
4777                 }))(obj)).ClimbSpeed
4778                 write32(w, math.Float32bits(x))
4779         }
4780         {
4781                 x := (*(*(struct {
4782                         DefaultAccel, AirAccel, FastAccel,
4783                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4784                         Fluidity, Smoothing, Sink,
4785                         Gravity float32
4786                 }))(obj)).JumpSpeed
4787                 write32(w, math.Float32bits(x))
4788         }
4789         {
4790                 x := (*(*(struct {
4791                         DefaultAccel, AirAccel, FastAccel,
4792                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4793                         Fluidity, Smoothing, Sink,
4794                         Gravity float32
4795                 }))(obj)).Fluidity
4796                 write32(w, math.Float32bits(x))
4797         }
4798         {
4799                 x := (*(*(struct {
4800                         DefaultAccel, AirAccel, FastAccel,
4801                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4802                         Fluidity, Smoothing, Sink,
4803                         Gravity float32
4804                 }))(obj)).Smoothing
4805                 write32(w, math.Float32bits(x))
4806         }
4807         {
4808                 x := (*(*(struct {
4809                         DefaultAccel, AirAccel, FastAccel,
4810                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4811                         Fluidity, Smoothing, Sink,
4812                         Gravity float32
4813                 }))(obj)).Sink
4814                 write32(w, math.Float32bits(x))
4815         }
4816         {
4817                 x := (*(*(struct {
4818                         DefaultAccel, AirAccel, FastAccel,
4819                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4820                         Fluidity, Smoothing, Sink,
4821                         Gravity float32
4822                 }))(obj)).Gravity
4823                 write32(w, math.Float32bits(x))
4824         }
4825 }
4826
4827 func (obj *ToCltMovement) Deserialize(r io.Reader) {
4828         {
4829                 p := &(*(*(struct {
4830                         DefaultAccel, AirAccel, FastAccel,
4831                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4832                         Fluidity, Smoothing, Sink,
4833                         Gravity float32
4834                 }))(obj)).DefaultAccel
4835                 *p = math.Float32frombits(read32(r))
4836         }
4837         {
4838                 p := &(*(*(struct {
4839                         DefaultAccel, AirAccel, FastAccel,
4840                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4841                         Fluidity, Smoothing, Sink,
4842                         Gravity float32
4843                 }))(obj)).AirAccel
4844                 *p = math.Float32frombits(read32(r))
4845         }
4846         {
4847                 p := &(*(*(struct {
4848                         DefaultAccel, AirAccel, FastAccel,
4849                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4850                         Fluidity, Smoothing, Sink,
4851                         Gravity float32
4852                 }))(obj)).FastAccel
4853                 *p = math.Float32frombits(read32(r))
4854         }
4855         {
4856                 p := &(*(*(struct {
4857                         DefaultAccel, AirAccel, FastAccel,
4858                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4859                         Fluidity, Smoothing, Sink,
4860                         Gravity float32
4861                 }))(obj)).WalkSpeed
4862                 *p = math.Float32frombits(read32(r))
4863         }
4864         {
4865                 p := &(*(*(struct {
4866                         DefaultAccel, AirAccel, FastAccel,
4867                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4868                         Fluidity, Smoothing, Sink,
4869                         Gravity float32
4870                 }))(obj)).CrouchSpeed
4871                 *p = math.Float32frombits(read32(r))
4872         }
4873         {
4874                 p := &(*(*(struct {
4875                         DefaultAccel, AirAccel, FastAccel,
4876                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4877                         Fluidity, Smoothing, Sink,
4878                         Gravity float32
4879                 }))(obj)).FastSpeed
4880                 *p = math.Float32frombits(read32(r))
4881         }
4882         {
4883                 p := &(*(*(struct {
4884                         DefaultAccel, AirAccel, FastAccel,
4885                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4886                         Fluidity, Smoothing, Sink,
4887                         Gravity float32
4888                 }))(obj)).ClimbSpeed
4889                 *p = math.Float32frombits(read32(r))
4890         }
4891         {
4892                 p := &(*(*(struct {
4893                         DefaultAccel, AirAccel, FastAccel,
4894                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4895                         Fluidity, Smoothing, Sink,
4896                         Gravity float32
4897                 }))(obj)).JumpSpeed
4898                 *p = math.Float32frombits(read32(r))
4899         }
4900         {
4901                 p := &(*(*(struct {
4902                         DefaultAccel, AirAccel, FastAccel,
4903                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4904                         Fluidity, Smoothing, Sink,
4905                         Gravity float32
4906                 }))(obj)).Fluidity
4907                 *p = math.Float32frombits(read32(r))
4908         }
4909         {
4910                 p := &(*(*(struct {
4911                         DefaultAccel, AirAccel, FastAccel,
4912                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4913                         Fluidity, Smoothing, Sink,
4914                         Gravity float32
4915                 }))(obj)).Smoothing
4916                 *p = math.Float32frombits(read32(r))
4917         }
4918         {
4919                 p := &(*(*(struct {
4920                         DefaultAccel, AirAccel, FastAccel,
4921                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4922                         Fluidity, Smoothing, Sink,
4923                         Gravity float32
4924                 }))(obj)).Sink
4925                 *p = math.Float32frombits(read32(r))
4926         }
4927         {
4928                 p := &(*(*(struct {
4929                         DefaultAccel, AirAccel, FastAccel,
4930                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4931                         Fluidity, Smoothing, Sink,
4932                         Gravity float32
4933                 }))(obj)).Gravity
4934                 *p = math.Float32frombits(read32(r))
4935         }
4936 }
4937
4938 func (obj *ToCltSpawnParticle) Serialize(w io.Writer) {
4939         for local148 := range (*(*(struct {
4940                 Pos, Vel, Acc  [3]float32
4941                 ExpirationTime float32 // in seconds.
4942                 Size           float32
4943                 Collide        bool
4944
4945                 //mt:len32
4946                 Texture
4947
4948                 Vertical    bool
4949                 CollisionRm bool
4950                 AnimParams  TileAnim
4951                 Glow        uint8
4952                 AOCollision bool
4953                 NodeParam0  Content
4954                 NodeParam2  uint8
4955                 NodeTile    uint8
4956         }))(obj)).Pos {
4957                 {
4958                         x := ((*(*(struct {
4959                                 Pos, Vel, Acc  [3]float32
4960                                 ExpirationTime float32 // in seconds.
4961                                 Size           float32
4962                                 Collide        bool
4963
4964                                 //mt:len32
4965                                 Texture
4966
4967                                 Vertical    bool
4968                                 CollisionRm bool
4969                                 AnimParams  TileAnim
4970                                 Glow        uint8
4971                                 AOCollision bool
4972                                 NodeParam0  Content
4973                                 NodeParam2  uint8
4974                                 NodeTile    uint8
4975                         }))(obj)).Pos)[local148]
4976                         write32(w, math.Float32bits(x))
4977                 }
4978         }
4979         for local149 := range (*(*(struct {
4980                 Pos, Vel, Acc  [3]float32
4981                 ExpirationTime float32 // in seconds.
4982                 Size           float32
4983                 Collide        bool
4984
4985                 //mt:len32
4986                 Texture
4987
4988                 Vertical    bool
4989                 CollisionRm bool
4990                 AnimParams  TileAnim
4991                 Glow        uint8
4992                 AOCollision bool
4993                 NodeParam0  Content
4994                 NodeParam2  uint8
4995                 NodeTile    uint8
4996         }))(obj)).Vel {
4997                 {
4998                         x := ((*(*(struct {
4999                                 Pos, Vel, Acc  [3]float32
5000                                 ExpirationTime float32 // in seconds.
5001                                 Size           float32
5002                                 Collide        bool
5003
5004                                 //mt:len32
5005                                 Texture
5006
5007                                 Vertical    bool
5008                                 CollisionRm bool
5009                                 AnimParams  TileAnim
5010                                 Glow        uint8
5011                                 AOCollision bool
5012                                 NodeParam0  Content
5013                                 NodeParam2  uint8
5014                                 NodeTile    uint8
5015                         }))(obj)).Vel)[local149]
5016                         write32(w, math.Float32bits(x))
5017                 }
5018         }
5019         for local150 := range (*(*(struct {
5020                 Pos, Vel, Acc  [3]float32
5021                 ExpirationTime float32 // in seconds.
5022                 Size           float32
5023                 Collide        bool
5024
5025                 //mt:len32
5026                 Texture
5027
5028                 Vertical    bool
5029                 CollisionRm bool
5030                 AnimParams  TileAnim
5031                 Glow        uint8
5032                 AOCollision bool
5033                 NodeParam0  Content
5034                 NodeParam2  uint8
5035                 NodeTile    uint8
5036         }))(obj)).Acc {
5037                 {
5038                         x := ((*(*(struct {
5039                                 Pos, Vel, Acc  [3]float32
5040                                 ExpirationTime float32 // in seconds.
5041                                 Size           float32
5042                                 Collide        bool
5043
5044                                 //mt:len32
5045                                 Texture
5046
5047                                 Vertical    bool
5048                                 CollisionRm bool
5049                                 AnimParams  TileAnim
5050                                 Glow        uint8
5051                                 AOCollision bool
5052                                 NodeParam0  Content
5053                                 NodeParam2  uint8
5054                                 NodeTile    uint8
5055                         }))(obj)).Acc)[local150]
5056                         write32(w, math.Float32bits(x))
5057                 }
5058         }
5059         {
5060                 x := (*(*(struct {
5061                         Pos, Vel, Acc  [3]float32
5062                         ExpirationTime float32 // in seconds.
5063                         Size           float32
5064                         Collide        bool
5065
5066                         //mt:len32
5067                         Texture
5068
5069                         Vertical    bool
5070                         CollisionRm bool
5071                         AnimParams  TileAnim
5072                         Glow        uint8
5073                         AOCollision bool
5074                         NodeParam0  Content
5075                         NodeParam2  uint8
5076                         NodeTile    uint8
5077                 }))(obj)).ExpirationTime
5078                 write32(w, math.Float32bits(x))
5079         }
5080         {
5081                 x := (*(*(struct {
5082                         Pos, Vel, Acc  [3]float32
5083                         ExpirationTime float32 // in seconds.
5084                         Size           float32
5085                         Collide        bool
5086
5087                         //mt:len32
5088                         Texture
5089
5090                         Vertical    bool
5091                         CollisionRm bool
5092                         AnimParams  TileAnim
5093                         Glow        uint8
5094                         AOCollision bool
5095                         NodeParam0  Content
5096                         NodeParam2  uint8
5097                         NodeTile    uint8
5098                 }))(obj)).Size
5099                 write32(w, math.Float32bits(x))
5100         }
5101         {
5102                 x := (*(*(struct {
5103                         Pos, Vel, Acc  [3]float32
5104                         ExpirationTime float32 // in seconds.
5105                         Size           float32
5106                         Collide        bool
5107
5108                         //mt:len32
5109                         Texture
5110
5111                         Vertical    bool
5112                         CollisionRm bool
5113                         AnimParams  TileAnim
5114                         Glow        uint8
5115                         AOCollision bool
5116                         NodeParam0  Content
5117                         NodeParam2  uint8
5118                         NodeTile    uint8
5119                 }))(obj)).Collide
5120                 if x {
5121                         write8(w, 1)
5122                 } else {
5123                         write8(w, 0)
5124                 }
5125         }
5126         if len(([]byte(*(*string)(&((*(*(struct {
5127                 Pos, Vel, Acc  [3]float32
5128                 ExpirationTime float32 // in seconds.
5129                 Size           float32
5130                 Collide        bool
5131
5132                 //mt:len32
5133                 Texture
5134
5135                 Vertical    bool
5136                 CollisionRm bool
5137                 AnimParams  TileAnim
5138                 Glow        uint8
5139                 AOCollision bool
5140                 NodeParam0  Content
5141                 NodeParam2  uint8
5142                 NodeTile    uint8
5143         }))(obj)).Texture))))) > math.MaxUint32 {
5144                 chk(ErrTooLong)
5145         }
5146         {
5147                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5148                         Pos, Vel, Acc  [3]float32
5149                         ExpirationTime float32 // in seconds.
5150                         Size           float32
5151                         Collide        bool
5152
5153                         //mt:len32
5154                         Texture
5155
5156                         Vertical    bool
5157                         CollisionRm bool
5158                         AnimParams  TileAnim
5159                         Glow        uint8
5160                         AOCollision bool
5161                         NodeParam0  Content
5162                         NodeParam2  uint8
5163                         NodeTile    uint8
5164                 }))(obj)).Texture))))))
5165                 write32(w, uint32(x))
5166         }
5167         {
5168                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5169                         Pos, Vel, Acc  [3]float32
5170                         ExpirationTime float32 // in seconds.
5171                         Size           float32
5172                         Collide        bool
5173
5174                         //mt:len32
5175                         Texture
5176
5177                         Vertical    bool
5178                         CollisionRm bool
5179                         AnimParams  TileAnim
5180                         Glow        uint8
5181                         AOCollision bool
5182                         NodeParam0  Content
5183                         NodeParam2  uint8
5184                         NodeTile    uint8
5185                 }))(obj)).Texture))))[:])
5186                 chk(err)
5187         }
5188         {
5189                 x := (*(*(struct {
5190                         Pos, Vel, Acc  [3]float32
5191                         ExpirationTime float32 // in seconds.
5192                         Size           float32
5193                         Collide        bool
5194
5195                         //mt:len32
5196                         Texture
5197
5198                         Vertical    bool
5199                         CollisionRm bool
5200                         AnimParams  TileAnim
5201                         Glow        uint8
5202                         AOCollision bool
5203                         NodeParam0  Content
5204                         NodeParam2  uint8
5205                         NodeTile    uint8
5206                 }))(obj)).Vertical
5207                 if x {
5208                         write8(w, 1)
5209                 } else {
5210                         write8(w, 0)
5211                 }
5212         }
5213         {
5214                 x := (*(*(struct {
5215                         Pos, Vel, Acc  [3]float32
5216                         ExpirationTime float32 // in seconds.
5217                         Size           float32
5218                         Collide        bool
5219
5220                         //mt:len32
5221                         Texture
5222
5223                         Vertical    bool
5224                         CollisionRm bool
5225                         AnimParams  TileAnim
5226                         Glow        uint8
5227                         AOCollision bool
5228                         NodeParam0  Content
5229                         NodeParam2  uint8
5230                         NodeTile    uint8
5231                 }))(obj)).CollisionRm
5232                 if x {
5233                         write8(w, 1)
5234                 } else {
5235                         write8(w, 0)
5236                 }
5237         }
5238         if err := pcall(func() {
5239                 ((*(*(struct {
5240                         Pos, Vel, Acc  [3]float32
5241                         ExpirationTime float32 // in seconds.
5242                         Size           float32
5243                         Collide        bool
5244
5245                         //mt:len32
5246                         Texture
5247
5248                         Vertical    bool
5249                         CollisionRm bool
5250                         AnimParams  TileAnim
5251                         Glow        uint8
5252                         AOCollision bool
5253                         NodeParam0  Content
5254                         NodeParam2  uint8
5255                         NodeTile    uint8
5256                 }))(obj)).AnimParams).Serialize(w)
5257         }); err != nil {
5258                 if err == io.EOF {
5259                         chk(io.EOF)
5260                 }
5261                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
5262         }
5263         {
5264                 x := (*(*(struct {
5265                         Pos, Vel, Acc  [3]float32
5266                         ExpirationTime float32 // in seconds.
5267                         Size           float32
5268                         Collide        bool
5269
5270                         //mt:len32
5271                         Texture
5272
5273                         Vertical    bool
5274                         CollisionRm bool
5275                         AnimParams  TileAnim
5276                         Glow        uint8
5277                         AOCollision bool
5278                         NodeParam0  Content
5279                         NodeParam2  uint8
5280                         NodeTile    uint8
5281                 }))(obj)).Glow
5282                 write8(w, uint8(x))
5283         }
5284         {
5285                 x := (*(*(struct {
5286                         Pos, Vel, Acc  [3]float32
5287                         ExpirationTime float32 // in seconds.
5288                         Size           float32
5289                         Collide        bool
5290
5291                         //mt:len32
5292                         Texture
5293
5294                         Vertical    bool
5295                         CollisionRm bool
5296                         AnimParams  TileAnim
5297                         Glow        uint8
5298                         AOCollision bool
5299                         NodeParam0  Content
5300                         NodeParam2  uint8
5301                         NodeTile    uint8
5302                 }))(obj)).AOCollision
5303                 if x {
5304                         write8(w, 1)
5305                 } else {
5306                         write8(w, 0)
5307                 }
5308         }
5309         if err := pcall(func() {
5310                 ((*(*(struct {
5311                         Pos, Vel, Acc  [3]float32
5312                         ExpirationTime float32 // in seconds.
5313                         Size           float32
5314                         Collide        bool
5315
5316                         //mt:len32
5317                         Texture
5318
5319                         Vertical    bool
5320                         CollisionRm bool
5321                         AnimParams  TileAnim
5322                         Glow        uint8
5323                         AOCollision bool
5324                         NodeParam0  Content
5325                         NodeParam2  uint8
5326                         NodeTile    uint8
5327                 }))(obj)).NodeParam0).Serialize(w)
5328         }); err != nil {
5329                 if err == io.EOF {
5330                         chk(io.EOF)
5331                 }
5332                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
5333         }
5334         {
5335                 x := (*(*(struct {
5336                         Pos, Vel, Acc  [3]float32
5337                         ExpirationTime float32 // in seconds.
5338                         Size           float32
5339                         Collide        bool
5340
5341                         //mt:len32
5342                         Texture
5343
5344                         Vertical    bool
5345                         CollisionRm bool
5346                         AnimParams  TileAnim
5347                         Glow        uint8
5348                         AOCollision bool
5349                         NodeParam0  Content
5350                         NodeParam2  uint8
5351                         NodeTile    uint8
5352                 }))(obj)).NodeParam2
5353                 write8(w, uint8(x))
5354         }
5355         {
5356                 x := (*(*(struct {
5357                         Pos, Vel, Acc  [3]float32
5358                         ExpirationTime float32 // in seconds.
5359                         Size           float32
5360                         Collide        bool
5361
5362                         //mt:len32
5363                         Texture
5364
5365                         Vertical    bool
5366                         CollisionRm bool
5367                         AnimParams  TileAnim
5368                         Glow        uint8
5369                         AOCollision bool
5370                         NodeParam0  Content
5371                         NodeParam2  uint8
5372                         NodeTile    uint8
5373                 }))(obj)).NodeTile
5374                 write8(w, uint8(x))
5375         }
5376 }
5377
5378 func (obj *ToCltSpawnParticle) Deserialize(r io.Reader) {
5379         for local151 := range (*(*(struct {
5380                 Pos, Vel, Acc  [3]float32
5381                 ExpirationTime float32 // in seconds.
5382                 Size           float32
5383                 Collide        bool
5384
5385                 //mt:len32
5386                 Texture
5387
5388                 Vertical    bool
5389                 CollisionRm bool
5390                 AnimParams  TileAnim
5391                 Glow        uint8
5392                 AOCollision bool
5393                 NodeParam0  Content
5394                 NodeParam2  uint8
5395                 NodeTile    uint8
5396         }))(obj)).Pos {
5397                 {
5398                         p := &((*(*(struct {
5399                                 Pos, Vel, Acc  [3]float32
5400                                 ExpirationTime float32 // in seconds.
5401                                 Size           float32
5402                                 Collide        bool
5403
5404                                 //mt:len32
5405                                 Texture
5406
5407                                 Vertical    bool
5408                                 CollisionRm bool
5409                                 AnimParams  TileAnim
5410                                 Glow        uint8
5411                                 AOCollision bool
5412                                 NodeParam0  Content
5413                                 NodeParam2  uint8
5414                                 NodeTile    uint8
5415                         }))(obj)).Pos)[local151]
5416                         *p = math.Float32frombits(read32(r))
5417                 }
5418         }
5419         for local152 := range (*(*(struct {
5420                 Pos, Vel, Acc  [3]float32
5421                 ExpirationTime float32 // in seconds.
5422                 Size           float32
5423                 Collide        bool
5424
5425                 //mt:len32
5426                 Texture
5427
5428                 Vertical    bool
5429                 CollisionRm bool
5430                 AnimParams  TileAnim
5431                 Glow        uint8
5432                 AOCollision bool
5433                 NodeParam0  Content
5434                 NodeParam2  uint8
5435                 NodeTile    uint8
5436         }))(obj)).Vel {
5437                 {
5438                         p := &((*(*(struct {
5439                                 Pos, Vel, Acc  [3]float32
5440                                 ExpirationTime float32 // in seconds.
5441                                 Size           float32
5442                                 Collide        bool
5443
5444                                 //mt:len32
5445                                 Texture
5446
5447                                 Vertical    bool
5448                                 CollisionRm bool
5449                                 AnimParams  TileAnim
5450                                 Glow        uint8
5451                                 AOCollision bool
5452                                 NodeParam0  Content
5453                                 NodeParam2  uint8
5454                                 NodeTile    uint8
5455                         }))(obj)).Vel)[local152]
5456                         *p = math.Float32frombits(read32(r))
5457                 }
5458         }
5459         for local153 := range (*(*(struct {
5460                 Pos, Vel, Acc  [3]float32
5461                 ExpirationTime float32 // in seconds.
5462                 Size           float32
5463                 Collide        bool
5464
5465                 //mt:len32
5466                 Texture
5467
5468                 Vertical    bool
5469                 CollisionRm bool
5470                 AnimParams  TileAnim
5471                 Glow        uint8
5472                 AOCollision bool
5473                 NodeParam0  Content
5474                 NodeParam2  uint8
5475                 NodeTile    uint8
5476         }))(obj)).Acc {
5477                 {
5478                         p := &((*(*(struct {
5479                                 Pos, Vel, Acc  [3]float32
5480                                 ExpirationTime float32 // in seconds.
5481                                 Size           float32
5482                                 Collide        bool
5483
5484                                 //mt:len32
5485                                 Texture
5486
5487                                 Vertical    bool
5488                                 CollisionRm bool
5489                                 AnimParams  TileAnim
5490                                 Glow        uint8
5491                                 AOCollision bool
5492                                 NodeParam0  Content
5493                                 NodeParam2  uint8
5494                                 NodeTile    uint8
5495                         }))(obj)).Acc)[local153]
5496                         *p = math.Float32frombits(read32(r))
5497                 }
5498         }
5499         {
5500                 p := &(*(*(struct {
5501                         Pos, Vel, Acc  [3]float32
5502                         ExpirationTime float32 // in seconds.
5503                         Size           float32
5504                         Collide        bool
5505
5506                         //mt:len32
5507                         Texture
5508
5509                         Vertical    bool
5510                         CollisionRm bool
5511                         AnimParams  TileAnim
5512                         Glow        uint8
5513                         AOCollision bool
5514                         NodeParam0  Content
5515                         NodeParam2  uint8
5516                         NodeTile    uint8
5517                 }))(obj)).ExpirationTime
5518                 *p = math.Float32frombits(read32(r))
5519         }
5520         {
5521                 p := &(*(*(struct {
5522                         Pos, Vel, Acc  [3]float32
5523                         ExpirationTime float32 // in seconds.
5524                         Size           float32
5525                         Collide        bool
5526
5527                         //mt:len32
5528                         Texture
5529
5530                         Vertical    bool
5531                         CollisionRm bool
5532                         AnimParams  TileAnim
5533                         Glow        uint8
5534                         AOCollision bool
5535                         NodeParam0  Content
5536                         NodeParam2  uint8
5537                         NodeTile    uint8
5538                 }))(obj)).Size
5539                 *p = math.Float32frombits(read32(r))
5540         }
5541         {
5542                 p := &(*(*(struct {
5543                         Pos, Vel, Acc  [3]float32
5544                         ExpirationTime float32 // in seconds.
5545                         Size           float32
5546                         Collide        bool
5547
5548                         //mt:len32
5549                         Texture
5550
5551                         Vertical    bool
5552                         CollisionRm bool
5553                         AnimParams  TileAnim
5554                         Glow        uint8
5555                         AOCollision bool
5556                         NodeParam0  Content
5557                         NodeParam2  uint8
5558                         NodeTile    uint8
5559                 }))(obj)).Collide
5560                 switch n := read8(r); n {
5561                 case 0:
5562                         *p = false
5563                 case 1:
5564                         *p = true
5565                 default:
5566                         chk(fmt.Errorf("invalid bool: %d", n))
5567                 }
5568         }
5569         var local154 []uint8
5570         var local155 uint32
5571         {
5572                 p := &local155
5573                 *p = read32(r)
5574         }
5575         (local154) = make([]uint8, local155)
5576         {
5577                 _, err := io.ReadFull(r, (local154)[:])
5578                 chk(err)
5579         }
5580         (*(*string)(&((*(*(struct {
5581                 Pos, Vel, Acc  [3]float32
5582                 ExpirationTime float32 // in seconds.
5583                 Size           float32
5584                 Collide        bool
5585
5586                 //mt:len32
5587                 Texture
5588
5589                 Vertical    bool
5590                 CollisionRm bool
5591                 AnimParams  TileAnim
5592                 Glow        uint8
5593                 AOCollision bool
5594                 NodeParam0  Content
5595                 NodeParam2  uint8
5596                 NodeTile    uint8
5597         }))(obj)).Texture))) = string(local154)
5598         {
5599                 p := &(*(*(struct {
5600                         Pos, Vel, Acc  [3]float32
5601                         ExpirationTime float32 // in seconds.
5602                         Size           float32
5603                         Collide        bool
5604
5605                         //mt:len32
5606                         Texture
5607
5608                         Vertical    bool
5609                         CollisionRm bool
5610                         AnimParams  TileAnim
5611                         Glow        uint8
5612                         AOCollision bool
5613                         NodeParam0  Content
5614                         NodeParam2  uint8
5615                         NodeTile    uint8
5616                 }))(obj)).Vertical
5617                 switch n := read8(r); n {
5618                 case 0:
5619                         *p = false
5620                 case 1:
5621                         *p = true
5622                 default:
5623                         chk(fmt.Errorf("invalid bool: %d", n))
5624                 }
5625         }
5626         {
5627                 p := &(*(*(struct {
5628                         Pos, Vel, Acc  [3]float32
5629                         ExpirationTime float32 // in seconds.
5630                         Size           float32
5631                         Collide        bool
5632
5633                         //mt:len32
5634                         Texture
5635
5636                         Vertical    bool
5637                         CollisionRm bool
5638                         AnimParams  TileAnim
5639                         Glow        uint8
5640                         AOCollision bool
5641                         NodeParam0  Content
5642                         NodeParam2  uint8
5643                         NodeTile    uint8
5644                 }))(obj)).CollisionRm
5645                 switch n := read8(r); n {
5646                 case 0:
5647                         *p = false
5648                 case 1:
5649                         *p = true
5650                 default:
5651                         chk(fmt.Errorf("invalid bool: %d", n))
5652                 }
5653         }
5654         if err := pcall(func() {
5655                 ((*(*(struct {
5656                         Pos, Vel, Acc  [3]float32
5657                         ExpirationTime float32 // in seconds.
5658                         Size           float32
5659                         Collide        bool
5660
5661                         //mt:len32
5662                         Texture
5663
5664                         Vertical    bool
5665                         CollisionRm bool
5666                         AnimParams  TileAnim
5667                         Glow        uint8
5668                         AOCollision bool
5669                         NodeParam0  Content
5670                         NodeParam2  uint8
5671                         NodeTile    uint8
5672                 }))(obj)).AnimParams).Deserialize(r)
5673         }); err != nil {
5674                 if err == io.EOF {
5675                         chk(io.EOF)
5676                 }
5677                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
5678         }
5679         {
5680                 p := &(*(*(struct {
5681                         Pos, Vel, Acc  [3]float32
5682                         ExpirationTime float32 // in seconds.
5683                         Size           float32
5684                         Collide        bool
5685
5686                         //mt:len32
5687                         Texture
5688
5689                         Vertical    bool
5690                         CollisionRm bool
5691                         AnimParams  TileAnim
5692                         Glow        uint8
5693                         AOCollision bool
5694                         NodeParam0  Content
5695                         NodeParam2  uint8
5696                         NodeTile    uint8
5697                 }))(obj)).Glow
5698                 *p = read8(r)
5699         }
5700         {
5701                 p := &(*(*(struct {
5702                         Pos, Vel, Acc  [3]float32
5703                         ExpirationTime float32 // in seconds.
5704                         Size           float32
5705                         Collide        bool
5706
5707                         //mt:len32
5708                         Texture
5709
5710                         Vertical    bool
5711                         CollisionRm bool
5712                         AnimParams  TileAnim
5713                         Glow        uint8
5714                         AOCollision bool
5715                         NodeParam0  Content
5716                         NodeParam2  uint8
5717                         NodeTile    uint8
5718                 }))(obj)).AOCollision
5719                 switch n := read8(r); n {
5720                 case 0:
5721                         *p = false
5722                 case 1:
5723                         *p = true
5724                 default:
5725                         chk(fmt.Errorf("invalid bool: %d", n))
5726                 }
5727         }
5728         if err := pcall(func() {
5729                 ((*(*(struct {
5730                         Pos, Vel, Acc  [3]float32
5731                         ExpirationTime float32 // in seconds.
5732                         Size           float32
5733                         Collide        bool
5734
5735                         //mt:len32
5736                         Texture
5737
5738                         Vertical    bool
5739                         CollisionRm bool
5740                         AnimParams  TileAnim
5741                         Glow        uint8
5742                         AOCollision bool
5743                         NodeParam0  Content
5744                         NodeParam2  uint8
5745                         NodeTile    uint8
5746                 }))(obj)).NodeParam0).Deserialize(r)
5747         }); err != nil {
5748                 if err == io.EOF {
5749                         chk(io.EOF)
5750                 }
5751                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
5752         }
5753         {
5754                 p := &(*(*(struct {
5755                         Pos, Vel, Acc  [3]float32
5756                         ExpirationTime float32 // in seconds.
5757                         Size           float32
5758                         Collide        bool
5759
5760                         //mt:len32
5761                         Texture
5762
5763                         Vertical    bool
5764                         CollisionRm bool
5765                         AnimParams  TileAnim
5766                         Glow        uint8
5767                         AOCollision bool
5768                         NodeParam0  Content
5769                         NodeParam2  uint8
5770                         NodeTile    uint8
5771                 }))(obj)).NodeParam2
5772                 *p = read8(r)
5773         }
5774         {
5775                 p := &(*(*(struct {
5776                         Pos, Vel, Acc  [3]float32
5777                         ExpirationTime float32 // in seconds.
5778                         Size           float32
5779                         Collide        bool
5780
5781                         //mt:len32
5782                         Texture
5783
5784                         Vertical    bool
5785                         CollisionRm bool
5786                         AnimParams  TileAnim
5787                         Glow        uint8
5788                         AOCollision bool
5789                         NodeParam0  Content
5790                         NodeParam2  uint8
5791                         NodeTile    uint8
5792                 }))(obj)).NodeTile
5793                 *p = read8(r)
5794         }
5795 }
5796
5797 func (obj *ToCltAddParticleSpawner) Serialize(w io.Writer) {
5798         {
5799                 x := (*(*(struct {
5800                         Amount         uint16
5801                         Duration       float32
5802                         Pos, Vel, Acc  [2][3]float32
5803                         ExpirationTime [2]float32 // in seconds.
5804                         Size           [2]float32
5805                         Collide        bool
5806
5807                         //mt:len32
5808                         Texture
5809
5810                         ID           ParticleSpawnerID
5811                         Vertical     bool
5812                         CollisionRm  bool
5813                         AttachedAOID AOID
5814                         AnimParams   TileAnim
5815                         Glow         uint8
5816                         AOCollision  bool
5817                         NodeParam0   Content
5818                         NodeParam2   uint8
5819                         NodeTile     uint8
5820                 }))(obj)).Amount
5821                 write16(w, uint16(x))
5822         }
5823         {
5824                 x := (*(*(struct {
5825                         Amount         uint16
5826                         Duration       float32
5827                         Pos, Vel, Acc  [2][3]float32
5828                         ExpirationTime [2]float32 // in seconds.
5829                         Size           [2]float32
5830                         Collide        bool
5831
5832                         //mt:len32
5833                         Texture
5834
5835                         ID           ParticleSpawnerID
5836                         Vertical     bool
5837                         CollisionRm  bool
5838                         AttachedAOID AOID
5839                         AnimParams   TileAnim
5840                         Glow         uint8
5841                         AOCollision  bool
5842                         NodeParam0   Content
5843                         NodeParam2   uint8
5844                         NodeTile     uint8
5845                 }))(obj)).Duration
5846                 write32(w, math.Float32bits(x))
5847         }
5848         for local156 := range (*(*(struct {
5849                 Amount         uint16
5850                 Duration       float32
5851                 Pos, Vel, Acc  [2][3]float32
5852                 ExpirationTime [2]float32 // in seconds.
5853                 Size           [2]float32
5854                 Collide        bool
5855
5856                 //mt:len32
5857                 Texture
5858
5859                 ID           ParticleSpawnerID
5860                 Vertical     bool
5861                 CollisionRm  bool
5862                 AttachedAOID AOID
5863                 AnimParams   TileAnim
5864                 Glow         uint8
5865                 AOCollision  bool
5866                 NodeParam0   Content
5867                 NodeParam2   uint8
5868                 NodeTile     uint8
5869         }))(obj)).Pos {
5870                 for local157 := range ((*(*(struct {
5871                         Amount         uint16
5872                         Duration       float32
5873                         Pos, Vel, Acc  [2][3]float32
5874                         ExpirationTime [2]float32 // in seconds.
5875                         Size           [2]float32
5876                         Collide        bool
5877
5878                         //mt:len32
5879                         Texture
5880
5881                         ID           ParticleSpawnerID
5882                         Vertical     bool
5883                         CollisionRm  bool
5884                         AttachedAOID AOID
5885                         AnimParams   TileAnim
5886                         Glow         uint8
5887                         AOCollision  bool
5888                         NodeParam0   Content
5889                         NodeParam2   uint8
5890                         NodeTile     uint8
5891                 }))(obj)).Pos)[local156] {
5892                         {
5893                                 x := (((*(*(struct {
5894                                         Amount         uint16
5895                                         Duration       float32
5896                                         Pos, Vel, Acc  [2][3]float32
5897                                         ExpirationTime [2]float32 // in seconds.
5898                                         Size           [2]float32
5899                                         Collide        bool
5900
5901                                         //mt:len32
5902                                         Texture
5903
5904                                         ID           ParticleSpawnerID
5905                                         Vertical     bool
5906                                         CollisionRm  bool
5907                                         AttachedAOID AOID
5908                                         AnimParams   TileAnim
5909                                         Glow         uint8
5910                                         AOCollision  bool
5911                                         NodeParam0   Content
5912                                         NodeParam2   uint8
5913                                         NodeTile     uint8
5914                                 }))(obj)).Pos)[local156])[local157]
5915                                 write32(w, math.Float32bits(x))
5916                         }
5917                 }
5918         }
5919         for local158 := range (*(*(struct {
5920                 Amount         uint16
5921                 Duration       float32
5922                 Pos, Vel, Acc  [2][3]float32
5923                 ExpirationTime [2]float32 // in seconds.
5924                 Size           [2]float32
5925                 Collide        bool
5926
5927                 //mt:len32
5928                 Texture
5929
5930                 ID           ParticleSpawnerID
5931                 Vertical     bool
5932                 CollisionRm  bool
5933                 AttachedAOID AOID
5934                 AnimParams   TileAnim
5935                 Glow         uint8
5936                 AOCollision  bool
5937                 NodeParam0   Content
5938                 NodeParam2   uint8
5939                 NodeTile     uint8
5940         }))(obj)).Vel {
5941                 for local159 := range ((*(*(struct {
5942                         Amount         uint16
5943                         Duration       float32
5944                         Pos, Vel, Acc  [2][3]float32
5945                         ExpirationTime [2]float32 // in seconds.
5946                         Size           [2]float32
5947                         Collide        bool
5948
5949                         //mt:len32
5950                         Texture
5951
5952                         ID           ParticleSpawnerID
5953                         Vertical     bool
5954                         CollisionRm  bool
5955                         AttachedAOID AOID
5956                         AnimParams   TileAnim
5957                         Glow         uint8
5958                         AOCollision  bool
5959                         NodeParam0   Content
5960                         NodeParam2   uint8
5961                         NodeTile     uint8
5962                 }))(obj)).Vel)[local158] {
5963                         {
5964                                 x := (((*(*(struct {
5965                                         Amount         uint16
5966                                         Duration       float32
5967                                         Pos, Vel, Acc  [2][3]float32
5968                                         ExpirationTime [2]float32 // in seconds.
5969                                         Size           [2]float32
5970                                         Collide        bool
5971
5972                                         //mt:len32
5973                                         Texture
5974
5975                                         ID           ParticleSpawnerID
5976                                         Vertical     bool
5977                                         CollisionRm  bool
5978                                         AttachedAOID AOID
5979                                         AnimParams   TileAnim
5980                                         Glow         uint8
5981                                         AOCollision  bool
5982                                         NodeParam0   Content
5983                                         NodeParam2   uint8
5984                                         NodeTile     uint8
5985                                 }))(obj)).Vel)[local158])[local159]
5986                                 write32(w, math.Float32bits(x))
5987                         }
5988                 }
5989         }
5990         for local160 := range (*(*(struct {
5991                 Amount         uint16
5992                 Duration       float32
5993                 Pos, Vel, Acc  [2][3]float32
5994                 ExpirationTime [2]float32 // in seconds.
5995                 Size           [2]float32
5996                 Collide        bool
5997
5998                 //mt:len32
5999                 Texture
6000
6001                 ID           ParticleSpawnerID
6002                 Vertical     bool
6003                 CollisionRm  bool
6004                 AttachedAOID AOID
6005                 AnimParams   TileAnim
6006                 Glow         uint8
6007                 AOCollision  bool
6008                 NodeParam0   Content
6009                 NodeParam2   uint8
6010                 NodeTile     uint8
6011         }))(obj)).Acc {
6012                 for local161 := range ((*(*(struct {
6013                         Amount         uint16
6014                         Duration       float32
6015                         Pos, Vel, Acc  [2][3]float32
6016                         ExpirationTime [2]float32 // in seconds.
6017                         Size           [2]float32
6018                         Collide        bool
6019
6020                         //mt:len32
6021                         Texture
6022
6023                         ID           ParticleSpawnerID
6024                         Vertical     bool
6025                         CollisionRm  bool
6026                         AttachedAOID AOID
6027                         AnimParams   TileAnim
6028                         Glow         uint8
6029                         AOCollision  bool
6030                         NodeParam0   Content
6031                         NodeParam2   uint8
6032                         NodeTile     uint8
6033                 }))(obj)).Acc)[local160] {
6034                         {
6035                                 x := (((*(*(struct {
6036                                         Amount         uint16
6037                                         Duration       float32
6038                                         Pos, Vel, Acc  [2][3]float32
6039                                         ExpirationTime [2]float32 // in seconds.
6040                                         Size           [2]float32
6041                                         Collide        bool
6042
6043                                         //mt:len32
6044                                         Texture
6045
6046                                         ID           ParticleSpawnerID
6047                                         Vertical     bool
6048                                         CollisionRm  bool
6049                                         AttachedAOID AOID
6050                                         AnimParams   TileAnim
6051                                         Glow         uint8
6052                                         AOCollision  bool
6053                                         NodeParam0   Content
6054                                         NodeParam2   uint8
6055                                         NodeTile     uint8
6056                                 }))(obj)).Acc)[local160])[local161]
6057                                 write32(w, math.Float32bits(x))
6058                         }
6059                 }
6060         }
6061         for local162 := range (*(*(struct {
6062                 Amount         uint16
6063                 Duration       float32
6064                 Pos, Vel, Acc  [2][3]float32
6065                 ExpirationTime [2]float32 // in seconds.
6066                 Size           [2]float32
6067                 Collide        bool
6068
6069                 //mt:len32
6070                 Texture
6071
6072                 ID           ParticleSpawnerID
6073                 Vertical     bool
6074                 CollisionRm  bool
6075                 AttachedAOID AOID
6076                 AnimParams   TileAnim
6077                 Glow         uint8
6078                 AOCollision  bool
6079                 NodeParam0   Content
6080                 NodeParam2   uint8
6081                 NodeTile     uint8
6082         }))(obj)).ExpirationTime {
6083                 {
6084                         x := ((*(*(struct {
6085                                 Amount         uint16
6086                                 Duration       float32
6087                                 Pos, Vel, Acc  [2][3]float32
6088                                 ExpirationTime [2]float32 // in seconds.
6089                                 Size           [2]float32
6090                                 Collide        bool
6091
6092                                 //mt:len32
6093                                 Texture
6094
6095                                 ID           ParticleSpawnerID
6096                                 Vertical     bool
6097                                 CollisionRm  bool
6098                                 AttachedAOID AOID
6099                                 AnimParams   TileAnim
6100                                 Glow         uint8
6101                                 AOCollision  bool
6102                                 NodeParam0   Content
6103                                 NodeParam2   uint8
6104                                 NodeTile     uint8
6105                         }))(obj)).ExpirationTime)[local162]
6106                         write32(w, math.Float32bits(x))
6107                 }
6108         }
6109         for local163 := range (*(*(struct {
6110                 Amount         uint16
6111                 Duration       float32
6112                 Pos, Vel, Acc  [2][3]float32
6113                 ExpirationTime [2]float32 // in seconds.
6114                 Size           [2]float32
6115                 Collide        bool
6116
6117                 //mt:len32
6118                 Texture
6119
6120                 ID           ParticleSpawnerID
6121                 Vertical     bool
6122                 CollisionRm  bool
6123                 AttachedAOID AOID
6124                 AnimParams   TileAnim
6125                 Glow         uint8
6126                 AOCollision  bool
6127                 NodeParam0   Content
6128                 NodeParam2   uint8
6129                 NodeTile     uint8
6130         }))(obj)).Size {
6131                 {
6132                         x := ((*(*(struct {
6133                                 Amount         uint16
6134                                 Duration       float32
6135                                 Pos, Vel, Acc  [2][3]float32
6136                                 ExpirationTime [2]float32 // in seconds.
6137                                 Size           [2]float32
6138                                 Collide        bool
6139
6140                                 //mt:len32
6141                                 Texture
6142
6143                                 ID           ParticleSpawnerID
6144                                 Vertical     bool
6145                                 CollisionRm  bool
6146                                 AttachedAOID AOID
6147                                 AnimParams   TileAnim
6148                                 Glow         uint8
6149                                 AOCollision  bool
6150                                 NodeParam0   Content
6151                                 NodeParam2   uint8
6152                                 NodeTile     uint8
6153                         }))(obj)).Size)[local163]
6154                         write32(w, math.Float32bits(x))
6155                 }
6156         }
6157         {
6158                 x := (*(*(struct {
6159                         Amount         uint16
6160                         Duration       float32
6161                         Pos, Vel, Acc  [2][3]float32
6162                         ExpirationTime [2]float32 // in seconds.
6163                         Size           [2]float32
6164                         Collide        bool
6165
6166                         //mt:len32
6167                         Texture
6168
6169                         ID           ParticleSpawnerID
6170                         Vertical     bool
6171                         CollisionRm  bool
6172                         AttachedAOID AOID
6173                         AnimParams   TileAnim
6174                         Glow         uint8
6175                         AOCollision  bool
6176                         NodeParam0   Content
6177                         NodeParam2   uint8
6178                         NodeTile     uint8
6179                 }))(obj)).Collide
6180                 if x {
6181                         write8(w, 1)
6182                 } else {
6183                         write8(w, 0)
6184                 }
6185         }
6186         if len(([]byte(*(*string)(&((*(*(struct {
6187                 Amount         uint16
6188                 Duration       float32
6189                 Pos, Vel, Acc  [2][3]float32
6190                 ExpirationTime [2]float32 // in seconds.
6191                 Size           [2]float32
6192                 Collide        bool
6193
6194                 //mt:len32
6195                 Texture
6196
6197                 ID           ParticleSpawnerID
6198                 Vertical     bool
6199                 CollisionRm  bool
6200                 AttachedAOID AOID
6201                 AnimParams   TileAnim
6202                 Glow         uint8
6203                 AOCollision  bool
6204                 NodeParam0   Content
6205                 NodeParam2   uint8
6206                 NodeTile     uint8
6207         }))(obj)).Texture))))) > math.MaxUint32 {
6208                 chk(ErrTooLong)
6209         }
6210         {
6211                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6212                         Amount         uint16
6213                         Duration       float32
6214                         Pos, Vel, Acc  [2][3]float32
6215                         ExpirationTime [2]float32 // in seconds.
6216                         Size           [2]float32
6217                         Collide        bool
6218
6219                         //mt:len32
6220                         Texture
6221
6222                         ID           ParticleSpawnerID
6223                         Vertical     bool
6224                         CollisionRm  bool
6225                         AttachedAOID AOID
6226                         AnimParams   TileAnim
6227                         Glow         uint8
6228                         AOCollision  bool
6229                         NodeParam0   Content
6230                         NodeParam2   uint8
6231                         NodeTile     uint8
6232                 }))(obj)).Texture))))))
6233                 write32(w, uint32(x))
6234         }
6235         {
6236                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6237                         Amount         uint16
6238                         Duration       float32
6239                         Pos, Vel, Acc  [2][3]float32
6240                         ExpirationTime [2]float32 // in seconds.
6241                         Size           [2]float32
6242                         Collide        bool
6243
6244                         //mt:len32
6245                         Texture
6246
6247                         ID           ParticleSpawnerID
6248                         Vertical     bool
6249                         CollisionRm  bool
6250                         AttachedAOID AOID
6251                         AnimParams   TileAnim
6252                         Glow         uint8
6253                         AOCollision  bool
6254                         NodeParam0   Content
6255                         NodeParam2   uint8
6256                         NodeTile     uint8
6257                 }))(obj)).Texture))))[:])
6258                 chk(err)
6259         }
6260         if err := pcall(func() {
6261                 ((*(*(struct {
6262                         Amount         uint16
6263                         Duration       float32
6264                         Pos, Vel, Acc  [2][3]float32
6265                         ExpirationTime [2]float32 // in seconds.
6266                         Size           [2]float32
6267                         Collide        bool
6268
6269                         //mt:len32
6270                         Texture
6271
6272                         ID           ParticleSpawnerID
6273                         Vertical     bool
6274                         CollisionRm  bool
6275                         AttachedAOID AOID
6276                         AnimParams   TileAnim
6277                         Glow         uint8
6278                         AOCollision  bool
6279                         NodeParam0   Content
6280                         NodeParam2   uint8
6281                         NodeTile     uint8
6282                 }))(obj)).ID).Serialize(w)
6283         }); err != nil {
6284                 if err == io.EOF {
6285                         chk(io.EOF)
6286                 }
6287                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
6288         }
6289         {
6290                 x := (*(*(struct {
6291                         Amount         uint16
6292                         Duration       float32
6293                         Pos, Vel, Acc  [2][3]float32
6294                         ExpirationTime [2]float32 // in seconds.
6295                         Size           [2]float32
6296                         Collide        bool
6297
6298                         //mt:len32
6299                         Texture
6300
6301                         ID           ParticleSpawnerID
6302                         Vertical     bool
6303                         CollisionRm  bool
6304                         AttachedAOID AOID
6305                         AnimParams   TileAnim
6306                         Glow         uint8
6307                         AOCollision  bool
6308                         NodeParam0   Content
6309                         NodeParam2   uint8
6310                         NodeTile     uint8
6311                 }))(obj)).Vertical
6312                 if x {
6313                         write8(w, 1)
6314                 } else {
6315                         write8(w, 0)
6316                 }
6317         }
6318         {
6319                 x := (*(*(struct {
6320                         Amount         uint16
6321                         Duration       float32
6322                         Pos, Vel, Acc  [2][3]float32
6323                         ExpirationTime [2]float32 // in seconds.
6324                         Size           [2]float32
6325                         Collide        bool
6326
6327                         //mt:len32
6328                         Texture
6329
6330                         ID           ParticleSpawnerID
6331                         Vertical     bool
6332                         CollisionRm  bool
6333                         AttachedAOID AOID
6334                         AnimParams   TileAnim
6335                         Glow         uint8
6336                         AOCollision  bool
6337                         NodeParam0   Content
6338                         NodeParam2   uint8
6339                         NodeTile     uint8
6340                 }))(obj)).CollisionRm
6341                 if x {
6342                         write8(w, 1)
6343                 } else {
6344                         write8(w, 0)
6345                 }
6346         }
6347         if err := pcall(func() {
6348                 ((*(*(struct {
6349                         Amount         uint16
6350                         Duration       float32
6351                         Pos, Vel, Acc  [2][3]float32
6352                         ExpirationTime [2]float32 // in seconds.
6353                         Size           [2]float32
6354                         Collide        bool
6355
6356                         //mt:len32
6357                         Texture
6358
6359                         ID           ParticleSpawnerID
6360                         Vertical     bool
6361                         CollisionRm  bool
6362                         AttachedAOID AOID
6363                         AnimParams   TileAnim
6364                         Glow         uint8
6365                         AOCollision  bool
6366                         NodeParam0   Content
6367                         NodeParam2   uint8
6368                         NodeTile     uint8
6369                 }))(obj)).AttachedAOID).Serialize(w)
6370         }); err != nil {
6371                 if err == io.EOF {
6372                         chk(io.EOF)
6373                 }
6374                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
6375         }
6376         if err := pcall(func() {
6377                 ((*(*(struct {
6378                         Amount         uint16
6379                         Duration       float32
6380                         Pos, Vel, Acc  [2][3]float32
6381                         ExpirationTime [2]float32 // in seconds.
6382                         Size           [2]float32
6383                         Collide        bool
6384
6385                         //mt:len32
6386                         Texture
6387
6388                         ID           ParticleSpawnerID
6389                         Vertical     bool
6390                         CollisionRm  bool
6391                         AttachedAOID AOID
6392                         AnimParams   TileAnim
6393                         Glow         uint8
6394                         AOCollision  bool
6395                         NodeParam0   Content
6396                         NodeParam2   uint8
6397                         NodeTile     uint8
6398                 }))(obj)).AnimParams).Serialize(w)
6399         }); err != nil {
6400                 if err == io.EOF {
6401                         chk(io.EOF)
6402                 }
6403                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
6404         }
6405         {
6406                 x := (*(*(struct {
6407                         Amount         uint16
6408                         Duration       float32
6409                         Pos, Vel, Acc  [2][3]float32
6410                         ExpirationTime [2]float32 // in seconds.
6411                         Size           [2]float32
6412                         Collide        bool
6413
6414                         //mt:len32
6415                         Texture
6416
6417                         ID           ParticleSpawnerID
6418                         Vertical     bool
6419                         CollisionRm  bool
6420                         AttachedAOID AOID
6421                         AnimParams   TileAnim
6422                         Glow         uint8
6423                         AOCollision  bool
6424                         NodeParam0   Content
6425                         NodeParam2   uint8
6426                         NodeTile     uint8
6427                 }))(obj)).Glow
6428                 write8(w, uint8(x))
6429         }
6430         {
6431                 x := (*(*(struct {
6432                         Amount         uint16
6433                         Duration       float32
6434                         Pos, Vel, Acc  [2][3]float32
6435                         ExpirationTime [2]float32 // in seconds.
6436                         Size           [2]float32
6437                         Collide        bool
6438
6439                         //mt:len32
6440                         Texture
6441
6442                         ID           ParticleSpawnerID
6443                         Vertical     bool
6444                         CollisionRm  bool
6445                         AttachedAOID AOID
6446                         AnimParams   TileAnim
6447                         Glow         uint8
6448                         AOCollision  bool
6449                         NodeParam0   Content
6450                         NodeParam2   uint8
6451                         NodeTile     uint8
6452                 }))(obj)).AOCollision
6453                 if x {
6454                         write8(w, 1)
6455                 } else {
6456                         write8(w, 0)
6457                 }
6458         }
6459         if err := pcall(func() {
6460                 ((*(*(struct {
6461                         Amount         uint16
6462                         Duration       float32
6463                         Pos, Vel, Acc  [2][3]float32
6464                         ExpirationTime [2]float32 // in seconds.
6465                         Size           [2]float32
6466                         Collide        bool
6467
6468                         //mt:len32
6469                         Texture
6470
6471                         ID           ParticleSpawnerID
6472                         Vertical     bool
6473                         CollisionRm  bool
6474                         AttachedAOID AOID
6475                         AnimParams   TileAnim
6476                         Glow         uint8
6477                         AOCollision  bool
6478                         NodeParam0   Content
6479                         NodeParam2   uint8
6480                         NodeTile     uint8
6481                 }))(obj)).NodeParam0).Serialize(w)
6482         }); err != nil {
6483                 if err == io.EOF {
6484                         chk(io.EOF)
6485                 }
6486                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
6487         }
6488         {
6489                 x := (*(*(struct {
6490                         Amount         uint16
6491                         Duration       float32
6492                         Pos, Vel, Acc  [2][3]float32
6493                         ExpirationTime [2]float32 // in seconds.
6494                         Size           [2]float32
6495                         Collide        bool
6496
6497                         //mt:len32
6498                         Texture
6499
6500                         ID           ParticleSpawnerID
6501                         Vertical     bool
6502                         CollisionRm  bool
6503                         AttachedAOID AOID
6504                         AnimParams   TileAnim
6505                         Glow         uint8
6506                         AOCollision  bool
6507                         NodeParam0   Content
6508                         NodeParam2   uint8
6509                         NodeTile     uint8
6510                 }))(obj)).NodeParam2
6511                 write8(w, uint8(x))
6512         }
6513         {
6514                 x := (*(*(struct {
6515                         Amount         uint16
6516                         Duration       float32
6517                         Pos, Vel, Acc  [2][3]float32
6518                         ExpirationTime [2]float32 // in seconds.
6519                         Size           [2]float32
6520                         Collide        bool
6521
6522                         //mt:len32
6523                         Texture
6524
6525                         ID           ParticleSpawnerID
6526                         Vertical     bool
6527                         CollisionRm  bool
6528                         AttachedAOID AOID
6529                         AnimParams   TileAnim
6530                         Glow         uint8
6531                         AOCollision  bool
6532                         NodeParam0   Content
6533                         NodeParam2   uint8
6534                         NodeTile     uint8
6535                 }))(obj)).NodeTile
6536                 write8(w, uint8(x))
6537         }
6538 }
6539
6540 func (obj *ToCltAddParticleSpawner) Deserialize(r io.Reader) {
6541         {
6542                 p := &(*(*(struct {
6543                         Amount         uint16
6544                         Duration       float32
6545                         Pos, Vel, Acc  [2][3]float32
6546                         ExpirationTime [2]float32 // in seconds.
6547                         Size           [2]float32
6548                         Collide        bool
6549
6550                         //mt:len32
6551                         Texture
6552
6553                         ID           ParticleSpawnerID
6554                         Vertical     bool
6555                         CollisionRm  bool
6556                         AttachedAOID AOID
6557                         AnimParams   TileAnim
6558                         Glow         uint8
6559                         AOCollision  bool
6560                         NodeParam0   Content
6561                         NodeParam2   uint8
6562                         NodeTile     uint8
6563                 }))(obj)).Amount
6564                 *p = read16(r)
6565         }
6566         {
6567                 p := &(*(*(struct {
6568                         Amount         uint16
6569                         Duration       float32
6570                         Pos, Vel, Acc  [2][3]float32
6571                         ExpirationTime [2]float32 // in seconds.
6572                         Size           [2]float32
6573                         Collide        bool
6574
6575                         //mt:len32
6576                         Texture
6577
6578                         ID           ParticleSpawnerID
6579                         Vertical     bool
6580                         CollisionRm  bool
6581                         AttachedAOID AOID
6582                         AnimParams   TileAnim
6583                         Glow         uint8
6584                         AOCollision  bool
6585                         NodeParam0   Content
6586                         NodeParam2   uint8
6587                         NodeTile     uint8
6588                 }))(obj)).Duration
6589                 *p = math.Float32frombits(read32(r))
6590         }
6591         for local164 := range (*(*(struct {
6592                 Amount         uint16
6593                 Duration       float32
6594                 Pos, Vel, Acc  [2][3]float32
6595                 ExpirationTime [2]float32 // in seconds.
6596                 Size           [2]float32
6597                 Collide        bool
6598
6599                 //mt:len32
6600                 Texture
6601
6602                 ID           ParticleSpawnerID
6603                 Vertical     bool
6604                 CollisionRm  bool
6605                 AttachedAOID AOID
6606                 AnimParams   TileAnim
6607                 Glow         uint8
6608                 AOCollision  bool
6609                 NodeParam0   Content
6610                 NodeParam2   uint8
6611                 NodeTile     uint8
6612         }))(obj)).Pos {
6613                 for local165 := range ((*(*(struct {
6614                         Amount         uint16
6615                         Duration       float32
6616                         Pos, Vel, Acc  [2][3]float32
6617                         ExpirationTime [2]float32 // in seconds.
6618                         Size           [2]float32
6619                         Collide        bool
6620
6621                         //mt:len32
6622                         Texture
6623
6624                         ID           ParticleSpawnerID
6625                         Vertical     bool
6626                         CollisionRm  bool
6627                         AttachedAOID AOID
6628                         AnimParams   TileAnim
6629                         Glow         uint8
6630                         AOCollision  bool
6631                         NodeParam0   Content
6632                         NodeParam2   uint8
6633                         NodeTile     uint8
6634                 }))(obj)).Pos)[local164] {
6635                         {
6636                                 p := &(((*(*(struct {
6637                                         Amount         uint16
6638                                         Duration       float32
6639                                         Pos, Vel, Acc  [2][3]float32
6640                                         ExpirationTime [2]float32 // in seconds.
6641                                         Size           [2]float32
6642                                         Collide        bool
6643
6644                                         //mt:len32
6645                                         Texture
6646
6647                                         ID           ParticleSpawnerID
6648                                         Vertical     bool
6649                                         CollisionRm  bool
6650                                         AttachedAOID AOID
6651                                         AnimParams   TileAnim
6652                                         Glow         uint8
6653                                         AOCollision  bool
6654                                         NodeParam0   Content
6655                                         NodeParam2   uint8
6656                                         NodeTile     uint8
6657                                 }))(obj)).Pos)[local164])[local165]
6658                                 *p = math.Float32frombits(read32(r))
6659                         }
6660                 }
6661         }
6662         for local166 := range (*(*(struct {
6663                 Amount         uint16
6664                 Duration       float32
6665                 Pos, Vel, Acc  [2][3]float32
6666                 ExpirationTime [2]float32 // in seconds.
6667                 Size           [2]float32
6668                 Collide        bool
6669
6670                 //mt:len32
6671                 Texture
6672
6673                 ID           ParticleSpawnerID
6674                 Vertical     bool
6675                 CollisionRm  bool
6676                 AttachedAOID AOID
6677                 AnimParams   TileAnim
6678                 Glow         uint8
6679                 AOCollision  bool
6680                 NodeParam0   Content
6681                 NodeParam2   uint8
6682                 NodeTile     uint8
6683         }))(obj)).Vel {
6684                 for local167 := range ((*(*(struct {
6685                         Amount         uint16
6686                         Duration       float32
6687                         Pos, Vel, Acc  [2][3]float32
6688                         ExpirationTime [2]float32 // in seconds.
6689                         Size           [2]float32
6690                         Collide        bool
6691
6692                         //mt:len32
6693                         Texture
6694
6695                         ID           ParticleSpawnerID
6696                         Vertical     bool
6697                         CollisionRm  bool
6698                         AttachedAOID AOID
6699                         AnimParams   TileAnim
6700                         Glow         uint8
6701                         AOCollision  bool
6702                         NodeParam0   Content
6703                         NodeParam2   uint8
6704                         NodeTile     uint8
6705                 }))(obj)).Vel)[local166] {
6706                         {
6707                                 p := &(((*(*(struct {
6708                                         Amount         uint16
6709                                         Duration       float32
6710                                         Pos, Vel, Acc  [2][3]float32
6711                                         ExpirationTime [2]float32 // in seconds.
6712                                         Size           [2]float32
6713                                         Collide        bool
6714
6715                                         //mt:len32
6716                                         Texture
6717
6718                                         ID           ParticleSpawnerID
6719                                         Vertical     bool
6720                                         CollisionRm  bool
6721                                         AttachedAOID AOID
6722                                         AnimParams   TileAnim
6723                                         Glow         uint8
6724                                         AOCollision  bool
6725                                         NodeParam0   Content
6726                                         NodeParam2   uint8
6727                                         NodeTile     uint8
6728                                 }))(obj)).Vel)[local166])[local167]
6729                                 *p = math.Float32frombits(read32(r))
6730                         }
6731                 }
6732         }
6733         for local168 := range (*(*(struct {
6734                 Amount         uint16
6735                 Duration       float32
6736                 Pos, Vel, Acc  [2][3]float32
6737                 ExpirationTime [2]float32 // in seconds.
6738                 Size           [2]float32
6739                 Collide        bool
6740
6741                 //mt:len32
6742                 Texture
6743
6744                 ID           ParticleSpawnerID
6745                 Vertical     bool
6746                 CollisionRm  bool
6747                 AttachedAOID AOID
6748                 AnimParams   TileAnim
6749                 Glow         uint8
6750                 AOCollision  bool
6751                 NodeParam0   Content
6752                 NodeParam2   uint8
6753                 NodeTile     uint8
6754         }))(obj)).Acc {
6755                 for local169 := range ((*(*(struct {
6756                         Amount         uint16
6757                         Duration       float32
6758                         Pos, Vel, Acc  [2][3]float32
6759                         ExpirationTime [2]float32 // in seconds.
6760                         Size           [2]float32
6761                         Collide        bool
6762
6763                         //mt:len32
6764                         Texture
6765
6766                         ID           ParticleSpawnerID
6767                         Vertical     bool
6768                         CollisionRm  bool
6769                         AttachedAOID AOID
6770                         AnimParams   TileAnim
6771                         Glow         uint8
6772                         AOCollision  bool
6773                         NodeParam0   Content
6774                         NodeParam2   uint8
6775                         NodeTile     uint8
6776                 }))(obj)).Acc)[local168] {
6777                         {
6778                                 p := &(((*(*(struct {
6779                                         Amount         uint16
6780                                         Duration       float32
6781                                         Pos, Vel, Acc  [2][3]float32
6782                                         ExpirationTime [2]float32 // in seconds.
6783                                         Size           [2]float32
6784                                         Collide        bool
6785
6786                                         //mt:len32
6787                                         Texture
6788
6789                                         ID           ParticleSpawnerID
6790                                         Vertical     bool
6791                                         CollisionRm  bool
6792                                         AttachedAOID AOID
6793                                         AnimParams   TileAnim
6794                                         Glow         uint8
6795                                         AOCollision  bool
6796                                         NodeParam0   Content
6797                                         NodeParam2   uint8
6798                                         NodeTile     uint8
6799                                 }))(obj)).Acc)[local168])[local169]
6800                                 *p = math.Float32frombits(read32(r))
6801                         }
6802                 }
6803         }
6804         for local170 := range (*(*(struct {
6805                 Amount         uint16
6806                 Duration       float32
6807                 Pos, Vel, Acc  [2][3]float32
6808                 ExpirationTime [2]float32 // in seconds.
6809                 Size           [2]float32
6810                 Collide        bool
6811
6812                 //mt:len32
6813                 Texture
6814
6815                 ID           ParticleSpawnerID
6816                 Vertical     bool
6817                 CollisionRm  bool
6818                 AttachedAOID AOID
6819                 AnimParams   TileAnim
6820                 Glow         uint8
6821                 AOCollision  bool
6822                 NodeParam0   Content
6823                 NodeParam2   uint8
6824                 NodeTile     uint8
6825         }))(obj)).ExpirationTime {
6826                 {
6827                         p := &((*(*(struct {
6828                                 Amount         uint16
6829                                 Duration       float32
6830                                 Pos, Vel, Acc  [2][3]float32
6831                                 ExpirationTime [2]float32 // in seconds.
6832                                 Size           [2]float32
6833                                 Collide        bool
6834
6835                                 //mt:len32
6836                                 Texture
6837
6838                                 ID           ParticleSpawnerID
6839                                 Vertical     bool
6840                                 CollisionRm  bool
6841                                 AttachedAOID AOID
6842                                 AnimParams   TileAnim
6843                                 Glow         uint8
6844                                 AOCollision  bool
6845                                 NodeParam0   Content
6846                                 NodeParam2   uint8
6847                                 NodeTile     uint8
6848                         }))(obj)).ExpirationTime)[local170]
6849                         *p = math.Float32frombits(read32(r))
6850                 }
6851         }
6852         for local171 := range (*(*(struct {
6853                 Amount         uint16
6854                 Duration       float32
6855                 Pos, Vel, Acc  [2][3]float32
6856                 ExpirationTime [2]float32 // in seconds.
6857                 Size           [2]float32
6858                 Collide        bool
6859
6860                 //mt:len32
6861                 Texture
6862
6863                 ID           ParticleSpawnerID
6864                 Vertical     bool
6865                 CollisionRm  bool
6866                 AttachedAOID AOID
6867                 AnimParams   TileAnim
6868                 Glow         uint8
6869                 AOCollision  bool
6870                 NodeParam0   Content
6871                 NodeParam2   uint8
6872                 NodeTile     uint8
6873         }))(obj)).Size {
6874                 {
6875                         p := &((*(*(struct {
6876                                 Amount         uint16
6877                                 Duration       float32
6878                                 Pos, Vel, Acc  [2][3]float32
6879                                 ExpirationTime [2]float32 // in seconds.
6880                                 Size           [2]float32
6881                                 Collide        bool
6882
6883                                 //mt:len32
6884                                 Texture
6885
6886                                 ID           ParticleSpawnerID
6887                                 Vertical     bool
6888                                 CollisionRm  bool
6889                                 AttachedAOID AOID
6890                                 AnimParams   TileAnim
6891                                 Glow         uint8
6892                                 AOCollision  bool
6893                                 NodeParam0   Content
6894                                 NodeParam2   uint8
6895                                 NodeTile     uint8
6896                         }))(obj)).Size)[local171]
6897                         *p = math.Float32frombits(read32(r))
6898                 }
6899         }
6900         {
6901                 p := &(*(*(struct {
6902                         Amount         uint16
6903                         Duration       float32
6904                         Pos, Vel, Acc  [2][3]float32
6905                         ExpirationTime [2]float32 // in seconds.
6906                         Size           [2]float32
6907                         Collide        bool
6908
6909                         //mt:len32
6910                         Texture
6911
6912                         ID           ParticleSpawnerID
6913                         Vertical     bool
6914                         CollisionRm  bool
6915                         AttachedAOID AOID
6916                         AnimParams   TileAnim
6917                         Glow         uint8
6918                         AOCollision  bool
6919                         NodeParam0   Content
6920                         NodeParam2   uint8
6921                         NodeTile     uint8
6922                 }))(obj)).Collide
6923                 switch n := read8(r); n {
6924                 case 0:
6925                         *p = false
6926                 case 1:
6927                         *p = true
6928                 default:
6929                         chk(fmt.Errorf("invalid bool: %d", n))
6930                 }
6931         }
6932         var local172 []uint8
6933         var local173 uint32
6934         {
6935                 p := &local173
6936                 *p = read32(r)
6937         }
6938         (local172) = make([]uint8, local173)
6939         {
6940                 _, err := io.ReadFull(r, (local172)[:])
6941                 chk(err)
6942         }
6943         (*(*string)(&((*(*(struct {
6944                 Amount         uint16
6945                 Duration       float32
6946                 Pos, Vel, Acc  [2][3]float32
6947                 ExpirationTime [2]float32 // in seconds.
6948                 Size           [2]float32
6949                 Collide        bool
6950
6951                 //mt:len32
6952                 Texture
6953
6954                 ID           ParticleSpawnerID
6955                 Vertical     bool
6956                 CollisionRm  bool
6957                 AttachedAOID AOID
6958                 AnimParams   TileAnim
6959                 Glow         uint8
6960                 AOCollision  bool
6961                 NodeParam0   Content
6962                 NodeParam2   uint8
6963                 NodeTile     uint8
6964         }))(obj)).Texture))) = string(local172)
6965         if err := pcall(func() {
6966                 ((*(*(struct {
6967                         Amount         uint16
6968                         Duration       float32
6969                         Pos, Vel, Acc  [2][3]float32
6970                         ExpirationTime [2]float32 // in seconds.
6971                         Size           [2]float32
6972                         Collide        bool
6973
6974                         //mt:len32
6975                         Texture
6976
6977                         ID           ParticleSpawnerID
6978                         Vertical     bool
6979                         CollisionRm  bool
6980                         AttachedAOID AOID
6981                         AnimParams   TileAnim
6982                         Glow         uint8
6983                         AOCollision  bool
6984                         NodeParam0   Content
6985                         NodeParam2   uint8
6986                         NodeTile     uint8
6987                 }))(obj)).ID).Deserialize(r)
6988         }); err != nil {
6989                 if err == io.EOF {
6990                         chk(io.EOF)
6991                 }
6992                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
6993         }
6994         {
6995                 p := &(*(*(struct {
6996                         Amount         uint16
6997                         Duration       float32
6998                         Pos, Vel, Acc  [2][3]float32
6999                         ExpirationTime [2]float32 // in seconds.
7000                         Size           [2]float32
7001                         Collide        bool
7002
7003                         //mt:len32
7004                         Texture
7005
7006                         ID           ParticleSpawnerID
7007                         Vertical     bool
7008                         CollisionRm  bool
7009                         AttachedAOID AOID
7010                         AnimParams   TileAnim
7011                         Glow         uint8
7012                         AOCollision  bool
7013                         NodeParam0   Content
7014                         NodeParam2   uint8
7015                         NodeTile     uint8
7016                 }))(obj)).Vertical
7017                 switch n := read8(r); n {
7018                 case 0:
7019                         *p = false
7020                 case 1:
7021                         *p = true
7022                 default:
7023                         chk(fmt.Errorf("invalid bool: %d", n))
7024                 }
7025         }
7026         {
7027                 p := &(*(*(struct {
7028                         Amount         uint16
7029                         Duration       float32
7030                         Pos, Vel, Acc  [2][3]float32
7031                         ExpirationTime [2]float32 // in seconds.
7032                         Size           [2]float32
7033                         Collide        bool
7034
7035                         //mt:len32
7036                         Texture
7037
7038                         ID           ParticleSpawnerID
7039                         Vertical     bool
7040                         CollisionRm  bool
7041                         AttachedAOID AOID
7042                         AnimParams   TileAnim
7043                         Glow         uint8
7044                         AOCollision  bool
7045                         NodeParam0   Content
7046                         NodeParam2   uint8
7047                         NodeTile     uint8
7048                 }))(obj)).CollisionRm
7049                 switch n := read8(r); n {
7050                 case 0:
7051                         *p = false
7052                 case 1:
7053                         *p = true
7054                 default:
7055                         chk(fmt.Errorf("invalid bool: %d", n))
7056                 }
7057         }
7058         if err := pcall(func() {
7059                 ((*(*(struct {
7060                         Amount         uint16
7061                         Duration       float32
7062                         Pos, Vel, Acc  [2][3]float32
7063                         ExpirationTime [2]float32 // in seconds.
7064                         Size           [2]float32
7065                         Collide        bool
7066
7067                         //mt:len32
7068                         Texture
7069
7070                         ID           ParticleSpawnerID
7071                         Vertical     bool
7072                         CollisionRm  bool
7073                         AttachedAOID AOID
7074                         AnimParams   TileAnim
7075                         Glow         uint8
7076                         AOCollision  bool
7077                         NodeParam0   Content
7078                         NodeParam2   uint8
7079                         NodeTile     uint8
7080                 }))(obj)).AttachedAOID).Deserialize(r)
7081         }); err != nil {
7082                 if err == io.EOF {
7083                         chk(io.EOF)
7084                 }
7085                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
7086         }
7087         if err := pcall(func() {
7088                 ((*(*(struct {
7089                         Amount         uint16
7090                         Duration       float32
7091                         Pos, Vel, Acc  [2][3]float32
7092                         ExpirationTime [2]float32 // in seconds.
7093                         Size           [2]float32
7094                         Collide        bool
7095
7096                         //mt:len32
7097                         Texture
7098
7099                         ID           ParticleSpawnerID
7100                         Vertical     bool
7101                         CollisionRm  bool
7102                         AttachedAOID AOID
7103                         AnimParams   TileAnim
7104                         Glow         uint8
7105                         AOCollision  bool
7106                         NodeParam0   Content
7107                         NodeParam2   uint8
7108                         NodeTile     uint8
7109                 }))(obj)).AnimParams).Deserialize(r)
7110         }); err != nil {
7111                 if err == io.EOF {
7112                         chk(io.EOF)
7113                 }
7114                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
7115         }
7116         {
7117                 p := &(*(*(struct {
7118                         Amount         uint16
7119                         Duration       float32
7120                         Pos, Vel, Acc  [2][3]float32
7121                         ExpirationTime [2]float32 // in seconds.
7122                         Size           [2]float32
7123                         Collide        bool
7124
7125                         //mt:len32
7126                         Texture
7127
7128                         ID           ParticleSpawnerID
7129                         Vertical     bool
7130                         CollisionRm  bool
7131                         AttachedAOID AOID
7132                         AnimParams   TileAnim
7133                         Glow         uint8
7134                         AOCollision  bool
7135                         NodeParam0   Content
7136                         NodeParam2   uint8
7137                         NodeTile     uint8
7138                 }))(obj)).Glow
7139                 *p = read8(r)
7140         }
7141         {
7142                 p := &(*(*(struct {
7143                         Amount         uint16
7144                         Duration       float32
7145                         Pos, Vel, Acc  [2][3]float32
7146                         ExpirationTime [2]float32 // in seconds.
7147                         Size           [2]float32
7148                         Collide        bool
7149
7150                         //mt:len32
7151                         Texture
7152
7153                         ID           ParticleSpawnerID
7154                         Vertical     bool
7155                         CollisionRm  bool
7156                         AttachedAOID AOID
7157                         AnimParams   TileAnim
7158                         Glow         uint8
7159                         AOCollision  bool
7160                         NodeParam0   Content
7161                         NodeParam2   uint8
7162                         NodeTile     uint8
7163                 }))(obj)).AOCollision
7164                 switch n := read8(r); n {
7165                 case 0:
7166                         *p = false
7167                 case 1:
7168                         *p = true
7169                 default:
7170                         chk(fmt.Errorf("invalid bool: %d", n))
7171                 }
7172         }
7173         if err := pcall(func() {
7174                 ((*(*(struct {
7175                         Amount         uint16
7176                         Duration       float32
7177                         Pos, Vel, Acc  [2][3]float32
7178                         ExpirationTime [2]float32 // in seconds.
7179                         Size           [2]float32
7180                         Collide        bool
7181
7182                         //mt:len32
7183                         Texture
7184
7185                         ID           ParticleSpawnerID
7186                         Vertical     bool
7187                         CollisionRm  bool
7188                         AttachedAOID AOID
7189                         AnimParams   TileAnim
7190                         Glow         uint8
7191                         AOCollision  bool
7192                         NodeParam0   Content
7193                         NodeParam2   uint8
7194                         NodeTile     uint8
7195                 }))(obj)).NodeParam0).Deserialize(r)
7196         }); err != nil {
7197                 if err == io.EOF {
7198                         chk(io.EOF)
7199                 }
7200                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
7201         }
7202         {
7203                 p := &(*(*(struct {
7204                         Amount         uint16
7205                         Duration       float32
7206                         Pos, Vel, Acc  [2][3]float32
7207                         ExpirationTime [2]float32 // in seconds.
7208                         Size           [2]float32
7209                         Collide        bool
7210
7211                         //mt:len32
7212                         Texture
7213
7214                         ID           ParticleSpawnerID
7215                         Vertical     bool
7216                         CollisionRm  bool
7217                         AttachedAOID AOID
7218                         AnimParams   TileAnim
7219                         Glow         uint8
7220                         AOCollision  bool
7221                         NodeParam0   Content
7222                         NodeParam2   uint8
7223                         NodeTile     uint8
7224                 }))(obj)).NodeParam2
7225                 *p = read8(r)
7226         }
7227         {
7228                 p := &(*(*(struct {
7229                         Amount         uint16
7230                         Duration       float32
7231                         Pos, Vel, Acc  [2][3]float32
7232                         ExpirationTime [2]float32 // in seconds.
7233                         Size           [2]float32
7234                         Collide        bool
7235
7236                         //mt:len32
7237                         Texture
7238
7239                         ID           ParticleSpawnerID
7240                         Vertical     bool
7241                         CollisionRm  bool
7242                         AttachedAOID AOID
7243                         AnimParams   TileAnim
7244                         Glow         uint8
7245                         AOCollision  bool
7246                         NodeParam0   Content
7247                         NodeParam2   uint8
7248                         NodeTile     uint8
7249                 }))(obj)).NodeTile
7250                 *p = read8(r)
7251         }
7252 }
7253
7254 func (obj *ToCltAddHUD) Serialize(w io.Writer) {
7255         if err := pcall(func() {
7256                 ((*(*(struct {
7257                         ID HUDID
7258                         HUD
7259                 }))(obj)).ID).Serialize(w)
7260         }); err != nil {
7261                 if err == io.EOF {
7262                         chk(io.EOF)
7263                 }
7264                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7265         }
7266         if err := pcall(func() {
7267                 ((*(*(struct {
7268                         ID HUDID
7269                         HUD
7270                 }))(obj)).HUD).Serialize(w)
7271         }); err != nil {
7272                 if err == io.EOF {
7273                         chk(io.EOF)
7274                 }
7275                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUD", err))
7276         }
7277 }
7278
7279 func (obj *ToCltAddHUD) Deserialize(r io.Reader) {
7280         if err := pcall(func() {
7281                 ((*(*(struct {
7282                         ID HUDID
7283                         HUD
7284                 }))(obj)).ID).Deserialize(r)
7285         }); err != nil {
7286                 if err == io.EOF {
7287                         chk(io.EOF)
7288                 }
7289                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7290         }
7291         if err := pcall(func() {
7292                 ((*(*(struct {
7293                         ID HUDID
7294                         HUD
7295                 }))(obj)).HUD).Deserialize(r)
7296         }); err != nil {
7297                 if err == io.EOF {
7298                         chk(io.EOF)
7299                 }
7300                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUD", err))
7301         }
7302 }
7303
7304 func (obj *ToCltRmHUD) Serialize(w io.Writer) {
7305         if err := pcall(func() {
7306                 ((*(*(struct {
7307                         ID HUDID
7308                 }))(obj)).ID).Serialize(w)
7309         }); err != nil {
7310                 if err == io.EOF {
7311                         chk(io.EOF)
7312                 }
7313                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7314         }
7315 }
7316
7317 func (obj *ToCltRmHUD) Deserialize(r io.Reader) {
7318         if err := pcall(func() {
7319                 ((*(*(struct {
7320                         ID HUDID
7321                 }))(obj)).ID).Deserialize(r)
7322         }); err != nil {
7323                 if err == io.EOF {
7324                         chk(io.EOF)
7325                 }
7326                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7327         }
7328 }
7329
7330 func (obj *ToCltChangeHUD) Serialize(w io.Writer) {
7331         if err := pcall(func() {
7332                 ((*(*(struct {
7333                         ID HUDID
7334
7335                         Field HUDField
7336
7337                         //mt:if %s.Field == HUDPos
7338                         Pos [2]float32
7339
7340                         //mt:if %s.Field == HUDName
7341                         Name string
7342
7343                         //mt:if %s.Field == HUDScale
7344                         Scale [2]float32
7345
7346                         //mt:if %s.Field == HUDText
7347                         Text string
7348
7349                         //mt:if %s.Field == HUDNumber
7350                         Number uint32
7351
7352                         //mt:if %s.Field == HUDItem
7353                         Item uint32
7354
7355                         //mt:if %s.Field == HUDDir
7356                         Dir uint32
7357
7358                         //mt:if %s.Field == HUDAlign
7359                         Align [2]float32
7360
7361                         //mt:if %s.Field == HUDOffset
7362                         Offset [2]float32
7363
7364                         //mt:if %s.Field == HUDWorldPos
7365                         WorldPos Pos
7366
7367                         //mt:if %s.Field == HUDSize
7368                         Size [2]int32
7369
7370                         //mt:if %s.Field == HUDZIndex
7371                         ZIndex int32
7372
7373                         //mt:if %s.Field == HUDText2
7374                         Text2 string
7375                 }))(obj)).ID).Serialize(w)
7376         }); err != nil {
7377                 if err == io.EOF {
7378                         chk(io.EOF)
7379                 }
7380                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7381         }
7382         if err := pcall(func() {
7383                 ((*(*(struct {
7384                         ID HUDID
7385
7386                         Field HUDField
7387
7388                         //mt:if %s.Field == HUDPos
7389                         Pos [2]float32
7390
7391                         //mt:if %s.Field == HUDName
7392                         Name string
7393
7394                         //mt:if %s.Field == HUDScale
7395                         Scale [2]float32
7396
7397                         //mt:if %s.Field == HUDText
7398                         Text string
7399
7400                         //mt:if %s.Field == HUDNumber
7401                         Number uint32
7402
7403                         //mt:if %s.Field == HUDItem
7404                         Item uint32
7405
7406                         //mt:if %s.Field == HUDDir
7407                         Dir uint32
7408
7409                         //mt:if %s.Field == HUDAlign
7410                         Align [2]float32
7411
7412                         //mt:if %s.Field == HUDOffset
7413                         Offset [2]float32
7414
7415                         //mt:if %s.Field == HUDWorldPos
7416                         WorldPos Pos
7417
7418                         //mt:if %s.Field == HUDSize
7419                         Size [2]int32
7420
7421                         //mt:if %s.Field == HUDZIndex
7422                         ZIndex int32
7423
7424                         //mt:if %s.Field == HUDText2
7425                         Text2 string
7426                 }))(obj)).Field).Serialize(w)
7427         }); err != nil {
7428                 if err == io.EOF {
7429                         chk(io.EOF)
7430                 }
7431                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDField", err))
7432         }
7433         if !((*(*(struct {
7434                 ID HUDID
7435
7436                 Field HUDField
7437
7438                 //mt:if %s.Field == HUDPos
7439                 Pos [2]float32
7440
7441                 //mt:if %s.Field == HUDName
7442                 Name string
7443
7444                 //mt:if %s.Field == HUDScale
7445                 Scale [2]float32
7446
7447                 //mt:if %s.Field == HUDText
7448                 Text string
7449
7450                 //mt:if %s.Field == HUDNumber
7451                 Number uint32
7452
7453                 //mt:if %s.Field == HUDItem
7454                 Item uint32
7455
7456                 //mt:if %s.Field == HUDDir
7457                 Dir uint32
7458
7459                 //mt:if %s.Field == HUDAlign
7460                 Align [2]float32
7461
7462                 //mt:if %s.Field == HUDOffset
7463                 Offset [2]float32
7464
7465                 //mt:if %s.Field == HUDWorldPos
7466                 WorldPos Pos
7467
7468                 //mt:if %s.Field == HUDSize
7469                 Size [2]int32
7470
7471                 //mt:if %s.Field == HUDZIndex
7472                 ZIndex int32
7473
7474                 //mt:if %s.Field == HUDText2
7475                 Text2 string
7476         }))(obj)).Field < hudMax) {
7477                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7478         }
7479         if (*(*(struct {
7480                 ID HUDID
7481
7482                 Field HUDField
7483
7484                 //mt:if %s.Field == HUDPos
7485                 Pos [2]float32
7486
7487                 //mt:if %s.Field == HUDName
7488                 Name string
7489
7490                 //mt:if %s.Field == HUDScale
7491                 Scale [2]float32
7492
7493                 //mt:if %s.Field == HUDText
7494                 Text string
7495
7496                 //mt:if %s.Field == HUDNumber
7497                 Number uint32
7498
7499                 //mt:if %s.Field == HUDItem
7500                 Item uint32
7501
7502                 //mt:if %s.Field == HUDDir
7503                 Dir uint32
7504
7505                 //mt:if %s.Field == HUDAlign
7506                 Align [2]float32
7507
7508                 //mt:if %s.Field == HUDOffset
7509                 Offset [2]float32
7510
7511                 //mt:if %s.Field == HUDWorldPos
7512                 WorldPos Pos
7513
7514                 //mt:if %s.Field == HUDSize
7515                 Size [2]int32
7516
7517                 //mt:if %s.Field == HUDZIndex
7518                 ZIndex int32
7519
7520                 //mt:if %s.Field == HUDText2
7521                 Text2 string
7522         }))(obj)).Field == HUDPos {
7523                 for local174 := range (*(*(struct {
7524                         ID HUDID
7525
7526                         Field HUDField
7527
7528                         //mt:if %s.Field == HUDPos
7529                         Pos [2]float32
7530
7531                         //mt:if %s.Field == HUDName
7532                         Name string
7533
7534                         //mt:if %s.Field == HUDScale
7535                         Scale [2]float32
7536
7537                         //mt:if %s.Field == HUDText
7538                         Text string
7539
7540                         //mt:if %s.Field == HUDNumber
7541                         Number uint32
7542
7543                         //mt:if %s.Field == HUDItem
7544                         Item uint32
7545
7546                         //mt:if %s.Field == HUDDir
7547                         Dir uint32
7548
7549                         //mt:if %s.Field == HUDAlign
7550                         Align [2]float32
7551
7552                         //mt:if %s.Field == HUDOffset
7553                         Offset [2]float32
7554
7555                         //mt:if %s.Field == HUDWorldPos
7556                         WorldPos Pos
7557
7558                         //mt:if %s.Field == HUDSize
7559                         Size [2]int32
7560
7561                         //mt:if %s.Field == HUDZIndex
7562                         ZIndex int32
7563
7564                         //mt:if %s.Field == HUDText2
7565                         Text2 string
7566                 }))(obj)).Pos {
7567                         {
7568                                 x := ((*(*(struct {
7569                                         ID HUDID
7570
7571                                         Field HUDField
7572
7573                                         //mt:if %s.Field == HUDPos
7574                                         Pos [2]float32
7575
7576                                         //mt:if %s.Field == HUDName
7577                                         Name string
7578
7579                                         //mt:if %s.Field == HUDScale
7580                                         Scale [2]float32
7581
7582                                         //mt:if %s.Field == HUDText
7583                                         Text string
7584
7585                                         //mt:if %s.Field == HUDNumber
7586                                         Number uint32
7587
7588                                         //mt:if %s.Field == HUDItem
7589                                         Item uint32
7590
7591                                         //mt:if %s.Field == HUDDir
7592                                         Dir uint32
7593
7594                                         //mt:if %s.Field == HUDAlign
7595                                         Align [2]float32
7596
7597                                         //mt:if %s.Field == HUDOffset
7598                                         Offset [2]float32
7599
7600                                         //mt:if %s.Field == HUDWorldPos
7601                                         WorldPos Pos
7602
7603                                         //mt:if %s.Field == HUDSize
7604                                         Size [2]int32
7605
7606                                         //mt:if %s.Field == HUDZIndex
7607                                         ZIndex int32
7608
7609                                         //mt:if %s.Field == HUDText2
7610                                         Text2 string
7611                                 }))(obj)).Pos)[local174]
7612                                 write32(w, math.Float32bits(x))
7613                         }
7614                 }
7615         }
7616         if (*(*(struct {
7617                 ID HUDID
7618
7619                 Field HUDField
7620
7621                 //mt:if %s.Field == HUDPos
7622                 Pos [2]float32
7623
7624                 //mt:if %s.Field == HUDName
7625                 Name string
7626
7627                 //mt:if %s.Field == HUDScale
7628                 Scale [2]float32
7629
7630                 //mt:if %s.Field == HUDText
7631                 Text string
7632
7633                 //mt:if %s.Field == HUDNumber
7634                 Number uint32
7635
7636                 //mt:if %s.Field == HUDItem
7637                 Item uint32
7638
7639                 //mt:if %s.Field == HUDDir
7640                 Dir uint32
7641
7642                 //mt:if %s.Field == HUDAlign
7643                 Align [2]float32
7644
7645                 //mt:if %s.Field == HUDOffset
7646                 Offset [2]float32
7647
7648                 //mt:if %s.Field == HUDWorldPos
7649                 WorldPos Pos
7650
7651                 //mt:if %s.Field == HUDSize
7652                 Size [2]int32
7653
7654                 //mt:if %s.Field == HUDZIndex
7655                 ZIndex int32
7656
7657                 //mt:if %s.Field == HUDText2
7658                 Text2 string
7659         }))(obj)).Field == HUDName {
7660                 if len(([]byte((*(*(struct {
7661                         ID HUDID
7662
7663                         Field HUDField
7664
7665                         //mt:if %s.Field == HUDPos
7666                         Pos [2]float32
7667
7668                         //mt:if %s.Field == HUDName
7669                         Name string
7670
7671                         //mt:if %s.Field == HUDScale
7672                         Scale [2]float32
7673
7674                         //mt:if %s.Field == HUDText
7675                         Text string
7676
7677                         //mt:if %s.Field == HUDNumber
7678                         Number uint32
7679
7680                         //mt:if %s.Field == HUDItem
7681                         Item uint32
7682
7683                         //mt:if %s.Field == HUDDir
7684                         Dir uint32
7685
7686                         //mt:if %s.Field == HUDAlign
7687                         Align [2]float32
7688
7689                         //mt:if %s.Field == HUDOffset
7690                         Offset [2]float32
7691
7692                         //mt:if %s.Field == HUDWorldPos
7693                         WorldPos Pos
7694
7695                         //mt:if %s.Field == HUDSize
7696                         Size [2]int32
7697
7698                         //mt:if %s.Field == HUDZIndex
7699                         ZIndex int32
7700
7701                         //mt:if %s.Field == HUDText2
7702                         Text2 string
7703                 }))(obj)).Name))) > math.MaxUint16 {
7704                         chk(ErrTooLong)
7705                 }
7706                 {
7707                         x := uint16(len(([]byte((*(*(struct {
7708                                 ID HUDID
7709
7710                                 Field HUDField
7711
7712                                 //mt:if %s.Field == HUDPos
7713                                 Pos [2]float32
7714
7715                                 //mt:if %s.Field == HUDName
7716                                 Name string
7717
7718                                 //mt:if %s.Field == HUDScale
7719                                 Scale [2]float32
7720
7721                                 //mt:if %s.Field == HUDText
7722                                 Text string
7723
7724                                 //mt:if %s.Field == HUDNumber
7725                                 Number uint32
7726
7727                                 //mt:if %s.Field == HUDItem
7728                                 Item uint32
7729
7730                                 //mt:if %s.Field == HUDDir
7731                                 Dir uint32
7732
7733                                 //mt:if %s.Field == HUDAlign
7734                                 Align [2]float32
7735
7736                                 //mt:if %s.Field == HUDOffset
7737                                 Offset [2]float32
7738
7739                                 //mt:if %s.Field == HUDWorldPos
7740                                 WorldPos Pos
7741
7742                                 //mt:if %s.Field == HUDSize
7743                                 Size [2]int32
7744
7745                                 //mt:if %s.Field == HUDZIndex
7746                                 ZIndex int32
7747
7748                                 //mt:if %s.Field == HUDText2
7749                                 Text2 string
7750                         }))(obj)).Name))))
7751                         write16(w, uint16(x))
7752                 }
7753                 {
7754                         _, err := w.Write(([]byte((*(*(struct {
7755                                 ID HUDID
7756
7757                                 Field HUDField
7758
7759                                 //mt:if %s.Field == HUDPos
7760                                 Pos [2]float32
7761
7762                                 //mt:if %s.Field == HUDName
7763                                 Name string
7764
7765                                 //mt:if %s.Field == HUDScale
7766                                 Scale [2]float32
7767
7768                                 //mt:if %s.Field == HUDText
7769                                 Text string
7770
7771                                 //mt:if %s.Field == HUDNumber
7772                                 Number uint32
7773
7774                                 //mt:if %s.Field == HUDItem
7775                                 Item uint32
7776
7777                                 //mt:if %s.Field == HUDDir
7778                                 Dir uint32
7779
7780                                 //mt:if %s.Field == HUDAlign
7781                                 Align [2]float32
7782
7783                                 //mt:if %s.Field == HUDOffset
7784                                 Offset [2]float32
7785
7786                                 //mt:if %s.Field == HUDWorldPos
7787                                 WorldPos Pos
7788
7789                                 //mt:if %s.Field == HUDSize
7790                                 Size [2]int32
7791
7792                                 //mt:if %s.Field == HUDZIndex
7793                                 ZIndex int32
7794
7795                                 //mt:if %s.Field == HUDText2
7796                                 Text2 string
7797                         }))(obj)).Name))[:])
7798                         chk(err)
7799                 }
7800         }
7801         if (*(*(struct {
7802                 ID HUDID
7803
7804                 Field HUDField
7805
7806                 //mt:if %s.Field == HUDPos
7807                 Pos [2]float32
7808
7809                 //mt:if %s.Field == HUDName
7810                 Name string
7811
7812                 //mt:if %s.Field == HUDScale
7813                 Scale [2]float32
7814
7815                 //mt:if %s.Field == HUDText
7816                 Text string
7817
7818                 //mt:if %s.Field == HUDNumber
7819                 Number uint32
7820
7821                 //mt:if %s.Field == HUDItem
7822                 Item uint32
7823
7824                 //mt:if %s.Field == HUDDir
7825                 Dir uint32
7826
7827                 //mt:if %s.Field == HUDAlign
7828                 Align [2]float32
7829
7830                 //mt:if %s.Field == HUDOffset
7831                 Offset [2]float32
7832
7833                 //mt:if %s.Field == HUDWorldPos
7834                 WorldPos Pos
7835
7836                 //mt:if %s.Field == HUDSize
7837                 Size [2]int32
7838
7839                 //mt:if %s.Field == HUDZIndex
7840                 ZIndex int32
7841
7842                 //mt:if %s.Field == HUDText2
7843                 Text2 string
7844         }))(obj)).Field == HUDScale {
7845                 for local175 := range (*(*(struct {
7846                         ID HUDID
7847
7848                         Field HUDField
7849
7850                         //mt:if %s.Field == HUDPos
7851                         Pos [2]float32
7852
7853                         //mt:if %s.Field == HUDName
7854                         Name string
7855
7856                         //mt:if %s.Field == HUDScale
7857                         Scale [2]float32
7858
7859                         //mt:if %s.Field == HUDText
7860                         Text string
7861
7862                         //mt:if %s.Field == HUDNumber
7863                         Number uint32
7864
7865                         //mt:if %s.Field == HUDItem
7866                         Item uint32
7867
7868                         //mt:if %s.Field == HUDDir
7869                         Dir uint32
7870
7871                         //mt:if %s.Field == HUDAlign
7872                         Align [2]float32
7873
7874                         //mt:if %s.Field == HUDOffset
7875                         Offset [2]float32
7876
7877                         //mt:if %s.Field == HUDWorldPos
7878                         WorldPos Pos
7879
7880                         //mt:if %s.Field == HUDSize
7881                         Size [2]int32
7882
7883                         //mt:if %s.Field == HUDZIndex
7884                         ZIndex int32
7885
7886                         //mt:if %s.Field == HUDText2
7887                         Text2 string
7888                 }))(obj)).Scale {
7889                         {
7890                                 x := ((*(*(struct {
7891                                         ID HUDID
7892
7893                                         Field HUDField
7894
7895                                         //mt:if %s.Field == HUDPos
7896                                         Pos [2]float32
7897
7898                                         //mt:if %s.Field == HUDName
7899                                         Name string
7900
7901                                         //mt:if %s.Field == HUDScale
7902                                         Scale [2]float32
7903
7904                                         //mt:if %s.Field == HUDText
7905                                         Text string
7906
7907                                         //mt:if %s.Field == HUDNumber
7908                                         Number uint32
7909
7910                                         //mt:if %s.Field == HUDItem
7911                                         Item uint32
7912
7913                                         //mt:if %s.Field == HUDDir
7914                                         Dir uint32
7915
7916                                         //mt:if %s.Field == HUDAlign
7917                                         Align [2]float32
7918
7919                                         //mt:if %s.Field == HUDOffset
7920                                         Offset [2]float32
7921
7922                                         //mt:if %s.Field == HUDWorldPos
7923                                         WorldPos Pos
7924
7925                                         //mt:if %s.Field == HUDSize
7926                                         Size [2]int32
7927
7928                                         //mt:if %s.Field == HUDZIndex
7929                                         ZIndex int32
7930
7931                                         //mt:if %s.Field == HUDText2
7932                                         Text2 string
7933                                 }))(obj)).Scale)[local175]
7934                                 write32(w, math.Float32bits(x))
7935                         }
7936                 }
7937         }
7938         if (*(*(struct {
7939                 ID HUDID
7940
7941                 Field HUDField
7942
7943                 //mt:if %s.Field == HUDPos
7944                 Pos [2]float32
7945
7946                 //mt:if %s.Field == HUDName
7947                 Name string
7948
7949                 //mt:if %s.Field == HUDScale
7950                 Scale [2]float32
7951
7952                 //mt:if %s.Field == HUDText
7953                 Text string
7954
7955                 //mt:if %s.Field == HUDNumber
7956                 Number uint32
7957
7958                 //mt:if %s.Field == HUDItem
7959                 Item uint32
7960
7961                 //mt:if %s.Field == HUDDir
7962                 Dir uint32
7963
7964                 //mt:if %s.Field == HUDAlign
7965                 Align [2]float32
7966
7967                 //mt:if %s.Field == HUDOffset
7968                 Offset [2]float32
7969
7970                 //mt:if %s.Field == HUDWorldPos
7971                 WorldPos Pos
7972
7973                 //mt:if %s.Field == HUDSize
7974                 Size [2]int32
7975
7976                 //mt:if %s.Field == HUDZIndex
7977                 ZIndex int32
7978
7979                 //mt:if %s.Field == HUDText2
7980                 Text2 string
7981         }))(obj)).Field == HUDText {
7982                 if len(([]byte((*(*(struct {
7983                         ID HUDID
7984
7985                         Field HUDField
7986
7987                         //mt:if %s.Field == HUDPos
7988                         Pos [2]float32
7989
7990                         //mt:if %s.Field == HUDName
7991                         Name string
7992
7993                         //mt:if %s.Field == HUDScale
7994                         Scale [2]float32
7995
7996                         //mt:if %s.Field == HUDText
7997                         Text string
7998
7999                         //mt:if %s.Field == HUDNumber
8000                         Number uint32
8001
8002                         //mt:if %s.Field == HUDItem
8003                         Item uint32
8004
8005                         //mt:if %s.Field == HUDDir
8006                         Dir uint32
8007
8008                         //mt:if %s.Field == HUDAlign
8009                         Align [2]float32
8010
8011                         //mt:if %s.Field == HUDOffset
8012                         Offset [2]float32
8013
8014                         //mt:if %s.Field == HUDWorldPos
8015                         WorldPos Pos
8016
8017                         //mt:if %s.Field == HUDSize
8018                         Size [2]int32
8019
8020                         //mt:if %s.Field == HUDZIndex
8021                         ZIndex int32
8022
8023                         //mt:if %s.Field == HUDText2
8024                         Text2 string
8025                 }))(obj)).Text))) > math.MaxUint16 {
8026                         chk(ErrTooLong)
8027                 }
8028                 {
8029                         x := uint16(len(([]byte((*(*(struct {
8030                                 ID HUDID
8031
8032                                 Field HUDField
8033
8034                                 //mt:if %s.Field == HUDPos
8035                                 Pos [2]float32
8036
8037                                 //mt:if %s.Field == HUDName
8038                                 Name string
8039
8040                                 //mt:if %s.Field == HUDScale
8041                                 Scale [2]float32
8042
8043                                 //mt:if %s.Field == HUDText
8044                                 Text string
8045
8046                                 //mt:if %s.Field == HUDNumber
8047                                 Number uint32
8048
8049                                 //mt:if %s.Field == HUDItem
8050                                 Item uint32
8051
8052                                 //mt:if %s.Field == HUDDir
8053                                 Dir uint32
8054
8055                                 //mt:if %s.Field == HUDAlign
8056                                 Align [2]float32
8057
8058                                 //mt:if %s.Field == HUDOffset
8059                                 Offset [2]float32
8060
8061                                 //mt:if %s.Field == HUDWorldPos
8062                                 WorldPos Pos
8063
8064                                 //mt:if %s.Field == HUDSize
8065                                 Size [2]int32
8066
8067                                 //mt:if %s.Field == HUDZIndex
8068                                 ZIndex int32
8069
8070                                 //mt:if %s.Field == HUDText2
8071                                 Text2 string
8072                         }))(obj)).Text))))
8073                         write16(w, uint16(x))
8074                 }
8075                 {
8076                         _, err := w.Write(([]byte((*(*(struct {
8077                                 ID HUDID
8078
8079                                 Field HUDField
8080
8081                                 //mt:if %s.Field == HUDPos
8082                                 Pos [2]float32
8083
8084                                 //mt:if %s.Field == HUDName
8085                                 Name string
8086
8087                                 //mt:if %s.Field == HUDScale
8088                                 Scale [2]float32
8089
8090                                 //mt:if %s.Field == HUDText
8091                                 Text string
8092
8093                                 //mt:if %s.Field == HUDNumber
8094                                 Number uint32
8095
8096                                 //mt:if %s.Field == HUDItem
8097                                 Item uint32
8098
8099                                 //mt:if %s.Field == HUDDir
8100                                 Dir uint32
8101
8102                                 //mt:if %s.Field == HUDAlign
8103                                 Align [2]float32
8104
8105                                 //mt:if %s.Field == HUDOffset
8106                                 Offset [2]float32
8107
8108                                 //mt:if %s.Field == HUDWorldPos
8109                                 WorldPos Pos
8110
8111                                 //mt:if %s.Field == HUDSize
8112                                 Size [2]int32
8113
8114                                 //mt:if %s.Field == HUDZIndex
8115                                 ZIndex int32
8116
8117                                 //mt:if %s.Field == HUDText2
8118                                 Text2 string
8119                         }))(obj)).Text))[:])
8120                         chk(err)
8121                 }
8122         }
8123         if (*(*(struct {
8124                 ID HUDID
8125
8126                 Field HUDField
8127
8128                 //mt:if %s.Field == HUDPos
8129                 Pos [2]float32
8130
8131                 //mt:if %s.Field == HUDName
8132                 Name string
8133
8134                 //mt:if %s.Field == HUDScale
8135                 Scale [2]float32
8136
8137                 //mt:if %s.Field == HUDText
8138                 Text string
8139
8140                 //mt:if %s.Field == HUDNumber
8141                 Number uint32
8142
8143                 //mt:if %s.Field == HUDItem
8144                 Item uint32
8145
8146                 //mt:if %s.Field == HUDDir
8147                 Dir uint32
8148
8149                 //mt:if %s.Field == HUDAlign
8150                 Align [2]float32
8151
8152                 //mt:if %s.Field == HUDOffset
8153                 Offset [2]float32
8154
8155                 //mt:if %s.Field == HUDWorldPos
8156                 WorldPos Pos
8157
8158                 //mt:if %s.Field == HUDSize
8159                 Size [2]int32
8160
8161                 //mt:if %s.Field == HUDZIndex
8162                 ZIndex int32
8163
8164                 //mt:if %s.Field == HUDText2
8165                 Text2 string
8166         }))(obj)).Field == HUDNumber {
8167                 {
8168                         x := (*(*(struct {
8169                                 ID HUDID
8170
8171                                 Field HUDField
8172
8173                                 //mt:if %s.Field == HUDPos
8174                                 Pos [2]float32
8175
8176                                 //mt:if %s.Field == HUDName
8177                                 Name string
8178
8179                                 //mt:if %s.Field == HUDScale
8180                                 Scale [2]float32
8181
8182                                 //mt:if %s.Field == HUDText
8183                                 Text string
8184
8185                                 //mt:if %s.Field == HUDNumber
8186                                 Number uint32
8187
8188                                 //mt:if %s.Field == HUDItem
8189                                 Item uint32
8190
8191                                 //mt:if %s.Field == HUDDir
8192                                 Dir uint32
8193
8194                                 //mt:if %s.Field == HUDAlign
8195                                 Align [2]float32
8196
8197                                 //mt:if %s.Field == HUDOffset
8198                                 Offset [2]float32
8199
8200                                 //mt:if %s.Field == HUDWorldPos
8201                                 WorldPos Pos
8202
8203                                 //mt:if %s.Field == HUDSize
8204                                 Size [2]int32
8205
8206                                 //mt:if %s.Field == HUDZIndex
8207                                 ZIndex int32
8208
8209                                 //mt:if %s.Field == HUDText2
8210                                 Text2 string
8211                         }))(obj)).Number
8212                         write32(w, uint32(x))
8213                 }
8214         }
8215         if (*(*(struct {
8216                 ID HUDID
8217
8218                 Field HUDField
8219
8220                 //mt:if %s.Field == HUDPos
8221                 Pos [2]float32
8222
8223                 //mt:if %s.Field == HUDName
8224                 Name string
8225
8226                 //mt:if %s.Field == HUDScale
8227                 Scale [2]float32
8228
8229                 //mt:if %s.Field == HUDText
8230                 Text string
8231
8232                 //mt:if %s.Field == HUDNumber
8233                 Number uint32
8234
8235                 //mt:if %s.Field == HUDItem
8236                 Item uint32
8237
8238                 //mt:if %s.Field == HUDDir
8239                 Dir uint32
8240
8241                 //mt:if %s.Field == HUDAlign
8242                 Align [2]float32
8243
8244                 //mt:if %s.Field == HUDOffset
8245                 Offset [2]float32
8246
8247                 //mt:if %s.Field == HUDWorldPos
8248                 WorldPos Pos
8249
8250                 //mt:if %s.Field == HUDSize
8251                 Size [2]int32
8252
8253                 //mt:if %s.Field == HUDZIndex
8254                 ZIndex int32
8255
8256                 //mt:if %s.Field == HUDText2
8257                 Text2 string
8258         }))(obj)).Field == HUDItem {
8259                 {
8260                         x := (*(*(struct {
8261                                 ID HUDID
8262
8263                                 Field HUDField
8264
8265                                 //mt:if %s.Field == HUDPos
8266                                 Pos [2]float32
8267
8268                                 //mt:if %s.Field == HUDName
8269                                 Name string
8270
8271                                 //mt:if %s.Field == HUDScale
8272                                 Scale [2]float32
8273
8274                                 //mt:if %s.Field == HUDText
8275                                 Text string
8276
8277                                 //mt:if %s.Field == HUDNumber
8278                                 Number uint32
8279
8280                                 //mt:if %s.Field == HUDItem
8281                                 Item uint32
8282
8283                                 //mt:if %s.Field == HUDDir
8284                                 Dir uint32
8285
8286                                 //mt:if %s.Field == HUDAlign
8287                                 Align [2]float32
8288
8289                                 //mt:if %s.Field == HUDOffset
8290                                 Offset [2]float32
8291
8292                                 //mt:if %s.Field == HUDWorldPos
8293                                 WorldPos Pos
8294
8295                                 //mt:if %s.Field == HUDSize
8296                                 Size [2]int32
8297
8298                                 //mt:if %s.Field == HUDZIndex
8299                                 ZIndex int32
8300
8301                                 //mt:if %s.Field == HUDText2
8302                                 Text2 string
8303                         }))(obj)).Item
8304                         write32(w, uint32(x))
8305                 }
8306         }
8307         if (*(*(struct {
8308                 ID HUDID
8309
8310                 Field HUDField
8311
8312                 //mt:if %s.Field == HUDPos
8313                 Pos [2]float32
8314
8315                 //mt:if %s.Field == HUDName
8316                 Name string
8317
8318                 //mt:if %s.Field == HUDScale
8319                 Scale [2]float32
8320
8321                 //mt:if %s.Field == HUDText
8322                 Text string
8323
8324                 //mt:if %s.Field == HUDNumber
8325                 Number uint32
8326
8327                 //mt:if %s.Field == HUDItem
8328                 Item uint32
8329
8330                 //mt:if %s.Field == HUDDir
8331                 Dir uint32
8332
8333                 //mt:if %s.Field == HUDAlign
8334                 Align [2]float32
8335
8336                 //mt:if %s.Field == HUDOffset
8337                 Offset [2]float32
8338
8339                 //mt:if %s.Field == HUDWorldPos
8340                 WorldPos Pos
8341
8342                 //mt:if %s.Field == HUDSize
8343                 Size [2]int32
8344
8345                 //mt:if %s.Field == HUDZIndex
8346                 ZIndex int32
8347
8348                 //mt:if %s.Field == HUDText2
8349                 Text2 string
8350         }))(obj)).Field == HUDDir {
8351                 {
8352                         x := (*(*(struct {
8353                                 ID HUDID
8354
8355                                 Field HUDField
8356
8357                                 //mt:if %s.Field == HUDPos
8358                                 Pos [2]float32
8359
8360                                 //mt:if %s.Field == HUDName
8361                                 Name string
8362
8363                                 //mt:if %s.Field == HUDScale
8364                                 Scale [2]float32
8365
8366                                 //mt:if %s.Field == HUDText
8367                                 Text string
8368
8369                                 //mt:if %s.Field == HUDNumber
8370                                 Number uint32
8371
8372                                 //mt:if %s.Field == HUDItem
8373                                 Item uint32
8374
8375                                 //mt:if %s.Field == HUDDir
8376                                 Dir uint32
8377
8378                                 //mt:if %s.Field == HUDAlign
8379                                 Align [2]float32
8380
8381                                 //mt:if %s.Field == HUDOffset
8382                                 Offset [2]float32
8383
8384                                 //mt:if %s.Field == HUDWorldPos
8385                                 WorldPos Pos
8386
8387                                 //mt:if %s.Field == HUDSize
8388                                 Size [2]int32
8389
8390                                 //mt:if %s.Field == HUDZIndex
8391                                 ZIndex int32
8392
8393                                 //mt:if %s.Field == HUDText2
8394                                 Text2 string
8395                         }))(obj)).Dir
8396                         write32(w, uint32(x))
8397                 }
8398         }
8399         if (*(*(struct {
8400                 ID HUDID
8401
8402                 Field HUDField
8403
8404                 //mt:if %s.Field == HUDPos
8405                 Pos [2]float32
8406
8407                 //mt:if %s.Field == HUDName
8408                 Name string
8409
8410                 //mt:if %s.Field == HUDScale
8411                 Scale [2]float32
8412
8413                 //mt:if %s.Field == HUDText
8414                 Text string
8415
8416                 //mt:if %s.Field == HUDNumber
8417                 Number uint32
8418
8419                 //mt:if %s.Field == HUDItem
8420                 Item uint32
8421
8422                 //mt:if %s.Field == HUDDir
8423                 Dir uint32
8424
8425                 //mt:if %s.Field == HUDAlign
8426                 Align [2]float32
8427
8428                 //mt:if %s.Field == HUDOffset
8429                 Offset [2]float32
8430
8431                 //mt:if %s.Field == HUDWorldPos
8432                 WorldPos Pos
8433
8434                 //mt:if %s.Field == HUDSize
8435                 Size [2]int32
8436
8437                 //mt:if %s.Field == HUDZIndex
8438                 ZIndex int32
8439
8440                 //mt:if %s.Field == HUDText2
8441                 Text2 string
8442         }))(obj)).Field == HUDAlign {
8443                 for local176 := range (*(*(struct {
8444                         ID HUDID
8445
8446                         Field HUDField
8447
8448                         //mt:if %s.Field == HUDPos
8449                         Pos [2]float32
8450
8451                         //mt:if %s.Field == HUDName
8452                         Name string
8453
8454                         //mt:if %s.Field == HUDScale
8455                         Scale [2]float32
8456
8457                         //mt:if %s.Field == HUDText
8458                         Text string
8459
8460                         //mt:if %s.Field == HUDNumber
8461                         Number uint32
8462
8463                         //mt:if %s.Field == HUDItem
8464                         Item uint32
8465
8466                         //mt:if %s.Field == HUDDir
8467                         Dir uint32
8468
8469                         //mt:if %s.Field == HUDAlign
8470                         Align [2]float32
8471
8472                         //mt:if %s.Field == HUDOffset
8473                         Offset [2]float32
8474
8475                         //mt:if %s.Field == HUDWorldPos
8476                         WorldPos Pos
8477
8478                         //mt:if %s.Field == HUDSize
8479                         Size [2]int32
8480
8481                         //mt:if %s.Field == HUDZIndex
8482                         ZIndex int32
8483
8484                         //mt:if %s.Field == HUDText2
8485                         Text2 string
8486                 }))(obj)).Align {
8487                         {
8488                                 x := ((*(*(struct {
8489                                         ID HUDID
8490
8491                                         Field HUDField
8492
8493                                         //mt:if %s.Field == HUDPos
8494                                         Pos [2]float32
8495
8496                                         //mt:if %s.Field == HUDName
8497                                         Name string
8498
8499                                         //mt:if %s.Field == HUDScale
8500                                         Scale [2]float32
8501
8502                                         //mt:if %s.Field == HUDText
8503                                         Text string
8504
8505                                         //mt:if %s.Field == HUDNumber
8506                                         Number uint32
8507
8508                                         //mt:if %s.Field == HUDItem
8509                                         Item uint32
8510
8511                                         //mt:if %s.Field == HUDDir
8512                                         Dir uint32
8513
8514                                         //mt:if %s.Field == HUDAlign
8515                                         Align [2]float32
8516
8517                                         //mt:if %s.Field == HUDOffset
8518                                         Offset [2]float32
8519
8520                                         //mt:if %s.Field == HUDWorldPos
8521                                         WorldPos Pos
8522
8523                                         //mt:if %s.Field == HUDSize
8524                                         Size [2]int32
8525
8526                                         //mt:if %s.Field == HUDZIndex
8527                                         ZIndex int32
8528
8529                                         //mt:if %s.Field == HUDText2
8530                                         Text2 string
8531                                 }))(obj)).Align)[local176]
8532                                 write32(w, math.Float32bits(x))
8533                         }
8534                 }
8535         }
8536         if (*(*(struct {
8537                 ID HUDID
8538
8539                 Field HUDField
8540
8541                 //mt:if %s.Field == HUDPos
8542                 Pos [2]float32
8543
8544                 //mt:if %s.Field == HUDName
8545                 Name string
8546
8547                 //mt:if %s.Field == HUDScale
8548                 Scale [2]float32
8549
8550                 //mt:if %s.Field == HUDText
8551                 Text string
8552
8553                 //mt:if %s.Field == HUDNumber
8554                 Number uint32
8555
8556                 //mt:if %s.Field == HUDItem
8557                 Item uint32
8558
8559                 //mt:if %s.Field == HUDDir
8560                 Dir uint32
8561
8562                 //mt:if %s.Field == HUDAlign
8563                 Align [2]float32
8564
8565                 //mt:if %s.Field == HUDOffset
8566                 Offset [2]float32
8567
8568                 //mt:if %s.Field == HUDWorldPos
8569                 WorldPos Pos
8570
8571                 //mt:if %s.Field == HUDSize
8572                 Size [2]int32
8573
8574                 //mt:if %s.Field == HUDZIndex
8575                 ZIndex int32
8576
8577                 //mt:if %s.Field == HUDText2
8578                 Text2 string
8579         }))(obj)).Field == HUDOffset {
8580                 for local177 := range (*(*(struct {
8581                         ID HUDID
8582
8583                         Field HUDField
8584
8585                         //mt:if %s.Field == HUDPos
8586                         Pos [2]float32
8587
8588                         //mt:if %s.Field == HUDName
8589                         Name string
8590
8591                         //mt:if %s.Field == HUDScale
8592                         Scale [2]float32
8593
8594                         //mt:if %s.Field == HUDText
8595                         Text string
8596
8597                         //mt:if %s.Field == HUDNumber
8598                         Number uint32
8599
8600                         //mt:if %s.Field == HUDItem
8601                         Item uint32
8602
8603                         //mt:if %s.Field == HUDDir
8604                         Dir uint32
8605
8606                         //mt:if %s.Field == HUDAlign
8607                         Align [2]float32
8608
8609                         //mt:if %s.Field == HUDOffset
8610                         Offset [2]float32
8611
8612                         //mt:if %s.Field == HUDWorldPos
8613                         WorldPos Pos
8614
8615                         //mt:if %s.Field == HUDSize
8616                         Size [2]int32
8617
8618                         //mt:if %s.Field == HUDZIndex
8619                         ZIndex int32
8620
8621                         //mt:if %s.Field == HUDText2
8622                         Text2 string
8623                 }))(obj)).Offset {
8624                         {
8625                                 x := ((*(*(struct {
8626                                         ID HUDID
8627
8628                                         Field HUDField
8629
8630                                         //mt:if %s.Field == HUDPos
8631                                         Pos [2]float32
8632
8633                                         //mt:if %s.Field == HUDName
8634                                         Name string
8635
8636                                         //mt:if %s.Field == HUDScale
8637                                         Scale [2]float32
8638
8639                                         //mt:if %s.Field == HUDText
8640                                         Text string
8641
8642                                         //mt:if %s.Field == HUDNumber
8643                                         Number uint32
8644
8645                                         //mt:if %s.Field == HUDItem
8646                                         Item uint32
8647
8648                                         //mt:if %s.Field == HUDDir
8649                                         Dir uint32
8650
8651                                         //mt:if %s.Field == HUDAlign
8652                                         Align [2]float32
8653
8654                                         //mt:if %s.Field == HUDOffset
8655                                         Offset [2]float32
8656
8657                                         //mt:if %s.Field == HUDWorldPos
8658                                         WorldPos Pos
8659
8660                                         //mt:if %s.Field == HUDSize
8661                                         Size [2]int32
8662
8663                                         //mt:if %s.Field == HUDZIndex
8664                                         ZIndex int32
8665
8666                                         //mt:if %s.Field == HUDText2
8667                                         Text2 string
8668                                 }))(obj)).Offset)[local177]
8669                                 write32(w, math.Float32bits(x))
8670                         }
8671                 }
8672         }
8673         if (*(*(struct {
8674                 ID HUDID
8675
8676                 Field HUDField
8677
8678                 //mt:if %s.Field == HUDPos
8679                 Pos [2]float32
8680
8681                 //mt:if %s.Field == HUDName
8682                 Name string
8683
8684                 //mt:if %s.Field == HUDScale
8685                 Scale [2]float32
8686
8687                 //mt:if %s.Field == HUDText
8688                 Text string
8689
8690                 //mt:if %s.Field == HUDNumber
8691                 Number uint32
8692
8693                 //mt:if %s.Field == HUDItem
8694                 Item uint32
8695
8696                 //mt:if %s.Field == HUDDir
8697                 Dir uint32
8698
8699                 //mt:if %s.Field == HUDAlign
8700                 Align [2]float32
8701
8702                 //mt:if %s.Field == HUDOffset
8703                 Offset [2]float32
8704
8705                 //mt:if %s.Field == HUDWorldPos
8706                 WorldPos Pos
8707
8708                 //mt:if %s.Field == HUDSize
8709                 Size [2]int32
8710
8711                 //mt:if %s.Field == HUDZIndex
8712                 ZIndex int32
8713
8714                 //mt:if %s.Field == HUDText2
8715                 Text2 string
8716         }))(obj)).Field == HUDWorldPos {
8717                 if err := pcall(func() {
8718                         ((*(*(struct {
8719                                 ID HUDID
8720
8721                                 Field HUDField
8722
8723                                 //mt:if %s.Field == HUDPos
8724                                 Pos [2]float32
8725
8726                                 //mt:if %s.Field == HUDName
8727                                 Name string
8728
8729                                 //mt:if %s.Field == HUDScale
8730                                 Scale [2]float32
8731
8732                                 //mt:if %s.Field == HUDText
8733                                 Text string
8734
8735                                 //mt:if %s.Field == HUDNumber
8736                                 Number uint32
8737
8738                                 //mt:if %s.Field == HUDItem
8739                                 Item uint32
8740
8741                                 //mt:if %s.Field == HUDDir
8742                                 Dir uint32
8743
8744                                 //mt:if %s.Field == HUDAlign
8745                                 Align [2]float32
8746
8747                                 //mt:if %s.Field == HUDOffset
8748                                 Offset [2]float32
8749
8750                                 //mt:if %s.Field == HUDWorldPos
8751                                 WorldPos Pos
8752
8753                                 //mt:if %s.Field == HUDSize
8754                                 Size [2]int32
8755
8756                                 //mt:if %s.Field == HUDZIndex
8757                                 ZIndex int32
8758
8759                                 //mt:if %s.Field == HUDText2
8760                                 Text2 string
8761                         }))(obj)).WorldPos).Serialize(w)
8762                 }); err != nil {
8763                         if err == io.EOF {
8764                                 chk(io.EOF)
8765                         }
8766                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
8767                 }
8768         }
8769         if (*(*(struct {
8770                 ID HUDID
8771
8772                 Field HUDField
8773
8774                 //mt:if %s.Field == HUDPos
8775                 Pos [2]float32
8776
8777                 //mt:if %s.Field == HUDName
8778                 Name string
8779
8780                 //mt:if %s.Field == HUDScale
8781                 Scale [2]float32
8782
8783                 //mt:if %s.Field == HUDText
8784                 Text string
8785
8786                 //mt:if %s.Field == HUDNumber
8787                 Number uint32
8788
8789                 //mt:if %s.Field == HUDItem
8790                 Item uint32
8791
8792                 //mt:if %s.Field == HUDDir
8793                 Dir uint32
8794
8795                 //mt:if %s.Field == HUDAlign
8796                 Align [2]float32
8797
8798                 //mt:if %s.Field == HUDOffset
8799                 Offset [2]float32
8800
8801                 //mt:if %s.Field == HUDWorldPos
8802                 WorldPos Pos
8803
8804                 //mt:if %s.Field == HUDSize
8805                 Size [2]int32
8806
8807                 //mt:if %s.Field == HUDZIndex
8808                 ZIndex int32
8809
8810                 //mt:if %s.Field == HUDText2
8811                 Text2 string
8812         }))(obj)).Field == HUDSize {
8813                 for local178 := range (*(*(struct {
8814                         ID HUDID
8815
8816                         Field HUDField
8817
8818                         //mt:if %s.Field == HUDPos
8819                         Pos [2]float32
8820
8821                         //mt:if %s.Field == HUDName
8822                         Name string
8823
8824                         //mt:if %s.Field == HUDScale
8825                         Scale [2]float32
8826
8827                         //mt:if %s.Field == HUDText
8828                         Text string
8829
8830                         //mt:if %s.Field == HUDNumber
8831                         Number uint32
8832
8833                         //mt:if %s.Field == HUDItem
8834                         Item uint32
8835
8836                         //mt:if %s.Field == HUDDir
8837                         Dir uint32
8838
8839                         //mt:if %s.Field == HUDAlign
8840                         Align [2]float32
8841
8842                         //mt:if %s.Field == HUDOffset
8843                         Offset [2]float32
8844
8845                         //mt:if %s.Field == HUDWorldPos
8846                         WorldPos Pos
8847
8848                         //mt:if %s.Field == HUDSize
8849                         Size [2]int32
8850
8851                         //mt:if %s.Field == HUDZIndex
8852                         ZIndex int32
8853
8854                         //mt:if %s.Field == HUDText2
8855                         Text2 string
8856                 }))(obj)).Size {
8857                         {
8858                                 x := ((*(*(struct {
8859                                         ID HUDID
8860
8861                                         Field HUDField
8862
8863                                         //mt:if %s.Field == HUDPos
8864                                         Pos [2]float32
8865
8866                                         //mt:if %s.Field == HUDName
8867                                         Name string
8868
8869                                         //mt:if %s.Field == HUDScale
8870                                         Scale [2]float32
8871
8872                                         //mt:if %s.Field == HUDText
8873                                         Text string
8874
8875                                         //mt:if %s.Field == HUDNumber
8876                                         Number uint32
8877
8878                                         //mt:if %s.Field == HUDItem
8879                                         Item uint32
8880
8881                                         //mt:if %s.Field == HUDDir
8882                                         Dir uint32
8883
8884                                         //mt:if %s.Field == HUDAlign
8885                                         Align [2]float32
8886
8887                                         //mt:if %s.Field == HUDOffset
8888                                         Offset [2]float32
8889
8890                                         //mt:if %s.Field == HUDWorldPos
8891                                         WorldPos Pos
8892
8893                                         //mt:if %s.Field == HUDSize
8894                                         Size [2]int32
8895
8896                                         //mt:if %s.Field == HUDZIndex
8897                                         ZIndex int32
8898
8899                                         //mt:if %s.Field == HUDText2
8900                                         Text2 string
8901                                 }))(obj)).Size)[local178]
8902                                 write32(w, uint32(x))
8903                         }
8904                 }
8905         }
8906         if (*(*(struct {
8907                 ID HUDID
8908
8909                 Field HUDField
8910
8911                 //mt:if %s.Field == HUDPos
8912                 Pos [2]float32
8913
8914                 //mt:if %s.Field == HUDName
8915                 Name string
8916
8917                 //mt:if %s.Field == HUDScale
8918                 Scale [2]float32
8919
8920                 //mt:if %s.Field == HUDText
8921                 Text string
8922
8923                 //mt:if %s.Field == HUDNumber
8924                 Number uint32
8925
8926                 //mt:if %s.Field == HUDItem
8927                 Item uint32
8928
8929                 //mt:if %s.Field == HUDDir
8930                 Dir uint32
8931
8932                 //mt:if %s.Field == HUDAlign
8933                 Align [2]float32
8934
8935                 //mt:if %s.Field == HUDOffset
8936                 Offset [2]float32
8937
8938                 //mt:if %s.Field == HUDWorldPos
8939                 WorldPos Pos
8940
8941                 //mt:if %s.Field == HUDSize
8942                 Size [2]int32
8943
8944                 //mt:if %s.Field == HUDZIndex
8945                 ZIndex int32
8946
8947                 //mt:if %s.Field == HUDText2
8948                 Text2 string
8949         }))(obj)).Field == HUDZIndex {
8950                 {
8951                         x := (*(*(struct {
8952                                 ID HUDID
8953
8954                                 Field HUDField
8955
8956                                 //mt:if %s.Field == HUDPos
8957                                 Pos [2]float32
8958
8959                                 //mt:if %s.Field == HUDName
8960                                 Name string
8961
8962                                 //mt:if %s.Field == HUDScale
8963                                 Scale [2]float32
8964
8965                                 //mt:if %s.Field == HUDText
8966                                 Text string
8967
8968                                 //mt:if %s.Field == HUDNumber
8969                                 Number uint32
8970
8971                                 //mt:if %s.Field == HUDItem
8972                                 Item uint32
8973
8974                                 //mt:if %s.Field == HUDDir
8975                                 Dir uint32
8976
8977                                 //mt:if %s.Field == HUDAlign
8978                                 Align [2]float32
8979
8980                                 //mt:if %s.Field == HUDOffset
8981                                 Offset [2]float32
8982
8983                                 //mt:if %s.Field == HUDWorldPos
8984                                 WorldPos Pos
8985
8986                                 //mt:if %s.Field == HUDSize
8987                                 Size [2]int32
8988
8989                                 //mt:if %s.Field == HUDZIndex
8990                                 ZIndex int32
8991
8992                                 //mt:if %s.Field == HUDText2
8993                                 Text2 string
8994                         }))(obj)).ZIndex
8995                         write32(w, uint32(x))
8996                 }
8997         }
8998         if (*(*(struct {
8999                 ID HUDID
9000
9001                 Field HUDField
9002
9003                 //mt:if %s.Field == HUDPos
9004                 Pos [2]float32
9005
9006                 //mt:if %s.Field == HUDName
9007                 Name string
9008
9009                 //mt:if %s.Field == HUDScale
9010                 Scale [2]float32
9011
9012                 //mt:if %s.Field == HUDText
9013                 Text string
9014
9015                 //mt:if %s.Field == HUDNumber
9016                 Number uint32
9017
9018                 //mt:if %s.Field == HUDItem
9019                 Item uint32
9020
9021                 //mt:if %s.Field == HUDDir
9022                 Dir uint32
9023
9024                 //mt:if %s.Field == HUDAlign
9025                 Align [2]float32
9026
9027                 //mt:if %s.Field == HUDOffset
9028                 Offset [2]float32
9029
9030                 //mt:if %s.Field == HUDWorldPos
9031                 WorldPos Pos
9032
9033                 //mt:if %s.Field == HUDSize
9034                 Size [2]int32
9035
9036                 //mt:if %s.Field == HUDZIndex
9037                 ZIndex int32
9038
9039                 //mt:if %s.Field == HUDText2
9040                 Text2 string
9041         }))(obj)).Field == HUDText2 {
9042                 if len(([]byte((*(*(struct {
9043                         ID HUDID
9044
9045                         Field HUDField
9046
9047                         //mt:if %s.Field == HUDPos
9048                         Pos [2]float32
9049
9050                         //mt:if %s.Field == HUDName
9051                         Name string
9052
9053                         //mt:if %s.Field == HUDScale
9054                         Scale [2]float32
9055
9056                         //mt:if %s.Field == HUDText
9057                         Text string
9058
9059                         //mt:if %s.Field == HUDNumber
9060                         Number uint32
9061
9062                         //mt:if %s.Field == HUDItem
9063                         Item uint32
9064
9065                         //mt:if %s.Field == HUDDir
9066                         Dir uint32
9067
9068                         //mt:if %s.Field == HUDAlign
9069                         Align [2]float32
9070
9071                         //mt:if %s.Field == HUDOffset
9072                         Offset [2]float32
9073
9074                         //mt:if %s.Field == HUDWorldPos
9075                         WorldPos Pos
9076
9077                         //mt:if %s.Field == HUDSize
9078                         Size [2]int32
9079
9080                         //mt:if %s.Field == HUDZIndex
9081                         ZIndex int32
9082
9083                         //mt:if %s.Field == HUDText2
9084                         Text2 string
9085                 }))(obj)).Text2))) > math.MaxUint16 {
9086                         chk(ErrTooLong)
9087                 }
9088                 {
9089                         x := uint16(len(([]byte((*(*(struct {
9090                                 ID HUDID
9091
9092                                 Field HUDField
9093
9094                                 //mt:if %s.Field == HUDPos
9095                                 Pos [2]float32
9096
9097                                 //mt:if %s.Field == HUDName
9098                                 Name string
9099
9100                                 //mt:if %s.Field == HUDScale
9101                                 Scale [2]float32
9102
9103                                 //mt:if %s.Field == HUDText
9104                                 Text string
9105
9106                                 //mt:if %s.Field == HUDNumber
9107                                 Number uint32
9108
9109                                 //mt:if %s.Field == HUDItem
9110                                 Item uint32
9111
9112                                 //mt:if %s.Field == HUDDir
9113                                 Dir uint32
9114
9115                                 //mt:if %s.Field == HUDAlign
9116                                 Align [2]float32
9117
9118                                 //mt:if %s.Field == HUDOffset
9119                                 Offset [2]float32
9120
9121                                 //mt:if %s.Field == HUDWorldPos
9122                                 WorldPos Pos
9123
9124                                 //mt:if %s.Field == HUDSize
9125                                 Size [2]int32
9126
9127                                 //mt:if %s.Field == HUDZIndex
9128                                 ZIndex int32
9129
9130                                 //mt:if %s.Field == HUDText2
9131                                 Text2 string
9132                         }))(obj)).Text2))))
9133                         write16(w, uint16(x))
9134                 }
9135                 {
9136                         _, err := w.Write(([]byte((*(*(struct {
9137                                 ID HUDID
9138
9139                                 Field HUDField
9140
9141                                 //mt:if %s.Field == HUDPos
9142                                 Pos [2]float32
9143
9144                                 //mt:if %s.Field == HUDName
9145                                 Name string
9146
9147                                 //mt:if %s.Field == HUDScale
9148                                 Scale [2]float32
9149
9150                                 //mt:if %s.Field == HUDText
9151                                 Text string
9152
9153                                 //mt:if %s.Field == HUDNumber
9154                                 Number uint32
9155
9156                                 //mt:if %s.Field == HUDItem
9157                                 Item uint32
9158
9159                                 //mt:if %s.Field == HUDDir
9160                                 Dir uint32
9161
9162                                 //mt:if %s.Field == HUDAlign
9163                                 Align [2]float32
9164
9165                                 //mt:if %s.Field == HUDOffset
9166                                 Offset [2]float32
9167
9168                                 //mt:if %s.Field == HUDWorldPos
9169                                 WorldPos Pos
9170
9171                                 //mt:if %s.Field == HUDSize
9172                                 Size [2]int32
9173
9174                                 //mt:if %s.Field == HUDZIndex
9175                                 ZIndex int32
9176
9177                                 //mt:if %s.Field == HUDText2
9178                                 Text2 string
9179                         }))(obj)).Text2))[:])
9180                         chk(err)
9181                 }
9182         }
9183 }
9184
9185 func (obj *ToCltChangeHUD) Deserialize(r io.Reader) {
9186         if err := pcall(func() {
9187                 ((*(*(struct {
9188                         ID HUDID
9189
9190                         Field HUDField
9191
9192                         //mt:if %s.Field == HUDPos
9193                         Pos [2]float32
9194
9195                         //mt:if %s.Field == HUDName
9196                         Name string
9197
9198                         //mt:if %s.Field == HUDScale
9199                         Scale [2]float32
9200
9201                         //mt:if %s.Field == HUDText
9202                         Text string
9203
9204                         //mt:if %s.Field == HUDNumber
9205                         Number uint32
9206
9207                         //mt:if %s.Field == HUDItem
9208                         Item uint32
9209
9210                         //mt:if %s.Field == HUDDir
9211                         Dir uint32
9212
9213                         //mt:if %s.Field == HUDAlign
9214                         Align [2]float32
9215
9216                         //mt:if %s.Field == HUDOffset
9217                         Offset [2]float32
9218
9219                         //mt:if %s.Field == HUDWorldPos
9220                         WorldPos Pos
9221
9222                         //mt:if %s.Field == HUDSize
9223                         Size [2]int32
9224
9225                         //mt:if %s.Field == HUDZIndex
9226                         ZIndex int32
9227
9228                         //mt:if %s.Field == HUDText2
9229                         Text2 string
9230                 }))(obj)).ID).Deserialize(r)
9231         }); err != nil {
9232                 if err == io.EOF {
9233                         chk(io.EOF)
9234                 }
9235                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
9236         }
9237         if err := pcall(func() {
9238                 ((*(*(struct {
9239                         ID HUDID
9240
9241                         Field HUDField
9242
9243                         //mt:if %s.Field == HUDPos
9244                         Pos [2]float32
9245
9246                         //mt:if %s.Field == HUDName
9247                         Name string
9248
9249                         //mt:if %s.Field == HUDScale
9250                         Scale [2]float32
9251
9252                         //mt:if %s.Field == HUDText
9253                         Text string
9254
9255                         //mt:if %s.Field == HUDNumber
9256                         Number uint32
9257
9258                         //mt:if %s.Field == HUDItem
9259                         Item uint32
9260
9261                         //mt:if %s.Field == HUDDir
9262                         Dir uint32
9263
9264                         //mt:if %s.Field == HUDAlign
9265                         Align [2]float32
9266
9267                         //mt:if %s.Field == HUDOffset
9268                         Offset [2]float32
9269
9270                         //mt:if %s.Field == HUDWorldPos
9271                         WorldPos Pos
9272
9273                         //mt:if %s.Field == HUDSize
9274                         Size [2]int32
9275
9276                         //mt:if %s.Field == HUDZIndex
9277                         ZIndex int32
9278
9279                         //mt:if %s.Field == HUDText2
9280                         Text2 string
9281                 }))(obj)).Field).Deserialize(r)
9282         }); err != nil {
9283                 if err == io.EOF {
9284                         chk(io.EOF)
9285                 }
9286                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDField", err))
9287         }
9288         if !((*(*(struct {
9289                 ID HUDID
9290
9291                 Field HUDField
9292
9293                 //mt:if %s.Field == HUDPos
9294                 Pos [2]float32
9295
9296                 //mt:if %s.Field == HUDName
9297                 Name string
9298
9299                 //mt:if %s.Field == HUDScale
9300                 Scale [2]float32
9301
9302                 //mt:if %s.Field == HUDText
9303                 Text string
9304
9305                 //mt:if %s.Field == HUDNumber
9306                 Number uint32
9307
9308                 //mt:if %s.Field == HUDItem
9309                 Item uint32
9310
9311                 //mt:if %s.Field == HUDDir
9312                 Dir uint32
9313
9314                 //mt:if %s.Field == HUDAlign
9315                 Align [2]float32
9316
9317                 //mt:if %s.Field == HUDOffset
9318                 Offset [2]float32
9319
9320                 //mt:if %s.Field == HUDWorldPos
9321                 WorldPos Pos
9322
9323                 //mt:if %s.Field == HUDSize
9324                 Size [2]int32
9325
9326                 //mt:if %s.Field == HUDZIndex
9327                 ZIndex int32
9328
9329                 //mt:if %s.Field == HUDText2
9330                 Text2 string
9331         }))(obj)).Field < hudMax) {
9332                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9333         }
9334         if (*(*(struct {
9335                 ID HUDID
9336
9337                 Field HUDField
9338
9339                 //mt:if %s.Field == HUDPos
9340                 Pos [2]float32
9341
9342                 //mt:if %s.Field == HUDName
9343                 Name string
9344
9345                 //mt:if %s.Field == HUDScale
9346                 Scale [2]float32
9347
9348                 //mt:if %s.Field == HUDText
9349                 Text string
9350
9351                 //mt:if %s.Field == HUDNumber
9352                 Number uint32
9353
9354                 //mt:if %s.Field == HUDItem
9355                 Item uint32
9356
9357                 //mt:if %s.Field == HUDDir
9358                 Dir uint32
9359
9360                 //mt:if %s.Field == HUDAlign
9361                 Align [2]float32
9362
9363                 //mt:if %s.Field == HUDOffset
9364                 Offset [2]float32
9365
9366                 //mt:if %s.Field == HUDWorldPos
9367                 WorldPos Pos
9368
9369                 //mt:if %s.Field == HUDSize
9370                 Size [2]int32
9371
9372                 //mt:if %s.Field == HUDZIndex
9373                 ZIndex int32
9374
9375                 //mt:if %s.Field == HUDText2
9376                 Text2 string
9377         }))(obj)).Field == HUDPos {
9378                 for local179 := range (*(*(struct {
9379                         ID HUDID
9380
9381                         Field HUDField
9382
9383                         //mt:if %s.Field == HUDPos
9384                         Pos [2]float32
9385
9386                         //mt:if %s.Field == HUDName
9387                         Name string
9388
9389                         //mt:if %s.Field == HUDScale
9390                         Scale [2]float32
9391
9392                         //mt:if %s.Field == HUDText
9393                         Text string
9394
9395                         //mt:if %s.Field == HUDNumber
9396                         Number uint32
9397
9398                         //mt:if %s.Field == HUDItem
9399                         Item uint32
9400
9401                         //mt:if %s.Field == HUDDir
9402                         Dir uint32
9403
9404                         //mt:if %s.Field == HUDAlign
9405                         Align [2]float32
9406
9407                         //mt:if %s.Field == HUDOffset
9408                         Offset [2]float32
9409
9410                         //mt:if %s.Field == HUDWorldPos
9411                         WorldPos Pos
9412
9413                         //mt:if %s.Field == HUDSize
9414                         Size [2]int32
9415
9416                         //mt:if %s.Field == HUDZIndex
9417                         ZIndex int32
9418
9419                         //mt:if %s.Field == HUDText2
9420                         Text2 string
9421                 }))(obj)).Pos {
9422                         {
9423                                 p := &((*(*(struct {
9424                                         ID HUDID
9425
9426                                         Field HUDField
9427
9428                                         //mt:if %s.Field == HUDPos
9429                                         Pos [2]float32
9430
9431                                         //mt:if %s.Field == HUDName
9432                                         Name string
9433
9434                                         //mt:if %s.Field == HUDScale
9435                                         Scale [2]float32
9436
9437                                         //mt:if %s.Field == HUDText
9438                                         Text string
9439
9440                                         //mt:if %s.Field == HUDNumber
9441                                         Number uint32
9442
9443                                         //mt:if %s.Field == HUDItem
9444                                         Item uint32
9445
9446                                         //mt:if %s.Field == HUDDir
9447                                         Dir uint32
9448
9449                                         //mt:if %s.Field == HUDAlign
9450                                         Align [2]float32
9451
9452                                         //mt:if %s.Field == HUDOffset
9453                                         Offset [2]float32
9454
9455                                         //mt:if %s.Field == HUDWorldPos
9456                                         WorldPos Pos
9457
9458                                         //mt:if %s.Field == HUDSize
9459                                         Size [2]int32
9460
9461                                         //mt:if %s.Field == HUDZIndex
9462                                         ZIndex int32
9463
9464                                         //mt:if %s.Field == HUDText2
9465                                         Text2 string
9466                                 }))(obj)).Pos)[local179]
9467                                 *p = math.Float32frombits(read32(r))
9468                         }
9469                 }
9470         }
9471         if (*(*(struct {
9472                 ID HUDID
9473
9474                 Field HUDField
9475
9476                 //mt:if %s.Field == HUDPos
9477                 Pos [2]float32
9478
9479                 //mt:if %s.Field == HUDName
9480                 Name string
9481
9482                 //mt:if %s.Field == HUDScale
9483                 Scale [2]float32
9484
9485                 //mt:if %s.Field == HUDText
9486                 Text string
9487
9488                 //mt:if %s.Field == HUDNumber
9489                 Number uint32
9490
9491                 //mt:if %s.Field == HUDItem
9492                 Item uint32
9493
9494                 //mt:if %s.Field == HUDDir
9495                 Dir uint32
9496
9497                 //mt:if %s.Field == HUDAlign
9498                 Align [2]float32
9499
9500                 //mt:if %s.Field == HUDOffset
9501                 Offset [2]float32
9502
9503                 //mt:if %s.Field == HUDWorldPos
9504                 WorldPos Pos
9505
9506                 //mt:if %s.Field == HUDSize
9507                 Size [2]int32
9508
9509                 //mt:if %s.Field == HUDZIndex
9510                 ZIndex int32
9511
9512                 //mt:if %s.Field == HUDText2
9513                 Text2 string
9514         }))(obj)).Field == HUDName {
9515                 var local180 []uint8
9516                 var local181 uint16
9517                 {
9518                         p := &local181
9519                         *p = read16(r)
9520                 }
9521                 (local180) = make([]uint8, local181)
9522                 {
9523                         _, err := io.ReadFull(r, (local180)[:])
9524                         chk(err)
9525                 }
9526                 ((*(*(struct {
9527                         ID HUDID
9528
9529                         Field HUDField
9530
9531                         //mt:if %s.Field == HUDPos
9532                         Pos [2]float32
9533
9534                         //mt:if %s.Field == HUDName
9535                         Name string
9536
9537                         //mt:if %s.Field == HUDScale
9538                         Scale [2]float32
9539
9540                         //mt:if %s.Field == HUDText
9541                         Text string
9542
9543                         //mt:if %s.Field == HUDNumber
9544                         Number uint32
9545
9546                         //mt:if %s.Field == HUDItem
9547                         Item uint32
9548
9549                         //mt:if %s.Field == HUDDir
9550                         Dir uint32
9551
9552                         //mt:if %s.Field == HUDAlign
9553                         Align [2]float32
9554
9555                         //mt:if %s.Field == HUDOffset
9556                         Offset [2]float32
9557
9558                         //mt:if %s.Field == HUDWorldPos
9559                         WorldPos Pos
9560
9561                         //mt:if %s.Field == HUDSize
9562                         Size [2]int32
9563
9564                         //mt:if %s.Field == HUDZIndex
9565                         ZIndex int32
9566
9567                         //mt:if %s.Field == HUDText2
9568                         Text2 string
9569                 }))(obj)).Name) = string(local180)
9570         }
9571         if (*(*(struct {
9572                 ID HUDID
9573
9574                 Field HUDField
9575
9576                 //mt:if %s.Field == HUDPos
9577                 Pos [2]float32
9578
9579                 //mt:if %s.Field == HUDName
9580                 Name string
9581
9582                 //mt:if %s.Field == HUDScale
9583                 Scale [2]float32
9584
9585                 //mt:if %s.Field == HUDText
9586                 Text string
9587
9588                 //mt:if %s.Field == HUDNumber
9589                 Number uint32
9590
9591                 //mt:if %s.Field == HUDItem
9592                 Item uint32
9593
9594                 //mt:if %s.Field == HUDDir
9595                 Dir uint32
9596
9597                 //mt:if %s.Field == HUDAlign
9598                 Align [2]float32
9599
9600                 //mt:if %s.Field == HUDOffset
9601                 Offset [2]float32
9602
9603                 //mt:if %s.Field == HUDWorldPos
9604                 WorldPos Pos
9605
9606                 //mt:if %s.Field == HUDSize
9607                 Size [2]int32
9608
9609                 //mt:if %s.Field == HUDZIndex
9610                 ZIndex int32
9611
9612                 //mt:if %s.Field == HUDText2
9613                 Text2 string
9614         }))(obj)).Field == HUDScale {
9615                 for local182 := range (*(*(struct {
9616                         ID HUDID
9617
9618                         Field HUDField
9619
9620                         //mt:if %s.Field == HUDPos
9621                         Pos [2]float32
9622
9623                         //mt:if %s.Field == HUDName
9624                         Name string
9625
9626                         //mt:if %s.Field == HUDScale
9627                         Scale [2]float32
9628
9629                         //mt:if %s.Field == HUDText
9630                         Text string
9631
9632                         //mt:if %s.Field == HUDNumber
9633                         Number uint32
9634
9635                         //mt:if %s.Field == HUDItem
9636                         Item uint32
9637
9638                         //mt:if %s.Field == HUDDir
9639                         Dir uint32
9640
9641                         //mt:if %s.Field == HUDAlign
9642                         Align [2]float32
9643
9644                         //mt:if %s.Field == HUDOffset
9645                         Offset [2]float32
9646
9647                         //mt:if %s.Field == HUDWorldPos
9648                         WorldPos Pos
9649
9650                         //mt:if %s.Field == HUDSize
9651                         Size [2]int32
9652
9653                         //mt:if %s.Field == HUDZIndex
9654                         ZIndex int32
9655
9656                         //mt:if %s.Field == HUDText2
9657                         Text2 string
9658                 }))(obj)).Scale {
9659                         {
9660                                 p := &((*(*(struct {
9661                                         ID HUDID
9662
9663                                         Field HUDField
9664
9665                                         //mt:if %s.Field == HUDPos
9666                                         Pos [2]float32
9667
9668                                         //mt:if %s.Field == HUDName
9669                                         Name string
9670
9671                                         //mt:if %s.Field == HUDScale
9672                                         Scale [2]float32
9673
9674                                         //mt:if %s.Field == HUDText
9675                                         Text string
9676
9677                                         //mt:if %s.Field == HUDNumber
9678                                         Number uint32
9679
9680                                         //mt:if %s.Field == HUDItem
9681                                         Item uint32
9682
9683                                         //mt:if %s.Field == HUDDir
9684                                         Dir uint32
9685
9686                                         //mt:if %s.Field == HUDAlign
9687                                         Align [2]float32
9688
9689                                         //mt:if %s.Field == HUDOffset
9690                                         Offset [2]float32
9691
9692                                         //mt:if %s.Field == HUDWorldPos
9693                                         WorldPos Pos
9694
9695                                         //mt:if %s.Field == HUDSize
9696                                         Size [2]int32
9697
9698                                         //mt:if %s.Field == HUDZIndex
9699                                         ZIndex int32
9700
9701                                         //mt:if %s.Field == HUDText2
9702                                         Text2 string
9703                                 }))(obj)).Scale)[local182]
9704                                 *p = math.Float32frombits(read32(r))
9705                         }
9706                 }
9707         }
9708         if (*(*(struct {
9709                 ID HUDID
9710
9711                 Field HUDField
9712
9713                 //mt:if %s.Field == HUDPos
9714                 Pos [2]float32
9715
9716                 //mt:if %s.Field == HUDName
9717                 Name string
9718
9719                 //mt:if %s.Field == HUDScale
9720                 Scale [2]float32
9721
9722                 //mt:if %s.Field == HUDText
9723                 Text string
9724
9725                 //mt:if %s.Field == HUDNumber
9726                 Number uint32
9727
9728                 //mt:if %s.Field == HUDItem
9729                 Item uint32
9730
9731                 //mt:if %s.Field == HUDDir
9732                 Dir uint32
9733
9734                 //mt:if %s.Field == HUDAlign
9735                 Align [2]float32
9736
9737                 //mt:if %s.Field == HUDOffset
9738                 Offset [2]float32
9739
9740                 //mt:if %s.Field == HUDWorldPos
9741                 WorldPos Pos
9742
9743                 //mt:if %s.Field == HUDSize
9744                 Size [2]int32
9745
9746                 //mt:if %s.Field == HUDZIndex
9747                 ZIndex int32
9748
9749                 //mt:if %s.Field == HUDText2
9750                 Text2 string
9751         }))(obj)).Field == HUDText {
9752                 var local183 []uint8
9753                 var local184 uint16
9754                 {
9755                         p := &local184
9756                         *p = read16(r)
9757                 }
9758                 (local183) = make([]uint8, local184)
9759                 {
9760                         _, err := io.ReadFull(r, (local183)[:])
9761                         chk(err)
9762                 }
9763                 ((*(*(struct {
9764                         ID HUDID
9765
9766                         Field HUDField
9767
9768                         //mt:if %s.Field == HUDPos
9769                         Pos [2]float32
9770
9771                         //mt:if %s.Field == HUDName
9772                         Name string
9773
9774                         //mt:if %s.Field == HUDScale
9775                         Scale [2]float32
9776
9777                         //mt:if %s.Field == HUDText
9778                         Text string
9779
9780                         //mt:if %s.Field == HUDNumber
9781                         Number uint32
9782
9783                         //mt:if %s.Field == HUDItem
9784                         Item uint32
9785
9786                         //mt:if %s.Field == HUDDir
9787                         Dir uint32
9788
9789                         //mt:if %s.Field == HUDAlign
9790                         Align [2]float32
9791
9792                         //mt:if %s.Field == HUDOffset
9793                         Offset [2]float32
9794
9795                         //mt:if %s.Field == HUDWorldPos
9796                         WorldPos Pos
9797
9798                         //mt:if %s.Field == HUDSize
9799                         Size [2]int32
9800
9801                         //mt:if %s.Field == HUDZIndex
9802                         ZIndex int32
9803
9804                         //mt:if %s.Field == HUDText2
9805                         Text2 string
9806                 }))(obj)).Text) = string(local183)
9807         }
9808         if (*(*(struct {
9809                 ID HUDID
9810
9811                 Field HUDField
9812
9813                 //mt:if %s.Field == HUDPos
9814                 Pos [2]float32
9815
9816                 //mt:if %s.Field == HUDName
9817                 Name string
9818
9819                 //mt:if %s.Field == HUDScale
9820                 Scale [2]float32
9821
9822                 //mt:if %s.Field == HUDText
9823                 Text string
9824
9825                 //mt:if %s.Field == HUDNumber
9826                 Number uint32
9827
9828                 //mt:if %s.Field == HUDItem
9829                 Item uint32
9830
9831                 //mt:if %s.Field == HUDDir
9832                 Dir uint32
9833
9834                 //mt:if %s.Field == HUDAlign
9835                 Align [2]float32
9836
9837                 //mt:if %s.Field == HUDOffset
9838                 Offset [2]float32
9839
9840                 //mt:if %s.Field == HUDWorldPos
9841                 WorldPos Pos
9842
9843                 //mt:if %s.Field == HUDSize
9844                 Size [2]int32
9845
9846                 //mt:if %s.Field == HUDZIndex
9847                 ZIndex int32
9848
9849                 //mt:if %s.Field == HUDText2
9850                 Text2 string
9851         }))(obj)).Field == HUDNumber {
9852                 {
9853                         p := &(*(*(struct {
9854                                 ID HUDID
9855
9856                                 Field HUDField
9857
9858                                 //mt:if %s.Field == HUDPos
9859                                 Pos [2]float32
9860
9861                                 //mt:if %s.Field == HUDName
9862                                 Name string
9863
9864                                 //mt:if %s.Field == HUDScale
9865                                 Scale [2]float32
9866
9867                                 //mt:if %s.Field == HUDText
9868                                 Text string
9869
9870                                 //mt:if %s.Field == HUDNumber
9871                                 Number uint32
9872
9873                                 //mt:if %s.Field == HUDItem
9874                                 Item uint32
9875
9876                                 //mt:if %s.Field == HUDDir
9877                                 Dir uint32
9878
9879                                 //mt:if %s.Field == HUDAlign
9880                                 Align [2]float32
9881
9882                                 //mt:if %s.Field == HUDOffset
9883                                 Offset [2]float32
9884
9885                                 //mt:if %s.Field == HUDWorldPos
9886                                 WorldPos Pos
9887
9888                                 //mt:if %s.Field == HUDSize
9889                                 Size [2]int32
9890
9891                                 //mt:if %s.Field == HUDZIndex
9892                                 ZIndex int32
9893
9894                                 //mt:if %s.Field == HUDText2
9895                                 Text2 string
9896                         }))(obj)).Number
9897                         *p = read32(r)
9898                 }
9899         }
9900         if (*(*(struct {
9901                 ID HUDID
9902
9903                 Field HUDField
9904
9905                 //mt:if %s.Field == HUDPos
9906                 Pos [2]float32
9907
9908                 //mt:if %s.Field == HUDName
9909                 Name string
9910
9911                 //mt:if %s.Field == HUDScale
9912                 Scale [2]float32
9913
9914                 //mt:if %s.Field == HUDText
9915                 Text string
9916
9917                 //mt:if %s.Field == HUDNumber
9918                 Number uint32
9919
9920                 //mt:if %s.Field == HUDItem
9921                 Item uint32
9922
9923                 //mt:if %s.Field == HUDDir
9924                 Dir uint32
9925
9926                 //mt:if %s.Field == HUDAlign
9927                 Align [2]float32
9928
9929                 //mt:if %s.Field == HUDOffset
9930                 Offset [2]float32
9931
9932                 //mt:if %s.Field == HUDWorldPos
9933                 WorldPos Pos
9934
9935                 //mt:if %s.Field == HUDSize
9936                 Size [2]int32
9937
9938                 //mt:if %s.Field == HUDZIndex
9939                 ZIndex int32
9940
9941                 //mt:if %s.Field == HUDText2
9942                 Text2 string
9943         }))(obj)).Field == HUDItem {
9944                 {
9945                         p := &(*(*(struct {
9946                                 ID HUDID
9947
9948                                 Field HUDField
9949
9950                                 //mt:if %s.Field == HUDPos
9951                                 Pos [2]float32
9952
9953                                 //mt:if %s.Field == HUDName
9954                                 Name string
9955
9956                                 //mt:if %s.Field == HUDScale
9957                                 Scale [2]float32
9958
9959                                 //mt:if %s.Field == HUDText
9960                                 Text string
9961
9962                                 //mt:if %s.Field == HUDNumber
9963                                 Number uint32
9964
9965                                 //mt:if %s.Field == HUDItem
9966                                 Item uint32
9967
9968                                 //mt:if %s.Field == HUDDir
9969                                 Dir uint32
9970
9971                                 //mt:if %s.Field == HUDAlign
9972                                 Align [2]float32
9973
9974                                 //mt:if %s.Field == HUDOffset
9975                                 Offset [2]float32
9976
9977                                 //mt:if %s.Field == HUDWorldPos
9978                                 WorldPos Pos
9979
9980                                 //mt:if %s.Field == HUDSize
9981                                 Size [2]int32
9982
9983                                 //mt:if %s.Field == HUDZIndex
9984                                 ZIndex int32
9985
9986                                 //mt:if %s.Field == HUDText2
9987                                 Text2 string
9988                         }))(obj)).Item
9989                         *p = read32(r)
9990                 }
9991         }
9992         if (*(*(struct {
9993                 ID HUDID
9994
9995                 Field HUDField
9996
9997                 //mt:if %s.Field == HUDPos
9998                 Pos [2]float32
9999
10000                 //mt:if %s.Field == HUDName
10001                 Name string
10002
10003                 //mt:if %s.Field == HUDScale
10004                 Scale [2]float32
10005
10006                 //mt:if %s.Field == HUDText
10007                 Text string
10008
10009                 //mt:if %s.Field == HUDNumber
10010                 Number uint32
10011
10012                 //mt:if %s.Field == HUDItem
10013                 Item uint32
10014
10015                 //mt:if %s.Field == HUDDir
10016                 Dir uint32
10017
10018                 //mt:if %s.Field == HUDAlign
10019                 Align [2]float32
10020
10021                 //mt:if %s.Field == HUDOffset
10022                 Offset [2]float32
10023
10024                 //mt:if %s.Field == HUDWorldPos
10025                 WorldPos Pos
10026
10027                 //mt:if %s.Field == HUDSize
10028                 Size [2]int32
10029
10030                 //mt:if %s.Field == HUDZIndex
10031                 ZIndex int32
10032
10033                 //mt:if %s.Field == HUDText2
10034                 Text2 string
10035         }))(obj)).Field == HUDDir {
10036                 {
10037                         p := &(*(*(struct {
10038                                 ID HUDID
10039
10040                                 Field HUDField
10041
10042                                 //mt:if %s.Field == HUDPos
10043                                 Pos [2]float32
10044
10045                                 //mt:if %s.Field == HUDName
10046                                 Name string
10047
10048                                 //mt:if %s.Field == HUDScale
10049                                 Scale [2]float32
10050
10051                                 //mt:if %s.Field == HUDText
10052                                 Text string
10053
10054                                 //mt:if %s.Field == HUDNumber
10055                                 Number uint32
10056
10057                                 //mt:if %s.Field == HUDItem
10058                                 Item uint32
10059
10060                                 //mt:if %s.Field == HUDDir
10061                                 Dir uint32
10062
10063                                 //mt:if %s.Field == HUDAlign
10064                                 Align [2]float32
10065
10066                                 //mt:if %s.Field == HUDOffset
10067                                 Offset [2]float32
10068
10069                                 //mt:if %s.Field == HUDWorldPos
10070                                 WorldPos Pos
10071
10072                                 //mt:if %s.Field == HUDSize
10073                                 Size [2]int32
10074
10075                                 //mt:if %s.Field == HUDZIndex
10076                                 ZIndex int32
10077
10078                                 //mt:if %s.Field == HUDText2
10079                                 Text2 string
10080                         }))(obj)).Dir
10081                         *p = read32(r)
10082                 }
10083         }
10084         if (*(*(struct {
10085                 ID HUDID
10086
10087                 Field HUDField
10088
10089                 //mt:if %s.Field == HUDPos
10090                 Pos [2]float32
10091
10092                 //mt:if %s.Field == HUDName
10093                 Name string
10094
10095                 //mt:if %s.Field == HUDScale
10096                 Scale [2]float32
10097
10098                 //mt:if %s.Field == HUDText
10099                 Text string
10100
10101                 //mt:if %s.Field == HUDNumber
10102                 Number uint32
10103
10104                 //mt:if %s.Field == HUDItem
10105                 Item uint32
10106
10107                 //mt:if %s.Field == HUDDir
10108                 Dir uint32
10109
10110                 //mt:if %s.Field == HUDAlign
10111                 Align [2]float32
10112
10113                 //mt:if %s.Field == HUDOffset
10114                 Offset [2]float32
10115
10116                 //mt:if %s.Field == HUDWorldPos
10117                 WorldPos Pos
10118
10119                 //mt:if %s.Field == HUDSize
10120                 Size [2]int32
10121
10122                 //mt:if %s.Field == HUDZIndex
10123                 ZIndex int32
10124
10125                 //mt:if %s.Field == HUDText2
10126                 Text2 string
10127         }))(obj)).Field == HUDAlign {
10128                 for local185 := range (*(*(struct {
10129                         ID HUDID
10130
10131                         Field HUDField
10132
10133                         //mt:if %s.Field == HUDPos
10134                         Pos [2]float32
10135
10136                         //mt:if %s.Field == HUDName
10137                         Name string
10138
10139                         //mt:if %s.Field == HUDScale
10140                         Scale [2]float32
10141
10142                         //mt:if %s.Field == HUDText
10143                         Text string
10144
10145                         //mt:if %s.Field == HUDNumber
10146                         Number uint32
10147
10148                         //mt:if %s.Field == HUDItem
10149                         Item uint32
10150
10151                         //mt:if %s.Field == HUDDir
10152                         Dir uint32
10153
10154                         //mt:if %s.Field == HUDAlign
10155                         Align [2]float32
10156
10157                         //mt:if %s.Field == HUDOffset
10158                         Offset [2]float32
10159
10160                         //mt:if %s.Field == HUDWorldPos
10161                         WorldPos Pos
10162
10163                         //mt:if %s.Field == HUDSize
10164                         Size [2]int32
10165
10166                         //mt:if %s.Field == HUDZIndex
10167                         ZIndex int32
10168
10169                         //mt:if %s.Field == HUDText2
10170                         Text2 string
10171                 }))(obj)).Align {
10172                         {
10173                                 p := &((*(*(struct {
10174                                         ID HUDID
10175
10176                                         Field HUDField
10177
10178                                         //mt:if %s.Field == HUDPos
10179                                         Pos [2]float32
10180
10181                                         //mt:if %s.Field == HUDName
10182                                         Name string
10183
10184                                         //mt:if %s.Field == HUDScale
10185                                         Scale [2]float32
10186
10187                                         //mt:if %s.Field == HUDText
10188                                         Text string
10189
10190                                         //mt:if %s.Field == HUDNumber
10191                                         Number uint32
10192
10193                                         //mt:if %s.Field == HUDItem
10194                                         Item uint32
10195
10196                                         //mt:if %s.Field == HUDDir
10197                                         Dir uint32
10198
10199                                         //mt:if %s.Field == HUDAlign
10200                                         Align [2]float32
10201
10202                                         //mt:if %s.Field == HUDOffset
10203                                         Offset [2]float32
10204
10205                                         //mt:if %s.Field == HUDWorldPos
10206                                         WorldPos Pos
10207
10208                                         //mt:if %s.Field == HUDSize
10209                                         Size [2]int32
10210
10211                                         //mt:if %s.Field == HUDZIndex
10212                                         ZIndex int32
10213
10214                                         //mt:if %s.Field == HUDText2
10215                                         Text2 string
10216                                 }))(obj)).Align)[local185]
10217                                 *p = math.Float32frombits(read32(r))
10218                         }
10219                 }
10220         }
10221         if (*(*(struct {
10222                 ID HUDID
10223
10224                 Field HUDField
10225
10226                 //mt:if %s.Field == HUDPos
10227                 Pos [2]float32
10228
10229                 //mt:if %s.Field == HUDName
10230                 Name string
10231
10232                 //mt:if %s.Field == HUDScale
10233                 Scale [2]float32
10234
10235                 //mt:if %s.Field == HUDText
10236                 Text string
10237
10238                 //mt:if %s.Field == HUDNumber
10239                 Number uint32
10240
10241                 //mt:if %s.Field == HUDItem
10242                 Item uint32
10243
10244                 //mt:if %s.Field == HUDDir
10245                 Dir uint32
10246
10247                 //mt:if %s.Field == HUDAlign
10248                 Align [2]float32
10249
10250                 //mt:if %s.Field == HUDOffset
10251                 Offset [2]float32
10252
10253                 //mt:if %s.Field == HUDWorldPos
10254                 WorldPos Pos
10255
10256                 //mt:if %s.Field == HUDSize
10257                 Size [2]int32
10258
10259                 //mt:if %s.Field == HUDZIndex
10260                 ZIndex int32
10261
10262                 //mt:if %s.Field == HUDText2
10263                 Text2 string
10264         }))(obj)).Field == HUDOffset {
10265                 for local186 := range (*(*(struct {
10266                         ID HUDID
10267
10268                         Field HUDField
10269
10270                         //mt:if %s.Field == HUDPos
10271                         Pos [2]float32
10272
10273                         //mt:if %s.Field == HUDName
10274                         Name string
10275
10276                         //mt:if %s.Field == HUDScale
10277                         Scale [2]float32
10278
10279                         //mt:if %s.Field == HUDText
10280                         Text string
10281
10282                         //mt:if %s.Field == HUDNumber
10283                         Number uint32
10284
10285                         //mt:if %s.Field == HUDItem
10286                         Item uint32
10287
10288                         //mt:if %s.Field == HUDDir
10289                         Dir uint32
10290
10291                         //mt:if %s.Field == HUDAlign
10292                         Align [2]float32
10293
10294                         //mt:if %s.Field == HUDOffset
10295                         Offset [2]float32
10296
10297                         //mt:if %s.Field == HUDWorldPos
10298                         WorldPos Pos
10299
10300                         //mt:if %s.Field == HUDSize
10301                         Size [2]int32
10302
10303                         //mt:if %s.Field == HUDZIndex
10304                         ZIndex int32
10305
10306                         //mt:if %s.Field == HUDText2
10307                         Text2 string
10308                 }))(obj)).Offset {
10309                         {
10310                                 p := &((*(*(struct {
10311                                         ID HUDID
10312
10313                                         Field HUDField
10314
10315                                         //mt:if %s.Field == HUDPos
10316                                         Pos [2]float32
10317
10318                                         //mt:if %s.Field == HUDName
10319                                         Name string
10320
10321                                         //mt:if %s.Field == HUDScale
10322                                         Scale [2]float32
10323
10324                                         //mt:if %s.Field == HUDText
10325                                         Text string
10326
10327                                         //mt:if %s.Field == HUDNumber
10328                                         Number uint32
10329
10330                                         //mt:if %s.Field == HUDItem
10331                                         Item uint32
10332
10333                                         //mt:if %s.Field == HUDDir
10334                                         Dir uint32
10335
10336                                         //mt:if %s.Field == HUDAlign
10337                                         Align [2]float32
10338
10339                                         //mt:if %s.Field == HUDOffset
10340                                         Offset [2]float32
10341
10342                                         //mt:if %s.Field == HUDWorldPos
10343                                         WorldPos Pos
10344
10345                                         //mt:if %s.Field == HUDSize
10346                                         Size [2]int32
10347
10348                                         //mt:if %s.Field == HUDZIndex
10349                                         ZIndex int32
10350
10351                                         //mt:if %s.Field == HUDText2
10352                                         Text2 string
10353                                 }))(obj)).Offset)[local186]
10354                                 *p = math.Float32frombits(read32(r))
10355                         }
10356                 }
10357         }
10358         if (*(*(struct {
10359                 ID HUDID
10360
10361                 Field HUDField
10362
10363                 //mt:if %s.Field == HUDPos
10364                 Pos [2]float32
10365
10366                 //mt:if %s.Field == HUDName
10367                 Name string
10368
10369                 //mt:if %s.Field == HUDScale
10370                 Scale [2]float32
10371
10372                 //mt:if %s.Field == HUDText
10373                 Text string
10374
10375                 //mt:if %s.Field == HUDNumber
10376                 Number uint32
10377
10378                 //mt:if %s.Field == HUDItem
10379                 Item uint32
10380
10381                 //mt:if %s.Field == HUDDir
10382                 Dir uint32
10383
10384                 //mt:if %s.Field == HUDAlign
10385                 Align [2]float32
10386
10387                 //mt:if %s.Field == HUDOffset
10388                 Offset [2]float32
10389
10390                 //mt:if %s.Field == HUDWorldPos
10391                 WorldPos Pos
10392
10393                 //mt:if %s.Field == HUDSize
10394                 Size [2]int32
10395
10396                 //mt:if %s.Field == HUDZIndex
10397                 ZIndex int32
10398
10399                 //mt:if %s.Field == HUDText2
10400                 Text2 string
10401         }))(obj)).Field == HUDWorldPos {
10402                 if err := pcall(func() {
10403                         ((*(*(struct {
10404                                 ID HUDID
10405
10406                                 Field HUDField
10407
10408                                 //mt:if %s.Field == HUDPos
10409                                 Pos [2]float32
10410
10411                                 //mt:if %s.Field == HUDName
10412                                 Name string
10413
10414                                 //mt:if %s.Field == HUDScale
10415                                 Scale [2]float32
10416
10417                                 //mt:if %s.Field == HUDText
10418                                 Text string
10419
10420                                 //mt:if %s.Field == HUDNumber
10421                                 Number uint32
10422
10423                                 //mt:if %s.Field == HUDItem
10424                                 Item uint32
10425
10426                                 //mt:if %s.Field == HUDDir
10427                                 Dir uint32
10428
10429                                 //mt:if %s.Field == HUDAlign
10430                                 Align [2]float32
10431
10432                                 //mt:if %s.Field == HUDOffset
10433                                 Offset [2]float32
10434
10435                                 //mt:if %s.Field == HUDWorldPos
10436                                 WorldPos Pos
10437
10438                                 //mt:if %s.Field == HUDSize
10439                                 Size [2]int32
10440
10441                                 //mt:if %s.Field == HUDZIndex
10442                                 ZIndex int32
10443
10444                                 //mt:if %s.Field == HUDText2
10445                                 Text2 string
10446                         }))(obj)).WorldPos).Deserialize(r)
10447                 }); err != nil {
10448                         if err == io.EOF {
10449                                 chk(io.EOF)
10450                         }
10451                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
10452                 }
10453         }
10454         if (*(*(struct {
10455                 ID HUDID
10456
10457                 Field HUDField
10458
10459                 //mt:if %s.Field == HUDPos
10460                 Pos [2]float32
10461
10462                 //mt:if %s.Field == HUDName
10463                 Name string
10464
10465                 //mt:if %s.Field == HUDScale
10466                 Scale [2]float32
10467
10468                 //mt:if %s.Field == HUDText
10469                 Text string
10470
10471                 //mt:if %s.Field == HUDNumber
10472                 Number uint32
10473
10474                 //mt:if %s.Field == HUDItem
10475                 Item uint32
10476
10477                 //mt:if %s.Field == HUDDir
10478                 Dir uint32
10479
10480                 //mt:if %s.Field == HUDAlign
10481                 Align [2]float32
10482
10483                 //mt:if %s.Field == HUDOffset
10484                 Offset [2]float32
10485
10486                 //mt:if %s.Field == HUDWorldPos
10487                 WorldPos Pos
10488
10489                 //mt:if %s.Field == HUDSize
10490                 Size [2]int32
10491
10492                 //mt:if %s.Field == HUDZIndex
10493                 ZIndex int32
10494
10495                 //mt:if %s.Field == HUDText2
10496                 Text2 string
10497         }))(obj)).Field == HUDSize {
10498                 for local187 := range (*(*(struct {
10499                         ID HUDID
10500
10501                         Field HUDField
10502
10503                         //mt:if %s.Field == HUDPos
10504                         Pos [2]float32
10505
10506                         //mt:if %s.Field == HUDName
10507                         Name string
10508
10509                         //mt:if %s.Field == HUDScale
10510                         Scale [2]float32
10511
10512                         //mt:if %s.Field == HUDText
10513                         Text string
10514
10515                         //mt:if %s.Field == HUDNumber
10516                         Number uint32
10517
10518                         //mt:if %s.Field == HUDItem
10519                         Item uint32
10520
10521                         //mt:if %s.Field == HUDDir
10522                         Dir uint32
10523
10524                         //mt:if %s.Field == HUDAlign
10525                         Align [2]float32
10526
10527                         //mt:if %s.Field == HUDOffset
10528                         Offset [2]float32
10529
10530                         //mt:if %s.Field == HUDWorldPos
10531                         WorldPos Pos
10532
10533                         //mt:if %s.Field == HUDSize
10534                         Size [2]int32
10535
10536                         //mt:if %s.Field == HUDZIndex
10537                         ZIndex int32
10538
10539                         //mt:if %s.Field == HUDText2
10540                         Text2 string
10541                 }))(obj)).Size {
10542                         {
10543                                 p := &((*(*(struct {
10544                                         ID HUDID
10545
10546                                         Field HUDField
10547
10548                                         //mt:if %s.Field == HUDPos
10549                                         Pos [2]float32
10550
10551                                         //mt:if %s.Field == HUDName
10552                                         Name string
10553
10554                                         //mt:if %s.Field == HUDScale
10555                                         Scale [2]float32
10556
10557                                         //mt:if %s.Field == HUDText
10558                                         Text string
10559
10560                                         //mt:if %s.Field == HUDNumber
10561                                         Number uint32
10562
10563                                         //mt:if %s.Field == HUDItem
10564                                         Item uint32
10565
10566                                         //mt:if %s.Field == HUDDir
10567                                         Dir uint32
10568
10569                                         //mt:if %s.Field == HUDAlign
10570                                         Align [2]float32
10571
10572                                         //mt:if %s.Field == HUDOffset
10573                                         Offset [2]float32
10574
10575                                         //mt:if %s.Field == HUDWorldPos
10576                                         WorldPos Pos
10577
10578                                         //mt:if %s.Field == HUDSize
10579                                         Size [2]int32
10580
10581                                         //mt:if %s.Field == HUDZIndex
10582                                         ZIndex int32
10583
10584                                         //mt:if %s.Field == HUDText2
10585                                         Text2 string
10586                                 }))(obj)).Size)[local187]
10587                                 *p = int32(read32(r))
10588                         }
10589                 }
10590         }
10591         if (*(*(struct {
10592                 ID HUDID
10593
10594                 Field HUDField
10595
10596                 //mt:if %s.Field == HUDPos
10597                 Pos [2]float32
10598
10599                 //mt:if %s.Field == HUDName
10600                 Name string
10601
10602                 //mt:if %s.Field == HUDScale
10603                 Scale [2]float32
10604
10605                 //mt:if %s.Field == HUDText
10606                 Text string
10607
10608                 //mt:if %s.Field == HUDNumber
10609                 Number uint32
10610
10611                 //mt:if %s.Field == HUDItem
10612                 Item uint32
10613
10614                 //mt:if %s.Field == HUDDir
10615                 Dir uint32
10616
10617                 //mt:if %s.Field == HUDAlign
10618                 Align [2]float32
10619
10620                 //mt:if %s.Field == HUDOffset
10621                 Offset [2]float32
10622
10623                 //mt:if %s.Field == HUDWorldPos
10624                 WorldPos Pos
10625
10626                 //mt:if %s.Field == HUDSize
10627                 Size [2]int32
10628
10629                 //mt:if %s.Field == HUDZIndex
10630                 ZIndex int32
10631
10632                 //mt:if %s.Field == HUDText2
10633                 Text2 string
10634         }))(obj)).Field == HUDZIndex {
10635                 {
10636                         p := &(*(*(struct {
10637                                 ID HUDID
10638
10639                                 Field HUDField
10640
10641                                 //mt:if %s.Field == HUDPos
10642                                 Pos [2]float32
10643
10644                                 //mt:if %s.Field == HUDName
10645                                 Name string
10646
10647                                 //mt:if %s.Field == HUDScale
10648                                 Scale [2]float32
10649
10650                                 //mt:if %s.Field == HUDText
10651                                 Text string
10652
10653                                 //mt:if %s.Field == HUDNumber
10654                                 Number uint32
10655
10656                                 //mt:if %s.Field == HUDItem
10657                                 Item uint32
10658
10659                                 //mt:if %s.Field == HUDDir
10660                                 Dir uint32
10661
10662                                 //mt:if %s.Field == HUDAlign
10663                                 Align [2]float32
10664
10665                                 //mt:if %s.Field == HUDOffset
10666                                 Offset [2]float32
10667
10668                                 //mt:if %s.Field == HUDWorldPos
10669                                 WorldPos Pos
10670
10671                                 //mt:if %s.Field == HUDSize
10672                                 Size [2]int32
10673
10674                                 //mt:if %s.Field == HUDZIndex
10675                                 ZIndex int32
10676
10677                                 //mt:if %s.Field == HUDText2
10678                                 Text2 string
10679                         }))(obj)).ZIndex
10680                         *p = int32(read32(r))
10681                 }
10682         }
10683         if (*(*(struct {
10684                 ID HUDID
10685
10686                 Field HUDField
10687
10688                 //mt:if %s.Field == HUDPos
10689                 Pos [2]float32
10690
10691                 //mt:if %s.Field == HUDName
10692                 Name string
10693
10694                 //mt:if %s.Field == HUDScale
10695                 Scale [2]float32
10696
10697                 //mt:if %s.Field == HUDText
10698                 Text string
10699
10700                 //mt:if %s.Field == HUDNumber
10701                 Number uint32
10702
10703                 //mt:if %s.Field == HUDItem
10704                 Item uint32
10705
10706                 //mt:if %s.Field == HUDDir
10707                 Dir uint32
10708
10709                 //mt:if %s.Field == HUDAlign
10710                 Align [2]float32
10711
10712                 //mt:if %s.Field == HUDOffset
10713                 Offset [2]float32
10714
10715                 //mt:if %s.Field == HUDWorldPos
10716                 WorldPos Pos
10717
10718                 //mt:if %s.Field == HUDSize
10719                 Size [2]int32
10720
10721                 //mt:if %s.Field == HUDZIndex
10722                 ZIndex int32
10723
10724                 //mt:if %s.Field == HUDText2
10725                 Text2 string
10726         }))(obj)).Field == HUDText2 {
10727                 var local188 []uint8
10728                 var local189 uint16
10729                 {
10730                         p := &local189
10731                         *p = read16(r)
10732                 }
10733                 (local188) = make([]uint8, local189)
10734                 {
10735                         _, err := io.ReadFull(r, (local188)[:])
10736                         chk(err)
10737                 }
10738                 ((*(*(struct {
10739                         ID HUDID
10740
10741                         Field HUDField
10742
10743                         //mt:if %s.Field == HUDPos
10744                         Pos [2]float32
10745
10746                         //mt:if %s.Field == HUDName
10747                         Name string
10748
10749                         //mt:if %s.Field == HUDScale
10750                         Scale [2]float32
10751
10752                         //mt:if %s.Field == HUDText
10753                         Text string
10754
10755                         //mt:if %s.Field == HUDNumber
10756                         Number uint32
10757
10758                         //mt:if %s.Field == HUDItem
10759                         Item uint32
10760
10761                         //mt:if %s.Field == HUDDir
10762                         Dir uint32
10763
10764                         //mt:if %s.Field == HUDAlign
10765                         Align [2]float32
10766
10767                         //mt:if %s.Field == HUDOffset
10768                         Offset [2]float32
10769
10770                         //mt:if %s.Field == HUDWorldPos
10771                         WorldPos Pos
10772
10773                         //mt:if %s.Field == HUDSize
10774                         Size [2]int32
10775
10776                         //mt:if %s.Field == HUDZIndex
10777                         ZIndex int32
10778
10779                         //mt:if %s.Field == HUDText2
10780                         Text2 string
10781                 }))(obj)).Text2) = string(local188)
10782         }
10783 }
10784
10785 func (obj *ToCltHUDFlags) Serialize(w io.Writer) {
10786         if err := pcall(func() {
10787                 ((*(*(struct {
10788                         // &^= Mask
10789                         // |= Flags
10790                         Flags, Mask HUDFlags
10791                 }))(obj)).Flags).Serialize(w)
10792         }); err != nil {
10793                 if err == io.EOF {
10794                         chk(io.EOF)
10795                 }
10796                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10797         }
10798         if err := pcall(func() {
10799                 ((*(*(struct {
10800                         // &^= Mask
10801                         // |= Flags
10802                         Flags, Mask HUDFlags
10803                 }))(obj)).Mask).Serialize(w)
10804         }); err != nil {
10805                 if err == io.EOF {
10806                         chk(io.EOF)
10807                 }
10808                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10809         }
10810 }
10811
10812 func (obj *ToCltHUDFlags) Deserialize(r io.Reader) {
10813         if err := pcall(func() {
10814                 ((*(*(struct {
10815                         // &^= Mask
10816                         // |= Flags
10817                         Flags, Mask HUDFlags
10818                 }))(obj)).Flags).Deserialize(r)
10819         }); err != nil {
10820                 if err == io.EOF {
10821                         chk(io.EOF)
10822                 }
10823                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10824         }
10825         if err := pcall(func() {
10826                 ((*(*(struct {
10827                         // &^= Mask
10828                         // |= Flags
10829                         Flags, Mask HUDFlags
10830                 }))(obj)).Mask).Deserialize(r)
10831         }); err != nil {
10832                 if err == io.EOF {
10833                         chk(io.EOF)
10834                 }
10835                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10836         }
10837 }
10838
10839 func (obj *ToCltSetHotbarParam) Serialize(w io.Writer) {
10840         if err := pcall(func() {
10841                 ((*(*(struct {
10842                         Param HotbarParam
10843
10844                         //mt:if %s.Param == HotbarSize
10845                         //mt:const uint16(4) // Size of Size field.
10846                         Size int32
10847
10848                         //mt:if %s.Param != HotbarSize
10849                         Img Texture
10850                 }))(obj)).Param).Serialize(w)
10851         }); err != nil {
10852                 if err == io.EOF {
10853                         chk(io.EOF)
10854                 }
10855                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HotbarParam", err))
10856         }
10857         if (*(*(struct {
10858                 Param HotbarParam
10859
10860                 //mt:if %s.Param == HotbarSize
10861                 //mt:const uint16(4) // Size of Size field.
10862                 Size int32
10863
10864                 //mt:if %s.Param != HotbarSize
10865                 Img Texture
10866         }))(obj)).Param == HotbarSize {
10867                 {
10868                         local190 := uint16(4) // Size of Size field.
10869                         {
10870                                 x := local190
10871                                 write16(w, uint16(x))
10872                         }
10873                 }
10874                 {
10875                         x := (*(*(struct {
10876                                 Param HotbarParam
10877
10878                                 //mt:if %s.Param == HotbarSize
10879                                 //mt:const uint16(4) // Size of Size field.
10880                                 Size int32
10881
10882                                 //mt:if %s.Param != HotbarSize
10883                                 Img Texture
10884                         }))(obj)).Size
10885                         write32(w, uint32(x))
10886                 }
10887         }
10888         if (*(*(struct {
10889                 Param HotbarParam
10890
10891                 //mt:if %s.Param == HotbarSize
10892                 //mt:const uint16(4) // Size of Size field.
10893                 Size int32
10894
10895                 //mt:if %s.Param != HotbarSize
10896                 Img Texture
10897         }))(obj)).Param != HotbarSize {
10898                 if err := pcall(func() {
10899                         ((*(*(struct {
10900                                 Param HotbarParam
10901
10902                                 //mt:if %s.Param == HotbarSize
10903                                 //mt:const uint16(4) // Size of Size field.
10904                                 Size int32
10905
10906                                 //mt:if %s.Param != HotbarSize
10907                                 Img Texture
10908                         }))(obj)).Img).Serialize(w)
10909                 }); err != nil {
10910                         if err == io.EOF {
10911                                 chk(io.EOF)
10912                         }
10913                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
10914                 }
10915         }
10916 }
10917
10918 func (obj *ToCltSetHotbarParam) Deserialize(r io.Reader) {
10919         if err := pcall(func() {
10920                 ((*(*(struct {
10921                         Param HotbarParam
10922
10923                         //mt:if %s.Param == HotbarSize
10924                         //mt:const uint16(4) // Size of Size field.
10925                         Size int32
10926
10927                         //mt:if %s.Param != HotbarSize
10928                         Img Texture
10929                 }))(obj)).Param).Deserialize(r)
10930         }); err != nil {
10931                 if err == io.EOF {
10932                         chk(io.EOF)
10933                 }
10934                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HotbarParam", err))
10935         }
10936         if (*(*(struct {
10937                 Param HotbarParam
10938
10939                 //mt:if %s.Param == HotbarSize
10940                 //mt:const uint16(4) // Size of Size field.
10941                 Size int32
10942
10943                 //mt:if %s.Param != HotbarSize
10944                 Img Texture
10945         }))(obj)).Param == HotbarSize {
10946                 {
10947                         var local191 uint16
10948                         local192 := uint16(4) // Size of Size field.
10949                         {
10950                                 p := &local191
10951                                 *p = read16(r)
10952                         }
10953                         if local191 != local192 {
10954                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local191))
10955                         }
10956                 }
10957                 {
10958                         p := &(*(*(struct {
10959                                 Param HotbarParam
10960
10961                                 //mt:if %s.Param == HotbarSize
10962                                 //mt:const uint16(4) // Size of Size field.
10963                                 Size int32
10964
10965                                 //mt:if %s.Param != HotbarSize
10966                                 Img Texture
10967                         }))(obj)).Size
10968                         *p = int32(read32(r))
10969                 }
10970         }
10971         if (*(*(struct {
10972                 Param HotbarParam
10973
10974                 //mt:if %s.Param == HotbarSize
10975                 //mt:const uint16(4) // Size of Size field.
10976                 Size int32
10977
10978                 //mt:if %s.Param != HotbarSize
10979                 Img Texture
10980         }))(obj)).Param != HotbarSize {
10981                 if err := pcall(func() {
10982                         ((*(*(struct {
10983                                 Param HotbarParam
10984
10985                                 //mt:if %s.Param == HotbarSize
10986                                 //mt:const uint16(4) // Size of Size field.
10987                                 Size int32
10988
10989                                 //mt:if %s.Param != HotbarSize
10990                                 Img Texture
10991                         }))(obj)).Img).Deserialize(r)
10992                 }); err != nil {
10993                         if err == io.EOF {
10994                                 chk(io.EOF)
10995                         }
10996                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
10997                 }
10998         }
10999 }
11000
11001 func (obj *ToCltBreath) Serialize(w io.Writer) {
11002         {
11003                 x := (*(*(struct {
11004                         Breath uint16
11005                 }))(obj)).Breath
11006                 write16(w, uint16(x))
11007         }
11008 }
11009
11010 func (obj *ToCltBreath) Deserialize(r io.Reader) {
11011         {
11012                 p := &(*(*(struct {
11013                         Breath uint16
11014                 }))(obj)).Breath
11015                 *p = read16(r)
11016         }
11017 }
11018
11019 func (obj *ToCltSkyParams) Serialize(w io.Writer) {
11020         {
11021                 x := (*(*(struct {
11022                         BgColor     color.NRGBA
11023                         Type        string
11024                         Clouds      bool
11025                         SunFogTint  color.NRGBA
11026                         MoonFogTint color.NRGBA
11027                         FogTintType string
11028
11029                         //mt:if %s.Type == "skybox"
11030                         Textures []Texture
11031
11032                         //mt:if %s.Type == "regular"
11033                         DaySky, DayHorizon,
11034                         DawnSky, DawnHorizon,
11035                         NightSky, NightHorizon,
11036                         Indoor color.NRGBA
11037                 }))(obj)).BgColor
11038                 w.Write([]byte{x.A, x.R, x.G, x.B})
11039         }
11040         if len(([]byte((*(*(struct {
11041                 BgColor     color.NRGBA
11042                 Type        string
11043                 Clouds      bool
11044                 SunFogTint  color.NRGBA
11045                 MoonFogTint color.NRGBA
11046                 FogTintType string
11047
11048                 //mt:if %s.Type == "skybox"
11049                 Textures []Texture
11050
11051                 //mt:if %s.Type == "regular"
11052                 DaySky, DayHorizon,
11053                 DawnSky, DawnHorizon,
11054                 NightSky, NightHorizon,
11055                 Indoor color.NRGBA
11056         }))(obj)).Type))) > math.MaxUint16 {
11057                 chk(ErrTooLong)
11058         }
11059         {
11060                 x := uint16(len(([]byte((*(*(struct {
11061                         BgColor     color.NRGBA
11062                         Type        string
11063                         Clouds      bool
11064                         SunFogTint  color.NRGBA
11065                         MoonFogTint color.NRGBA
11066                         FogTintType string
11067
11068                         //mt:if %s.Type == "skybox"
11069                         Textures []Texture
11070
11071                         //mt:if %s.Type == "regular"
11072                         DaySky, DayHorizon,
11073                         DawnSky, DawnHorizon,
11074                         NightSky, NightHorizon,
11075                         Indoor color.NRGBA
11076                 }))(obj)).Type))))
11077                 write16(w, uint16(x))
11078         }
11079         {
11080                 _, err := w.Write(([]byte((*(*(struct {
11081                         BgColor     color.NRGBA
11082                         Type        string
11083                         Clouds      bool
11084                         SunFogTint  color.NRGBA
11085                         MoonFogTint color.NRGBA
11086                         FogTintType string
11087
11088                         //mt:if %s.Type == "skybox"
11089                         Textures []Texture
11090
11091                         //mt:if %s.Type == "regular"
11092                         DaySky, DayHorizon,
11093                         DawnSky, DawnHorizon,
11094                         NightSky, NightHorizon,
11095                         Indoor color.NRGBA
11096                 }))(obj)).Type))[:])
11097                 chk(err)
11098         }
11099         {
11100                 x := (*(*(struct {
11101                         BgColor     color.NRGBA
11102                         Type        string
11103                         Clouds      bool
11104                         SunFogTint  color.NRGBA
11105                         MoonFogTint color.NRGBA
11106                         FogTintType string
11107
11108                         //mt:if %s.Type == "skybox"
11109                         Textures []Texture
11110
11111                         //mt:if %s.Type == "regular"
11112                         DaySky, DayHorizon,
11113                         DawnSky, DawnHorizon,
11114                         NightSky, NightHorizon,
11115                         Indoor color.NRGBA
11116                 }))(obj)).Clouds
11117                 if x {
11118                         write8(w, 1)
11119                 } else {
11120                         write8(w, 0)
11121                 }
11122         }
11123         {
11124                 x := (*(*(struct {
11125                         BgColor     color.NRGBA
11126                         Type        string
11127                         Clouds      bool
11128                         SunFogTint  color.NRGBA
11129                         MoonFogTint color.NRGBA
11130                         FogTintType string
11131
11132                         //mt:if %s.Type == "skybox"
11133                         Textures []Texture
11134
11135                         //mt:if %s.Type == "regular"
11136                         DaySky, DayHorizon,
11137                         DawnSky, DawnHorizon,
11138                         NightSky, NightHorizon,
11139                         Indoor color.NRGBA
11140                 }))(obj)).SunFogTint
11141                 w.Write([]byte{x.A, x.R, x.G, x.B})
11142         }
11143         {
11144                 x := (*(*(struct {
11145                         BgColor     color.NRGBA
11146                         Type        string
11147                         Clouds      bool
11148                         SunFogTint  color.NRGBA
11149                         MoonFogTint color.NRGBA
11150                         FogTintType string
11151
11152                         //mt:if %s.Type == "skybox"
11153                         Textures []Texture
11154
11155                         //mt:if %s.Type == "regular"
11156                         DaySky, DayHorizon,
11157                         DawnSky, DawnHorizon,
11158                         NightSky, NightHorizon,
11159                         Indoor color.NRGBA
11160                 }))(obj)).MoonFogTint
11161                 w.Write([]byte{x.A, x.R, x.G, x.B})
11162         }
11163         if len(([]byte((*(*(struct {
11164                 BgColor     color.NRGBA
11165                 Type        string
11166                 Clouds      bool
11167                 SunFogTint  color.NRGBA
11168                 MoonFogTint color.NRGBA
11169                 FogTintType string
11170
11171                 //mt:if %s.Type == "skybox"
11172                 Textures []Texture
11173
11174                 //mt:if %s.Type == "regular"
11175                 DaySky, DayHorizon,
11176                 DawnSky, DawnHorizon,
11177                 NightSky, NightHorizon,
11178                 Indoor color.NRGBA
11179         }))(obj)).FogTintType))) > math.MaxUint16 {
11180                 chk(ErrTooLong)
11181         }
11182         {
11183                 x := uint16(len(([]byte((*(*(struct {
11184                         BgColor     color.NRGBA
11185                         Type        string
11186                         Clouds      bool
11187                         SunFogTint  color.NRGBA
11188                         MoonFogTint color.NRGBA
11189                         FogTintType string
11190
11191                         //mt:if %s.Type == "skybox"
11192                         Textures []Texture
11193
11194                         //mt:if %s.Type == "regular"
11195                         DaySky, DayHorizon,
11196                         DawnSky, DawnHorizon,
11197                         NightSky, NightHorizon,
11198                         Indoor color.NRGBA
11199                 }))(obj)).FogTintType))))
11200                 write16(w, uint16(x))
11201         }
11202         {
11203                 _, err := w.Write(([]byte((*(*(struct {
11204                         BgColor     color.NRGBA
11205                         Type        string
11206                         Clouds      bool
11207                         SunFogTint  color.NRGBA
11208                         MoonFogTint color.NRGBA
11209                         FogTintType string
11210
11211                         //mt:if %s.Type == "skybox"
11212                         Textures []Texture
11213
11214                         //mt:if %s.Type == "regular"
11215                         DaySky, DayHorizon,
11216                         DawnSky, DawnHorizon,
11217                         NightSky, NightHorizon,
11218                         Indoor color.NRGBA
11219                 }))(obj)).FogTintType))[:])
11220                 chk(err)
11221         }
11222         if (*(*(struct {
11223                 BgColor     color.NRGBA
11224                 Type        string
11225                 Clouds      bool
11226                 SunFogTint  color.NRGBA
11227                 MoonFogTint color.NRGBA
11228                 FogTintType string
11229
11230                 //mt:if %s.Type == "skybox"
11231                 Textures []Texture
11232
11233                 //mt:if %s.Type == "regular"
11234                 DaySky, DayHorizon,
11235                 DawnSky, DawnHorizon,
11236                 NightSky, NightHorizon,
11237                 Indoor color.NRGBA
11238         }))(obj)).Type == "skybox" {
11239                 if len(((*(*(struct {
11240                         BgColor     color.NRGBA
11241                         Type        string
11242                         Clouds      bool
11243                         SunFogTint  color.NRGBA
11244                         MoonFogTint color.NRGBA
11245                         FogTintType string
11246
11247                         //mt:if %s.Type == "skybox"
11248                         Textures []Texture
11249
11250                         //mt:if %s.Type == "regular"
11251                         DaySky, DayHorizon,
11252                         DawnSky, DawnHorizon,
11253                         NightSky, NightHorizon,
11254                         Indoor color.NRGBA
11255                 }))(obj)).Textures)) > math.MaxUint16 {
11256                         chk(ErrTooLong)
11257                 }
11258                 {
11259                         x := uint16(len(((*(*(struct {
11260                                 BgColor     color.NRGBA
11261                                 Type        string
11262                                 Clouds      bool
11263                                 SunFogTint  color.NRGBA
11264                                 MoonFogTint color.NRGBA
11265                                 FogTintType string
11266
11267                                 //mt:if %s.Type == "skybox"
11268                                 Textures []Texture
11269
11270                                 //mt:if %s.Type == "regular"
11271                                 DaySky, DayHorizon,
11272                                 DawnSky, DawnHorizon,
11273                                 NightSky, NightHorizon,
11274                                 Indoor color.NRGBA
11275                         }))(obj)).Textures)))
11276                         write16(w, uint16(x))
11277                 }
11278                 for local193 := range (*(*(struct {
11279                         BgColor     color.NRGBA
11280                         Type        string
11281                         Clouds      bool
11282                         SunFogTint  color.NRGBA
11283                         MoonFogTint color.NRGBA
11284                         FogTintType string
11285
11286                         //mt:if %s.Type == "skybox"
11287                         Textures []Texture
11288
11289                         //mt:if %s.Type == "regular"
11290                         DaySky, DayHorizon,
11291                         DawnSky, DawnHorizon,
11292                         NightSky, NightHorizon,
11293                         Indoor color.NRGBA
11294                 }))(obj)).Textures {
11295                         if err := pcall(func() {
11296                                 (((*(*(struct {
11297                                         BgColor     color.NRGBA
11298                                         Type        string
11299                                         Clouds      bool
11300                                         SunFogTint  color.NRGBA
11301                                         MoonFogTint color.NRGBA
11302                                         FogTintType string
11303
11304                                         //mt:if %s.Type == "skybox"
11305                                         Textures []Texture
11306
11307                                         //mt:if %s.Type == "regular"
11308                                         DaySky, DayHorizon,
11309                                         DawnSky, DawnHorizon,
11310                                         NightSky, NightHorizon,
11311                                         Indoor color.NRGBA
11312                                 }))(obj)).Textures)[local193]).Serialize(w)
11313                         }); err != nil {
11314                                 if err == io.EOF {
11315                                         chk(io.EOF)
11316                                 }
11317                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
11318                         }
11319                 }
11320         }
11321         if (*(*(struct {
11322                 BgColor     color.NRGBA
11323                 Type        string
11324                 Clouds      bool
11325                 SunFogTint  color.NRGBA
11326                 MoonFogTint color.NRGBA
11327                 FogTintType string
11328
11329                 //mt:if %s.Type == "skybox"
11330                 Textures []Texture
11331
11332                 //mt:if %s.Type == "regular"
11333                 DaySky, DayHorizon,
11334                 DawnSky, DawnHorizon,
11335                 NightSky, NightHorizon,
11336                 Indoor color.NRGBA
11337         }))(obj)).Type == "regular" {
11338                 {
11339                         x := (*(*(struct {
11340                                 BgColor     color.NRGBA
11341                                 Type        string
11342                                 Clouds      bool
11343                                 SunFogTint  color.NRGBA
11344                                 MoonFogTint color.NRGBA
11345                                 FogTintType string
11346
11347                                 //mt:if %s.Type == "skybox"
11348                                 Textures []Texture
11349
11350                                 //mt:if %s.Type == "regular"
11351                                 DaySky, DayHorizon,
11352                                 DawnSky, DawnHorizon,
11353                                 NightSky, NightHorizon,
11354                                 Indoor color.NRGBA
11355                         }))(obj)).DaySky
11356                         w.Write([]byte{x.A, x.R, x.G, x.B})
11357                 }
11358                 {
11359                         x := (*(*(struct {
11360                                 BgColor     color.NRGBA
11361                                 Type        string
11362                                 Clouds      bool
11363                                 SunFogTint  color.NRGBA
11364                                 MoonFogTint color.NRGBA
11365                                 FogTintType string
11366
11367                                 //mt:if %s.Type == "skybox"
11368                                 Textures []Texture
11369
11370                                 //mt:if %s.Type == "regular"
11371                                 DaySky, DayHorizon,
11372                                 DawnSky, DawnHorizon,
11373                                 NightSky, NightHorizon,
11374                                 Indoor color.NRGBA
11375                         }))(obj)).DayHorizon
11376                         w.Write([]byte{x.A, x.R, x.G, x.B})
11377                 }
11378                 {
11379                         x := (*(*(struct {
11380                                 BgColor     color.NRGBA
11381                                 Type        string
11382                                 Clouds      bool
11383                                 SunFogTint  color.NRGBA
11384                                 MoonFogTint color.NRGBA
11385                                 FogTintType string
11386
11387                                 //mt:if %s.Type == "skybox"
11388                                 Textures []Texture
11389
11390                                 //mt:if %s.Type == "regular"
11391                                 DaySky, DayHorizon,
11392                                 DawnSky, DawnHorizon,
11393                                 NightSky, NightHorizon,
11394                                 Indoor color.NRGBA
11395                         }))(obj)).DawnSky
11396                         w.Write([]byte{x.A, x.R, x.G, x.B})
11397                 }
11398                 {
11399                         x := (*(*(struct {
11400                                 BgColor     color.NRGBA
11401                                 Type        string
11402                                 Clouds      bool
11403                                 SunFogTint  color.NRGBA
11404                                 MoonFogTint color.NRGBA
11405                                 FogTintType string
11406
11407                                 //mt:if %s.Type == "skybox"
11408                                 Textures []Texture
11409
11410                                 //mt:if %s.Type == "regular"
11411                                 DaySky, DayHorizon,
11412                                 DawnSky, DawnHorizon,
11413                                 NightSky, NightHorizon,
11414                                 Indoor color.NRGBA
11415                         }))(obj)).DawnHorizon
11416                         w.Write([]byte{x.A, x.R, x.G, x.B})
11417                 }
11418                 {
11419                         x := (*(*(struct {
11420                                 BgColor     color.NRGBA
11421                                 Type        string
11422                                 Clouds      bool
11423                                 SunFogTint  color.NRGBA
11424                                 MoonFogTint color.NRGBA
11425                                 FogTintType string
11426
11427                                 //mt:if %s.Type == "skybox"
11428                                 Textures []Texture
11429
11430                                 //mt:if %s.Type == "regular"
11431                                 DaySky, DayHorizon,
11432                                 DawnSky, DawnHorizon,
11433                                 NightSky, NightHorizon,
11434                                 Indoor color.NRGBA
11435                         }))(obj)).NightSky
11436                         w.Write([]byte{x.A, x.R, x.G, x.B})
11437                 }
11438                 {
11439                         x := (*(*(struct {
11440                                 BgColor     color.NRGBA
11441                                 Type        string
11442                                 Clouds      bool
11443                                 SunFogTint  color.NRGBA
11444                                 MoonFogTint color.NRGBA
11445                                 FogTintType string
11446
11447                                 //mt:if %s.Type == "skybox"
11448                                 Textures []Texture
11449
11450                                 //mt:if %s.Type == "regular"
11451                                 DaySky, DayHorizon,
11452                                 DawnSky, DawnHorizon,
11453                                 NightSky, NightHorizon,
11454                                 Indoor color.NRGBA
11455                         }))(obj)).NightHorizon
11456                         w.Write([]byte{x.A, x.R, x.G, x.B})
11457                 }
11458                 {
11459                         x := (*(*(struct {
11460                                 BgColor     color.NRGBA
11461                                 Type        string
11462                                 Clouds      bool
11463                                 SunFogTint  color.NRGBA
11464                                 MoonFogTint color.NRGBA
11465                                 FogTintType string
11466
11467                                 //mt:if %s.Type == "skybox"
11468                                 Textures []Texture
11469
11470                                 //mt:if %s.Type == "regular"
11471                                 DaySky, DayHorizon,
11472                                 DawnSky, DawnHorizon,
11473                                 NightSky, NightHorizon,
11474                                 Indoor color.NRGBA
11475                         }))(obj)).Indoor
11476                         w.Write([]byte{x.A, x.R, x.G, x.B})
11477                 }
11478         }
11479 }
11480
11481 func (obj *ToCltSkyParams) Deserialize(r io.Reader) {
11482         {
11483                 p := &(*(*(struct {
11484                         BgColor     color.NRGBA
11485                         Type        string
11486                         Clouds      bool
11487                         SunFogTint  color.NRGBA
11488                         MoonFogTint color.NRGBA
11489                         FogTintType string
11490
11491                         //mt:if %s.Type == "skybox"
11492                         Textures []Texture
11493
11494                         //mt:if %s.Type == "regular"
11495                         DaySky, DayHorizon,
11496                         DawnSky, DawnHorizon,
11497                         NightSky, NightHorizon,
11498                         Indoor color.NRGBA
11499                 }))(obj)).BgColor
11500                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11501         }
11502         var local194 []uint8
11503         var local195 uint16
11504         {
11505                 p := &local195
11506                 *p = read16(r)
11507         }
11508         (local194) = make([]uint8, local195)
11509         {
11510                 _, err := io.ReadFull(r, (local194)[:])
11511                 chk(err)
11512         }
11513         ((*(*(struct {
11514                 BgColor     color.NRGBA
11515                 Type        string
11516                 Clouds      bool
11517                 SunFogTint  color.NRGBA
11518                 MoonFogTint color.NRGBA
11519                 FogTintType string
11520
11521                 //mt:if %s.Type == "skybox"
11522                 Textures []Texture
11523
11524                 //mt:if %s.Type == "regular"
11525                 DaySky, DayHorizon,
11526                 DawnSky, DawnHorizon,
11527                 NightSky, NightHorizon,
11528                 Indoor color.NRGBA
11529         }))(obj)).Type) = string(local194)
11530         {
11531                 p := &(*(*(struct {
11532                         BgColor     color.NRGBA
11533                         Type        string
11534                         Clouds      bool
11535                         SunFogTint  color.NRGBA
11536                         MoonFogTint color.NRGBA
11537                         FogTintType string
11538
11539                         //mt:if %s.Type == "skybox"
11540                         Textures []Texture
11541
11542                         //mt:if %s.Type == "regular"
11543                         DaySky, DayHorizon,
11544                         DawnSky, DawnHorizon,
11545                         NightSky, NightHorizon,
11546                         Indoor color.NRGBA
11547                 }))(obj)).Clouds
11548                 switch n := read8(r); n {
11549                 case 0:
11550                         *p = false
11551                 case 1:
11552                         *p = true
11553                 default:
11554                         chk(fmt.Errorf("invalid bool: %d", n))
11555                 }
11556         }
11557         {
11558                 p := &(*(*(struct {
11559                         BgColor     color.NRGBA
11560                         Type        string
11561                         Clouds      bool
11562                         SunFogTint  color.NRGBA
11563                         MoonFogTint color.NRGBA
11564                         FogTintType string
11565
11566                         //mt:if %s.Type == "skybox"
11567                         Textures []Texture
11568
11569                         //mt:if %s.Type == "regular"
11570                         DaySky, DayHorizon,
11571                         DawnSky, DawnHorizon,
11572                         NightSky, NightHorizon,
11573                         Indoor color.NRGBA
11574                 }))(obj)).SunFogTint
11575                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11576         }
11577         {
11578                 p := &(*(*(struct {
11579                         BgColor     color.NRGBA
11580                         Type        string
11581                         Clouds      bool
11582                         SunFogTint  color.NRGBA
11583                         MoonFogTint color.NRGBA
11584                         FogTintType string
11585
11586                         //mt:if %s.Type == "skybox"
11587                         Textures []Texture
11588
11589                         //mt:if %s.Type == "regular"
11590                         DaySky, DayHorizon,
11591                         DawnSky, DawnHorizon,
11592                         NightSky, NightHorizon,
11593                         Indoor color.NRGBA
11594                 }))(obj)).MoonFogTint
11595                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11596         }
11597         var local196 []uint8
11598         var local197 uint16
11599         {
11600                 p := &local197
11601                 *p = read16(r)
11602         }
11603         (local196) = make([]uint8, local197)
11604         {
11605                 _, err := io.ReadFull(r, (local196)[:])
11606                 chk(err)
11607         }
11608         ((*(*(struct {
11609                 BgColor     color.NRGBA
11610                 Type        string
11611                 Clouds      bool
11612                 SunFogTint  color.NRGBA
11613                 MoonFogTint color.NRGBA
11614                 FogTintType string
11615
11616                 //mt:if %s.Type == "skybox"
11617                 Textures []Texture
11618
11619                 //mt:if %s.Type == "regular"
11620                 DaySky, DayHorizon,
11621                 DawnSky, DawnHorizon,
11622                 NightSky, NightHorizon,
11623                 Indoor color.NRGBA
11624         }))(obj)).FogTintType) = string(local196)
11625         if (*(*(struct {
11626                 BgColor     color.NRGBA
11627                 Type        string
11628                 Clouds      bool
11629                 SunFogTint  color.NRGBA
11630                 MoonFogTint color.NRGBA
11631                 FogTintType string
11632
11633                 //mt:if %s.Type == "skybox"
11634                 Textures []Texture
11635
11636                 //mt:if %s.Type == "regular"
11637                 DaySky, DayHorizon,
11638                 DawnSky, DawnHorizon,
11639                 NightSky, NightHorizon,
11640                 Indoor color.NRGBA
11641         }))(obj)).Type == "skybox" {
11642                 var local198 uint16
11643                 {
11644                         p := &local198
11645                         *p = read16(r)
11646                 }
11647                 ((*(*(struct {
11648                         BgColor     color.NRGBA
11649                         Type        string
11650                         Clouds      bool
11651                         SunFogTint  color.NRGBA
11652                         MoonFogTint color.NRGBA
11653                         FogTintType string
11654
11655                         //mt:if %s.Type == "skybox"
11656                         Textures []Texture
11657
11658                         //mt:if %s.Type == "regular"
11659                         DaySky, DayHorizon,
11660                         DawnSky, DawnHorizon,
11661                         NightSky, NightHorizon,
11662                         Indoor color.NRGBA
11663                 }))(obj)).Textures) = make([]Texture, local198)
11664                 for local199 := range (*(*(struct {
11665                         BgColor     color.NRGBA
11666                         Type        string
11667                         Clouds      bool
11668                         SunFogTint  color.NRGBA
11669                         MoonFogTint color.NRGBA
11670                         FogTintType string
11671
11672                         //mt:if %s.Type == "skybox"
11673                         Textures []Texture
11674
11675                         //mt:if %s.Type == "regular"
11676                         DaySky, DayHorizon,
11677                         DawnSky, DawnHorizon,
11678                         NightSky, NightHorizon,
11679                         Indoor color.NRGBA
11680                 }))(obj)).Textures {
11681                         if err := pcall(func() {
11682                                 (((*(*(struct {
11683                                         BgColor     color.NRGBA
11684                                         Type        string
11685                                         Clouds      bool
11686                                         SunFogTint  color.NRGBA
11687                                         MoonFogTint color.NRGBA
11688                                         FogTintType string
11689
11690                                         //mt:if %s.Type == "skybox"
11691                                         Textures []Texture
11692
11693                                         //mt:if %s.Type == "regular"
11694                                         DaySky, DayHorizon,
11695                                         DawnSky, DawnHorizon,
11696                                         NightSky, NightHorizon,
11697                                         Indoor color.NRGBA
11698                                 }))(obj)).Textures)[local199]).Deserialize(r)
11699                         }); err != nil {
11700                                 if err == io.EOF {
11701                                         chk(io.EOF)
11702                                 }
11703                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
11704                         }
11705                 }
11706         }
11707         if (*(*(struct {
11708                 BgColor     color.NRGBA
11709                 Type        string
11710                 Clouds      bool
11711                 SunFogTint  color.NRGBA
11712                 MoonFogTint color.NRGBA
11713                 FogTintType string
11714
11715                 //mt:if %s.Type == "skybox"
11716                 Textures []Texture
11717
11718                 //mt:if %s.Type == "regular"
11719                 DaySky, DayHorizon,
11720                 DawnSky, DawnHorizon,
11721                 NightSky, NightHorizon,
11722                 Indoor color.NRGBA
11723         }))(obj)).Type == "regular" {
11724                 {
11725                         p := &(*(*(struct {
11726                                 BgColor     color.NRGBA
11727                                 Type        string
11728                                 Clouds      bool
11729                                 SunFogTint  color.NRGBA
11730                                 MoonFogTint color.NRGBA
11731                                 FogTintType string
11732
11733                                 //mt:if %s.Type == "skybox"
11734                                 Textures []Texture
11735
11736                                 //mt:if %s.Type == "regular"
11737                                 DaySky, DayHorizon,
11738                                 DawnSky, DawnHorizon,
11739                                 NightSky, NightHorizon,
11740                                 Indoor color.NRGBA
11741                         }))(obj)).DaySky
11742                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11743                 }
11744                 {
11745                         p := &(*(*(struct {
11746                                 BgColor     color.NRGBA
11747                                 Type        string
11748                                 Clouds      bool
11749                                 SunFogTint  color.NRGBA
11750                                 MoonFogTint color.NRGBA
11751                                 FogTintType string
11752
11753                                 //mt:if %s.Type == "skybox"
11754                                 Textures []Texture
11755
11756                                 //mt:if %s.Type == "regular"
11757                                 DaySky, DayHorizon,
11758                                 DawnSky, DawnHorizon,
11759                                 NightSky, NightHorizon,
11760                                 Indoor color.NRGBA
11761                         }))(obj)).DayHorizon
11762                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11763                 }
11764                 {
11765                         p := &(*(*(struct {
11766                                 BgColor     color.NRGBA
11767                                 Type        string
11768                                 Clouds      bool
11769                                 SunFogTint  color.NRGBA
11770                                 MoonFogTint color.NRGBA
11771                                 FogTintType string
11772
11773                                 //mt:if %s.Type == "skybox"
11774                                 Textures []Texture
11775
11776                                 //mt:if %s.Type == "regular"
11777                                 DaySky, DayHorizon,
11778                                 DawnSky, DawnHorizon,
11779                                 NightSky, NightHorizon,
11780                                 Indoor color.NRGBA
11781                         }))(obj)).DawnSky
11782                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11783                 }
11784                 {
11785                         p := &(*(*(struct {
11786                                 BgColor     color.NRGBA
11787                                 Type        string
11788                                 Clouds      bool
11789                                 SunFogTint  color.NRGBA
11790                                 MoonFogTint color.NRGBA
11791                                 FogTintType string
11792
11793                                 //mt:if %s.Type == "skybox"
11794                                 Textures []Texture
11795
11796                                 //mt:if %s.Type == "regular"
11797                                 DaySky, DayHorizon,
11798                                 DawnSky, DawnHorizon,
11799                                 NightSky, NightHorizon,
11800                                 Indoor color.NRGBA
11801                         }))(obj)).DawnHorizon
11802                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11803                 }
11804                 {
11805                         p := &(*(*(struct {
11806                                 BgColor     color.NRGBA
11807                                 Type        string
11808                                 Clouds      bool
11809                                 SunFogTint  color.NRGBA
11810                                 MoonFogTint color.NRGBA
11811                                 FogTintType string
11812
11813                                 //mt:if %s.Type == "skybox"
11814                                 Textures []Texture
11815
11816                                 //mt:if %s.Type == "regular"
11817                                 DaySky, DayHorizon,
11818                                 DawnSky, DawnHorizon,
11819                                 NightSky, NightHorizon,
11820                                 Indoor color.NRGBA
11821                         }))(obj)).NightSky
11822                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11823                 }
11824                 {
11825                         p := &(*(*(struct {
11826                                 BgColor     color.NRGBA
11827                                 Type        string
11828                                 Clouds      bool
11829                                 SunFogTint  color.NRGBA
11830                                 MoonFogTint color.NRGBA
11831                                 FogTintType string
11832
11833                                 //mt:if %s.Type == "skybox"
11834                                 Textures []Texture
11835
11836                                 //mt:if %s.Type == "regular"
11837                                 DaySky, DayHorizon,
11838                                 DawnSky, DawnHorizon,
11839                                 NightSky, NightHorizon,
11840                                 Indoor color.NRGBA
11841                         }))(obj)).NightHorizon
11842                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11843                 }
11844                 {
11845                         p := &(*(*(struct {
11846                                 BgColor     color.NRGBA
11847                                 Type        string
11848                                 Clouds      bool
11849                                 SunFogTint  color.NRGBA
11850                                 MoonFogTint color.NRGBA
11851                                 FogTintType string
11852
11853                                 //mt:if %s.Type == "skybox"
11854                                 Textures []Texture
11855
11856                                 //mt:if %s.Type == "regular"
11857                                 DaySky, DayHorizon,
11858                                 DawnSky, DawnHorizon,
11859                                 NightSky, NightHorizon,
11860                                 Indoor color.NRGBA
11861                         }))(obj)).Indoor
11862                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11863                 }
11864         }
11865 }
11866
11867 func (obj *ToCltOverrideDayNightRatio) Serialize(w io.Writer) {
11868         {
11869                 x := (*(*(struct {
11870                         Override bool
11871                         Ratio    uint16
11872                 }))(obj)).Override
11873                 if x {
11874                         write8(w, 1)
11875                 } else {
11876                         write8(w, 0)
11877                 }
11878         }
11879         {
11880                 x := (*(*(struct {
11881                         Override bool
11882                         Ratio    uint16
11883                 }))(obj)).Ratio
11884                 write16(w, uint16(x))
11885         }
11886 }
11887
11888 func (obj *ToCltOverrideDayNightRatio) Deserialize(r io.Reader) {
11889         {
11890                 p := &(*(*(struct {
11891                         Override bool
11892                         Ratio    uint16
11893                 }))(obj)).Override
11894                 switch n := read8(r); n {
11895                 case 0:
11896                         *p = false
11897                 case 1:
11898                         *p = true
11899                 default:
11900                         chk(fmt.Errorf("invalid bool: %d", n))
11901                 }
11902         }
11903         {
11904                 p := &(*(*(struct {
11905                         Override bool
11906                         Ratio    uint16
11907                 }))(obj)).Ratio
11908                 *p = read16(r)
11909         }
11910 }
11911
11912 func (obj *ToCltLocalPlayerAnim) Serialize(w io.Writer) {
11913         for local200 := range (*(*(struct {
11914                 Idle, Walk, Dig, WalkDig [2]int32
11915                 Speed                    float32
11916         }))(obj)).Idle {
11917                 {
11918                         x := ((*(*(struct {
11919                                 Idle, Walk, Dig, WalkDig [2]int32
11920                                 Speed                    float32
11921                         }))(obj)).Idle)[local200]
11922                         write32(w, uint32(x))
11923                 }
11924         }
11925         for local201 := range (*(*(struct {
11926                 Idle, Walk, Dig, WalkDig [2]int32
11927                 Speed                    float32
11928         }))(obj)).Walk {
11929                 {
11930                         x := ((*(*(struct {
11931                                 Idle, Walk, Dig, WalkDig [2]int32
11932                                 Speed                    float32
11933                         }))(obj)).Walk)[local201]
11934                         write32(w, uint32(x))
11935                 }
11936         }
11937         for local202 := range (*(*(struct {
11938                 Idle, Walk, Dig, WalkDig [2]int32
11939                 Speed                    float32
11940         }))(obj)).Dig {
11941                 {
11942                         x := ((*(*(struct {
11943                                 Idle, Walk, Dig, WalkDig [2]int32
11944                                 Speed                    float32
11945                         }))(obj)).Dig)[local202]
11946                         write32(w, uint32(x))
11947                 }
11948         }
11949         for local203 := range (*(*(struct {
11950                 Idle, Walk, Dig, WalkDig [2]int32
11951                 Speed                    float32
11952         }))(obj)).WalkDig {
11953                 {
11954                         x := ((*(*(struct {
11955                                 Idle, Walk, Dig, WalkDig [2]int32
11956                                 Speed                    float32
11957                         }))(obj)).WalkDig)[local203]
11958                         write32(w, uint32(x))
11959                 }
11960         }
11961         {
11962                 x := (*(*(struct {
11963                         Idle, Walk, Dig, WalkDig [2]int32
11964                         Speed                    float32
11965                 }))(obj)).Speed
11966                 write32(w, math.Float32bits(x))
11967         }
11968 }
11969
11970 func (obj *ToCltLocalPlayerAnim) Deserialize(r io.Reader) {
11971         for local204 := range (*(*(struct {
11972                 Idle, Walk, Dig, WalkDig [2]int32
11973                 Speed                    float32
11974         }))(obj)).Idle {
11975                 {
11976                         p := &((*(*(struct {
11977                                 Idle, Walk, Dig, WalkDig [2]int32
11978                                 Speed                    float32
11979                         }))(obj)).Idle)[local204]
11980                         *p = int32(read32(r))
11981                 }
11982         }
11983         for local205 := range (*(*(struct {
11984                 Idle, Walk, Dig, WalkDig [2]int32
11985                 Speed                    float32
11986         }))(obj)).Walk {
11987                 {
11988                         p := &((*(*(struct {
11989                                 Idle, Walk, Dig, WalkDig [2]int32
11990                                 Speed                    float32
11991                         }))(obj)).Walk)[local205]
11992                         *p = int32(read32(r))
11993                 }
11994         }
11995         for local206 := range (*(*(struct {
11996                 Idle, Walk, Dig, WalkDig [2]int32
11997                 Speed                    float32
11998         }))(obj)).Dig {
11999                 {
12000                         p := &((*(*(struct {
12001                                 Idle, Walk, Dig, WalkDig [2]int32
12002                                 Speed                    float32
12003                         }))(obj)).Dig)[local206]
12004                         *p = int32(read32(r))
12005                 }
12006         }
12007         for local207 := range (*(*(struct {
12008                 Idle, Walk, Dig, WalkDig [2]int32
12009                 Speed                    float32
12010         }))(obj)).WalkDig {
12011                 {
12012                         p := &((*(*(struct {
12013                                 Idle, Walk, Dig, WalkDig [2]int32
12014                                 Speed                    float32
12015                         }))(obj)).WalkDig)[local207]
12016                         *p = int32(read32(r))
12017                 }
12018         }
12019         {
12020                 p := &(*(*(struct {
12021                         Idle, Walk, Dig, WalkDig [2]int32
12022                         Speed                    float32
12023                 }))(obj)).Speed
12024                 *p = math.Float32frombits(read32(r))
12025         }
12026 }
12027
12028 func (obj *ToCltEyeOffset) Serialize(w io.Writer) {
12029         if err := pcall(func() {
12030                 ((*(*(struct {
12031                         First, Third Vec
12032                 }))(obj)).First).Serialize(w)
12033         }); err != nil {
12034                 if err == io.EOF {
12035                         chk(io.EOF)
12036                 }
12037                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12038         }
12039         if err := pcall(func() {
12040                 ((*(*(struct {
12041                         First, Third Vec
12042                 }))(obj)).Third).Serialize(w)
12043         }); err != nil {
12044                 if err == io.EOF {
12045                         chk(io.EOF)
12046                 }
12047                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12048         }
12049 }
12050
12051 func (obj *ToCltEyeOffset) Deserialize(r io.Reader) {
12052         if err := pcall(func() {
12053                 ((*(*(struct {
12054                         First, Third Vec
12055                 }))(obj)).First).Deserialize(r)
12056         }); err != nil {
12057                 if err == io.EOF {
12058                         chk(io.EOF)
12059                 }
12060                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12061         }
12062         if err := pcall(func() {
12063                 ((*(*(struct {
12064                         First, Third Vec
12065                 }))(obj)).Third).Deserialize(r)
12066         }); err != nil {
12067                 if err == io.EOF {
12068                         chk(io.EOF)
12069                 }
12070                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12071         }
12072 }
12073
12074 func (obj *ToCltDelParticleSpawner) Serialize(w io.Writer) {
12075         if err := pcall(func() {
12076                 ((*(*(struct {
12077                         ID ParticleSpawnerID
12078                 }))(obj)).ID).Serialize(w)
12079         }); err != nil {
12080                 if err == io.EOF {
12081                         chk(io.EOF)
12082                 }
12083                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
12084         }
12085 }
12086
12087 func (obj *ToCltDelParticleSpawner) Deserialize(r io.Reader) {
12088         if err := pcall(func() {
12089                 ((*(*(struct {
12090                         ID ParticleSpawnerID
12091                 }))(obj)).ID).Deserialize(r)
12092         }); err != nil {
12093                 if err == io.EOF {
12094                         chk(io.EOF)
12095                 }
12096                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
12097         }
12098 }
12099
12100 func (obj *ToCltCloudParams) Serialize(w io.Writer) {
12101         {
12102                 x := (*(*(struct {
12103                         Density      float32
12104                         DiffuseColor color.NRGBA
12105                         AmbientColor color.NRGBA
12106                         Height       float32
12107                         Thickness    float32
12108                         Speed        [2]float32
12109                 }))(obj)).Density
12110                 write32(w, math.Float32bits(x))
12111         }
12112         {
12113                 x := (*(*(struct {
12114                         Density      float32
12115                         DiffuseColor color.NRGBA
12116                         AmbientColor color.NRGBA
12117                         Height       float32
12118                         Thickness    float32
12119                         Speed        [2]float32
12120                 }))(obj)).DiffuseColor
12121                 w.Write([]byte{x.A, x.R, x.G, x.B})
12122         }
12123         {
12124                 x := (*(*(struct {
12125                         Density      float32
12126                         DiffuseColor color.NRGBA
12127                         AmbientColor color.NRGBA
12128                         Height       float32
12129                         Thickness    float32
12130                         Speed        [2]float32
12131                 }))(obj)).AmbientColor
12132                 w.Write([]byte{x.A, x.R, x.G, x.B})
12133         }
12134         {
12135                 x := (*(*(struct {
12136                         Density      float32
12137                         DiffuseColor color.NRGBA
12138                         AmbientColor color.NRGBA
12139                         Height       float32
12140                         Thickness    float32
12141                         Speed        [2]float32
12142                 }))(obj)).Height
12143                 write32(w, math.Float32bits(x))
12144         }
12145         {
12146                 x := (*(*(struct {
12147                         Density      float32
12148                         DiffuseColor color.NRGBA
12149                         AmbientColor color.NRGBA
12150                         Height       float32
12151                         Thickness    float32
12152                         Speed        [2]float32
12153                 }))(obj)).Thickness
12154                 write32(w, math.Float32bits(x))
12155         }
12156         for local208 := range (*(*(struct {
12157                 Density      float32
12158                 DiffuseColor color.NRGBA
12159                 AmbientColor color.NRGBA
12160                 Height       float32
12161                 Thickness    float32
12162                 Speed        [2]float32
12163         }))(obj)).Speed {
12164                 {
12165                         x := ((*(*(struct {
12166                                 Density      float32
12167                                 DiffuseColor color.NRGBA
12168                                 AmbientColor color.NRGBA
12169                                 Height       float32
12170                                 Thickness    float32
12171                                 Speed        [2]float32
12172                         }))(obj)).Speed)[local208]
12173                         write32(w, math.Float32bits(x))
12174                 }
12175         }
12176 }
12177
12178 func (obj *ToCltCloudParams) Deserialize(r io.Reader) {
12179         {
12180                 p := &(*(*(struct {
12181                         Density      float32
12182                         DiffuseColor color.NRGBA
12183                         AmbientColor color.NRGBA
12184                         Height       float32
12185                         Thickness    float32
12186                         Speed        [2]float32
12187                 }))(obj)).Density
12188                 *p = math.Float32frombits(read32(r))
12189         }
12190         {
12191                 p := &(*(*(struct {
12192                         Density      float32
12193                         DiffuseColor color.NRGBA
12194                         AmbientColor color.NRGBA
12195                         Height       float32
12196                         Thickness    float32
12197                         Speed        [2]float32
12198                 }))(obj)).DiffuseColor
12199                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12200         }
12201         {
12202                 p := &(*(*(struct {
12203                         Density      float32
12204                         DiffuseColor color.NRGBA
12205                         AmbientColor color.NRGBA
12206                         Height       float32
12207                         Thickness    float32
12208                         Speed        [2]float32
12209                 }))(obj)).AmbientColor
12210                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12211         }
12212         {
12213                 p := &(*(*(struct {
12214                         Density      float32
12215                         DiffuseColor color.NRGBA
12216                         AmbientColor color.NRGBA
12217                         Height       float32
12218                         Thickness    float32
12219                         Speed        [2]float32
12220                 }))(obj)).Height
12221                 *p = math.Float32frombits(read32(r))
12222         }
12223         {
12224                 p := &(*(*(struct {
12225                         Density      float32
12226                         DiffuseColor color.NRGBA
12227                         AmbientColor color.NRGBA
12228                         Height       float32
12229                         Thickness    float32
12230                         Speed        [2]float32
12231                 }))(obj)).Thickness
12232                 *p = math.Float32frombits(read32(r))
12233         }
12234         for local209 := range (*(*(struct {
12235                 Density      float32
12236                 DiffuseColor color.NRGBA
12237                 AmbientColor color.NRGBA
12238                 Height       float32
12239                 Thickness    float32
12240                 Speed        [2]float32
12241         }))(obj)).Speed {
12242                 {
12243                         p := &((*(*(struct {
12244                                 Density      float32
12245                                 DiffuseColor color.NRGBA
12246                                 AmbientColor color.NRGBA
12247                                 Height       float32
12248                                 Thickness    float32
12249                                 Speed        [2]float32
12250                         }))(obj)).Speed)[local209]
12251                         *p = math.Float32frombits(read32(r))
12252                 }
12253         }
12254 }
12255
12256 func (obj *ToCltFadeSound) Serialize(w io.Writer) {
12257         if err := pcall(func() {
12258                 ((*(*(struct {
12259                         ID   SoundID
12260                         Step float32
12261                         Gain float32
12262                 }))(obj)).ID).Serialize(w)
12263         }); err != nil {
12264                 if err == io.EOF {
12265                         chk(io.EOF)
12266                 }
12267                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
12268         }
12269         {
12270                 x := (*(*(struct {
12271                         ID   SoundID
12272                         Step float32
12273                         Gain float32
12274                 }))(obj)).Step
12275                 write32(w, math.Float32bits(x))
12276         }
12277         {
12278                 x := (*(*(struct {
12279                         ID   SoundID
12280                         Step float32
12281                         Gain float32
12282                 }))(obj)).Gain
12283                 write32(w, math.Float32bits(x))
12284         }
12285 }
12286
12287 func (obj *ToCltFadeSound) Deserialize(r io.Reader) {
12288         if err := pcall(func() {
12289                 ((*(*(struct {
12290                         ID   SoundID
12291                         Step float32
12292                         Gain float32
12293                 }))(obj)).ID).Deserialize(r)
12294         }); err != nil {
12295                 if err == io.EOF {
12296                         chk(io.EOF)
12297                 }
12298                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
12299         }
12300         {
12301                 p := &(*(*(struct {
12302                         ID   SoundID
12303                         Step float32
12304                         Gain float32
12305                 }))(obj)).Step
12306                 *p = math.Float32frombits(read32(r))
12307         }
12308         {
12309                 p := &(*(*(struct {
12310                         ID   SoundID
12311                         Step float32
12312                         Gain float32
12313                 }))(obj)).Gain
12314                 *p = math.Float32frombits(read32(r))
12315         }
12316 }
12317
12318 func (obj *ToCltUpdatePlayerList) Serialize(w io.Writer) {
12319         if err := pcall(func() {
12320                 ((*(*(struct {
12321                         Type    PlayerListUpdateType
12322                         Players []string
12323                 }))(obj)).Type).Serialize(w)
12324         }); err != nil {
12325                 if err == io.EOF {
12326                         chk(io.EOF)
12327                 }
12328                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
12329         }
12330         if len(((*(*(struct {
12331                 Type    PlayerListUpdateType
12332                 Players []string
12333         }))(obj)).Players)) > math.MaxUint16 {
12334                 chk(ErrTooLong)
12335         }
12336         {
12337                 x := uint16(len(((*(*(struct {
12338                         Type    PlayerListUpdateType
12339                         Players []string
12340                 }))(obj)).Players)))
12341                 write16(w, uint16(x))
12342         }
12343         for local210 := range (*(*(struct {
12344                 Type    PlayerListUpdateType
12345                 Players []string
12346         }))(obj)).Players {
12347                 if len(([]byte(((*(*(struct {
12348                         Type    PlayerListUpdateType
12349                         Players []string
12350                 }))(obj)).Players)[local210]))) > math.MaxUint16 {
12351                         chk(ErrTooLong)
12352                 }
12353                 {
12354                         x := uint16(len(([]byte(((*(*(struct {
12355                                 Type    PlayerListUpdateType
12356                                 Players []string
12357                         }))(obj)).Players)[local210]))))
12358                         write16(w, uint16(x))
12359                 }
12360                 {
12361                         _, err := w.Write(([]byte(((*(*(struct {
12362                                 Type    PlayerListUpdateType
12363                                 Players []string
12364                         }))(obj)).Players)[local210]))[:])
12365                         chk(err)
12366                 }
12367         }
12368 }
12369
12370 func (obj *ToCltUpdatePlayerList) Deserialize(r io.Reader) {
12371         if err := pcall(func() {
12372                 ((*(*(struct {
12373                         Type    PlayerListUpdateType
12374                         Players []string
12375                 }))(obj)).Type).Deserialize(r)
12376         }); err != nil {
12377                 if err == io.EOF {
12378                         chk(io.EOF)
12379                 }
12380                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
12381         }
12382         var local211 uint16
12383         {
12384                 p := &local211
12385                 *p = read16(r)
12386         }
12387         ((*(*(struct {
12388                 Type    PlayerListUpdateType
12389                 Players []string
12390         }))(obj)).Players) = make([]string, local211)
12391         for local212 := range (*(*(struct {
12392                 Type    PlayerListUpdateType
12393                 Players []string
12394         }))(obj)).Players {
12395                 var local213 []uint8
12396                 var local214 uint16
12397                 {
12398                         p := &local214
12399                         *p = read16(r)
12400                 }
12401                 (local213) = make([]uint8, local214)
12402                 {
12403                         _, err := io.ReadFull(r, (local213)[:])
12404                         chk(err)
12405                 }
12406                 (((*(*(struct {
12407                         Type    PlayerListUpdateType
12408                         Players []string
12409                 }))(obj)).Players)[local212]) = string(local213)
12410         }
12411 }
12412
12413 func (obj *ToCltModChanMsg) Serialize(w io.Writer) {
12414         if len(([]byte((*(*(struct {
12415                 Channel string
12416                 Sender  string
12417                 Msg     string
12418         }))(obj)).Channel))) > math.MaxUint16 {
12419                 chk(ErrTooLong)
12420         }
12421         {
12422                 x := uint16(len(([]byte((*(*(struct {
12423                         Channel string
12424                         Sender  string
12425                         Msg     string
12426                 }))(obj)).Channel))))
12427                 write16(w, uint16(x))
12428         }
12429         {
12430                 _, err := w.Write(([]byte((*(*(struct {
12431                         Channel string
12432                         Sender  string
12433                         Msg     string
12434                 }))(obj)).Channel))[:])
12435                 chk(err)
12436         }
12437         if len(([]byte((*(*(struct {
12438                 Channel string
12439                 Sender  string
12440                 Msg     string
12441         }))(obj)).Sender))) > math.MaxUint16 {
12442                 chk(ErrTooLong)
12443         }
12444         {
12445                 x := uint16(len(([]byte((*(*(struct {
12446                         Channel string
12447                         Sender  string
12448                         Msg     string
12449                 }))(obj)).Sender))))
12450                 write16(w, uint16(x))
12451         }
12452         {
12453                 _, err := w.Write(([]byte((*(*(struct {
12454                         Channel string
12455                         Sender  string
12456                         Msg     string
12457                 }))(obj)).Sender))[:])
12458                 chk(err)
12459         }
12460         if len(([]byte((*(*(struct {
12461                 Channel string
12462                 Sender  string
12463                 Msg     string
12464         }))(obj)).Msg))) > math.MaxUint16 {
12465                 chk(ErrTooLong)
12466         }
12467         {
12468                 x := uint16(len(([]byte((*(*(struct {
12469                         Channel string
12470                         Sender  string
12471                         Msg     string
12472                 }))(obj)).Msg))))
12473                 write16(w, uint16(x))
12474         }
12475         {
12476                 _, err := w.Write(([]byte((*(*(struct {
12477                         Channel string
12478                         Sender  string
12479                         Msg     string
12480                 }))(obj)).Msg))[:])
12481                 chk(err)
12482         }
12483 }
12484
12485 func (obj *ToCltModChanMsg) Deserialize(r io.Reader) {
12486         var local215 []uint8
12487         var local216 uint16
12488         {
12489                 p := &local216
12490                 *p = read16(r)
12491         }
12492         (local215) = make([]uint8, local216)
12493         {
12494                 _, err := io.ReadFull(r, (local215)[:])
12495                 chk(err)
12496         }
12497         ((*(*(struct {
12498                 Channel string
12499                 Sender  string
12500                 Msg     string
12501         }))(obj)).Channel) = string(local215)
12502         var local217 []uint8
12503         var local218 uint16
12504         {
12505                 p := &local218
12506                 *p = read16(r)
12507         }
12508         (local217) = make([]uint8, local218)
12509         {
12510                 _, err := io.ReadFull(r, (local217)[:])
12511                 chk(err)
12512         }
12513         ((*(*(struct {
12514                 Channel string
12515                 Sender  string
12516                 Msg     string
12517         }))(obj)).Sender) = string(local217)
12518         var local219 []uint8
12519         var local220 uint16
12520         {
12521                 p := &local220
12522                 *p = read16(r)
12523         }
12524         (local219) = make([]uint8, local220)
12525         {
12526                 _, err := io.ReadFull(r, (local219)[:])
12527                 chk(err)
12528         }
12529         ((*(*(struct {
12530                 Channel string
12531                 Sender  string
12532                 Msg     string
12533         }))(obj)).Msg) = string(local219)
12534 }
12535
12536 func (obj *ToCltModChanSig) Serialize(w io.Writer) {
12537         if err := pcall(func() {
12538                 ((*(*(struct {
12539                         Signal  ModChanSig
12540                         Channel string
12541                 }))(obj)).Signal).Serialize(w)
12542         }); err != nil {
12543                 if err == io.EOF {
12544                         chk(io.EOF)
12545                 }
12546                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
12547         }
12548         if len(([]byte((*(*(struct {
12549                 Signal  ModChanSig
12550                 Channel string
12551         }))(obj)).Channel))) > math.MaxUint16 {
12552                 chk(ErrTooLong)
12553         }
12554         {
12555                 x := uint16(len(([]byte((*(*(struct {
12556                         Signal  ModChanSig
12557                         Channel string
12558                 }))(obj)).Channel))))
12559                 write16(w, uint16(x))
12560         }
12561         {
12562                 _, err := w.Write(([]byte((*(*(struct {
12563                         Signal  ModChanSig
12564                         Channel string
12565                 }))(obj)).Channel))[:])
12566                 chk(err)
12567         }
12568 }
12569
12570 func (obj *ToCltModChanSig) Deserialize(r io.Reader) {
12571         if err := pcall(func() {
12572                 ((*(*(struct {
12573                         Signal  ModChanSig
12574                         Channel string
12575                 }))(obj)).Signal).Deserialize(r)
12576         }); err != nil {
12577                 if err == io.EOF {
12578                         chk(io.EOF)
12579                 }
12580                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
12581         }
12582         var local221 []uint8
12583         var local222 uint16
12584         {
12585                 p := &local222
12586                 *p = read16(r)
12587         }
12588         (local221) = make([]uint8, local222)
12589         {
12590                 _, err := io.ReadFull(r, (local221)[:])
12591                 chk(err)
12592         }
12593         ((*(*(struct {
12594                 Signal  ModChanSig
12595                 Channel string
12596         }))(obj)).Channel) = string(local221)
12597 }
12598
12599 func (obj *ToCltNodeMetasChanged) Serialize(w io.Writer) {
12600         {
12601                 ow := w
12602                 w := new(bytes.Buffer)
12603                 {
12604                         x := (*(*(struct {
12605                                 //mt:lenhdr 32
12606                                 Changed map[[3]int16]*NodeMeta
12607                         }))(obj)).Changed
12608                         {
12609                                 w := zlib.NewWriter(w)
12610                                 if x == nil {
12611                                         write8(w, 0)
12612                                 } else {
12613                                         write8(w, 2)
12614                                         if len(x) > math.MaxUint16 {
12615                                                 chk(ErrTooLong)
12616                                         }
12617                                         write16(w, uint16(len(x)))
12618                                         keys := make([][3]int16, 0, len(x))
12619                                         for key := range x {
12620                                                 keys = append(keys, key)
12621                                         }
12622                                         sort.Slice(keys, func(i, j int) bool {
12623                                                 p, q := keys[i], keys[j]
12624                                                 for i := range p {
12625                                                         switch {
12626                                                         case p[i] < q[i]:
12627                                                                 return true
12628                                                         case p[i] > q[i]:
12629                                                                 return false
12630                                                         }
12631                                                 }
12632                                                 return false
12633                                         })
12634                                         for _, key := range keys {
12635                                                 for _, n := range key {
12636                                                         write16(w, uint16(n))
12637                                                 }
12638                                                 chk(serialize(w, x[key]))
12639                                         }
12640                                 }
12641                                 chk(w.Close())
12642                         }
12643                 }
12644                 {
12645                         buf := w
12646                         w := ow
12647                         if len((buf.Bytes())) > math.MaxUint32 {
12648                                 chk(ErrTooLong)
12649                         }
12650                         {
12651                                 x := uint32(len((buf.Bytes())))
12652                                 write32(w, uint32(x))
12653                         }
12654                         {
12655                                 _, err := w.Write((buf.Bytes())[:])
12656                                 chk(err)
12657                         }
12658                 }
12659         }
12660 }
12661
12662 func (obj *ToCltNodeMetasChanged) Deserialize(r io.Reader) {
12663         {
12664                 var n uint32
12665                 {
12666                         p := &n
12667                         *p = read32(r)
12668                 }
12669                 r := &io.LimitedReader{R: r, N: int64(n)}
12670                 {
12671                         p := &(*(*(struct {
12672                                 //mt:lenhdr 32
12673                                 Changed map[[3]int16]*NodeMeta
12674                         }))(obj)).Changed
12675                         {
12676                                 r, err := zlib.NewReader(byteReader{r})
12677                                 chk(err)
12678                                 switch ver := read8(r); ver {
12679                                 case 0:
12680                                         *p = nil
12681                                 case 2:
12682                                         n := read16(r)
12683                                         *p = make(map[[3]int16]*NodeMeta, n)
12684                                         for ; n > 0; n-- {
12685                                                 var pos [3]int16
12686                                                 for i := range pos {
12687                                                         pos[i] = int16(read16(r))
12688                                                 }
12689                                                 nm := new(NodeMeta)
12690                                                 chk(deserialize(r, nm))
12691                                                 (*p)[pos] = nm
12692                                         }
12693                                 default:
12694                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
12695                                 }
12696                                 chk(r.Close())
12697                         }
12698                 }
12699                 if r.N > 0 {
12700                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
12701                 }
12702         }
12703 }
12704
12705 func (obj *ToCltSunParams) Serialize(w io.Writer) {
12706         {
12707                 x := (*(*(struct {
12708                         Visible bool
12709                         Texture
12710                         ToneMap Texture
12711                         Rise    Texture
12712                         Rising  bool
12713                         Size    float32
12714                 }))(obj)).Visible
12715                 if x {
12716                         write8(w, 1)
12717                 } else {
12718                         write8(w, 0)
12719                 }
12720         }
12721         if err := pcall(func() {
12722                 ((*(*(struct {
12723                         Visible bool
12724                         Texture
12725                         ToneMap Texture
12726                         Rise    Texture
12727                         Rising  bool
12728                         Size    float32
12729                 }))(obj)).Texture).Serialize(w)
12730         }); err != nil {
12731                 if err == io.EOF {
12732                         chk(io.EOF)
12733                 }
12734                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12735         }
12736         if err := pcall(func() {
12737                 ((*(*(struct {
12738                         Visible bool
12739                         Texture
12740                         ToneMap Texture
12741                         Rise    Texture
12742                         Rising  bool
12743                         Size    float32
12744                 }))(obj)).ToneMap).Serialize(w)
12745         }); err != nil {
12746                 if err == io.EOF {
12747                         chk(io.EOF)
12748                 }
12749                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12750         }
12751         if err := pcall(func() {
12752                 ((*(*(struct {
12753                         Visible bool
12754                         Texture
12755                         ToneMap Texture
12756                         Rise    Texture
12757                         Rising  bool
12758                         Size    float32
12759                 }))(obj)).Rise).Serialize(w)
12760         }); err != nil {
12761                 if err == io.EOF {
12762                         chk(io.EOF)
12763                 }
12764                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12765         }
12766         {
12767                 x := (*(*(struct {
12768                         Visible bool
12769                         Texture
12770                         ToneMap Texture
12771                         Rise    Texture
12772                         Rising  bool
12773                         Size    float32
12774                 }))(obj)).Rising
12775                 if x {
12776                         write8(w, 1)
12777                 } else {
12778                         write8(w, 0)
12779                 }
12780         }
12781         {
12782                 x := (*(*(struct {
12783                         Visible bool
12784                         Texture
12785                         ToneMap Texture
12786                         Rise    Texture
12787                         Rising  bool
12788                         Size    float32
12789                 }))(obj)).Size
12790                 write32(w, math.Float32bits(x))
12791         }
12792 }
12793
12794 func (obj *ToCltSunParams) Deserialize(r io.Reader) {
12795         {
12796                 p := &(*(*(struct {
12797                         Visible bool
12798                         Texture
12799                         ToneMap Texture
12800                         Rise    Texture
12801                         Rising  bool
12802                         Size    float32
12803                 }))(obj)).Visible
12804                 switch n := read8(r); n {
12805                 case 0:
12806                         *p = false
12807                 case 1:
12808                         *p = true
12809                 default:
12810                         chk(fmt.Errorf("invalid bool: %d", n))
12811                 }
12812         }
12813         if err := pcall(func() {
12814                 ((*(*(struct {
12815                         Visible bool
12816                         Texture
12817                         ToneMap Texture
12818                         Rise    Texture
12819                         Rising  bool
12820                         Size    float32
12821                 }))(obj)).Texture).Deserialize(r)
12822         }); err != nil {
12823                 if err == io.EOF {
12824                         chk(io.EOF)
12825                 }
12826                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12827         }
12828         if err := pcall(func() {
12829                 ((*(*(struct {
12830                         Visible bool
12831                         Texture
12832                         ToneMap Texture
12833                         Rise    Texture
12834                         Rising  bool
12835                         Size    float32
12836                 }))(obj)).ToneMap).Deserialize(r)
12837         }); err != nil {
12838                 if err == io.EOF {
12839                         chk(io.EOF)
12840                 }
12841                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12842         }
12843         if err := pcall(func() {
12844                 ((*(*(struct {
12845                         Visible bool
12846                         Texture
12847                         ToneMap Texture
12848                         Rise    Texture
12849                         Rising  bool
12850                         Size    float32
12851                 }))(obj)).Rise).Deserialize(r)
12852         }); err != nil {
12853                 if err == io.EOF {
12854                         chk(io.EOF)
12855                 }
12856                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12857         }
12858         {
12859                 p := &(*(*(struct {
12860                         Visible bool
12861                         Texture
12862                         ToneMap Texture
12863                         Rise    Texture
12864                         Rising  bool
12865                         Size    float32
12866                 }))(obj)).Rising
12867                 switch n := read8(r); n {
12868                 case 0:
12869                         *p = false
12870                 case 1:
12871                         *p = true
12872                 default:
12873                         chk(fmt.Errorf("invalid bool: %d", n))
12874                 }
12875         }
12876         {
12877                 p := &(*(*(struct {
12878                         Visible bool
12879                         Texture
12880                         ToneMap Texture
12881                         Rise    Texture
12882                         Rising  bool
12883                         Size    float32
12884                 }))(obj)).Size
12885                 *p = math.Float32frombits(read32(r))
12886         }
12887 }
12888
12889 func (obj *ToCltMoonParams) Serialize(w io.Writer) {
12890         {
12891                 x := (*(*(struct {
12892                         Visible bool
12893                         Texture
12894                         ToneMap Texture
12895                         Size    float32
12896                 }))(obj)).Visible
12897                 if x {
12898                         write8(w, 1)
12899                 } else {
12900                         write8(w, 0)
12901                 }
12902         }
12903         if err := pcall(func() {
12904                 ((*(*(struct {
12905                         Visible bool
12906                         Texture
12907                         ToneMap Texture
12908                         Size    float32
12909                 }))(obj)).Texture).Serialize(w)
12910         }); err != nil {
12911                 if err == io.EOF {
12912                         chk(io.EOF)
12913                 }
12914                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12915         }
12916         if err := pcall(func() {
12917                 ((*(*(struct {
12918                         Visible bool
12919                         Texture
12920                         ToneMap Texture
12921                         Size    float32
12922                 }))(obj)).ToneMap).Serialize(w)
12923         }); err != nil {
12924                 if err == io.EOF {
12925                         chk(io.EOF)
12926                 }
12927                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12928         }
12929         {
12930                 x := (*(*(struct {
12931                         Visible bool
12932                         Texture
12933                         ToneMap Texture
12934                         Size    float32
12935                 }))(obj)).Size
12936                 write32(w, math.Float32bits(x))
12937         }
12938 }
12939
12940 func (obj *ToCltMoonParams) Deserialize(r io.Reader) {
12941         {
12942                 p := &(*(*(struct {
12943                         Visible bool
12944                         Texture
12945                         ToneMap Texture
12946                         Size    float32
12947                 }))(obj)).Visible
12948                 switch n := read8(r); n {
12949                 case 0:
12950                         *p = false
12951                 case 1:
12952                         *p = true
12953                 default:
12954                         chk(fmt.Errorf("invalid bool: %d", n))
12955                 }
12956         }
12957         if err := pcall(func() {
12958                 ((*(*(struct {
12959                         Visible bool
12960                         Texture
12961                         ToneMap Texture
12962                         Size    float32
12963                 }))(obj)).Texture).Deserialize(r)
12964         }); err != nil {
12965                 if err == io.EOF {
12966                         chk(io.EOF)
12967                 }
12968                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12969         }
12970         if err := pcall(func() {
12971                 ((*(*(struct {
12972                         Visible bool
12973                         Texture
12974                         ToneMap Texture
12975                         Size    float32
12976                 }))(obj)).ToneMap).Deserialize(r)
12977         }); err != nil {
12978                 if err == io.EOF {
12979                         chk(io.EOF)
12980                 }
12981                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12982         }
12983         {
12984                 p := &(*(*(struct {
12985                         Visible bool
12986                         Texture
12987                         ToneMap Texture
12988                         Size    float32
12989                 }))(obj)).Size
12990                 *p = math.Float32frombits(read32(r))
12991         }
12992 }
12993
12994 func (obj *ToCltStarParams) Serialize(w io.Writer) {
12995         {
12996                 x := (*(*(struct {
12997                         Visible bool
12998                         Count   uint32
12999                         Color   color.NRGBA
13000                         Size    float32
13001                 }))(obj)).Visible
13002                 if x {
13003                         write8(w, 1)
13004                 } else {
13005                         write8(w, 0)
13006                 }
13007         }
13008         {
13009                 x := (*(*(struct {
13010                         Visible bool
13011                         Count   uint32
13012                         Color   color.NRGBA
13013                         Size    float32
13014                 }))(obj)).Count
13015                 write32(w, uint32(x))
13016         }
13017         {
13018                 x := (*(*(struct {
13019                         Visible bool
13020                         Count   uint32
13021                         Color   color.NRGBA
13022                         Size    float32
13023                 }))(obj)).Color
13024                 w.Write([]byte{x.A, x.R, x.G, x.B})
13025         }
13026         {
13027                 x := (*(*(struct {
13028                         Visible bool
13029                         Count   uint32
13030                         Color   color.NRGBA
13031                         Size    float32
13032                 }))(obj)).Size
13033                 write32(w, math.Float32bits(x))
13034         }
13035 }
13036
13037 func (obj *ToCltStarParams) Deserialize(r io.Reader) {
13038         {
13039                 p := &(*(*(struct {
13040                         Visible bool
13041                         Count   uint32
13042                         Color   color.NRGBA
13043                         Size    float32
13044                 }))(obj)).Visible
13045                 switch n := read8(r); n {
13046                 case 0:
13047                         *p = false
13048                 case 1:
13049                         *p = true
13050                 default:
13051                         chk(fmt.Errorf("invalid bool: %d", n))
13052                 }
13053         }
13054         {
13055                 p := &(*(*(struct {
13056                         Visible bool
13057                         Count   uint32
13058                         Color   color.NRGBA
13059                         Size    float32
13060                 }))(obj)).Count
13061                 *p = read32(r)
13062         }
13063         {
13064                 p := &(*(*(struct {
13065                         Visible bool
13066                         Count   uint32
13067                         Color   color.NRGBA
13068                         Size    float32
13069                 }))(obj)).Color
13070                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13071         }
13072         {
13073                 p := &(*(*(struct {
13074                         Visible bool
13075                         Count   uint32
13076                         Color   color.NRGBA
13077                         Size    float32
13078                 }))(obj)).Size
13079                 *p = math.Float32frombits(read32(r))
13080         }
13081 }
13082
13083 func (obj *ToCltSRPBytesSaltB) Serialize(w io.Writer) {
13084         if len(((*(*(struct {
13085                 Salt, B []byte
13086         }))(obj)).Salt)) > math.MaxUint16 {
13087                 chk(ErrTooLong)
13088         }
13089         {
13090                 x := uint16(len(((*(*(struct {
13091                         Salt, B []byte
13092                 }))(obj)).Salt)))
13093                 write16(w, uint16(x))
13094         }
13095         {
13096                 _, err := w.Write(((*(*(struct {
13097                         Salt, B []byte
13098                 }))(obj)).Salt)[:])
13099                 chk(err)
13100         }
13101         if len(((*(*(struct {
13102                 Salt, B []byte
13103         }))(obj)).B)) > math.MaxUint16 {
13104                 chk(ErrTooLong)
13105         }
13106         {
13107                 x := uint16(len(((*(*(struct {
13108                         Salt, B []byte
13109                 }))(obj)).B)))
13110                 write16(w, uint16(x))
13111         }
13112         {
13113                 _, err := w.Write(((*(*(struct {
13114                         Salt, B []byte
13115                 }))(obj)).B)[:])
13116                 chk(err)
13117         }
13118 }
13119
13120 func (obj *ToCltSRPBytesSaltB) Deserialize(r io.Reader) {
13121         var local223 uint16
13122         {
13123                 p := &local223
13124                 *p = read16(r)
13125         }
13126         ((*(*(struct {
13127                 Salt, B []byte
13128         }))(obj)).Salt) = make([]byte, local223)
13129         {
13130                 _, err := io.ReadFull(r, ((*(*(struct {
13131                         Salt, B []byte
13132                 }))(obj)).Salt)[:])
13133                 chk(err)
13134         }
13135         var local224 uint16
13136         {
13137                 p := &local224
13138                 *p = read16(r)
13139         }
13140         ((*(*(struct {
13141                 Salt, B []byte
13142         }))(obj)).B) = make([]byte, local224)
13143         {
13144                 _, err := io.ReadFull(r, ((*(*(struct {
13145                         Salt, B []byte
13146                 }))(obj)).B)[:])
13147                 chk(err)
13148         }
13149 }
13150
13151 func (obj *ToCltFormspecPrepend) Serialize(w io.Writer) {
13152         if len(([]byte((*(*(struct {
13153                 Prepend string
13154         }))(obj)).Prepend))) > math.MaxUint16 {
13155                 chk(ErrTooLong)
13156         }
13157         {
13158                 x := uint16(len(([]byte((*(*(struct {
13159                         Prepend string
13160                 }))(obj)).Prepend))))
13161                 write16(w, uint16(x))
13162         }
13163         {
13164                 _, err := w.Write(([]byte((*(*(struct {
13165                         Prepend string
13166                 }))(obj)).Prepend))[:])
13167                 chk(err)
13168         }
13169 }
13170
13171 func (obj *ToCltFormspecPrepend) Deserialize(r io.Reader) {
13172         var local225 []uint8
13173         var local226 uint16
13174         {
13175                 p := &local226
13176                 *p = read16(r)
13177         }
13178         (local225) = make([]uint8, local226)
13179         {
13180                 _, err := io.ReadFull(r, (local225)[:])
13181                 chk(err)
13182         }
13183         ((*(*(struct {
13184                 Prepend string
13185         }))(obj)).Prepend) = string(local225)
13186 }
13187
13188 func (obj *AOCmdProps) Serialize(w io.Writer) {
13189         if err := pcall(func() {
13190                 ((*(*(struct {
13191                         Props AOProps
13192                 }))(obj)).Props).Serialize(w)
13193         }); err != nil {
13194                 if err == io.EOF {
13195                         chk(io.EOF)
13196                 }
13197                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOProps", err))
13198         }
13199 }
13200
13201 func (obj *AOCmdProps) Deserialize(r io.Reader) {
13202         if err := pcall(func() {
13203                 ((*(*(struct {
13204                         Props AOProps
13205                 }))(obj)).Props).Deserialize(r)
13206         }); err != nil {
13207                 if err == io.EOF {
13208                         chk(io.EOF)
13209                 }
13210                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOProps", err))
13211         }
13212 }
13213
13214 func (obj *AOCmdPos) Serialize(w io.Writer) {
13215         if err := pcall(func() {
13216                 ((*(*(struct {
13217                         Pos AOPos
13218                 }))(obj)).Pos).Serialize(w)
13219         }); err != nil {
13220                 if err == io.EOF {
13221                         chk(io.EOF)
13222                 }
13223                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPos", err))
13224         }
13225 }
13226
13227 func (obj *AOCmdPos) Deserialize(r io.Reader) {
13228         if err := pcall(func() {
13229                 ((*(*(struct {
13230                         Pos AOPos
13231                 }))(obj)).Pos).Deserialize(r)
13232         }); err != nil {
13233                 if err == io.EOF {
13234                         chk(io.EOF)
13235                 }
13236                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPos", err))
13237         }
13238 }
13239
13240 func (obj *AOCmdTextureMod) Serialize(w io.Writer) {
13241         if err := pcall(func() {
13242                 ((*(*(struct {
13243                         Mod Texture // suffix
13244                 }))(obj)).Mod).Serialize(w)
13245         }); err != nil {
13246                 if err == io.EOF {
13247                         chk(io.EOF)
13248                 }
13249                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13250         }
13251 }
13252
13253 func (obj *AOCmdTextureMod) Deserialize(r io.Reader) {
13254         if err := pcall(func() {
13255                 ((*(*(struct {
13256                         Mod Texture // suffix
13257                 }))(obj)).Mod).Deserialize(r)
13258         }); err != nil {
13259                 if err == io.EOF {
13260                         chk(io.EOF)
13261                 }
13262                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13263         }
13264 }
13265
13266 func (obj *AOCmdSprite) Serialize(w io.Writer) {
13267         if err := pcall(func() {
13268                 ((*(*(struct {
13269                         Sprite AOSprite
13270                 }))(obj)).Sprite).Serialize(w)
13271         }); err != nil {
13272                 if err == io.EOF {
13273                         chk(io.EOF)
13274                 }
13275                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOSprite", err))
13276         }
13277 }
13278
13279 func (obj *AOCmdSprite) Deserialize(r io.Reader) {
13280         if err := pcall(func() {
13281                 ((*(*(struct {
13282                         Sprite AOSprite
13283                 }))(obj)).Sprite).Deserialize(r)
13284         }); err != nil {
13285                 if err == io.EOF {
13286                         chk(io.EOF)
13287                 }
13288                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOSprite", err))
13289         }
13290 }
13291
13292 func (obj *AOCmdHP) Serialize(w io.Writer) {
13293         {
13294                 x := (*(*(struct {
13295                         HP uint16
13296                 }))(obj)).HP
13297                 write16(w, uint16(x))
13298         }
13299 }
13300
13301 func (obj *AOCmdHP) Deserialize(r io.Reader) {
13302         {
13303                 p := &(*(*(struct {
13304                         HP uint16
13305                 }))(obj)).HP
13306                 *p = read16(r)
13307         }
13308 }
13309
13310 func (obj *AOCmdArmorGroups) Serialize(w io.Writer) {
13311         if len(((*(*(struct {
13312                 Armor []Group
13313         }))(obj)).Armor)) > math.MaxUint16 {
13314                 chk(ErrTooLong)
13315         }
13316         {
13317                 x := uint16(len(((*(*(struct {
13318                         Armor []Group
13319                 }))(obj)).Armor)))
13320                 write16(w, uint16(x))
13321         }
13322         for local227 := range (*(*(struct {
13323                 Armor []Group
13324         }))(obj)).Armor {
13325                 if err := pcall(func() {
13326                         (((*(*(struct {
13327                                 Armor []Group
13328                         }))(obj)).Armor)[local227]).Serialize(w)
13329                 }); err != nil {
13330                         if err == io.EOF {
13331                                 chk(io.EOF)
13332                         }
13333                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
13334                 }
13335         }
13336 }
13337
13338 func (obj *AOCmdArmorGroups) Deserialize(r io.Reader) {
13339         var local228 uint16
13340         {
13341                 p := &local228
13342                 *p = read16(r)
13343         }
13344         ((*(*(struct {
13345                 Armor []Group
13346         }))(obj)).Armor) = make([]Group, local228)
13347         for local229 := range (*(*(struct {
13348                 Armor []Group
13349         }))(obj)).Armor {
13350                 if err := pcall(func() {
13351                         (((*(*(struct {
13352                                 Armor []Group
13353                         }))(obj)).Armor)[local229]).Deserialize(r)
13354                 }); err != nil {
13355                         if err == io.EOF {
13356                                 chk(io.EOF)
13357                         }
13358                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
13359                 }
13360         }
13361 }
13362
13363 func (obj *AOCmdAnim) Serialize(w io.Writer) {
13364         if err := pcall(func() {
13365                 ((*(*(struct {
13366                         Anim AOAnim
13367                 }))(obj)).Anim).Serialize(w)
13368         }); err != nil {
13369                 if err == io.EOF {
13370                         chk(io.EOF)
13371                 }
13372                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAnim", err))
13373         }
13374 }
13375
13376 func (obj *AOCmdAnim) Deserialize(r io.Reader) {
13377         if err := pcall(func() {
13378                 ((*(*(struct {
13379                         Anim AOAnim
13380                 }))(obj)).Anim).Deserialize(r)
13381         }); err != nil {
13382                 if err == io.EOF {
13383                         chk(io.EOF)
13384                 }
13385                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAnim", err))
13386         }
13387 }
13388
13389 func (obj *AOCmdBonePos) Serialize(w io.Writer) {
13390         if len(([]byte((*(*(struct {
13391                 Bone string
13392                 Pos  AOBonePos
13393         }))(obj)).Bone))) > math.MaxUint16 {
13394                 chk(ErrTooLong)
13395         }
13396         {
13397                 x := uint16(len(([]byte((*(*(struct {
13398                         Bone string
13399                         Pos  AOBonePos
13400                 }))(obj)).Bone))))
13401                 write16(w, uint16(x))
13402         }
13403         {
13404                 _, err := w.Write(([]byte((*(*(struct {
13405                         Bone string
13406                         Pos  AOBonePos
13407                 }))(obj)).Bone))[:])
13408                 chk(err)
13409         }
13410         if err := pcall(func() {
13411                 ((*(*(struct {
13412                         Bone string
13413                         Pos  AOBonePos
13414                 }))(obj)).Pos).Serialize(w)
13415         }); err != nil {
13416                 if err == io.EOF {
13417                         chk(io.EOF)
13418                 }
13419                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOBonePos", err))
13420         }
13421 }
13422
13423 func (obj *AOCmdBonePos) Deserialize(r io.Reader) {
13424         var local230 []uint8
13425         var local231 uint16
13426         {
13427                 p := &local231
13428                 *p = read16(r)
13429         }
13430         (local230) = make([]uint8, local231)
13431         {
13432                 _, err := io.ReadFull(r, (local230)[:])
13433                 chk(err)
13434         }
13435         ((*(*(struct {
13436                 Bone string
13437                 Pos  AOBonePos
13438         }))(obj)).Bone) = string(local230)
13439         if err := pcall(func() {
13440                 ((*(*(struct {
13441                         Bone string
13442                         Pos  AOBonePos
13443                 }))(obj)).Pos).Deserialize(r)
13444         }); err != nil {
13445                 if err == io.EOF {
13446                         chk(io.EOF)
13447                 }
13448                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOBonePos", err))
13449         }
13450 }
13451
13452 func (obj *AOCmdAttach) Serialize(w io.Writer) {
13453         if err := pcall(func() {
13454                 ((*(*(struct {
13455                         Attach AOAttach
13456                 }))(obj)).Attach).Serialize(w)
13457         }); err != nil {
13458                 if err == io.EOF {
13459                         chk(io.EOF)
13460                 }
13461                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAttach", err))
13462         }
13463 }
13464
13465 func (obj *AOCmdAttach) Deserialize(r io.Reader) {
13466         if err := pcall(func() {
13467                 ((*(*(struct {
13468                         Attach AOAttach
13469                 }))(obj)).Attach).Deserialize(r)
13470         }); err != nil {
13471                 if err == io.EOF {
13472                         chk(io.EOF)
13473                 }
13474                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAttach", err))
13475         }
13476 }
13477
13478 func (obj *AOCmdPhysOverride) Serialize(w io.Writer) {
13479         if err := pcall(func() {
13480                 ((*(*(struct {
13481                         Phys AOPhysOverride
13482                 }))(obj)).Phys).Serialize(w)
13483         }); err != nil {
13484                 if err == io.EOF {
13485                         chk(io.EOF)
13486                 }
13487                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPhysOverride", err))
13488         }
13489 }
13490
13491 func (obj *AOCmdPhysOverride) Deserialize(r io.Reader) {
13492         if err := pcall(func() {
13493                 ((*(*(struct {
13494                         Phys AOPhysOverride
13495                 }))(obj)).Phys).Deserialize(r)
13496         }); err != nil {
13497                 if err == io.EOF {
13498                         chk(io.EOF)
13499                 }
13500                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPhysOverride", err))
13501         }
13502 }
13503
13504 func (obj *AOCmdSpawnInfant) Serialize(w io.Writer) {
13505         if err := pcall(func() {
13506                 ((*(*(struct {
13507                         ID AOID
13508                 }))(obj)).ID).Serialize(w)
13509         }); err != nil {
13510                 if err == io.EOF {
13511                         chk(io.EOF)
13512                 }
13513                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
13514         }
13515         {
13516                 local232 := genericCAO
13517                 if err := pcall(func() {
13518                         (local232).Serialize(w)
13519                 }); err != nil {
13520                         if err == io.EOF {
13521                                 chk(io.EOF)
13522                         }
13523                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
13524                 }
13525         }
13526 }
13527
13528 func (obj *AOCmdSpawnInfant) Deserialize(r io.Reader) {
13529         if err := pcall(func() {
13530                 ((*(*(struct {
13531                         ID AOID
13532                 }))(obj)).ID).Deserialize(r)
13533         }); err != nil {
13534                 if err == io.EOF {
13535                         chk(io.EOF)
13536                 }
13537                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
13538         }
13539         {
13540                 var local233 aoType
13541                 local234 := genericCAO
13542                 if err := pcall(func() {
13543                         (local233).Deserialize(r)
13544                 }); err != nil {
13545                         if err == io.EOF {
13546                                 chk(io.EOF)
13547                         }
13548                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
13549                 }
13550                 if local233 != local234 {
13551                         chk(fmt.Errorf("const %v: %v", "genericCAO", local233))
13552                 }
13553         }
13554 }
13555
13556 func (obj *AOCmdAnimSpeed) Serialize(w io.Writer) {
13557         {
13558                 x := (*(*(struct {
13559                         Speed float32
13560                 }))(obj)).Speed
13561                 write32(w, math.Float32bits(x))
13562         }
13563 }
13564
13565 func (obj *AOCmdAnimSpeed) Deserialize(r io.Reader) {
13566         {
13567                 p := &(*(*(struct {
13568                         Speed float32
13569                 }))(obj)).Speed
13570                 *p = math.Float32frombits(read32(r))
13571         }
13572 }
13573
13574 func (obj *NodeMeta) Serialize(w io.Writer) {
13575         if len(((*(*(struct {
13576                 //mt:len32
13577                 Fields []NodeMetaField
13578
13579                 Inv Inv
13580         }))(obj)).Fields)) > math.MaxUint32 {
13581                 chk(ErrTooLong)
13582         }
13583         {
13584                 x := uint32(len(((*(*(struct {
13585                         //mt:len32
13586                         Fields []NodeMetaField
13587
13588                         Inv Inv
13589                 }))(obj)).Fields)))
13590                 write32(w, uint32(x))
13591         }
13592         for local235 := range (*(*(struct {
13593                 //mt:len32
13594                 Fields []NodeMetaField
13595
13596                 Inv Inv
13597         }))(obj)).Fields {
13598                 if err := pcall(func() {
13599                         (((*(*(struct {
13600                                 //mt:len32
13601                                 Fields []NodeMetaField
13602
13603                                 Inv Inv
13604                         }))(obj)).Fields)[local235]).Serialize(w)
13605                 }); err != nil {
13606                         if err == io.EOF {
13607                                 chk(io.EOF)
13608                         }
13609                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeMetaField", err))
13610                 }
13611         }
13612         chk(((*(*(struct {
13613                 //mt:len32
13614                 Fields []NodeMetaField
13615
13616                 Inv Inv
13617         }))(obj)).Inv).Serialize(w))
13618 }
13619
13620 func (obj *NodeMeta) Deserialize(r io.Reader) {
13621         var local236 uint32
13622         {
13623                 p := &local236
13624                 *p = read32(r)
13625         }
13626         ((*(*(struct {
13627                 //mt:len32
13628                 Fields []NodeMetaField
13629
13630                 Inv Inv
13631         }))(obj)).Fields) = make([]NodeMetaField, local236)
13632         for local237 := range (*(*(struct {
13633                 //mt:len32
13634                 Fields []NodeMetaField
13635
13636                 Inv Inv
13637         }))(obj)).Fields {
13638                 if err := pcall(func() {
13639                         (((*(*(struct {
13640                                 //mt:len32
13641                                 Fields []NodeMetaField
13642
13643                                 Inv Inv
13644                         }))(obj)).Fields)[local237]).Deserialize(r)
13645                 }); err != nil {
13646                         if err == io.EOF {
13647                                 chk(io.EOF)
13648                         }
13649                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeMetaField", err))
13650                 }
13651         }
13652         chk(((*(*(struct {
13653                 //mt:len32
13654                 Fields []NodeMetaField
13655
13656                 Inv Inv
13657         }))(obj)).Inv).Deserialize(r))
13658 }
13659
13660 func (obj *MinimapMode) Serialize(w io.Writer) {
13661         if err := pcall(func() {
13662                 ((*(*(struct {
13663                         Type  MinimapType
13664                         Label string
13665                         Size  uint16
13666                         Texture
13667                         Scale uint16
13668                 }))(obj)).Type).Serialize(w)
13669         }); err != nil {
13670                 if err == io.EOF {
13671                         chk(io.EOF)
13672                 }
13673                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
13674         }
13675         if len(([]byte((*(*(struct {
13676                 Type  MinimapType
13677                 Label string
13678                 Size  uint16
13679                 Texture
13680                 Scale uint16
13681         }))(obj)).Label))) > math.MaxUint16 {
13682                 chk(ErrTooLong)
13683         }
13684         {
13685                 x := uint16(len(([]byte((*(*(struct {
13686                         Type  MinimapType
13687                         Label string
13688                         Size  uint16
13689                         Texture
13690                         Scale uint16
13691                 }))(obj)).Label))))
13692                 write16(w, uint16(x))
13693         }
13694         {
13695                 _, err := w.Write(([]byte((*(*(struct {
13696                         Type  MinimapType
13697                         Label string
13698                         Size  uint16
13699                         Texture
13700                         Scale uint16
13701                 }))(obj)).Label))[:])
13702                 chk(err)
13703         }
13704         {
13705                 x := (*(*(struct {
13706                         Type  MinimapType
13707                         Label string
13708                         Size  uint16
13709                         Texture
13710                         Scale uint16
13711                 }))(obj)).Size
13712                 write16(w, uint16(x))
13713         }
13714         if err := pcall(func() {
13715                 ((*(*(struct {
13716                         Type  MinimapType
13717                         Label string
13718                         Size  uint16
13719                         Texture
13720                         Scale uint16
13721                 }))(obj)).Texture).Serialize(w)
13722         }); err != nil {
13723                 if err == io.EOF {
13724                         chk(io.EOF)
13725                 }
13726                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13727         }
13728         {
13729                 x := (*(*(struct {
13730                         Type  MinimapType
13731                         Label string
13732                         Size  uint16
13733                         Texture
13734                         Scale uint16
13735                 }))(obj)).Scale
13736                 write16(w, uint16(x))
13737         }
13738 }
13739
13740 func (obj *MinimapMode) Deserialize(r io.Reader) {
13741         if err := pcall(func() {
13742                 ((*(*(struct {
13743                         Type  MinimapType
13744                         Label string
13745                         Size  uint16
13746                         Texture
13747                         Scale uint16
13748                 }))(obj)).Type).Deserialize(r)
13749         }); err != nil {
13750                 if err == io.EOF {
13751                         chk(io.EOF)
13752                 }
13753                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
13754         }
13755         var local238 []uint8
13756         var local239 uint16
13757         {
13758                 p := &local239
13759                 *p = read16(r)
13760         }
13761         (local238) = make([]uint8, local239)
13762         {
13763                 _, err := io.ReadFull(r, (local238)[:])
13764                 chk(err)
13765         }
13766         ((*(*(struct {
13767                 Type  MinimapType
13768                 Label string
13769                 Size  uint16
13770                 Texture
13771                 Scale uint16
13772         }))(obj)).Label) = string(local238)
13773         {
13774                 p := &(*(*(struct {
13775                         Type  MinimapType
13776                         Label string
13777                         Size  uint16
13778                         Texture
13779                         Scale uint16
13780                 }))(obj)).Size
13781                 *p = read16(r)
13782         }
13783         if err := pcall(func() {
13784                 ((*(*(struct {
13785                         Type  MinimapType
13786                         Label string
13787                         Size  uint16
13788                         Texture
13789                         Scale uint16
13790                 }))(obj)).Texture).Deserialize(r)
13791         }); err != nil {
13792                 if err == io.EOF {
13793                         chk(io.EOF)
13794                 }
13795                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13796         }
13797         {
13798                 p := &(*(*(struct {
13799                         Type  MinimapType
13800                         Label string
13801                         Size  uint16
13802                         Texture
13803                         Scale uint16
13804                 }))(obj)).Scale
13805                 *p = read16(r)
13806         }
13807 }
13808
13809 func (obj *NodeDef) Serialize(w io.Writer) {
13810         if err := pcall(func() {
13811                 ((*(*(struct {
13812                         Param0 Content
13813
13814                         Name   string
13815                         Groups []Group
13816
13817                         P1Type   Param1Type
13818                         P2Type   Param2Type
13819                         DrawType DrawType
13820
13821                         Mesh  string
13822                         Scale float32
13823                         //mt:const uint8(6)
13824                         Tiles        [6]TileDef
13825                         OverlayTiles [6]TileDef
13826                         //mt:const uint8(6)
13827                         SpecialTiles [6]TileDef
13828
13829                         Color   color.NRGBA
13830                         Palette Texture
13831
13832                         Waving       WaveType
13833                         ConnectSides uint8
13834                         ConnectTo    []Content
13835                         InsideTint   color.NRGBA
13836                         Level        uint8 // Must be < 128.
13837
13838                         Translucent bool // Sunlight is scattered and becomes normal light.
13839                         Transparent bool // Sunlight isn't scattered.
13840                         LightSrc    uint8
13841
13842                         GndContent   bool
13843                         Collides     bool
13844                         Pointable    bool
13845                         Diggable     bool
13846                         Climbable    bool
13847                         Replaceable  bool
13848                         OnRightClick bool
13849
13850                         DmgPerSec int32
13851
13852                         LiquidType   LiquidType
13853                         FlowingAlt   string
13854                         SrcAlt       string
13855                         Viscosity    uint8 // 0-7
13856                         LiqRenewable bool
13857                         FlowRange    uint8
13858                         DrownDmg     uint8
13859                         Floodable    bool
13860
13861                         DrawBox, ColBox, SelBox NodeBox
13862
13863                         FootstepSnd, DiggingSnd, DugSnd SoundDef
13864
13865                         LegacyFaceDir bool
13866                         LegacyMounted bool
13867
13868                         DigPredict string
13869
13870                         MaxLvl uint8
13871
13872                         AlphaUse
13873                 }))(obj)).Param0).Serialize(w)
13874         }); err != nil {
13875                 if err == io.EOF {
13876                         chk(io.EOF)
13877                 }
13878                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
13879         }
13880         {
13881                 ow := w
13882                 w := new(bytes.Buffer)
13883                 {
13884                         local240 := uint8(13)
13885                         {
13886                                 x := local240
13887                                 write8(w, uint8(x))
13888                         }
13889                 }
13890                 if len(([]byte((*(*(struct {
13891                         Param0 Content
13892
13893                         Name   string
13894                         Groups []Group
13895
13896                         P1Type   Param1Type
13897                         P2Type   Param2Type
13898                         DrawType DrawType
13899
13900                         Mesh  string
13901                         Scale float32
13902                         //mt:const uint8(6)
13903                         Tiles        [6]TileDef
13904                         OverlayTiles [6]TileDef
13905                         //mt:const uint8(6)
13906                         SpecialTiles [6]TileDef
13907
13908                         Color   color.NRGBA
13909                         Palette Texture
13910
13911                         Waving       WaveType
13912                         ConnectSides uint8
13913                         ConnectTo    []Content
13914                         InsideTint   color.NRGBA
13915                         Level        uint8 // Must be < 128.
13916
13917                         Translucent bool // Sunlight is scattered and becomes normal light.
13918                         Transparent bool // Sunlight isn't scattered.
13919                         LightSrc    uint8
13920
13921                         GndContent   bool
13922                         Collides     bool
13923                         Pointable    bool
13924                         Diggable     bool
13925                         Climbable    bool
13926                         Replaceable  bool
13927                         OnRightClick bool
13928
13929                         DmgPerSec int32
13930
13931                         LiquidType   LiquidType
13932                         FlowingAlt   string
13933                         SrcAlt       string
13934                         Viscosity    uint8 // 0-7
13935                         LiqRenewable bool
13936                         FlowRange    uint8
13937                         DrownDmg     uint8
13938                         Floodable    bool
13939
13940                         DrawBox, ColBox, SelBox NodeBox
13941
13942                         FootstepSnd, DiggingSnd, DugSnd SoundDef
13943
13944                         LegacyFaceDir bool
13945                         LegacyMounted bool
13946
13947                         DigPredict string
13948
13949                         MaxLvl uint8
13950
13951                         AlphaUse
13952                 }))(obj)).Name))) > math.MaxUint16 {
13953                         chk(ErrTooLong)
13954                 }
13955                 {
13956                         x := uint16(len(([]byte((*(*(struct {
13957                                 Param0 Content
13958
13959                                 Name   string
13960                                 Groups []Group
13961
13962                                 P1Type   Param1Type
13963                                 P2Type   Param2Type
13964                                 DrawType DrawType
13965
13966                                 Mesh  string
13967                                 Scale float32
13968                                 //mt:const uint8(6)
13969                                 Tiles        [6]TileDef
13970                                 OverlayTiles [6]TileDef
13971                                 //mt:const uint8(6)
13972                                 SpecialTiles [6]TileDef
13973
13974                                 Color   color.NRGBA
13975                                 Palette Texture
13976
13977                                 Waving       WaveType
13978                                 ConnectSides uint8
13979                                 ConnectTo    []Content
13980                                 InsideTint   color.NRGBA
13981                                 Level        uint8 // Must be < 128.
13982
13983                                 Translucent bool // Sunlight is scattered and becomes normal light.
13984                                 Transparent bool // Sunlight isn't scattered.
13985                                 LightSrc    uint8
13986
13987                                 GndContent   bool
13988                                 Collides     bool
13989                                 Pointable    bool
13990                                 Diggable     bool
13991                                 Climbable    bool
13992                                 Replaceable  bool
13993                                 OnRightClick bool
13994
13995                                 DmgPerSec int32
13996
13997                                 LiquidType   LiquidType
13998                                 FlowingAlt   string
13999                                 SrcAlt       string
14000                                 Viscosity    uint8 // 0-7
14001                                 LiqRenewable bool
14002                                 FlowRange    uint8
14003                                 DrownDmg     uint8
14004                                 Floodable    bool
14005
14006                                 DrawBox, ColBox, SelBox NodeBox
14007
14008                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14009
14010                                 LegacyFaceDir bool
14011                                 LegacyMounted bool
14012
14013                                 DigPredict string
14014
14015                                 MaxLvl uint8
14016
14017                                 AlphaUse
14018                         }))(obj)).Name))))
14019                         write16(w, uint16(x))
14020                 }
14021                 {
14022                         _, err := w.Write(([]byte((*(*(struct {
14023                                 Param0 Content
14024
14025                                 Name   string
14026                                 Groups []Group
14027
14028                                 P1Type   Param1Type
14029                                 P2Type   Param2Type
14030                                 DrawType DrawType
14031
14032                                 Mesh  string
14033                                 Scale float32
14034                                 //mt:const uint8(6)
14035                                 Tiles        [6]TileDef
14036                                 OverlayTiles [6]TileDef
14037                                 //mt:const uint8(6)
14038                                 SpecialTiles [6]TileDef
14039
14040                                 Color   color.NRGBA
14041                                 Palette Texture
14042
14043                                 Waving       WaveType
14044                                 ConnectSides uint8
14045                                 ConnectTo    []Content
14046                                 InsideTint   color.NRGBA
14047                                 Level        uint8 // Must be < 128.
14048
14049                                 Translucent bool // Sunlight is scattered and becomes normal light.
14050                                 Transparent bool // Sunlight isn't scattered.
14051                                 LightSrc    uint8
14052
14053                                 GndContent   bool
14054                                 Collides     bool
14055                                 Pointable    bool
14056                                 Diggable     bool
14057                                 Climbable    bool
14058                                 Replaceable  bool
14059                                 OnRightClick bool
14060
14061                                 DmgPerSec int32
14062
14063                                 LiquidType   LiquidType
14064                                 FlowingAlt   string
14065                                 SrcAlt       string
14066                                 Viscosity    uint8 // 0-7
14067                                 LiqRenewable bool
14068                                 FlowRange    uint8
14069                                 DrownDmg     uint8
14070                                 Floodable    bool
14071
14072                                 DrawBox, ColBox, SelBox NodeBox
14073
14074                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14075
14076                                 LegacyFaceDir bool
14077                                 LegacyMounted bool
14078
14079                                 DigPredict string
14080
14081                                 MaxLvl uint8
14082
14083                                 AlphaUse
14084                         }))(obj)).Name))[:])
14085                         chk(err)
14086                 }
14087                 if len(((*(*(struct {
14088                         Param0 Content
14089
14090                         Name   string
14091                         Groups []Group
14092
14093                         P1Type   Param1Type
14094                         P2Type   Param2Type
14095                         DrawType DrawType
14096
14097                         Mesh  string
14098                         Scale float32
14099                         //mt:const uint8(6)
14100                         Tiles        [6]TileDef
14101                         OverlayTiles [6]TileDef
14102                         //mt:const uint8(6)
14103                         SpecialTiles [6]TileDef
14104
14105                         Color   color.NRGBA
14106                         Palette Texture
14107
14108                         Waving       WaveType
14109                         ConnectSides uint8
14110                         ConnectTo    []Content
14111                         InsideTint   color.NRGBA
14112                         Level        uint8 // Must be < 128.
14113
14114                         Translucent bool // Sunlight is scattered and becomes normal light.
14115                         Transparent bool // Sunlight isn't scattered.
14116                         LightSrc    uint8
14117
14118                         GndContent   bool
14119                         Collides     bool
14120                         Pointable    bool
14121                         Diggable     bool
14122                         Climbable    bool
14123                         Replaceable  bool
14124                         OnRightClick bool
14125
14126                         DmgPerSec int32
14127
14128                         LiquidType   LiquidType
14129                         FlowingAlt   string
14130                         SrcAlt       string
14131                         Viscosity    uint8 // 0-7
14132                         LiqRenewable bool
14133                         FlowRange    uint8
14134                         DrownDmg     uint8
14135                         Floodable    bool
14136
14137                         DrawBox, ColBox, SelBox NodeBox
14138
14139                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14140
14141                         LegacyFaceDir bool
14142                         LegacyMounted bool
14143
14144                         DigPredict string
14145
14146                         MaxLvl uint8
14147
14148                         AlphaUse
14149                 }))(obj)).Groups)) > math.MaxUint16 {
14150                         chk(ErrTooLong)
14151                 }
14152                 {
14153                         x := uint16(len(((*(*(struct {
14154                                 Param0 Content
14155
14156                                 Name   string
14157                                 Groups []Group
14158
14159                                 P1Type   Param1Type
14160                                 P2Type   Param2Type
14161                                 DrawType DrawType
14162
14163                                 Mesh  string
14164                                 Scale float32
14165                                 //mt:const uint8(6)
14166                                 Tiles        [6]TileDef
14167                                 OverlayTiles [6]TileDef
14168                                 //mt:const uint8(6)
14169                                 SpecialTiles [6]TileDef
14170
14171                                 Color   color.NRGBA
14172                                 Palette Texture
14173
14174                                 Waving       WaveType
14175                                 ConnectSides uint8
14176                                 ConnectTo    []Content
14177                                 InsideTint   color.NRGBA
14178                                 Level        uint8 // Must be < 128.
14179
14180                                 Translucent bool // Sunlight is scattered and becomes normal light.
14181                                 Transparent bool // Sunlight isn't scattered.
14182                                 LightSrc    uint8
14183
14184                                 GndContent   bool
14185                                 Collides     bool
14186                                 Pointable    bool
14187                                 Diggable     bool
14188                                 Climbable    bool
14189                                 Replaceable  bool
14190                                 OnRightClick bool
14191
14192                                 DmgPerSec int32
14193
14194                                 LiquidType   LiquidType
14195                                 FlowingAlt   string
14196                                 SrcAlt       string
14197                                 Viscosity    uint8 // 0-7
14198                                 LiqRenewable bool
14199                                 FlowRange    uint8
14200                                 DrownDmg     uint8
14201                                 Floodable    bool
14202
14203                                 DrawBox, ColBox, SelBox NodeBox
14204
14205                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14206
14207                                 LegacyFaceDir bool
14208                                 LegacyMounted bool
14209
14210                                 DigPredict string
14211
14212                                 MaxLvl uint8
14213
14214                                 AlphaUse
14215                         }))(obj)).Groups)))
14216                         write16(w, uint16(x))
14217                 }
14218                 for local241 := range (*(*(struct {
14219                         Param0 Content
14220
14221                         Name   string
14222                         Groups []Group
14223
14224                         P1Type   Param1Type
14225                         P2Type   Param2Type
14226                         DrawType DrawType
14227
14228                         Mesh  string
14229                         Scale float32
14230                         //mt:const uint8(6)
14231                         Tiles        [6]TileDef
14232                         OverlayTiles [6]TileDef
14233                         //mt:const uint8(6)
14234                         SpecialTiles [6]TileDef
14235
14236                         Color   color.NRGBA
14237                         Palette Texture
14238
14239                         Waving       WaveType
14240                         ConnectSides uint8
14241                         ConnectTo    []Content
14242                         InsideTint   color.NRGBA
14243                         Level        uint8 // Must be < 128.
14244
14245                         Translucent bool // Sunlight is scattered and becomes normal light.
14246                         Transparent bool // Sunlight isn't scattered.
14247                         LightSrc    uint8
14248
14249                         GndContent   bool
14250                         Collides     bool
14251                         Pointable    bool
14252                         Diggable     bool
14253                         Climbable    bool
14254                         Replaceable  bool
14255                         OnRightClick bool
14256
14257                         DmgPerSec int32
14258
14259                         LiquidType   LiquidType
14260                         FlowingAlt   string
14261                         SrcAlt       string
14262                         Viscosity    uint8 // 0-7
14263                         LiqRenewable bool
14264                         FlowRange    uint8
14265                         DrownDmg     uint8
14266                         Floodable    bool
14267
14268                         DrawBox, ColBox, SelBox NodeBox
14269
14270                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14271
14272                         LegacyFaceDir bool
14273                         LegacyMounted bool
14274
14275                         DigPredict string
14276
14277                         MaxLvl uint8
14278
14279                         AlphaUse
14280                 }))(obj)).Groups {
14281                         if err := pcall(func() {
14282                                 (((*(*(struct {
14283                                         Param0 Content
14284
14285                                         Name   string
14286                                         Groups []Group
14287
14288                                         P1Type   Param1Type
14289                                         P2Type   Param2Type
14290                                         DrawType DrawType
14291
14292                                         Mesh  string
14293                                         Scale float32
14294                                         //mt:const uint8(6)
14295                                         Tiles        [6]TileDef
14296                                         OverlayTiles [6]TileDef
14297                                         //mt:const uint8(6)
14298                                         SpecialTiles [6]TileDef
14299
14300                                         Color   color.NRGBA
14301                                         Palette Texture
14302
14303                                         Waving       WaveType
14304                                         ConnectSides uint8
14305                                         ConnectTo    []Content
14306                                         InsideTint   color.NRGBA
14307                                         Level        uint8 // Must be < 128.
14308
14309                                         Translucent bool // Sunlight is scattered and becomes normal light.
14310                                         Transparent bool // Sunlight isn't scattered.
14311                                         LightSrc    uint8
14312
14313                                         GndContent   bool
14314                                         Collides     bool
14315                                         Pointable    bool
14316                                         Diggable     bool
14317                                         Climbable    bool
14318                                         Replaceable  bool
14319                                         OnRightClick bool
14320
14321                                         DmgPerSec int32
14322
14323                                         LiquidType   LiquidType
14324                                         FlowingAlt   string
14325                                         SrcAlt       string
14326                                         Viscosity    uint8 // 0-7
14327                                         LiqRenewable bool
14328                                         FlowRange    uint8
14329                                         DrownDmg     uint8
14330                                         Floodable    bool
14331
14332                                         DrawBox, ColBox, SelBox NodeBox
14333
14334                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14335
14336                                         LegacyFaceDir bool
14337                                         LegacyMounted bool
14338
14339                                         DigPredict string
14340
14341                                         MaxLvl uint8
14342
14343                                         AlphaUse
14344                                 }))(obj)).Groups)[local241]).Serialize(w)
14345                         }); err != nil {
14346                                 if err == io.EOF {
14347                                         chk(io.EOF)
14348                                 }
14349                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
14350                         }
14351                 }
14352                 if err := pcall(func() {
14353                         ((*(*(struct {
14354                                 Param0 Content
14355
14356                                 Name   string
14357                                 Groups []Group
14358
14359                                 P1Type   Param1Type
14360                                 P2Type   Param2Type
14361                                 DrawType DrawType
14362
14363                                 Mesh  string
14364                                 Scale float32
14365                                 //mt:const uint8(6)
14366                                 Tiles        [6]TileDef
14367                                 OverlayTiles [6]TileDef
14368                                 //mt:const uint8(6)
14369                                 SpecialTiles [6]TileDef
14370
14371                                 Color   color.NRGBA
14372                                 Palette Texture
14373
14374                                 Waving       WaveType
14375                                 ConnectSides uint8
14376                                 ConnectTo    []Content
14377                                 InsideTint   color.NRGBA
14378                                 Level        uint8 // Must be < 128.
14379
14380                                 Translucent bool // Sunlight is scattered and becomes normal light.
14381                                 Transparent bool // Sunlight isn't scattered.
14382                                 LightSrc    uint8
14383
14384                                 GndContent   bool
14385                                 Collides     bool
14386                                 Pointable    bool
14387                                 Diggable     bool
14388                                 Climbable    bool
14389                                 Replaceable  bool
14390                                 OnRightClick bool
14391
14392                                 DmgPerSec int32
14393
14394                                 LiquidType   LiquidType
14395                                 FlowingAlt   string
14396                                 SrcAlt       string
14397                                 Viscosity    uint8 // 0-7
14398                                 LiqRenewable bool
14399                                 FlowRange    uint8
14400                                 DrownDmg     uint8
14401                                 Floodable    bool
14402
14403                                 DrawBox, ColBox, SelBox NodeBox
14404
14405                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14406
14407                                 LegacyFaceDir bool
14408                                 LegacyMounted bool
14409
14410                                 DigPredict string
14411
14412                                 MaxLvl uint8
14413
14414                                 AlphaUse
14415                         }))(obj)).P1Type).Serialize(w)
14416                 }); err != nil {
14417                         if err == io.EOF {
14418                                 chk(io.EOF)
14419                         }
14420                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param1Type", err))
14421                 }
14422                 if err := pcall(func() {
14423                         ((*(*(struct {
14424                                 Param0 Content
14425
14426                                 Name   string
14427                                 Groups []Group
14428
14429                                 P1Type   Param1Type
14430                                 P2Type   Param2Type
14431                                 DrawType DrawType
14432
14433                                 Mesh  string
14434                                 Scale float32
14435                                 //mt:const uint8(6)
14436                                 Tiles        [6]TileDef
14437                                 OverlayTiles [6]TileDef
14438                                 //mt:const uint8(6)
14439                                 SpecialTiles [6]TileDef
14440
14441                                 Color   color.NRGBA
14442                                 Palette Texture
14443
14444                                 Waving       WaveType
14445                                 ConnectSides uint8
14446                                 ConnectTo    []Content
14447                                 InsideTint   color.NRGBA
14448                                 Level        uint8 // Must be < 128.
14449
14450                                 Translucent bool // Sunlight is scattered and becomes normal light.
14451                                 Transparent bool // Sunlight isn't scattered.
14452                                 LightSrc    uint8
14453
14454                                 GndContent   bool
14455                                 Collides     bool
14456                                 Pointable    bool
14457                                 Diggable     bool
14458                                 Climbable    bool
14459                                 Replaceable  bool
14460                                 OnRightClick bool
14461
14462                                 DmgPerSec int32
14463
14464                                 LiquidType   LiquidType
14465                                 FlowingAlt   string
14466                                 SrcAlt       string
14467                                 Viscosity    uint8 // 0-7
14468                                 LiqRenewable bool
14469                                 FlowRange    uint8
14470                                 DrownDmg     uint8
14471                                 Floodable    bool
14472
14473                                 DrawBox, ColBox, SelBox NodeBox
14474
14475                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14476
14477                                 LegacyFaceDir bool
14478                                 LegacyMounted bool
14479
14480                                 DigPredict string
14481
14482                                 MaxLvl uint8
14483
14484                                 AlphaUse
14485                         }))(obj)).P2Type).Serialize(w)
14486                 }); err != nil {
14487                         if err == io.EOF {
14488                                 chk(io.EOF)
14489                         }
14490                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param2Type", err))
14491                 }
14492                 if err := pcall(func() {
14493                         ((*(*(struct {
14494                                 Param0 Content
14495
14496                                 Name   string
14497                                 Groups []Group
14498
14499                                 P1Type   Param1Type
14500                                 P2Type   Param2Type
14501                                 DrawType DrawType
14502
14503                                 Mesh  string
14504                                 Scale float32
14505                                 //mt:const uint8(6)
14506                                 Tiles        [6]TileDef
14507                                 OverlayTiles [6]TileDef
14508                                 //mt:const uint8(6)
14509                                 SpecialTiles [6]TileDef
14510
14511                                 Color   color.NRGBA
14512                                 Palette Texture
14513
14514                                 Waving       WaveType
14515                                 ConnectSides uint8
14516                                 ConnectTo    []Content
14517                                 InsideTint   color.NRGBA
14518                                 Level        uint8 // Must be < 128.
14519
14520                                 Translucent bool // Sunlight is scattered and becomes normal light.
14521                                 Transparent bool // Sunlight isn't scattered.
14522                                 LightSrc    uint8
14523
14524                                 GndContent   bool
14525                                 Collides     bool
14526                                 Pointable    bool
14527                                 Diggable     bool
14528                                 Climbable    bool
14529                                 Replaceable  bool
14530                                 OnRightClick bool
14531
14532                                 DmgPerSec int32
14533
14534                                 LiquidType   LiquidType
14535                                 FlowingAlt   string
14536                                 SrcAlt       string
14537                                 Viscosity    uint8 // 0-7
14538                                 LiqRenewable bool
14539                                 FlowRange    uint8
14540                                 DrownDmg     uint8
14541                                 Floodable    bool
14542
14543                                 DrawBox, ColBox, SelBox NodeBox
14544
14545                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14546
14547                                 LegacyFaceDir bool
14548                                 LegacyMounted bool
14549
14550                                 DigPredict string
14551
14552                                 MaxLvl uint8
14553
14554                                 AlphaUse
14555                         }))(obj)).DrawType).Serialize(w)
14556                 }); err != nil {
14557                         if err == io.EOF {
14558                                 chk(io.EOF)
14559                         }
14560                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
14561                 }
14562                 if len(([]byte((*(*(struct {
14563                         Param0 Content
14564
14565                         Name   string
14566                         Groups []Group
14567
14568                         P1Type   Param1Type
14569                         P2Type   Param2Type
14570                         DrawType DrawType
14571
14572                         Mesh  string
14573                         Scale float32
14574                         //mt:const uint8(6)
14575                         Tiles        [6]TileDef
14576                         OverlayTiles [6]TileDef
14577                         //mt:const uint8(6)
14578                         SpecialTiles [6]TileDef
14579
14580                         Color   color.NRGBA
14581                         Palette Texture
14582
14583                         Waving       WaveType
14584                         ConnectSides uint8
14585                         ConnectTo    []Content
14586                         InsideTint   color.NRGBA
14587                         Level        uint8 // Must be < 128.
14588
14589                         Translucent bool // Sunlight is scattered and becomes normal light.
14590                         Transparent bool // Sunlight isn't scattered.
14591                         LightSrc    uint8
14592
14593                         GndContent   bool
14594                         Collides     bool
14595                         Pointable    bool
14596                         Diggable     bool
14597                         Climbable    bool
14598                         Replaceable  bool
14599                         OnRightClick bool
14600
14601                         DmgPerSec int32
14602
14603                         LiquidType   LiquidType
14604                         FlowingAlt   string
14605                         SrcAlt       string
14606                         Viscosity    uint8 // 0-7
14607                         LiqRenewable bool
14608                         FlowRange    uint8
14609                         DrownDmg     uint8
14610                         Floodable    bool
14611
14612                         DrawBox, ColBox, SelBox NodeBox
14613
14614                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14615
14616                         LegacyFaceDir bool
14617                         LegacyMounted bool
14618
14619                         DigPredict string
14620
14621                         MaxLvl uint8
14622
14623                         AlphaUse
14624                 }))(obj)).Mesh))) > math.MaxUint16 {
14625                         chk(ErrTooLong)
14626                 }
14627                 {
14628                         x := uint16(len(([]byte((*(*(struct {
14629                                 Param0 Content
14630
14631                                 Name   string
14632                                 Groups []Group
14633
14634                                 P1Type   Param1Type
14635                                 P2Type   Param2Type
14636                                 DrawType DrawType
14637
14638                                 Mesh  string
14639                                 Scale float32
14640                                 //mt:const uint8(6)
14641                                 Tiles        [6]TileDef
14642                                 OverlayTiles [6]TileDef
14643                                 //mt:const uint8(6)
14644                                 SpecialTiles [6]TileDef
14645
14646                                 Color   color.NRGBA
14647                                 Palette Texture
14648
14649                                 Waving       WaveType
14650                                 ConnectSides uint8
14651                                 ConnectTo    []Content
14652                                 InsideTint   color.NRGBA
14653                                 Level        uint8 // Must be < 128.
14654
14655                                 Translucent bool // Sunlight is scattered and becomes normal light.
14656                                 Transparent bool // Sunlight isn't scattered.
14657                                 LightSrc    uint8
14658
14659                                 GndContent   bool
14660                                 Collides     bool
14661                                 Pointable    bool
14662                                 Diggable     bool
14663                                 Climbable    bool
14664                                 Replaceable  bool
14665                                 OnRightClick bool
14666
14667                                 DmgPerSec int32
14668
14669                                 LiquidType   LiquidType
14670                                 FlowingAlt   string
14671                                 SrcAlt       string
14672                                 Viscosity    uint8 // 0-7
14673                                 LiqRenewable bool
14674                                 FlowRange    uint8
14675                                 DrownDmg     uint8
14676                                 Floodable    bool
14677
14678                                 DrawBox, ColBox, SelBox NodeBox
14679
14680                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14681
14682                                 LegacyFaceDir bool
14683                                 LegacyMounted bool
14684
14685                                 DigPredict string
14686
14687                                 MaxLvl uint8
14688
14689                                 AlphaUse
14690                         }))(obj)).Mesh))))
14691                         write16(w, uint16(x))
14692                 }
14693                 {
14694                         _, err := w.Write(([]byte((*(*(struct {
14695                                 Param0 Content
14696
14697                                 Name   string
14698                                 Groups []Group
14699
14700                                 P1Type   Param1Type
14701                                 P2Type   Param2Type
14702                                 DrawType DrawType
14703
14704                                 Mesh  string
14705                                 Scale float32
14706                                 //mt:const uint8(6)
14707                                 Tiles        [6]TileDef
14708                                 OverlayTiles [6]TileDef
14709                                 //mt:const uint8(6)
14710                                 SpecialTiles [6]TileDef
14711
14712                                 Color   color.NRGBA
14713                                 Palette Texture
14714
14715                                 Waving       WaveType
14716                                 ConnectSides uint8
14717                                 ConnectTo    []Content
14718                                 InsideTint   color.NRGBA
14719                                 Level        uint8 // Must be < 128.
14720
14721                                 Translucent bool // Sunlight is scattered and becomes normal light.
14722                                 Transparent bool // Sunlight isn't scattered.
14723                                 LightSrc    uint8
14724
14725                                 GndContent   bool
14726                                 Collides     bool
14727                                 Pointable    bool
14728                                 Diggable     bool
14729                                 Climbable    bool
14730                                 Replaceable  bool
14731                                 OnRightClick bool
14732
14733                                 DmgPerSec int32
14734
14735                                 LiquidType   LiquidType
14736                                 FlowingAlt   string
14737                                 SrcAlt       string
14738                                 Viscosity    uint8 // 0-7
14739                                 LiqRenewable bool
14740                                 FlowRange    uint8
14741                                 DrownDmg     uint8
14742                                 Floodable    bool
14743
14744                                 DrawBox, ColBox, SelBox NodeBox
14745
14746                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14747
14748                                 LegacyFaceDir bool
14749                                 LegacyMounted bool
14750
14751                                 DigPredict string
14752
14753                                 MaxLvl uint8
14754
14755                                 AlphaUse
14756                         }))(obj)).Mesh))[:])
14757                         chk(err)
14758                 }
14759                 {
14760                         x := (*(*(struct {
14761                                 Param0 Content
14762
14763                                 Name   string
14764                                 Groups []Group
14765
14766                                 P1Type   Param1Type
14767                                 P2Type   Param2Type
14768                                 DrawType DrawType
14769
14770                                 Mesh  string
14771                                 Scale float32
14772                                 //mt:const uint8(6)
14773                                 Tiles        [6]TileDef
14774                                 OverlayTiles [6]TileDef
14775                                 //mt:const uint8(6)
14776                                 SpecialTiles [6]TileDef
14777
14778                                 Color   color.NRGBA
14779                                 Palette Texture
14780
14781                                 Waving       WaveType
14782                                 ConnectSides uint8
14783                                 ConnectTo    []Content
14784                                 InsideTint   color.NRGBA
14785                                 Level        uint8 // Must be < 128.
14786
14787                                 Translucent bool // Sunlight is scattered and becomes normal light.
14788                                 Transparent bool // Sunlight isn't scattered.
14789                                 LightSrc    uint8
14790
14791                                 GndContent   bool
14792                                 Collides     bool
14793                                 Pointable    bool
14794                                 Diggable     bool
14795                                 Climbable    bool
14796                                 Replaceable  bool
14797                                 OnRightClick bool
14798
14799                                 DmgPerSec int32
14800
14801                                 LiquidType   LiquidType
14802                                 FlowingAlt   string
14803                                 SrcAlt       string
14804                                 Viscosity    uint8 // 0-7
14805                                 LiqRenewable bool
14806                                 FlowRange    uint8
14807                                 DrownDmg     uint8
14808                                 Floodable    bool
14809
14810                                 DrawBox, ColBox, SelBox NodeBox
14811
14812                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14813
14814                                 LegacyFaceDir bool
14815                                 LegacyMounted bool
14816
14817                                 DigPredict string
14818
14819                                 MaxLvl uint8
14820
14821                                 AlphaUse
14822                         }))(obj)).Scale
14823                         write32(w, math.Float32bits(x))
14824                 }
14825                 {
14826                         local242 := uint8(6)
14827                         {
14828                                 x := local242
14829                                 write8(w, uint8(x))
14830                         }
14831                 }
14832                 for local243 := range (*(*(struct {
14833                         Param0 Content
14834
14835                         Name   string
14836                         Groups []Group
14837
14838                         P1Type   Param1Type
14839                         P2Type   Param2Type
14840                         DrawType DrawType
14841
14842                         Mesh  string
14843                         Scale float32
14844                         //mt:const uint8(6)
14845                         Tiles        [6]TileDef
14846                         OverlayTiles [6]TileDef
14847                         //mt:const uint8(6)
14848                         SpecialTiles [6]TileDef
14849
14850                         Color   color.NRGBA
14851                         Palette Texture
14852
14853                         Waving       WaveType
14854                         ConnectSides uint8
14855                         ConnectTo    []Content
14856                         InsideTint   color.NRGBA
14857                         Level        uint8 // Must be < 128.
14858
14859                         Translucent bool // Sunlight is scattered and becomes normal light.
14860                         Transparent bool // Sunlight isn't scattered.
14861                         LightSrc    uint8
14862
14863                         GndContent   bool
14864                         Collides     bool
14865                         Pointable    bool
14866                         Diggable     bool
14867                         Climbable    bool
14868                         Replaceable  bool
14869                         OnRightClick bool
14870
14871                         DmgPerSec int32
14872
14873                         LiquidType   LiquidType
14874                         FlowingAlt   string
14875                         SrcAlt       string
14876                         Viscosity    uint8 // 0-7
14877                         LiqRenewable bool
14878                         FlowRange    uint8
14879                         DrownDmg     uint8
14880                         Floodable    bool
14881
14882                         DrawBox, ColBox, SelBox NodeBox
14883
14884                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14885
14886                         LegacyFaceDir bool
14887                         LegacyMounted bool
14888
14889                         DigPredict string
14890
14891                         MaxLvl uint8
14892
14893                         AlphaUse
14894                 }))(obj)).Tiles {
14895                         if err := pcall(func() {
14896                                 (((*(*(struct {
14897                                         Param0 Content
14898
14899                                         Name   string
14900                                         Groups []Group
14901
14902                                         P1Type   Param1Type
14903                                         P2Type   Param2Type
14904                                         DrawType DrawType
14905
14906                                         Mesh  string
14907                                         Scale float32
14908                                         //mt:const uint8(6)
14909                                         Tiles        [6]TileDef
14910                                         OverlayTiles [6]TileDef
14911                                         //mt:const uint8(6)
14912                                         SpecialTiles [6]TileDef
14913
14914                                         Color   color.NRGBA
14915                                         Palette Texture
14916
14917                                         Waving       WaveType
14918                                         ConnectSides uint8
14919                                         ConnectTo    []Content
14920                                         InsideTint   color.NRGBA
14921                                         Level        uint8 // Must be < 128.
14922
14923                                         Translucent bool // Sunlight is scattered and becomes normal light.
14924                                         Transparent bool // Sunlight isn't scattered.
14925                                         LightSrc    uint8
14926
14927                                         GndContent   bool
14928                                         Collides     bool
14929                                         Pointable    bool
14930                                         Diggable     bool
14931                                         Climbable    bool
14932                                         Replaceable  bool
14933                                         OnRightClick bool
14934
14935                                         DmgPerSec int32
14936
14937                                         LiquidType   LiquidType
14938                                         FlowingAlt   string
14939                                         SrcAlt       string
14940                                         Viscosity    uint8 // 0-7
14941                                         LiqRenewable bool
14942                                         FlowRange    uint8
14943                                         DrownDmg     uint8
14944                                         Floodable    bool
14945
14946                                         DrawBox, ColBox, SelBox NodeBox
14947
14948                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14949
14950                                         LegacyFaceDir bool
14951                                         LegacyMounted bool
14952
14953                                         DigPredict string
14954
14955                                         MaxLvl uint8
14956
14957                                         AlphaUse
14958                                 }))(obj)).Tiles)[local243]).Serialize(w)
14959                         }); err != nil {
14960                                 if err == io.EOF {
14961                                         chk(io.EOF)
14962                                 }
14963                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
14964                         }
14965                 }
14966                 for local244 := range (*(*(struct {
14967                         Param0 Content
14968
14969                         Name   string
14970                         Groups []Group
14971
14972                         P1Type   Param1Type
14973                         P2Type   Param2Type
14974                         DrawType DrawType
14975
14976                         Mesh  string
14977                         Scale float32
14978                         //mt:const uint8(6)
14979                         Tiles        [6]TileDef
14980                         OverlayTiles [6]TileDef
14981                         //mt:const uint8(6)
14982                         SpecialTiles [6]TileDef
14983
14984                         Color   color.NRGBA
14985                         Palette Texture
14986
14987                         Waving       WaveType
14988                         ConnectSides uint8
14989                         ConnectTo    []Content
14990                         InsideTint   color.NRGBA
14991                         Level        uint8 // Must be < 128.
14992
14993                         Translucent bool // Sunlight is scattered and becomes normal light.
14994                         Transparent bool // Sunlight isn't scattered.
14995                         LightSrc    uint8
14996
14997                         GndContent   bool
14998                         Collides     bool
14999                         Pointable    bool
15000                         Diggable     bool
15001                         Climbable    bool
15002                         Replaceable  bool
15003                         OnRightClick bool
15004
15005                         DmgPerSec int32
15006
15007                         LiquidType   LiquidType
15008                         FlowingAlt   string
15009                         SrcAlt       string
15010                         Viscosity    uint8 // 0-7
15011                         LiqRenewable bool
15012                         FlowRange    uint8
15013                         DrownDmg     uint8
15014                         Floodable    bool
15015
15016                         DrawBox, ColBox, SelBox NodeBox
15017
15018                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15019
15020                         LegacyFaceDir bool
15021                         LegacyMounted bool
15022
15023                         DigPredict string
15024
15025                         MaxLvl uint8
15026
15027                         AlphaUse
15028                 }))(obj)).OverlayTiles {
15029                         if err := pcall(func() {
15030                                 (((*(*(struct {
15031                                         Param0 Content
15032
15033                                         Name   string
15034                                         Groups []Group
15035
15036                                         P1Type   Param1Type
15037                                         P2Type   Param2Type
15038                                         DrawType DrawType
15039
15040                                         Mesh  string
15041                                         Scale float32
15042                                         //mt:const uint8(6)
15043                                         Tiles        [6]TileDef
15044                                         OverlayTiles [6]TileDef
15045                                         //mt:const uint8(6)
15046                                         SpecialTiles [6]TileDef
15047
15048                                         Color   color.NRGBA
15049                                         Palette Texture
15050
15051                                         Waving       WaveType
15052                                         ConnectSides uint8
15053                                         ConnectTo    []Content
15054                                         InsideTint   color.NRGBA
15055                                         Level        uint8 // Must be < 128.
15056
15057                                         Translucent bool // Sunlight is scattered and becomes normal light.
15058                                         Transparent bool // Sunlight isn't scattered.
15059                                         LightSrc    uint8
15060
15061                                         GndContent   bool
15062                                         Collides     bool
15063                                         Pointable    bool
15064                                         Diggable     bool
15065                                         Climbable    bool
15066                                         Replaceable  bool
15067                                         OnRightClick bool
15068
15069                                         DmgPerSec int32
15070
15071                                         LiquidType   LiquidType
15072                                         FlowingAlt   string
15073                                         SrcAlt       string
15074                                         Viscosity    uint8 // 0-7
15075                                         LiqRenewable bool
15076                                         FlowRange    uint8
15077                                         DrownDmg     uint8
15078                                         Floodable    bool
15079
15080                                         DrawBox, ColBox, SelBox NodeBox
15081
15082                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15083
15084                                         LegacyFaceDir bool
15085                                         LegacyMounted bool
15086
15087                                         DigPredict string
15088
15089                                         MaxLvl uint8
15090
15091                                         AlphaUse
15092                                 }))(obj)).OverlayTiles)[local244]).Serialize(w)
15093                         }); err != nil {
15094                                 if err == io.EOF {
15095                                         chk(io.EOF)
15096                                 }
15097                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
15098                         }
15099                 }
15100                 {
15101                         local245 := uint8(6)
15102                         {
15103                                 x := local245
15104                                 write8(w, uint8(x))
15105                         }
15106                 }
15107                 for local246 := range (*(*(struct {
15108                         Param0 Content
15109
15110                         Name   string
15111                         Groups []Group
15112
15113                         P1Type   Param1Type
15114                         P2Type   Param2Type
15115                         DrawType DrawType
15116
15117                         Mesh  string
15118                         Scale float32
15119                         //mt:const uint8(6)
15120                         Tiles        [6]TileDef
15121                         OverlayTiles [6]TileDef
15122                         //mt:const uint8(6)
15123                         SpecialTiles [6]TileDef
15124
15125                         Color   color.NRGBA
15126                         Palette Texture
15127
15128                         Waving       WaveType
15129                         ConnectSides uint8
15130                         ConnectTo    []Content
15131                         InsideTint   color.NRGBA
15132                         Level        uint8 // Must be < 128.
15133
15134                         Translucent bool // Sunlight is scattered and becomes normal light.
15135                         Transparent bool // Sunlight isn't scattered.
15136                         LightSrc    uint8
15137
15138                         GndContent   bool
15139                         Collides     bool
15140                         Pointable    bool
15141                         Diggable     bool
15142                         Climbable    bool
15143                         Replaceable  bool
15144                         OnRightClick bool
15145
15146                         DmgPerSec int32
15147
15148                         LiquidType   LiquidType
15149                         FlowingAlt   string
15150                         SrcAlt       string
15151                         Viscosity    uint8 // 0-7
15152                         LiqRenewable bool
15153                         FlowRange    uint8
15154                         DrownDmg     uint8
15155                         Floodable    bool
15156
15157                         DrawBox, ColBox, SelBox NodeBox
15158
15159                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15160
15161                         LegacyFaceDir bool
15162                         LegacyMounted bool
15163
15164                         DigPredict string
15165
15166                         MaxLvl uint8
15167
15168                         AlphaUse
15169                 }))(obj)).SpecialTiles {
15170                         if err := pcall(func() {
15171                                 (((*(*(struct {
15172                                         Param0 Content
15173
15174                                         Name   string
15175                                         Groups []Group
15176
15177                                         P1Type   Param1Type
15178                                         P2Type   Param2Type
15179                                         DrawType DrawType
15180
15181                                         Mesh  string
15182                                         Scale float32
15183                                         //mt:const uint8(6)
15184                                         Tiles        [6]TileDef
15185                                         OverlayTiles [6]TileDef
15186                                         //mt:const uint8(6)
15187                                         SpecialTiles [6]TileDef
15188
15189                                         Color   color.NRGBA
15190                                         Palette Texture
15191
15192                                         Waving       WaveType
15193                                         ConnectSides uint8
15194                                         ConnectTo    []Content
15195                                         InsideTint   color.NRGBA
15196                                         Level        uint8 // Must be < 128.
15197
15198                                         Translucent bool // Sunlight is scattered and becomes normal light.
15199                                         Transparent bool // Sunlight isn't scattered.
15200                                         LightSrc    uint8
15201
15202                                         GndContent   bool
15203                                         Collides     bool
15204                                         Pointable    bool
15205                                         Diggable     bool
15206                                         Climbable    bool
15207                                         Replaceable  bool
15208                                         OnRightClick bool
15209
15210                                         DmgPerSec int32
15211
15212                                         LiquidType   LiquidType
15213                                         FlowingAlt   string
15214                                         SrcAlt       string
15215                                         Viscosity    uint8 // 0-7
15216                                         LiqRenewable bool
15217                                         FlowRange    uint8
15218                                         DrownDmg     uint8
15219                                         Floodable    bool
15220
15221                                         DrawBox, ColBox, SelBox NodeBox
15222
15223                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15224
15225                                         LegacyFaceDir bool
15226                                         LegacyMounted bool
15227
15228                                         DigPredict string
15229
15230                                         MaxLvl uint8
15231
15232                                         AlphaUse
15233                                 }))(obj)).SpecialTiles)[local246]).Serialize(w)
15234                         }); err != nil {
15235                                 if err == io.EOF {
15236                                         chk(io.EOF)
15237                                 }
15238                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
15239                         }
15240                 }
15241                 {
15242                         x := (*(*(struct {
15243                                 Param0 Content
15244
15245                                 Name   string
15246                                 Groups []Group
15247
15248                                 P1Type   Param1Type
15249                                 P2Type   Param2Type
15250                                 DrawType DrawType
15251
15252                                 Mesh  string
15253                                 Scale float32
15254                                 //mt:const uint8(6)
15255                                 Tiles        [6]TileDef
15256                                 OverlayTiles [6]TileDef
15257                                 //mt:const uint8(6)
15258                                 SpecialTiles [6]TileDef
15259
15260                                 Color   color.NRGBA
15261                                 Palette Texture
15262
15263                                 Waving       WaveType
15264                                 ConnectSides uint8
15265                                 ConnectTo    []Content
15266                                 InsideTint   color.NRGBA
15267                                 Level        uint8 // Must be < 128.
15268
15269                                 Translucent bool // Sunlight is scattered and becomes normal light.
15270                                 Transparent bool // Sunlight isn't scattered.
15271                                 LightSrc    uint8
15272
15273                                 GndContent   bool
15274                                 Collides     bool
15275                                 Pointable    bool
15276                                 Diggable     bool
15277                                 Climbable    bool
15278                                 Replaceable  bool
15279                                 OnRightClick bool
15280
15281                                 DmgPerSec int32
15282
15283                                 LiquidType   LiquidType
15284                                 FlowingAlt   string
15285                                 SrcAlt       string
15286                                 Viscosity    uint8 // 0-7
15287                                 LiqRenewable bool
15288                                 FlowRange    uint8
15289                                 DrownDmg     uint8
15290                                 Floodable    bool
15291
15292                                 DrawBox, ColBox, SelBox NodeBox
15293
15294                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15295
15296                                 LegacyFaceDir bool
15297                                 LegacyMounted bool
15298
15299                                 DigPredict string
15300
15301                                 MaxLvl uint8
15302
15303                                 AlphaUse
15304                         }))(obj)).Color
15305                         w.Write([]byte{x.A, x.R, x.G, x.B})
15306                 }
15307                 if err := pcall(func() {
15308                         ((*(*(struct {
15309                                 Param0 Content
15310
15311                                 Name   string
15312                                 Groups []Group
15313
15314                                 P1Type   Param1Type
15315                                 P2Type   Param2Type
15316                                 DrawType DrawType
15317
15318                                 Mesh  string
15319                                 Scale float32
15320                                 //mt:const uint8(6)
15321                                 Tiles        [6]TileDef
15322                                 OverlayTiles [6]TileDef
15323                                 //mt:const uint8(6)
15324                                 SpecialTiles [6]TileDef
15325
15326                                 Color   color.NRGBA
15327                                 Palette Texture
15328
15329                                 Waving       WaveType
15330                                 ConnectSides uint8
15331                                 ConnectTo    []Content
15332                                 InsideTint   color.NRGBA
15333                                 Level        uint8 // Must be < 128.
15334
15335                                 Translucent bool // Sunlight is scattered and becomes normal light.
15336                                 Transparent bool // Sunlight isn't scattered.
15337                                 LightSrc    uint8
15338
15339                                 GndContent   bool
15340                                 Collides     bool
15341                                 Pointable    bool
15342                                 Diggable     bool
15343                                 Climbable    bool
15344                                 Replaceable  bool
15345                                 OnRightClick bool
15346
15347                                 DmgPerSec int32
15348
15349                                 LiquidType   LiquidType
15350                                 FlowingAlt   string
15351                                 SrcAlt       string
15352                                 Viscosity    uint8 // 0-7
15353                                 LiqRenewable bool
15354                                 FlowRange    uint8
15355                                 DrownDmg     uint8
15356                                 Floodable    bool
15357
15358                                 DrawBox, ColBox, SelBox NodeBox
15359
15360                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15361
15362                                 LegacyFaceDir bool
15363                                 LegacyMounted bool
15364
15365                                 DigPredict string
15366
15367                                 MaxLvl uint8
15368
15369                                 AlphaUse
15370                         }))(obj)).Palette).Serialize(w)
15371                 }); err != nil {
15372                         if err == io.EOF {
15373                                 chk(io.EOF)
15374                         }
15375                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
15376                 }
15377                 if err := pcall(func() {
15378                         ((*(*(struct {
15379                                 Param0 Content
15380
15381                                 Name   string
15382                                 Groups []Group
15383
15384                                 P1Type   Param1Type
15385                                 P2Type   Param2Type
15386                                 DrawType DrawType
15387
15388                                 Mesh  string
15389                                 Scale float32
15390                                 //mt:const uint8(6)
15391                                 Tiles        [6]TileDef
15392                                 OverlayTiles [6]TileDef
15393                                 //mt:const uint8(6)
15394                                 SpecialTiles [6]TileDef
15395
15396                                 Color   color.NRGBA
15397                                 Palette Texture
15398
15399                                 Waving       WaveType
15400                                 ConnectSides uint8
15401                                 ConnectTo    []Content
15402                                 InsideTint   color.NRGBA
15403                                 Level        uint8 // Must be < 128.
15404
15405                                 Translucent bool // Sunlight is scattered and becomes normal light.
15406                                 Transparent bool // Sunlight isn't scattered.
15407                                 LightSrc    uint8
15408
15409                                 GndContent   bool
15410                                 Collides     bool
15411                                 Pointable    bool
15412                                 Diggable     bool
15413                                 Climbable    bool
15414                                 Replaceable  bool
15415                                 OnRightClick bool
15416
15417                                 DmgPerSec int32
15418
15419                                 LiquidType   LiquidType
15420                                 FlowingAlt   string
15421                                 SrcAlt       string
15422                                 Viscosity    uint8 // 0-7
15423                                 LiqRenewable bool
15424                                 FlowRange    uint8
15425                                 DrownDmg     uint8
15426                                 Floodable    bool
15427
15428                                 DrawBox, ColBox, SelBox NodeBox
15429
15430                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15431
15432                                 LegacyFaceDir bool
15433                                 LegacyMounted bool
15434
15435                                 DigPredict string
15436
15437                                 MaxLvl uint8
15438
15439                                 AlphaUse
15440                         }))(obj)).Waving).Serialize(w)
15441                 }); err != nil {
15442                         if err == io.EOF {
15443                                 chk(io.EOF)
15444                         }
15445                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.WaveType", err))
15446                 }
15447                 {
15448                         x := (*(*(struct {
15449                                 Param0 Content
15450
15451                                 Name   string
15452                                 Groups []Group
15453
15454                                 P1Type   Param1Type
15455                                 P2Type   Param2Type
15456                                 DrawType DrawType
15457
15458                                 Mesh  string
15459                                 Scale float32
15460                                 //mt:const uint8(6)
15461                                 Tiles        [6]TileDef
15462                                 OverlayTiles [6]TileDef
15463                                 //mt:const uint8(6)
15464                                 SpecialTiles [6]TileDef
15465
15466                                 Color   color.NRGBA
15467                                 Palette Texture
15468
15469                                 Waving       WaveType
15470                                 ConnectSides uint8
15471                                 ConnectTo    []Content
15472                                 InsideTint   color.NRGBA
15473                                 Level        uint8 // Must be < 128.
15474
15475                                 Translucent bool // Sunlight is scattered and becomes normal light.
15476                                 Transparent bool // Sunlight isn't scattered.
15477                                 LightSrc    uint8
15478
15479                                 GndContent   bool
15480                                 Collides     bool
15481                                 Pointable    bool
15482                                 Diggable     bool
15483                                 Climbable    bool
15484                                 Replaceable  bool
15485                                 OnRightClick bool
15486
15487                                 DmgPerSec int32
15488
15489                                 LiquidType   LiquidType
15490                                 FlowingAlt   string
15491                                 SrcAlt       string
15492                                 Viscosity    uint8 // 0-7
15493                                 LiqRenewable bool
15494                                 FlowRange    uint8
15495                                 DrownDmg     uint8
15496                                 Floodable    bool
15497
15498                                 DrawBox, ColBox, SelBox NodeBox
15499
15500                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15501
15502                                 LegacyFaceDir bool
15503                                 LegacyMounted bool
15504
15505                                 DigPredict string
15506
15507                                 MaxLvl uint8
15508
15509                                 AlphaUse
15510                         }))(obj)).ConnectSides
15511                         write8(w, uint8(x))
15512                 }
15513                 if len(((*(*(struct {
15514                         Param0 Content
15515
15516                         Name   string
15517                         Groups []Group
15518
15519                         P1Type   Param1Type
15520                         P2Type   Param2Type
15521                         DrawType DrawType
15522
15523                         Mesh  string
15524                         Scale float32
15525                         //mt:const uint8(6)
15526                         Tiles        [6]TileDef
15527                         OverlayTiles [6]TileDef
15528                         //mt:const uint8(6)
15529                         SpecialTiles [6]TileDef
15530
15531                         Color   color.NRGBA
15532                         Palette Texture
15533
15534                         Waving       WaveType
15535                         ConnectSides uint8
15536                         ConnectTo    []Content
15537                         InsideTint   color.NRGBA
15538                         Level        uint8 // Must be < 128.
15539
15540                         Translucent bool // Sunlight is scattered and becomes normal light.
15541                         Transparent bool // Sunlight isn't scattered.
15542                         LightSrc    uint8
15543
15544                         GndContent   bool
15545                         Collides     bool
15546                         Pointable    bool
15547                         Diggable     bool
15548                         Climbable    bool
15549                         Replaceable  bool
15550                         OnRightClick bool
15551
15552                         DmgPerSec int32
15553
15554                         LiquidType   LiquidType
15555                         FlowingAlt   string
15556                         SrcAlt       string
15557                         Viscosity    uint8 // 0-7
15558                         LiqRenewable bool
15559                         FlowRange    uint8
15560                         DrownDmg     uint8
15561                         Floodable    bool
15562
15563                         DrawBox, ColBox, SelBox NodeBox
15564
15565                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15566
15567                         LegacyFaceDir bool
15568                         LegacyMounted bool
15569
15570                         DigPredict string
15571
15572                         MaxLvl uint8
15573
15574                         AlphaUse
15575                 }))(obj)).ConnectTo)) > math.MaxUint16 {
15576                         chk(ErrTooLong)
15577                 }
15578                 {
15579                         x := uint16(len(((*(*(struct {
15580                                 Param0 Content
15581
15582                                 Name   string
15583                                 Groups []Group
15584
15585                                 P1Type   Param1Type
15586                                 P2Type   Param2Type
15587                                 DrawType DrawType
15588
15589                                 Mesh  string
15590                                 Scale float32
15591                                 //mt:const uint8(6)
15592                                 Tiles        [6]TileDef
15593                                 OverlayTiles [6]TileDef
15594                                 //mt:const uint8(6)
15595                                 SpecialTiles [6]TileDef
15596
15597                                 Color   color.NRGBA
15598                                 Palette Texture
15599
15600                                 Waving       WaveType
15601                                 ConnectSides uint8
15602                                 ConnectTo    []Content
15603                                 InsideTint   color.NRGBA
15604                                 Level        uint8 // Must be < 128.
15605
15606                                 Translucent bool // Sunlight is scattered and becomes normal light.
15607                                 Transparent bool // Sunlight isn't scattered.
15608                                 LightSrc    uint8
15609
15610                                 GndContent   bool
15611                                 Collides     bool
15612                                 Pointable    bool
15613                                 Diggable     bool
15614                                 Climbable    bool
15615                                 Replaceable  bool
15616                                 OnRightClick bool
15617
15618                                 DmgPerSec int32
15619
15620                                 LiquidType   LiquidType
15621                                 FlowingAlt   string
15622                                 SrcAlt       string
15623                                 Viscosity    uint8 // 0-7
15624                                 LiqRenewable bool
15625                                 FlowRange    uint8
15626                                 DrownDmg     uint8
15627                                 Floodable    bool
15628
15629                                 DrawBox, ColBox, SelBox NodeBox
15630
15631                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15632
15633                                 LegacyFaceDir bool
15634                                 LegacyMounted bool
15635
15636                                 DigPredict string
15637
15638                                 MaxLvl uint8
15639
15640                                 AlphaUse
15641                         }))(obj)).ConnectTo)))
15642                         write16(w, uint16(x))
15643                 }
15644                 for local247 := range (*(*(struct {
15645                         Param0 Content
15646
15647                         Name   string
15648                         Groups []Group
15649
15650                         P1Type   Param1Type
15651                         P2Type   Param2Type
15652                         DrawType DrawType
15653
15654                         Mesh  string
15655                         Scale float32
15656                         //mt:const uint8(6)
15657                         Tiles        [6]TileDef
15658                         OverlayTiles [6]TileDef
15659                         //mt:const uint8(6)
15660                         SpecialTiles [6]TileDef
15661
15662                         Color   color.NRGBA
15663                         Palette Texture
15664
15665                         Waving       WaveType
15666                         ConnectSides uint8
15667                         ConnectTo    []Content
15668                         InsideTint   color.NRGBA
15669                         Level        uint8 // Must be < 128.
15670
15671                         Translucent bool // Sunlight is scattered and becomes normal light.
15672                         Transparent bool // Sunlight isn't scattered.
15673                         LightSrc    uint8
15674
15675                         GndContent   bool
15676                         Collides     bool
15677                         Pointable    bool
15678                         Diggable     bool
15679                         Climbable    bool
15680                         Replaceable  bool
15681                         OnRightClick bool
15682
15683                         DmgPerSec int32
15684
15685                         LiquidType   LiquidType
15686                         FlowingAlt   string
15687                         SrcAlt       string
15688                         Viscosity    uint8 // 0-7
15689                         LiqRenewable bool
15690                         FlowRange    uint8
15691                         DrownDmg     uint8
15692                         Floodable    bool
15693
15694                         DrawBox, ColBox, SelBox NodeBox
15695
15696                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15697
15698                         LegacyFaceDir bool
15699                         LegacyMounted bool
15700
15701                         DigPredict string
15702
15703                         MaxLvl uint8
15704
15705                         AlphaUse
15706                 }))(obj)).ConnectTo {
15707                         if err := pcall(func() {
15708                                 (((*(*(struct {
15709                                         Param0 Content
15710
15711                                         Name   string
15712                                         Groups []Group
15713
15714                                         P1Type   Param1Type
15715                                         P2Type   Param2Type
15716                                         DrawType DrawType
15717
15718                                         Mesh  string
15719                                         Scale float32
15720                                         //mt:const uint8(6)
15721                                         Tiles        [6]TileDef
15722                                         OverlayTiles [6]TileDef
15723                                         //mt:const uint8(6)
15724                                         SpecialTiles [6]TileDef
15725
15726                                         Color   color.NRGBA
15727                                         Palette Texture
15728
15729                                         Waving       WaveType
15730                                         ConnectSides uint8
15731                                         ConnectTo    []Content
15732                                         InsideTint   color.NRGBA
15733                                         Level        uint8 // Must be < 128.
15734
15735                                         Translucent bool // Sunlight is scattered and becomes normal light.
15736                                         Transparent bool // Sunlight isn't scattered.
15737                                         LightSrc    uint8
15738
15739                                         GndContent   bool
15740                                         Collides     bool
15741                                         Pointable    bool
15742                                         Diggable     bool
15743                                         Climbable    bool
15744                                         Replaceable  bool
15745                                         OnRightClick bool
15746
15747                                         DmgPerSec int32
15748
15749                                         LiquidType   LiquidType
15750                                         FlowingAlt   string
15751                                         SrcAlt       string
15752                                         Viscosity    uint8 // 0-7
15753                                         LiqRenewable bool
15754                                         FlowRange    uint8
15755                                         DrownDmg     uint8
15756                                         Floodable    bool
15757
15758                                         DrawBox, ColBox, SelBox NodeBox
15759
15760                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15761
15762                                         LegacyFaceDir bool
15763                                         LegacyMounted bool
15764
15765                                         DigPredict string
15766
15767                                         MaxLvl uint8
15768
15769                                         AlphaUse
15770                                 }))(obj)).ConnectTo)[local247]).Serialize(w)
15771                         }); err != nil {
15772                                 if err == io.EOF {
15773                                         chk(io.EOF)
15774                                 }
15775                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
15776                         }
15777                 }
15778                 {
15779                         x := (*(*(struct {
15780                                 Param0 Content
15781
15782                                 Name   string
15783                                 Groups []Group
15784
15785                                 P1Type   Param1Type
15786                                 P2Type   Param2Type
15787                                 DrawType DrawType
15788
15789                                 Mesh  string
15790                                 Scale float32
15791                                 //mt:const uint8(6)
15792                                 Tiles        [6]TileDef
15793                                 OverlayTiles [6]TileDef
15794                                 //mt:const uint8(6)
15795                                 SpecialTiles [6]TileDef
15796
15797                                 Color   color.NRGBA
15798                                 Palette Texture
15799
15800                                 Waving       WaveType
15801                                 ConnectSides uint8
15802                                 ConnectTo    []Content
15803                                 InsideTint   color.NRGBA
15804                                 Level        uint8 // Must be < 128.
15805
15806                                 Translucent bool // Sunlight is scattered and becomes normal light.
15807                                 Transparent bool // Sunlight isn't scattered.
15808                                 LightSrc    uint8
15809
15810                                 GndContent   bool
15811                                 Collides     bool
15812                                 Pointable    bool
15813                                 Diggable     bool
15814                                 Climbable    bool
15815                                 Replaceable  bool
15816                                 OnRightClick bool
15817
15818                                 DmgPerSec int32
15819
15820                                 LiquidType   LiquidType
15821                                 FlowingAlt   string
15822                                 SrcAlt       string
15823                                 Viscosity    uint8 // 0-7
15824                                 LiqRenewable bool
15825                                 FlowRange    uint8
15826                                 DrownDmg     uint8
15827                                 Floodable    bool
15828
15829                                 DrawBox, ColBox, SelBox NodeBox
15830
15831                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15832
15833                                 LegacyFaceDir bool
15834                                 LegacyMounted bool
15835
15836                                 DigPredict string
15837
15838                                 MaxLvl uint8
15839
15840                                 AlphaUse
15841                         }))(obj)).InsideTint
15842                         w.Write([]byte{x.A, x.R, x.G, x.B})
15843                 }
15844                 {
15845                         x := (*(*(struct {
15846                                 Param0 Content
15847
15848                                 Name   string
15849                                 Groups []Group
15850
15851                                 P1Type   Param1Type
15852                                 P2Type   Param2Type
15853                                 DrawType DrawType
15854
15855                                 Mesh  string
15856                                 Scale float32
15857                                 //mt:const uint8(6)
15858                                 Tiles        [6]TileDef
15859                                 OverlayTiles [6]TileDef
15860                                 //mt:const uint8(6)
15861                                 SpecialTiles [6]TileDef
15862
15863                                 Color   color.NRGBA
15864                                 Palette Texture
15865
15866                                 Waving       WaveType
15867                                 ConnectSides uint8
15868                                 ConnectTo    []Content
15869                                 InsideTint   color.NRGBA
15870                                 Level        uint8 // Must be < 128.
15871
15872                                 Translucent bool // Sunlight is scattered and becomes normal light.
15873                                 Transparent bool // Sunlight isn't scattered.
15874                                 LightSrc    uint8
15875
15876                                 GndContent   bool
15877                                 Collides     bool
15878                                 Pointable    bool
15879                                 Diggable     bool
15880                                 Climbable    bool
15881                                 Replaceable  bool
15882                                 OnRightClick bool
15883
15884                                 DmgPerSec int32
15885
15886                                 LiquidType   LiquidType
15887                                 FlowingAlt   string
15888                                 SrcAlt       string
15889                                 Viscosity    uint8 // 0-7
15890                                 LiqRenewable bool
15891                                 FlowRange    uint8
15892                                 DrownDmg     uint8
15893                                 Floodable    bool
15894
15895                                 DrawBox, ColBox, SelBox NodeBox
15896
15897                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15898
15899                                 LegacyFaceDir bool
15900                                 LegacyMounted bool
15901
15902                                 DigPredict string
15903
15904                                 MaxLvl uint8
15905
15906                                 AlphaUse
15907                         }))(obj)).Level
15908                         write8(w, uint8(x))
15909                 }
15910                 {
15911                         x := (*(*(struct {
15912                                 Param0 Content
15913
15914                                 Name   string
15915                                 Groups []Group
15916
15917                                 P1Type   Param1Type
15918                                 P2Type   Param2Type
15919                                 DrawType DrawType
15920
15921                                 Mesh  string
15922                                 Scale float32
15923                                 //mt:const uint8(6)
15924                                 Tiles        [6]TileDef
15925                                 OverlayTiles [6]TileDef
15926                                 //mt:const uint8(6)
15927                                 SpecialTiles [6]TileDef
15928
15929                                 Color   color.NRGBA
15930                                 Palette Texture
15931
15932                                 Waving       WaveType
15933                                 ConnectSides uint8
15934                                 ConnectTo    []Content
15935                                 InsideTint   color.NRGBA
15936                                 Level        uint8 // Must be < 128.
15937
15938                                 Translucent bool // Sunlight is scattered and becomes normal light.
15939                                 Transparent bool // Sunlight isn't scattered.
15940                                 LightSrc    uint8
15941
15942                                 GndContent   bool
15943                                 Collides     bool
15944                                 Pointable    bool
15945                                 Diggable     bool
15946                                 Climbable    bool
15947                                 Replaceable  bool
15948                                 OnRightClick bool
15949
15950                                 DmgPerSec int32
15951
15952                                 LiquidType   LiquidType
15953                                 FlowingAlt   string
15954                                 SrcAlt       string
15955                                 Viscosity    uint8 // 0-7
15956                                 LiqRenewable bool
15957                                 FlowRange    uint8
15958                                 DrownDmg     uint8
15959                                 Floodable    bool
15960
15961                                 DrawBox, ColBox, SelBox NodeBox
15962
15963                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15964
15965                                 LegacyFaceDir bool
15966                                 LegacyMounted bool
15967
15968                                 DigPredict string
15969
15970                                 MaxLvl uint8
15971
15972                                 AlphaUse
15973                         }))(obj)).Translucent
15974                         if x {
15975                                 write8(w, 1)
15976                         } else {
15977                                 write8(w, 0)
15978                         }
15979                 }
15980                 {
15981                         x := (*(*(struct {
15982                                 Param0 Content
15983
15984                                 Name   string
15985                                 Groups []Group
15986
15987                                 P1Type   Param1Type
15988                                 P2Type   Param2Type
15989                                 DrawType DrawType
15990
15991                                 Mesh  string
15992                                 Scale float32
15993                                 //mt:const uint8(6)
15994                                 Tiles        [6]TileDef
15995                                 OverlayTiles [6]TileDef
15996                                 //mt:const uint8(6)
15997                                 SpecialTiles [6]TileDef
15998
15999                                 Color   color.NRGBA
16000                                 Palette Texture
16001
16002                                 Waving       WaveType
16003                                 ConnectSides uint8
16004                                 ConnectTo    []Content
16005                                 InsideTint   color.NRGBA
16006                                 Level        uint8 // Must be < 128.
16007
16008                                 Translucent bool // Sunlight is scattered and becomes normal light.
16009                                 Transparent bool // Sunlight isn't scattered.
16010                                 LightSrc    uint8
16011
16012                                 GndContent   bool
16013                                 Collides     bool
16014                                 Pointable    bool
16015                                 Diggable     bool
16016                                 Climbable    bool
16017                                 Replaceable  bool
16018                                 OnRightClick bool
16019
16020                                 DmgPerSec int32
16021
16022                                 LiquidType   LiquidType
16023                                 FlowingAlt   string
16024                                 SrcAlt       string
16025                                 Viscosity    uint8 // 0-7
16026                                 LiqRenewable bool
16027                                 FlowRange    uint8
16028                                 DrownDmg     uint8
16029                                 Floodable    bool
16030
16031                                 DrawBox, ColBox, SelBox NodeBox
16032
16033                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16034
16035                                 LegacyFaceDir bool
16036                                 LegacyMounted bool
16037
16038                                 DigPredict string
16039
16040                                 MaxLvl uint8
16041
16042                                 AlphaUse
16043                         }))(obj)).Transparent
16044                         if x {
16045                                 write8(w, 1)
16046                         } else {
16047                                 write8(w, 0)
16048                         }
16049                 }
16050                 {
16051                         x := (*(*(struct {
16052                                 Param0 Content
16053
16054                                 Name   string
16055                                 Groups []Group
16056
16057                                 P1Type   Param1Type
16058                                 P2Type   Param2Type
16059                                 DrawType DrawType
16060
16061                                 Mesh  string
16062                                 Scale float32
16063                                 //mt:const uint8(6)
16064                                 Tiles        [6]TileDef
16065                                 OverlayTiles [6]TileDef
16066                                 //mt:const uint8(6)
16067                                 SpecialTiles [6]TileDef
16068
16069                                 Color   color.NRGBA
16070                                 Palette Texture
16071
16072                                 Waving       WaveType
16073                                 ConnectSides uint8
16074                                 ConnectTo    []Content
16075                                 InsideTint   color.NRGBA
16076                                 Level        uint8 // Must be < 128.
16077
16078                                 Translucent bool // Sunlight is scattered and becomes normal light.
16079                                 Transparent bool // Sunlight isn't scattered.
16080                                 LightSrc    uint8
16081
16082                                 GndContent   bool
16083                                 Collides     bool
16084                                 Pointable    bool
16085                                 Diggable     bool
16086                                 Climbable    bool
16087                                 Replaceable  bool
16088                                 OnRightClick bool
16089
16090                                 DmgPerSec int32
16091
16092                                 LiquidType   LiquidType
16093                                 FlowingAlt   string
16094                                 SrcAlt       string
16095                                 Viscosity    uint8 // 0-7
16096                                 LiqRenewable bool
16097                                 FlowRange    uint8
16098                                 DrownDmg     uint8
16099                                 Floodable    bool
16100
16101                                 DrawBox, ColBox, SelBox NodeBox
16102
16103                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16104
16105                                 LegacyFaceDir bool
16106                                 LegacyMounted bool
16107
16108                                 DigPredict string
16109
16110                                 MaxLvl uint8
16111
16112                                 AlphaUse
16113                         }))(obj)).LightSrc
16114                         write8(w, uint8(x))
16115                 }
16116                 {
16117                         x := (*(*(struct {
16118                                 Param0 Content
16119
16120                                 Name   string
16121                                 Groups []Group
16122
16123                                 P1Type   Param1Type
16124                                 P2Type   Param2Type
16125                                 DrawType DrawType
16126
16127                                 Mesh  string
16128                                 Scale float32
16129                                 //mt:const uint8(6)
16130                                 Tiles        [6]TileDef
16131                                 OverlayTiles [6]TileDef
16132                                 //mt:const uint8(6)
16133                                 SpecialTiles [6]TileDef
16134
16135                                 Color   color.NRGBA
16136                                 Palette Texture
16137
16138                                 Waving       WaveType
16139                                 ConnectSides uint8
16140                                 ConnectTo    []Content
16141                                 InsideTint   color.NRGBA
16142                                 Level        uint8 // Must be < 128.
16143
16144                                 Translucent bool // Sunlight is scattered and becomes normal light.
16145                                 Transparent bool // Sunlight isn't scattered.
16146                                 LightSrc    uint8
16147
16148                                 GndContent   bool
16149                                 Collides     bool
16150                                 Pointable    bool
16151                                 Diggable     bool
16152                                 Climbable    bool
16153                                 Replaceable  bool
16154                                 OnRightClick bool
16155
16156                                 DmgPerSec int32
16157
16158                                 LiquidType   LiquidType
16159                                 FlowingAlt   string
16160                                 SrcAlt       string
16161                                 Viscosity    uint8 // 0-7
16162                                 LiqRenewable bool
16163                                 FlowRange    uint8
16164                                 DrownDmg     uint8
16165                                 Floodable    bool
16166
16167                                 DrawBox, ColBox, SelBox NodeBox
16168
16169                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16170
16171                                 LegacyFaceDir bool
16172                                 LegacyMounted bool
16173
16174                                 DigPredict string
16175
16176                                 MaxLvl uint8
16177
16178                                 AlphaUse
16179                         }))(obj)).GndContent
16180                         if x {
16181                                 write8(w, 1)
16182                         } else {
16183                                 write8(w, 0)
16184                         }
16185                 }
16186                 {
16187                         x := (*(*(struct {
16188                                 Param0 Content
16189
16190                                 Name   string
16191                                 Groups []Group
16192
16193                                 P1Type   Param1Type
16194                                 P2Type   Param2Type
16195                                 DrawType DrawType
16196
16197                                 Mesh  string
16198                                 Scale float32
16199                                 //mt:const uint8(6)
16200                                 Tiles        [6]TileDef
16201                                 OverlayTiles [6]TileDef
16202                                 //mt:const uint8(6)
16203                                 SpecialTiles [6]TileDef
16204
16205                                 Color   color.NRGBA
16206                                 Palette Texture
16207
16208                                 Waving       WaveType
16209                                 ConnectSides uint8
16210                                 ConnectTo    []Content
16211                                 InsideTint   color.NRGBA
16212                                 Level        uint8 // Must be < 128.
16213
16214                                 Translucent bool // Sunlight is scattered and becomes normal light.
16215                                 Transparent bool // Sunlight isn't scattered.
16216                                 LightSrc    uint8
16217
16218                                 GndContent   bool
16219                                 Collides     bool
16220                                 Pointable    bool
16221                                 Diggable     bool
16222                                 Climbable    bool
16223                                 Replaceable  bool
16224                                 OnRightClick bool
16225
16226                                 DmgPerSec int32
16227
16228                                 LiquidType   LiquidType
16229                                 FlowingAlt   string
16230                                 SrcAlt       string
16231                                 Viscosity    uint8 // 0-7
16232                                 LiqRenewable bool
16233                                 FlowRange    uint8
16234                                 DrownDmg     uint8
16235                                 Floodable    bool
16236
16237                                 DrawBox, ColBox, SelBox NodeBox
16238
16239                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16240
16241                                 LegacyFaceDir bool
16242                                 LegacyMounted bool
16243
16244                                 DigPredict string
16245
16246                                 MaxLvl uint8
16247
16248                                 AlphaUse
16249                         }))(obj)).Collides
16250                         if x {
16251                                 write8(w, 1)
16252                         } else {
16253                                 write8(w, 0)
16254                         }
16255                 }
16256                 {
16257                         x := (*(*(struct {
16258                                 Param0 Content
16259
16260                                 Name   string
16261                                 Groups []Group
16262
16263                                 P1Type   Param1Type
16264                                 P2Type   Param2Type
16265                                 DrawType DrawType
16266
16267                                 Mesh  string
16268                                 Scale float32
16269                                 //mt:const uint8(6)
16270                                 Tiles        [6]TileDef
16271                                 OverlayTiles [6]TileDef
16272                                 //mt:const uint8(6)
16273                                 SpecialTiles [6]TileDef
16274
16275                                 Color   color.NRGBA
16276                                 Palette Texture
16277
16278                                 Waving       WaveType
16279                                 ConnectSides uint8
16280                                 ConnectTo    []Content
16281                                 InsideTint   color.NRGBA
16282                                 Level        uint8 // Must be < 128.
16283
16284                                 Translucent bool // Sunlight is scattered and becomes normal light.
16285                                 Transparent bool // Sunlight isn't scattered.
16286                                 LightSrc    uint8
16287
16288                                 GndContent   bool
16289                                 Collides     bool
16290                                 Pointable    bool
16291                                 Diggable     bool
16292                                 Climbable    bool
16293                                 Replaceable  bool
16294                                 OnRightClick bool
16295
16296                                 DmgPerSec int32
16297
16298                                 LiquidType   LiquidType
16299                                 FlowingAlt   string
16300                                 SrcAlt       string
16301                                 Viscosity    uint8 // 0-7
16302                                 LiqRenewable bool
16303                                 FlowRange    uint8
16304                                 DrownDmg     uint8
16305                                 Floodable    bool
16306
16307                                 DrawBox, ColBox, SelBox NodeBox
16308
16309                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16310
16311                                 LegacyFaceDir bool
16312                                 LegacyMounted bool
16313
16314                                 DigPredict string
16315
16316                                 MaxLvl uint8
16317
16318                                 AlphaUse
16319                         }))(obj)).Pointable
16320                         if x {
16321                                 write8(w, 1)
16322                         } else {
16323                                 write8(w, 0)
16324                         }
16325                 }
16326                 {
16327                         x := (*(*(struct {
16328                                 Param0 Content
16329
16330                                 Name   string
16331                                 Groups []Group
16332
16333                                 P1Type   Param1Type
16334                                 P2Type   Param2Type
16335                                 DrawType DrawType
16336
16337                                 Mesh  string
16338                                 Scale float32
16339                                 //mt:const uint8(6)
16340                                 Tiles        [6]TileDef
16341                                 OverlayTiles [6]TileDef
16342                                 //mt:const uint8(6)
16343                                 SpecialTiles [6]TileDef
16344
16345                                 Color   color.NRGBA
16346                                 Palette Texture
16347
16348                                 Waving       WaveType
16349                                 ConnectSides uint8
16350                                 ConnectTo    []Content
16351                                 InsideTint   color.NRGBA
16352                                 Level        uint8 // Must be < 128.
16353
16354                                 Translucent bool // Sunlight is scattered and becomes normal light.
16355                                 Transparent bool // Sunlight isn't scattered.
16356                                 LightSrc    uint8
16357
16358                                 GndContent   bool
16359                                 Collides     bool
16360                                 Pointable    bool
16361                                 Diggable     bool
16362                                 Climbable    bool
16363                                 Replaceable  bool
16364                                 OnRightClick bool
16365
16366                                 DmgPerSec int32
16367
16368                                 LiquidType   LiquidType
16369                                 FlowingAlt   string
16370                                 SrcAlt       string
16371                                 Viscosity    uint8 // 0-7
16372                                 LiqRenewable bool
16373                                 FlowRange    uint8
16374                                 DrownDmg     uint8
16375                                 Floodable    bool
16376
16377                                 DrawBox, ColBox, SelBox NodeBox
16378
16379                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16380
16381                                 LegacyFaceDir bool
16382                                 LegacyMounted bool
16383
16384                                 DigPredict string
16385
16386                                 MaxLvl uint8
16387
16388                                 AlphaUse
16389                         }))(obj)).Diggable
16390                         if x {
16391                                 write8(w, 1)
16392                         } else {
16393                                 write8(w, 0)
16394                         }
16395                 }
16396                 {
16397                         x := (*(*(struct {
16398                                 Param0 Content
16399
16400                                 Name   string
16401                                 Groups []Group
16402
16403                                 P1Type   Param1Type
16404                                 P2Type   Param2Type
16405                                 DrawType DrawType
16406
16407                                 Mesh  string
16408                                 Scale float32
16409                                 //mt:const uint8(6)
16410                                 Tiles        [6]TileDef
16411                                 OverlayTiles [6]TileDef
16412                                 //mt:const uint8(6)
16413                                 SpecialTiles [6]TileDef
16414
16415                                 Color   color.NRGBA
16416                                 Palette Texture
16417
16418                                 Waving       WaveType
16419                                 ConnectSides uint8
16420                                 ConnectTo    []Content
16421                                 InsideTint   color.NRGBA
16422                                 Level        uint8 // Must be < 128.
16423
16424                                 Translucent bool // Sunlight is scattered and becomes normal light.
16425                                 Transparent bool // Sunlight isn't scattered.
16426                                 LightSrc    uint8
16427
16428                                 GndContent   bool
16429                                 Collides     bool
16430                                 Pointable    bool
16431                                 Diggable     bool
16432                                 Climbable    bool
16433                                 Replaceable  bool
16434                                 OnRightClick bool
16435
16436                                 DmgPerSec int32
16437
16438                                 LiquidType   LiquidType
16439                                 FlowingAlt   string
16440                                 SrcAlt       string
16441                                 Viscosity    uint8 // 0-7
16442                                 LiqRenewable bool
16443                                 FlowRange    uint8
16444                                 DrownDmg     uint8
16445                                 Floodable    bool
16446
16447                                 DrawBox, ColBox, SelBox NodeBox
16448
16449                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16450
16451                                 LegacyFaceDir bool
16452                                 LegacyMounted bool
16453
16454                                 DigPredict string
16455
16456                                 MaxLvl uint8
16457
16458                                 AlphaUse
16459                         }))(obj)).Climbable
16460                         if x {
16461                                 write8(w, 1)
16462                         } else {
16463                                 write8(w, 0)
16464                         }
16465                 }
16466                 {
16467                         x := (*(*(struct {
16468                                 Param0 Content
16469
16470                                 Name   string
16471                                 Groups []Group
16472
16473                                 P1Type   Param1Type
16474                                 P2Type   Param2Type
16475                                 DrawType DrawType
16476
16477                                 Mesh  string
16478                                 Scale float32
16479                                 //mt:const uint8(6)
16480                                 Tiles        [6]TileDef
16481                                 OverlayTiles [6]TileDef
16482                                 //mt:const uint8(6)
16483                                 SpecialTiles [6]TileDef
16484
16485                                 Color   color.NRGBA
16486                                 Palette Texture
16487
16488                                 Waving       WaveType
16489                                 ConnectSides uint8
16490                                 ConnectTo    []Content
16491                                 InsideTint   color.NRGBA
16492                                 Level        uint8 // Must be < 128.
16493
16494                                 Translucent bool // Sunlight is scattered and becomes normal light.
16495                                 Transparent bool // Sunlight isn't scattered.
16496                                 LightSrc    uint8
16497
16498                                 GndContent   bool
16499                                 Collides     bool
16500                                 Pointable    bool
16501                                 Diggable     bool
16502                                 Climbable    bool
16503                                 Replaceable  bool
16504                                 OnRightClick bool
16505
16506                                 DmgPerSec int32
16507
16508                                 LiquidType   LiquidType
16509                                 FlowingAlt   string
16510                                 SrcAlt       string
16511                                 Viscosity    uint8 // 0-7
16512                                 LiqRenewable bool
16513                                 FlowRange    uint8
16514                                 DrownDmg     uint8
16515                                 Floodable    bool
16516
16517                                 DrawBox, ColBox, SelBox NodeBox
16518
16519                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16520
16521                                 LegacyFaceDir bool
16522                                 LegacyMounted bool
16523
16524                                 DigPredict string
16525
16526                                 MaxLvl uint8
16527
16528                                 AlphaUse
16529                         }))(obj)).Replaceable
16530                         if x {
16531                                 write8(w, 1)
16532                         } else {
16533                                 write8(w, 0)
16534                         }
16535                 }
16536                 {
16537                         x := (*(*(struct {
16538                                 Param0 Content
16539
16540                                 Name   string
16541                                 Groups []Group
16542
16543                                 P1Type   Param1Type
16544                                 P2Type   Param2Type
16545                                 DrawType DrawType
16546
16547                                 Mesh  string
16548                                 Scale float32
16549                                 //mt:const uint8(6)
16550                                 Tiles        [6]TileDef
16551                                 OverlayTiles [6]TileDef
16552                                 //mt:const uint8(6)
16553                                 SpecialTiles [6]TileDef
16554
16555                                 Color   color.NRGBA
16556                                 Palette Texture
16557
16558                                 Waving       WaveType
16559                                 ConnectSides uint8
16560                                 ConnectTo    []Content
16561                                 InsideTint   color.NRGBA
16562                                 Level        uint8 // Must be < 128.
16563
16564                                 Translucent bool // Sunlight is scattered and becomes normal light.
16565                                 Transparent bool // Sunlight isn't scattered.
16566                                 LightSrc    uint8
16567
16568                                 GndContent   bool
16569                                 Collides     bool
16570                                 Pointable    bool
16571                                 Diggable     bool
16572                                 Climbable    bool
16573                                 Replaceable  bool
16574                                 OnRightClick bool
16575
16576                                 DmgPerSec int32
16577
16578                                 LiquidType   LiquidType
16579                                 FlowingAlt   string
16580                                 SrcAlt       string
16581                                 Viscosity    uint8 // 0-7
16582                                 LiqRenewable bool
16583                                 FlowRange    uint8
16584                                 DrownDmg     uint8
16585                                 Floodable    bool
16586
16587                                 DrawBox, ColBox, SelBox NodeBox
16588
16589                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16590
16591                                 LegacyFaceDir bool
16592                                 LegacyMounted bool
16593
16594                                 DigPredict string
16595
16596                                 MaxLvl uint8
16597
16598                                 AlphaUse
16599                         }))(obj)).OnRightClick
16600                         if x {
16601                                 write8(w, 1)
16602                         } else {
16603                                 write8(w, 0)
16604                         }
16605                 }
16606                 {
16607                         x := (*(*(struct {
16608                                 Param0 Content
16609
16610                                 Name   string
16611                                 Groups []Group
16612
16613                                 P1Type   Param1Type
16614                                 P2Type   Param2Type
16615                                 DrawType DrawType
16616
16617                                 Mesh  string
16618                                 Scale float32
16619                                 //mt:const uint8(6)
16620                                 Tiles        [6]TileDef
16621                                 OverlayTiles [6]TileDef
16622                                 //mt:const uint8(6)
16623                                 SpecialTiles [6]TileDef
16624
16625                                 Color   color.NRGBA
16626                                 Palette Texture
16627
16628                                 Waving       WaveType
16629                                 ConnectSides uint8
16630                                 ConnectTo    []Content
16631                                 InsideTint   color.NRGBA
16632                                 Level        uint8 // Must be < 128.
16633
16634                                 Translucent bool // Sunlight is scattered and becomes normal light.
16635                                 Transparent bool // Sunlight isn't scattered.
16636                                 LightSrc    uint8
16637
16638                                 GndContent   bool
16639                                 Collides     bool
16640                                 Pointable    bool
16641                                 Diggable     bool
16642                                 Climbable    bool
16643                                 Replaceable  bool
16644                                 OnRightClick bool
16645
16646                                 DmgPerSec int32
16647
16648                                 LiquidType   LiquidType
16649                                 FlowingAlt   string
16650                                 SrcAlt       string
16651                                 Viscosity    uint8 // 0-7
16652                                 LiqRenewable bool
16653                                 FlowRange    uint8
16654                                 DrownDmg     uint8
16655                                 Floodable    bool
16656
16657                                 DrawBox, ColBox, SelBox NodeBox
16658
16659                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16660
16661                                 LegacyFaceDir bool
16662                                 LegacyMounted bool
16663
16664                                 DigPredict string
16665
16666                                 MaxLvl uint8
16667
16668                                 AlphaUse
16669                         }))(obj)).DmgPerSec
16670                         write32(w, uint32(x))
16671                 }
16672                 if err := pcall(func() {
16673                         ((*(*(struct {
16674                                 Param0 Content
16675
16676                                 Name   string
16677                                 Groups []Group
16678
16679                                 P1Type   Param1Type
16680                                 P2Type   Param2Type
16681                                 DrawType DrawType
16682
16683                                 Mesh  string
16684                                 Scale float32
16685                                 //mt:const uint8(6)
16686                                 Tiles        [6]TileDef
16687                                 OverlayTiles [6]TileDef
16688                                 //mt:const uint8(6)
16689                                 SpecialTiles [6]TileDef
16690
16691                                 Color   color.NRGBA
16692                                 Palette Texture
16693
16694                                 Waving       WaveType
16695                                 ConnectSides uint8
16696                                 ConnectTo    []Content
16697                                 InsideTint   color.NRGBA
16698                                 Level        uint8 // Must be < 128.
16699
16700                                 Translucent bool // Sunlight is scattered and becomes normal light.
16701                                 Transparent bool // Sunlight isn't scattered.
16702                                 LightSrc    uint8
16703
16704                                 GndContent   bool
16705                                 Collides     bool
16706                                 Pointable    bool
16707                                 Diggable     bool
16708                                 Climbable    bool
16709                                 Replaceable  bool
16710                                 OnRightClick bool
16711
16712                                 DmgPerSec int32
16713
16714                                 LiquidType   LiquidType
16715                                 FlowingAlt   string
16716                                 SrcAlt       string
16717                                 Viscosity    uint8 // 0-7
16718                                 LiqRenewable bool
16719                                 FlowRange    uint8
16720                                 DrownDmg     uint8
16721                                 Floodable    bool
16722
16723                                 DrawBox, ColBox, SelBox NodeBox
16724
16725                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16726
16727                                 LegacyFaceDir bool
16728                                 LegacyMounted bool
16729
16730                                 DigPredict string
16731
16732                                 MaxLvl uint8
16733
16734                                 AlphaUse
16735                         }))(obj)).LiquidType).Serialize(w)
16736                 }); err != nil {
16737                         if err == io.EOF {
16738                                 chk(io.EOF)
16739                         }
16740                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
16741                 }
16742                 if len(([]byte((*(*(struct {
16743                         Param0 Content
16744
16745                         Name   string
16746                         Groups []Group
16747
16748                         P1Type   Param1Type
16749                         P2Type   Param2Type
16750                         DrawType DrawType
16751
16752                         Mesh  string
16753                         Scale float32
16754                         //mt:const uint8(6)
16755                         Tiles        [6]TileDef
16756                         OverlayTiles [6]TileDef
16757                         //mt:const uint8(6)
16758                         SpecialTiles [6]TileDef
16759
16760                         Color   color.NRGBA
16761                         Palette Texture
16762
16763                         Waving       WaveType
16764                         ConnectSides uint8
16765                         ConnectTo    []Content
16766                         InsideTint   color.NRGBA
16767                         Level        uint8 // Must be < 128.
16768
16769                         Translucent bool // Sunlight is scattered and becomes normal light.
16770                         Transparent bool // Sunlight isn't scattered.
16771                         LightSrc    uint8
16772
16773                         GndContent   bool
16774                         Collides     bool
16775                         Pointable    bool
16776                         Diggable     bool
16777                         Climbable    bool
16778                         Replaceable  bool
16779                         OnRightClick bool
16780
16781                         DmgPerSec int32
16782
16783                         LiquidType   LiquidType
16784                         FlowingAlt   string
16785                         SrcAlt       string
16786                         Viscosity    uint8 // 0-7
16787                         LiqRenewable bool
16788                         FlowRange    uint8
16789                         DrownDmg     uint8
16790                         Floodable    bool
16791
16792                         DrawBox, ColBox, SelBox NodeBox
16793
16794                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16795
16796                         LegacyFaceDir bool
16797                         LegacyMounted bool
16798
16799                         DigPredict string
16800
16801                         MaxLvl uint8
16802
16803                         AlphaUse
16804                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
16805                         chk(ErrTooLong)
16806                 }
16807                 {
16808                         x := uint16(len(([]byte((*(*(struct {
16809                                 Param0 Content
16810
16811                                 Name   string
16812                                 Groups []Group
16813
16814                                 P1Type   Param1Type
16815                                 P2Type   Param2Type
16816                                 DrawType DrawType
16817
16818                                 Mesh  string
16819                                 Scale float32
16820                                 //mt:const uint8(6)
16821                                 Tiles        [6]TileDef
16822                                 OverlayTiles [6]TileDef
16823                                 //mt:const uint8(6)
16824                                 SpecialTiles [6]TileDef
16825
16826                                 Color   color.NRGBA
16827                                 Palette Texture
16828
16829                                 Waving       WaveType
16830                                 ConnectSides uint8
16831                                 ConnectTo    []Content
16832                                 InsideTint   color.NRGBA
16833                                 Level        uint8 // Must be < 128.
16834
16835                                 Translucent bool // Sunlight is scattered and becomes normal light.
16836                                 Transparent bool // Sunlight isn't scattered.
16837                                 LightSrc    uint8
16838
16839                                 GndContent   bool
16840                                 Collides     bool
16841                                 Pointable    bool
16842                                 Diggable     bool
16843                                 Climbable    bool
16844                                 Replaceable  bool
16845                                 OnRightClick bool
16846
16847                                 DmgPerSec int32
16848
16849                                 LiquidType   LiquidType
16850                                 FlowingAlt   string
16851                                 SrcAlt       string
16852                                 Viscosity    uint8 // 0-7
16853                                 LiqRenewable bool
16854                                 FlowRange    uint8
16855                                 DrownDmg     uint8
16856                                 Floodable    bool
16857
16858                                 DrawBox, ColBox, SelBox NodeBox
16859
16860                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16861
16862                                 LegacyFaceDir bool
16863                                 LegacyMounted bool
16864
16865                                 DigPredict string
16866
16867                                 MaxLvl uint8
16868
16869                                 AlphaUse
16870                         }))(obj)).FlowingAlt))))
16871                         write16(w, uint16(x))
16872                 }
16873                 {
16874                         _, err := w.Write(([]byte((*(*(struct {
16875                                 Param0 Content
16876
16877                                 Name   string
16878                                 Groups []Group
16879
16880                                 P1Type   Param1Type
16881                                 P2Type   Param2Type
16882                                 DrawType DrawType
16883
16884                                 Mesh  string
16885                                 Scale float32
16886                                 //mt:const uint8(6)
16887                                 Tiles        [6]TileDef
16888                                 OverlayTiles [6]TileDef
16889                                 //mt:const uint8(6)
16890                                 SpecialTiles [6]TileDef
16891
16892                                 Color   color.NRGBA
16893                                 Palette Texture
16894
16895                                 Waving       WaveType
16896                                 ConnectSides uint8
16897                                 ConnectTo    []Content
16898                                 InsideTint   color.NRGBA
16899                                 Level        uint8 // Must be < 128.
16900
16901                                 Translucent bool // Sunlight is scattered and becomes normal light.
16902                                 Transparent bool // Sunlight isn't scattered.
16903                                 LightSrc    uint8
16904
16905                                 GndContent   bool
16906                                 Collides     bool
16907                                 Pointable    bool
16908                                 Diggable     bool
16909                                 Climbable    bool
16910                                 Replaceable  bool
16911                                 OnRightClick bool
16912
16913                                 DmgPerSec int32
16914
16915                                 LiquidType   LiquidType
16916                                 FlowingAlt   string
16917                                 SrcAlt       string
16918                                 Viscosity    uint8 // 0-7
16919                                 LiqRenewable bool
16920                                 FlowRange    uint8
16921                                 DrownDmg     uint8
16922                                 Floodable    bool
16923
16924                                 DrawBox, ColBox, SelBox NodeBox
16925
16926                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16927
16928                                 LegacyFaceDir bool
16929                                 LegacyMounted bool
16930
16931                                 DigPredict string
16932
16933                                 MaxLvl uint8
16934
16935                                 AlphaUse
16936                         }))(obj)).FlowingAlt))[:])
16937                         chk(err)
16938                 }
16939                 if len(([]byte((*(*(struct {
16940                         Param0 Content
16941
16942                         Name   string
16943                         Groups []Group
16944
16945                         P1Type   Param1Type
16946                         P2Type   Param2Type
16947                         DrawType DrawType
16948
16949                         Mesh  string
16950                         Scale float32
16951                         //mt:const uint8(6)
16952                         Tiles        [6]TileDef
16953                         OverlayTiles [6]TileDef
16954                         //mt:const uint8(6)
16955                         SpecialTiles [6]TileDef
16956
16957                         Color   color.NRGBA
16958                         Palette Texture
16959
16960                         Waving       WaveType
16961                         ConnectSides uint8
16962                         ConnectTo    []Content
16963                         InsideTint   color.NRGBA
16964                         Level        uint8 // Must be < 128.
16965
16966                         Translucent bool // Sunlight is scattered and becomes normal light.
16967                         Transparent bool // Sunlight isn't scattered.
16968                         LightSrc    uint8
16969
16970                         GndContent   bool
16971                         Collides     bool
16972                         Pointable    bool
16973                         Diggable     bool
16974                         Climbable    bool
16975                         Replaceable  bool
16976                         OnRightClick bool
16977
16978                         DmgPerSec int32
16979
16980                         LiquidType   LiquidType
16981                         FlowingAlt   string
16982                         SrcAlt       string
16983                         Viscosity    uint8 // 0-7
16984                         LiqRenewable bool
16985                         FlowRange    uint8
16986                         DrownDmg     uint8
16987                         Floodable    bool
16988
16989                         DrawBox, ColBox, SelBox NodeBox
16990
16991                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16992
16993                         LegacyFaceDir bool
16994                         LegacyMounted bool
16995
16996                         DigPredict string
16997
16998                         MaxLvl uint8
16999
17000                         AlphaUse
17001                 }))(obj)).SrcAlt))) > math.MaxUint16 {
17002                         chk(ErrTooLong)
17003                 }
17004                 {
17005                         x := uint16(len(([]byte((*(*(struct {
17006                                 Param0 Content
17007
17008                                 Name   string
17009                                 Groups []Group
17010
17011                                 P1Type   Param1Type
17012                                 P2Type   Param2Type
17013                                 DrawType DrawType
17014
17015                                 Mesh  string
17016                                 Scale float32
17017                                 //mt:const uint8(6)
17018                                 Tiles        [6]TileDef
17019                                 OverlayTiles [6]TileDef
17020                                 //mt:const uint8(6)
17021                                 SpecialTiles [6]TileDef
17022
17023                                 Color   color.NRGBA
17024                                 Palette Texture
17025
17026                                 Waving       WaveType
17027                                 ConnectSides uint8
17028                                 ConnectTo    []Content
17029                                 InsideTint   color.NRGBA
17030                                 Level        uint8 // Must be < 128.
17031
17032                                 Translucent bool // Sunlight is scattered and becomes normal light.
17033                                 Transparent bool // Sunlight isn't scattered.
17034                                 LightSrc    uint8
17035
17036                                 GndContent   bool
17037                                 Collides     bool
17038                                 Pointable    bool
17039                                 Diggable     bool
17040                                 Climbable    bool
17041                                 Replaceable  bool
17042                                 OnRightClick bool
17043
17044                                 DmgPerSec int32
17045
17046                                 LiquidType   LiquidType
17047                                 FlowingAlt   string
17048                                 SrcAlt       string
17049                                 Viscosity    uint8 // 0-7
17050                                 LiqRenewable bool
17051                                 FlowRange    uint8
17052                                 DrownDmg     uint8
17053                                 Floodable    bool
17054
17055                                 DrawBox, ColBox, SelBox NodeBox
17056
17057                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17058
17059                                 LegacyFaceDir bool
17060                                 LegacyMounted bool
17061
17062                                 DigPredict string
17063
17064                                 MaxLvl uint8
17065
17066                                 AlphaUse
17067                         }))(obj)).SrcAlt))))
17068                         write16(w, uint16(x))
17069                 }
17070                 {
17071                         _, err := w.Write(([]byte((*(*(struct {
17072                                 Param0 Content
17073
17074                                 Name   string
17075                                 Groups []Group
17076
17077                                 P1Type   Param1Type
17078                                 P2Type   Param2Type
17079                                 DrawType DrawType
17080
17081                                 Mesh  string
17082                                 Scale float32
17083                                 //mt:const uint8(6)
17084                                 Tiles        [6]TileDef
17085                                 OverlayTiles [6]TileDef
17086                                 //mt:const uint8(6)
17087                                 SpecialTiles [6]TileDef
17088
17089                                 Color   color.NRGBA
17090                                 Palette Texture
17091
17092                                 Waving       WaveType
17093                                 ConnectSides uint8
17094                                 ConnectTo    []Content
17095                                 InsideTint   color.NRGBA
17096                                 Level        uint8 // Must be < 128.
17097
17098                                 Translucent bool // Sunlight is scattered and becomes normal light.
17099                                 Transparent bool // Sunlight isn't scattered.
17100                                 LightSrc    uint8
17101
17102                                 GndContent   bool
17103                                 Collides     bool
17104                                 Pointable    bool
17105                                 Diggable     bool
17106                                 Climbable    bool
17107                                 Replaceable  bool
17108                                 OnRightClick bool
17109
17110                                 DmgPerSec int32
17111
17112                                 LiquidType   LiquidType
17113                                 FlowingAlt   string
17114                                 SrcAlt       string
17115                                 Viscosity    uint8 // 0-7
17116                                 LiqRenewable bool
17117                                 FlowRange    uint8
17118                                 DrownDmg     uint8
17119                                 Floodable    bool
17120
17121                                 DrawBox, ColBox, SelBox NodeBox
17122
17123                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17124
17125                                 LegacyFaceDir bool
17126                                 LegacyMounted bool
17127
17128                                 DigPredict string
17129
17130                                 MaxLvl uint8
17131
17132                                 AlphaUse
17133                         }))(obj)).SrcAlt))[:])
17134                         chk(err)
17135                 }
17136                 {
17137                         x := (*(*(struct {
17138                                 Param0 Content
17139
17140                                 Name   string
17141                                 Groups []Group
17142
17143                                 P1Type   Param1Type
17144                                 P2Type   Param2Type
17145                                 DrawType DrawType
17146
17147                                 Mesh  string
17148                                 Scale float32
17149                                 //mt:const uint8(6)
17150                                 Tiles        [6]TileDef
17151                                 OverlayTiles [6]TileDef
17152                                 //mt:const uint8(6)
17153                                 SpecialTiles [6]TileDef
17154
17155                                 Color   color.NRGBA
17156                                 Palette Texture
17157
17158                                 Waving       WaveType
17159                                 ConnectSides uint8
17160                                 ConnectTo    []Content
17161                                 InsideTint   color.NRGBA
17162                                 Level        uint8 // Must be < 128.
17163
17164                                 Translucent bool // Sunlight is scattered and becomes normal light.
17165                                 Transparent bool // Sunlight isn't scattered.
17166                                 LightSrc    uint8
17167
17168                                 GndContent   bool
17169                                 Collides     bool
17170                                 Pointable    bool
17171                                 Diggable     bool
17172                                 Climbable    bool
17173                                 Replaceable  bool
17174                                 OnRightClick bool
17175
17176                                 DmgPerSec int32
17177
17178                                 LiquidType   LiquidType
17179                                 FlowingAlt   string
17180                                 SrcAlt       string
17181                                 Viscosity    uint8 // 0-7
17182                                 LiqRenewable bool
17183                                 FlowRange    uint8
17184                                 DrownDmg     uint8
17185                                 Floodable    bool
17186
17187                                 DrawBox, ColBox, SelBox NodeBox
17188
17189                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17190
17191                                 LegacyFaceDir bool
17192                                 LegacyMounted bool
17193
17194                                 DigPredict string
17195
17196                                 MaxLvl uint8
17197
17198                                 AlphaUse
17199                         }))(obj)).Viscosity
17200                         write8(w, uint8(x))
17201                 }
17202                 {
17203                         x := (*(*(struct {
17204                                 Param0 Content
17205
17206                                 Name   string
17207                                 Groups []Group
17208
17209                                 P1Type   Param1Type
17210                                 P2Type   Param2Type
17211                                 DrawType DrawType
17212
17213                                 Mesh  string
17214                                 Scale float32
17215                                 //mt:const uint8(6)
17216                                 Tiles        [6]TileDef
17217                                 OverlayTiles [6]TileDef
17218                                 //mt:const uint8(6)
17219                                 SpecialTiles [6]TileDef
17220
17221                                 Color   color.NRGBA
17222                                 Palette Texture
17223
17224                                 Waving       WaveType
17225                                 ConnectSides uint8
17226                                 ConnectTo    []Content
17227                                 InsideTint   color.NRGBA
17228                                 Level        uint8 // Must be < 128.
17229
17230                                 Translucent bool // Sunlight is scattered and becomes normal light.
17231                                 Transparent bool // Sunlight isn't scattered.
17232                                 LightSrc    uint8
17233
17234                                 GndContent   bool
17235                                 Collides     bool
17236                                 Pointable    bool
17237                                 Diggable     bool
17238                                 Climbable    bool
17239                                 Replaceable  bool
17240                                 OnRightClick bool
17241
17242                                 DmgPerSec int32
17243
17244                                 LiquidType   LiquidType
17245                                 FlowingAlt   string
17246                                 SrcAlt       string
17247                                 Viscosity    uint8 // 0-7
17248                                 LiqRenewable bool
17249                                 FlowRange    uint8
17250                                 DrownDmg     uint8
17251                                 Floodable    bool
17252
17253                                 DrawBox, ColBox, SelBox NodeBox
17254
17255                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17256
17257                                 LegacyFaceDir bool
17258                                 LegacyMounted bool
17259
17260                                 DigPredict string
17261
17262                                 MaxLvl uint8
17263
17264                                 AlphaUse
17265                         }))(obj)).LiqRenewable
17266                         if x {
17267                                 write8(w, 1)
17268                         } else {
17269                                 write8(w, 0)
17270                         }
17271                 }
17272                 {
17273                         x := (*(*(struct {
17274                                 Param0 Content
17275
17276                                 Name   string
17277                                 Groups []Group
17278
17279                                 P1Type   Param1Type
17280                                 P2Type   Param2Type
17281                                 DrawType DrawType
17282
17283                                 Mesh  string
17284                                 Scale float32
17285                                 //mt:const uint8(6)
17286                                 Tiles        [6]TileDef
17287                                 OverlayTiles [6]TileDef
17288                                 //mt:const uint8(6)
17289                                 SpecialTiles [6]TileDef
17290
17291                                 Color   color.NRGBA
17292                                 Palette Texture
17293
17294                                 Waving       WaveType
17295                                 ConnectSides uint8
17296                                 ConnectTo    []Content
17297                                 InsideTint   color.NRGBA
17298                                 Level        uint8 // Must be < 128.
17299
17300                                 Translucent bool // Sunlight is scattered and becomes normal light.
17301                                 Transparent bool // Sunlight isn't scattered.
17302                                 LightSrc    uint8
17303
17304                                 GndContent   bool
17305                                 Collides     bool
17306                                 Pointable    bool
17307                                 Diggable     bool
17308                                 Climbable    bool
17309                                 Replaceable  bool
17310                                 OnRightClick bool
17311
17312                                 DmgPerSec int32
17313
17314                                 LiquidType   LiquidType
17315                                 FlowingAlt   string
17316                                 SrcAlt       string
17317                                 Viscosity    uint8 // 0-7
17318                                 LiqRenewable bool
17319                                 FlowRange    uint8
17320                                 DrownDmg     uint8
17321                                 Floodable    bool
17322
17323                                 DrawBox, ColBox, SelBox NodeBox
17324
17325                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17326
17327                                 LegacyFaceDir bool
17328                                 LegacyMounted bool
17329
17330                                 DigPredict string
17331
17332                                 MaxLvl uint8
17333
17334                                 AlphaUse
17335                         }))(obj)).FlowRange
17336                         write8(w, uint8(x))
17337                 }
17338                 {
17339                         x := (*(*(struct {
17340                                 Param0 Content
17341
17342                                 Name   string
17343                                 Groups []Group
17344
17345                                 P1Type   Param1Type
17346                                 P2Type   Param2Type
17347                                 DrawType DrawType
17348
17349                                 Mesh  string
17350                                 Scale float32
17351                                 //mt:const uint8(6)
17352                                 Tiles        [6]TileDef
17353                                 OverlayTiles [6]TileDef
17354                                 //mt:const uint8(6)
17355                                 SpecialTiles [6]TileDef
17356
17357                                 Color   color.NRGBA
17358                                 Palette Texture
17359
17360                                 Waving       WaveType
17361                                 ConnectSides uint8
17362                                 ConnectTo    []Content
17363                                 InsideTint   color.NRGBA
17364                                 Level        uint8 // Must be < 128.
17365
17366                                 Translucent bool // Sunlight is scattered and becomes normal light.
17367                                 Transparent bool // Sunlight isn't scattered.
17368                                 LightSrc    uint8
17369
17370                                 GndContent   bool
17371                                 Collides     bool
17372                                 Pointable    bool
17373                                 Diggable     bool
17374                                 Climbable    bool
17375                                 Replaceable  bool
17376                                 OnRightClick bool
17377
17378                                 DmgPerSec int32
17379
17380                                 LiquidType   LiquidType
17381                                 FlowingAlt   string
17382                                 SrcAlt       string
17383                                 Viscosity    uint8 // 0-7
17384                                 LiqRenewable bool
17385                                 FlowRange    uint8
17386                                 DrownDmg     uint8
17387                                 Floodable    bool
17388
17389                                 DrawBox, ColBox, SelBox NodeBox
17390
17391                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17392
17393                                 LegacyFaceDir bool
17394                                 LegacyMounted bool
17395
17396                                 DigPredict string
17397
17398                                 MaxLvl uint8
17399
17400                                 AlphaUse
17401                         }))(obj)).DrownDmg
17402                         write8(w, uint8(x))
17403                 }
17404                 {
17405                         x := (*(*(struct {
17406                                 Param0 Content
17407
17408                                 Name   string
17409                                 Groups []Group
17410
17411                                 P1Type   Param1Type
17412                                 P2Type   Param2Type
17413                                 DrawType DrawType
17414
17415                                 Mesh  string
17416                                 Scale float32
17417                                 //mt:const uint8(6)
17418                                 Tiles        [6]TileDef
17419                                 OverlayTiles [6]TileDef
17420                                 //mt:const uint8(6)
17421                                 SpecialTiles [6]TileDef
17422
17423                                 Color   color.NRGBA
17424                                 Palette Texture
17425
17426                                 Waving       WaveType
17427                                 ConnectSides uint8
17428                                 ConnectTo    []Content
17429                                 InsideTint   color.NRGBA
17430                                 Level        uint8 // Must be < 128.
17431
17432                                 Translucent bool // Sunlight is scattered and becomes normal light.
17433                                 Transparent bool // Sunlight isn't scattered.
17434                                 LightSrc    uint8
17435
17436                                 GndContent   bool
17437                                 Collides     bool
17438                                 Pointable    bool
17439                                 Diggable     bool
17440                                 Climbable    bool
17441                                 Replaceable  bool
17442                                 OnRightClick bool
17443
17444                                 DmgPerSec int32
17445
17446                                 LiquidType   LiquidType
17447                                 FlowingAlt   string
17448                                 SrcAlt       string
17449                                 Viscosity    uint8 // 0-7
17450                                 LiqRenewable bool
17451                                 FlowRange    uint8
17452                                 DrownDmg     uint8
17453                                 Floodable    bool
17454
17455                                 DrawBox, ColBox, SelBox NodeBox
17456
17457                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17458
17459                                 LegacyFaceDir bool
17460                                 LegacyMounted bool
17461
17462                                 DigPredict string
17463
17464                                 MaxLvl uint8
17465
17466                                 AlphaUse
17467                         }))(obj)).Floodable
17468                         if x {
17469                                 write8(w, 1)
17470                         } else {
17471                                 write8(w, 0)
17472                         }
17473                 }
17474                 if err := pcall(func() {
17475                         ((*(*(struct {
17476                                 Param0 Content
17477
17478                                 Name   string
17479                                 Groups []Group
17480
17481                                 P1Type   Param1Type
17482                                 P2Type   Param2Type
17483                                 DrawType DrawType
17484
17485                                 Mesh  string
17486                                 Scale float32
17487                                 //mt:const uint8(6)
17488                                 Tiles        [6]TileDef
17489                                 OverlayTiles [6]TileDef
17490                                 //mt:const uint8(6)
17491                                 SpecialTiles [6]TileDef
17492
17493                                 Color   color.NRGBA
17494                                 Palette Texture
17495
17496                                 Waving       WaveType
17497                                 ConnectSides uint8
17498                                 ConnectTo    []Content
17499                                 InsideTint   color.NRGBA
17500                                 Level        uint8 // Must be < 128.
17501
17502                                 Translucent bool // Sunlight is scattered and becomes normal light.
17503                                 Transparent bool // Sunlight isn't scattered.
17504                                 LightSrc    uint8
17505
17506                                 GndContent   bool
17507                                 Collides     bool
17508                                 Pointable    bool
17509                                 Diggable     bool
17510                                 Climbable    bool
17511                                 Replaceable  bool
17512                                 OnRightClick bool
17513
17514                                 DmgPerSec int32
17515
17516                                 LiquidType   LiquidType
17517                                 FlowingAlt   string
17518                                 SrcAlt       string
17519                                 Viscosity    uint8 // 0-7
17520                                 LiqRenewable bool
17521                                 FlowRange    uint8
17522                                 DrownDmg     uint8
17523                                 Floodable    bool
17524
17525                                 DrawBox, ColBox, SelBox NodeBox
17526
17527                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17528
17529                                 LegacyFaceDir bool
17530                                 LegacyMounted bool
17531
17532                                 DigPredict string
17533
17534                                 MaxLvl uint8
17535
17536                                 AlphaUse
17537                         }))(obj)).DrawBox).Serialize(w)
17538                 }); err != nil {
17539                         if err == io.EOF {
17540                                 chk(io.EOF)
17541                         }
17542                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17543                 }
17544                 if err := pcall(func() {
17545                         ((*(*(struct {
17546                                 Param0 Content
17547
17548                                 Name   string
17549                                 Groups []Group
17550
17551                                 P1Type   Param1Type
17552                                 P2Type   Param2Type
17553                                 DrawType DrawType
17554
17555                                 Mesh  string
17556                                 Scale float32
17557                                 //mt:const uint8(6)
17558                                 Tiles        [6]TileDef
17559                                 OverlayTiles [6]TileDef
17560                                 //mt:const uint8(6)
17561                                 SpecialTiles [6]TileDef
17562
17563                                 Color   color.NRGBA
17564                                 Palette Texture
17565
17566                                 Waving       WaveType
17567                                 ConnectSides uint8
17568                                 ConnectTo    []Content
17569                                 InsideTint   color.NRGBA
17570                                 Level        uint8 // Must be < 128.
17571
17572                                 Translucent bool // Sunlight is scattered and becomes normal light.
17573                                 Transparent bool // Sunlight isn't scattered.
17574                                 LightSrc    uint8
17575
17576                                 GndContent   bool
17577                                 Collides     bool
17578                                 Pointable    bool
17579                                 Diggable     bool
17580                                 Climbable    bool
17581                                 Replaceable  bool
17582                                 OnRightClick bool
17583
17584                                 DmgPerSec int32
17585
17586                                 LiquidType   LiquidType
17587                                 FlowingAlt   string
17588                                 SrcAlt       string
17589                                 Viscosity    uint8 // 0-7
17590                                 LiqRenewable bool
17591                                 FlowRange    uint8
17592                                 DrownDmg     uint8
17593                                 Floodable    bool
17594
17595                                 DrawBox, ColBox, SelBox NodeBox
17596
17597                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17598
17599                                 LegacyFaceDir bool
17600                                 LegacyMounted bool
17601
17602                                 DigPredict string
17603
17604                                 MaxLvl uint8
17605
17606                                 AlphaUse
17607                         }))(obj)).ColBox).Serialize(w)
17608                 }); err != nil {
17609                         if err == io.EOF {
17610                                 chk(io.EOF)
17611                         }
17612                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17613                 }
17614                 if err := pcall(func() {
17615                         ((*(*(struct {
17616                                 Param0 Content
17617
17618                                 Name   string
17619                                 Groups []Group
17620
17621                                 P1Type   Param1Type
17622                                 P2Type   Param2Type
17623                                 DrawType DrawType
17624
17625                                 Mesh  string
17626                                 Scale float32
17627                                 //mt:const uint8(6)
17628                                 Tiles        [6]TileDef
17629                                 OverlayTiles [6]TileDef
17630                                 //mt:const uint8(6)
17631                                 SpecialTiles [6]TileDef
17632
17633                                 Color   color.NRGBA
17634                                 Palette Texture
17635
17636                                 Waving       WaveType
17637                                 ConnectSides uint8
17638                                 ConnectTo    []Content
17639                                 InsideTint   color.NRGBA
17640                                 Level        uint8 // Must be < 128.
17641
17642                                 Translucent bool // Sunlight is scattered and becomes normal light.
17643                                 Transparent bool // Sunlight isn't scattered.
17644                                 LightSrc    uint8
17645
17646                                 GndContent   bool
17647                                 Collides     bool
17648                                 Pointable    bool
17649                                 Diggable     bool
17650                                 Climbable    bool
17651                                 Replaceable  bool
17652                                 OnRightClick bool
17653
17654                                 DmgPerSec int32
17655
17656                                 LiquidType   LiquidType
17657                                 FlowingAlt   string
17658                                 SrcAlt       string
17659                                 Viscosity    uint8 // 0-7
17660                                 LiqRenewable bool
17661                                 FlowRange    uint8
17662                                 DrownDmg     uint8
17663                                 Floodable    bool
17664
17665                                 DrawBox, ColBox, SelBox NodeBox
17666
17667                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17668
17669                                 LegacyFaceDir bool
17670                                 LegacyMounted bool
17671
17672                                 DigPredict string
17673
17674                                 MaxLvl uint8
17675
17676                                 AlphaUse
17677                         }))(obj)).SelBox).Serialize(w)
17678                 }); err != nil {
17679                         if err == io.EOF {
17680                                 chk(io.EOF)
17681                         }
17682                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17683                 }
17684                 if err := pcall(func() {
17685                         ((*(*(struct {
17686                                 Param0 Content
17687
17688                                 Name   string
17689                                 Groups []Group
17690
17691                                 P1Type   Param1Type
17692                                 P2Type   Param2Type
17693                                 DrawType DrawType
17694
17695                                 Mesh  string
17696                                 Scale float32
17697                                 //mt:const uint8(6)
17698                                 Tiles        [6]TileDef
17699                                 OverlayTiles [6]TileDef
17700                                 //mt:const uint8(6)
17701                                 SpecialTiles [6]TileDef
17702
17703                                 Color   color.NRGBA
17704                                 Palette Texture
17705
17706                                 Waving       WaveType
17707                                 ConnectSides uint8
17708                                 ConnectTo    []Content
17709                                 InsideTint   color.NRGBA
17710                                 Level        uint8 // Must be < 128.
17711
17712                                 Translucent bool // Sunlight is scattered and becomes normal light.
17713                                 Transparent bool // Sunlight isn't scattered.
17714                                 LightSrc    uint8
17715
17716                                 GndContent   bool
17717                                 Collides     bool
17718                                 Pointable    bool
17719                                 Diggable     bool
17720                                 Climbable    bool
17721                                 Replaceable  bool
17722                                 OnRightClick bool
17723
17724                                 DmgPerSec int32
17725
17726                                 LiquidType   LiquidType
17727                                 FlowingAlt   string
17728                                 SrcAlt       string
17729                                 Viscosity    uint8 // 0-7
17730                                 LiqRenewable bool
17731                                 FlowRange    uint8
17732                                 DrownDmg     uint8
17733                                 Floodable    bool
17734
17735                                 DrawBox, ColBox, SelBox NodeBox
17736
17737                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17738
17739                                 LegacyFaceDir bool
17740                                 LegacyMounted bool
17741
17742                                 DigPredict string
17743
17744                                 MaxLvl uint8
17745
17746                                 AlphaUse
17747                         }))(obj)).FootstepSnd).Serialize(w)
17748                 }); err != nil {
17749                         if err == io.EOF {
17750                                 chk(io.EOF)
17751                         }
17752                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
17753                 }
17754                 if err := pcall(func() {
17755                         ((*(*(struct {
17756                                 Param0 Content
17757
17758                                 Name   string
17759                                 Groups []Group
17760
17761                                 P1Type   Param1Type
17762                                 P2Type   Param2Type
17763                                 DrawType DrawType
17764
17765                                 Mesh  string
17766                                 Scale float32
17767                                 //mt:const uint8(6)
17768                                 Tiles        [6]TileDef
17769                                 OverlayTiles [6]TileDef
17770                                 //mt:const uint8(6)
17771                                 SpecialTiles [6]TileDef
17772
17773                                 Color   color.NRGBA
17774                                 Palette Texture
17775
17776                                 Waving       WaveType
17777                                 ConnectSides uint8
17778                                 ConnectTo    []Content
17779                                 InsideTint   color.NRGBA
17780                                 Level        uint8 // Must be < 128.
17781
17782                                 Translucent bool // Sunlight is scattered and becomes normal light.
17783                                 Transparent bool // Sunlight isn't scattered.
17784                                 LightSrc    uint8
17785
17786                                 GndContent   bool
17787                                 Collides     bool
17788                                 Pointable    bool
17789                                 Diggable     bool
17790                                 Climbable    bool
17791                                 Replaceable  bool
17792                                 OnRightClick bool
17793
17794                                 DmgPerSec int32
17795
17796                                 LiquidType   LiquidType
17797                                 FlowingAlt   string
17798                                 SrcAlt       string
17799                                 Viscosity    uint8 // 0-7
17800                                 LiqRenewable bool
17801                                 FlowRange    uint8
17802                                 DrownDmg     uint8
17803                                 Floodable    bool
17804
17805                                 DrawBox, ColBox, SelBox NodeBox
17806
17807                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17808
17809                                 LegacyFaceDir bool
17810                                 LegacyMounted bool
17811
17812                                 DigPredict string
17813
17814                                 MaxLvl uint8
17815
17816                                 AlphaUse
17817                         }))(obj)).DiggingSnd).Serialize(w)
17818                 }); err != nil {
17819                         if err == io.EOF {
17820                                 chk(io.EOF)
17821                         }
17822                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
17823                 }
17824                 if err := pcall(func() {
17825                         ((*(*(struct {
17826                                 Param0 Content
17827
17828                                 Name   string
17829                                 Groups []Group
17830
17831                                 P1Type   Param1Type
17832                                 P2Type   Param2Type
17833                                 DrawType DrawType
17834
17835                                 Mesh  string
17836                                 Scale float32
17837                                 //mt:const uint8(6)
17838                                 Tiles        [6]TileDef
17839                                 OverlayTiles [6]TileDef
17840                                 //mt:const uint8(6)
17841                                 SpecialTiles [6]TileDef
17842
17843                                 Color   color.NRGBA
17844                                 Palette Texture
17845
17846                                 Waving       WaveType
17847                                 ConnectSides uint8
17848                                 ConnectTo    []Content
17849                                 InsideTint   color.NRGBA
17850                                 Level        uint8 // Must be < 128.
17851
17852                                 Translucent bool // Sunlight is scattered and becomes normal light.
17853                                 Transparent bool // Sunlight isn't scattered.
17854                                 LightSrc    uint8
17855
17856                                 GndContent   bool
17857                                 Collides     bool
17858                                 Pointable    bool
17859                                 Diggable     bool
17860                                 Climbable    bool
17861                                 Replaceable  bool
17862                                 OnRightClick bool
17863
17864                                 DmgPerSec int32
17865
17866                                 LiquidType   LiquidType
17867                                 FlowingAlt   string
17868                                 SrcAlt       string
17869                                 Viscosity    uint8 // 0-7
17870                                 LiqRenewable bool
17871                                 FlowRange    uint8
17872                                 DrownDmg     uint8
17873                                 Floodable    bool
17874
17875                                 DrawBox, ColBox, SelBox NodeBox
17876
17877                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17878
17879                                 LegacyFaceDir bool
17880                                 LegacyMounted bool
17881
17882                                 DigPredict string
17883
17884                                 MaxLvl uint8
17885
17886                                 AlphaUse
17887                         }))(obj)).DugSnd).Serialize(w)
17888                 }); err != nil {
17889                         if err == io.EOF {
17890                                 chk(io.EOF)
17891                         }
17892                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
17893                 }
17894                 {
17895                         x := (*(*(struct {
17896                                 Param0 Content
17897
17898                                 Name   string
17899                                 Groups []Group
17900
17901                                 P1Type   Param1Type
17902                                 P2Type   Param2Type
17903                                 DrawType DrawType
17904
17905                                 Mesh  string
17906                                 Scale float32
17907                                 //mt:const uint8(6)
17908                                 Tiles        [6]TileDef
17909                                 OverlayTiles [6]TileDef
17910                                 //mt:const uint8(6)
17911                                 SpecialTiles [6]TileDef
17912
17913                                 Color   color.NRGBA
17914                                 Palette Texture
17915
17916                                 Waving       WaveType
17917                                 ConnectSides uint8
17918                                 ConnectTo    []Content
17919                                 InsideTint   color.NRGBA
17920                                 Level        uint8 // Must be < 128.
17921
17922                                 Translucent bool // Sunlight is scattered and becomes normal light.
17923                                 Transparent bool // Sunlight isn't scattered.
17924                                 LightSrc    uint8
17925
17926                                 GndContent   bool
17927                                 Collides     bool
17928                                 Pointable    bool
17929                                 Diggable     bool
17930                                 Climbable    bool
17931                                 Replaceable  bool
17932                                 OnRightClick bool
17933
17934                                 DmgPerSec int32
17935
17936                                 LiquidType   LiquidType
17937                                 FlowingAlt   string
17938                                 SrcAlt       string
17939                                 Viscosity    uint8 // 0-7
17940                                 LiqRenewable bool
17941                                 FlowRange    uint8
17942                                 DrownDmg     uint8
17943                                 Floodable    bool
17944
17945                                 DrawBox, ColBox, SelBox NodeBox
17946
17947                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17948
17949                                 LegacyFaceDir bool
17950                                 LegacyMounted bool
17951
17952                                 DigPredict string
17953
17954                                 MaxLvl uint8
17955
17956                                 AlphaUse
17957                         }))(obj)).LegacyFaceDir
17958                         if x {
17959                                 write8(w, 1)
17960                         } else {
17961                                 write8(w, 0)
17962                         }
17963                 }
17964                 {
17965                         x := (*(*(struct {
17966                                 Param0 Content
17967
17968                                 Name   string
17969                                 Groups []Group
17970
17971                                 P1Type   Param1Type
17972                                 P2Type   Param2Type
17973                                 DrawType DrawType
17974
17975                                 Mesh  string
17976                                 Scale float32
17977                                 //mt:const uint8(6)
17978                                 Tiles        [6]TileDef
17979                                 OverlayTiles [6]TileDef
17980                                 //mt:const uint8(6)
17981                                 SpecialTiles [6]TileDef
17982
17983                                 Color   color.NRGBA
17984                                 Palette Texture
17985
17986                                 Waving       WaveType
17987                                 ConnectSides uint8
17988                                 ConnectTo    []Content
17989                                 InsideTint   color.NRGBA
17990                                 Level        uint8 // Must be < 128.
17991
17992                                 Translucent bool // Sunlight is scattered and becomes normal light.
17993                                 Transparent bool // Sunlight isn't scattered.
17994                                 LightSrc    uint8
17995
17996                                 GndContent   bool
17997                                 Collides     bool
17998                                 Pointable    bool
17999                                 Diggable     bool
18000                                 Climbable    bool
18001                                 Replaceable  bool
18002                                 OnRightClick bool
18003
18004                                 DmgPerSec int32
18005
18006                                 LiquidType   LiquidType
18007                                 FlowingAlt   string
18008                                 SrcAlt       string
18009                                 Viscosity    uint8 // 0-7
18010                                 LiqRenewable bool
18011                                 FlowRange    uint8
18012                                 DrownDmg     uint8
18013                                 Floodable    bool
18014
18015                                 DrawBox, ColBox, SelBox NodeBox
18016
18017                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18018
18019                                 LegacyFaceDir bool
18020                                 LegacyMounted bool
18021
18022                                 DigPredict string
18023
18024                                 MaxLvl uint8
18025
18026                                 AlphaUse
18027                         }))(obj)).LegacyMounted
18028                         if x {
18029                                 write8(w, 1)
18030                         } else {
18031                                 write8(w, 0)
18032                         }
18033                 }
18034                 if len(([]byte((*(*(struct {
18035                         Param0 Content
18036
18037                         Name   string
18038                         Groups []Group
18039
18040                         P1Type   Param1Type
18041                         P2Type   Param2Type
18042                         DrawType DrawType
18043
18044                         Mesh  string
18045                         Scale float32
18046                         //mt:const uint8(6)
18047                         Tiles        [6]TileDef
18048                         OverlayTiles [6]TileDef
18049                         //mt:const uint8(6)
18050                         SpecialTiles [6]TileDef
18051
18052                         Color   color.NRGBA
18053                         Palette Texture
18054
18055                         Waving       WaveType
18056                         ConnectSides uint8
18057                         ConnectTo    []Content
18058                         InsideTint   color.NRGBA
18059                         Level        uint8 // Must be < 128.
18060
18061                         Translucent bool // Sunlight is scattered and becomes normal light.
18062                         Transparent bool // Sunlight isn't scattered.
18063                         LightSrc    uint8
18064
18065                         GndContent   bool
18066                         Collides     bool
18067                         Pointable    bool
18068                         Diggable     bool
18069                         Climbable    bool
18070                         Replaceable  bool
18071                         OnRightClick bool
18072
18073                         DmgPerSec int32
18074
18075                         LiquidType   LiquidType
18076                         FlowingAlt   string
18077                         SrcAlt       string
18078                         Viscosity    uint8 // 0-7
18079                         LiqRenewable bool
18080                         FlowRange    uint8
18081                         DrownDmg     uint8
18082                         Floodable    bool
18083
18084                         DrawBox, ColBox, SelBox NodeBox
18085
18086                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18087
18088                         LegacyFaceDir bool
18089                         LegacyMounted bool
18090
18091                         DigPredict string
18092
18093                         MaxLvl uint8
18094
18095                         AlphaUse
18096                 }))(obj)).DigPredict))) > math.MaxUint16 {
18097                         chk(ErrTooLong)
18098                 }
18099                 {
18100                         x := uint16(len(([]byte((*(*(struct {
18101                                 Param0 Content
18102
18103                                 Name   string
18104                                 Groups []Group
18105
18106                                 P1Type   Param1Type
18107                                 P2Type   Param2Type
18108                                 DrawType DrawType
18109
18110                                 Mesh  string
18111                                 Scale float32
18112                                 //mt:const uint8(6)
18113                                 Tiles        [6]TileDef
18114                                 OverlayTiles [6]TileDef
18115                                 //mt:const uint8(6)
18116                                 SpecialTiles [6]TileDef
18117
18118                                 Color   color.NRGBA
18119                                 Palette Texture
18120
18121                                 Waving       WaveType
18122                                 ConnectSides uint8
18123                                 ConnectTo    []Content
18124                                 InsideTint   color.NRGBA
18125                                 Level        uint8 // Must be < 128.
18126
18127                                 Translucent bool // Sunlight is scattered and becomes normal light.
18128                                 Transparent bool // Sunlight isn't scattered.
18129                                 LightSrc    uint8
18130
18131                                 GndContent   bool
18132                                 Collides     bool
18133                                 Pointable    bool
18134                                 Diggable     bool
18135                                 Climbable    bool
18136                                 Replaceable  bool
18137                                 OnRightClick bool
18138
18139                                 DmgPerSec int32
18140
18141                                 LiquidType   LiquidType
18142                                 FlowingAlt   string
18143                                 SrcAlt       string
18144                                 Viscosity    uint8 // 0-7
18145                                 LiqRenewable bool
18146                                 FlowRange    uint8
18147                                 DrownDmg     uint8
18148                                 Floodable    bool
18149
18150                                 DrawBox, ColBox, SelBox NodeBox
18151
18152                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18153
18154                                 LegacyFaceDir bool
18155                                 LegacyMounted bool
18156
18157                                 DigPredict string
18158
18159                                 MaxLvl uint8
18160
18161                                 AlphaUse
18162                         }))(obj)).DigPredict))))
18163                         write16(w, uint16(x))
18164                 }
18165                 {
18166                         _, err := w.Write(([]byte((*(*(struct {
18167                                 Param0 Content
18168
18169                                 Name   string
18170                                 Groups []Group
18171
18172                                 P1Type   Param1Type
18173                                 P2Type   Param2Type
18174                                 DrawType DrawType
18175
18176                                 Mesh  string
18177                                 Scale float32
18178                                 //mt:const uint8(6)
18179                                 Tiles        [6]TileDef
18180                                 OverlayTiles [6]TileDef
18181                                 //mt:const uint8(6)
18182                                 SpecialTiles [6]TileDef
18183
18184                                 Color   color.NRGBA
18185                                 Palette Texture
18186
18187                                 Waving       WaveType
18188                                 ConnectSides uint8
18189                                 ConnectTo    []Content
18190                                 InsideTint   color.NRGBA
18191                                 Level        uint8 // Must be < 128.
18192
18193                                 Translucent bool // Sunlight is scattered and becomes normal light.
18194                                 Transparent bool // Sunlight isn't scattered.
18195                                 LightSrc    uint8
18196
18197                                 GndContent   bool
18198                                 Collides     bool
18199                                 Pointable    bool
18200                                 Diggable     bool
18201                                 Climbable    bool
18202                                 Replaceable  bool
18203                                 OnRightClick bool
18204
18205                                 DmgPerSec int32
18206
18207                                 LiquidType   LiquidType
18208                                 FlowingAlt   string
18209                                 SrcAlt       string
18210                                 Viscosity    uint8 // 0-7
18211                                 LiqRenewable bool
18212                                 FlowRange    uint8
18213                                 DrownDmg     uint8
18214                                 Floodable    bool
18215
18216                                 DrawBox, ColBox, SelBox NodeBox
18217
18218                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18219
18220                                 LegacyFaceDir bool
18221                                 LegacyMounted bool
18222
18223                                 DigPredict string
18224
18225                                 MaxLvl uint8
18226
18227                                 AlphaUse
18228                         }))(obj)).DigPredict))[:])
18229                         chk(err)
18230                 }
18231                 {
18232                         x := (*(*(struct {
18233                                 Param0 Content
18234
18235                                 Name   string
18236                                 Groups []Group
18237
18238                                 P1Type   Param1Type
18239                                 P2Type   Param2Type
18240                                 DrawType DrawType
18241
18242                                 Mesh  string
18243                                 Scale float32
18244                                 //mt:const uint8(6)
18245                                 Tiles        [6]TileDef
18246                                 OverlayTiles [6]TileDef
18247                                 //mt:const uint8(6)
18248                                 SpecialTiles [6]TileDef
18249
18250                                 Color   color.NRGBA
18251                                 Palette Texture
18252
18253                                 Waving       WaveType
18254                                 ConnectSides uint8
18255                                 ConnectTo    []Content
18256                                 InsideTint   color.NRGBA
18257                                 Level        uint8 // Must be < 128.
18258
18259                                 Translucent bool // Sunlight is scattered and becomes normal light.
18260                                 Transparent bool // Sunlight isn't scattered.
18261                                 LightSrc    uint8
18262
18263                                 GndContent   bool
18264                                 Collides     bool
18265                                 Pointable    bool
18266                                 Diggable     bool
18267                                 Climbable    bool
18268                                 Replaceable  bool
18269                                 OnRightClick bool
18270
18271                                 DmgPerSec int32
18272
18273                                 LiquidType   LiquidType
18274                                 FlowingAlt   string
18275                                 SrcAlt       string
18276                                 Viscosity    uint8 // 0-7
18277                                 LiqRenewable bool
18278                                 FlowRange    uint8
18279                                 DrownDmg     uint8
18280                                 Floodable    bool
18281
18282                                 DrawBox, ColBox, SelBox NodeBox
18283
18284                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18285
18286                                 LegacyFaceDir bool
18287                                 LegacyMounted bool
18288
18289                                 DigPredict string
18290
18291                                 MaxLvl uint8
18292
18293                                 AlphaUse
18294                         }))(obj)).MaxLvl
18295                         write8(w, uint8(x))
18296                 }
18297                 if err := pcall(func() {
18298                         ((*(*(struct {
18299                                 Param0 Content
18300
18301                                 Name   string
18302                                 Groups []Group
18303
18304                                 P1Type   Param1Type
18305                                 P2Type   Param2Type
18306                                 DrawType DrawType
18307
18308                                 Mesh  string
18309                                 Scale float32
18310                                 //mt:const uint8(6)
18311                                 Tiles        [6]TileDef
18312                                 OverlayTiles [6]TileDef
18313                                 //mt:const uint8(6)
18314                                 SpecialTiles [6]TileDef
18315
18316                                 Color   color.NRGBA
18317                                 Palette Texture
18318
18319                                 Waving       WaveType
18320                                 ConnectSides uint8
18321                                 ConnectTo    []Content
18322                                 InsideTint   color.NRGBA
18323                                 Level        uint8 // Must be < 128.
18324
18325                                 Translucent bool // Sunlight is scattered and becomes normal light.
18326                                 Transparent bool // Sunlight isn't scattered.
18327                                 LightSrc    uint8
18328
18329                                 GndContent   bool
18330                                 Collides     bool
18331                                 Pointable    bool
18332                                 Diggable     bool
18333                                 Climbable    bool
18334                                 Replaceable  bool
18335                                 OnRightClick bool
18336
18337                                 DmgPerSec int32
18338
18339                                 LiquidType   LiquidType
18340                                 FlowingAlt   string
18341                                 SrcAlt       string
18342                                 Viscosity    uint8 // 0-7
18343                                 LiqRenewable bool
18344                                 FlowRange    uint8
18345                                 DrownDmg     uint8
18346                                 Floodable    bool
18347
18348                                 DrawBox, ColBox, SelBox NodeBox
18349
18350                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18351
18352                                 LegacyFaceDir bool
18353                                 LegacyMounted bool
18354
18355                                 DigPredict string
18356
18357                                 MaxLvl uint8
18358
18359                                 AlphaUse
18360                         }))(obj)).AlphaUse).Serialize(w)
18361                 }); err != nil {
18362                         if err == io.EOF {
18363                                 chk(io.EOF)
18364                         }
18365                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlphaUse", err))
18366                 }
18367                 {
18368                         buf := w
18369                         w := ow
18370                         if len((buf.Bytes())) > math.MaxUint16 {
18371                                 chk(ErrTooLong)
18372                         }
18373                         {
18374                                 x := uint16(len((buf.Bytes())))
18375                                 write16(w, uint16(x))
18376                         }
18377                         {
18378                                 _, err := w.Write((buf.Bytes())[:])
18379                                 chk(err)
18380                         }
18381                 }
18382         }
18383 }
18384
18385 func (obj *NodeDef) Deserialize(r io.Reader) {
18386         if err := pcall(func() {
18387                 ((*(*(struct {
18388                         Param0 Content
18389
18390                         Name   string
18391                         Groups []Group
18392
18393                         P1Type   Param1Type
18394                         P2Type   Param2Type
18395                         DrawType DrawType
18396
18397                         Mesh  string
18398                         Scale float32
18399                         //mt:const uint8(6)
18400                         Tiles        [6]TileDef
18401                         OverlayTiles [6]TileDef
18402                         //mt:const uint8(6)
18403                         SpecialTiles [6]TileDef
18404
18405                         Color   color.NRGBA
18406                         Palette Texture
18407
18408                         Waving       WaveType
18409                         ConnectSides uint8
18410                         ConnectTo    []Content
18411                         InsideTint   color.NRGBA
18412                         Level        uint8 // Must be < 128.
18413
18414                         Translucent bool // Sunlight is scattered and becomes normal light.
18415                         Transparent bool // Sunlight isn't scattered.
18416                         LightSrc    uint8
18417
18418                         GndContent   bool
18419                         Collides     bool
18420                         Pointable    bool
18421                         Diggable     bool
18422                         Climbable    bool
18423                         Replaceable  bool
18424                         OnRightClick bool
18425
18426                         DmgPerSec int32
18427
18428                         LiquidType   LiquidType
18429                         FlowingAlt   string
18430                         SrcAlt       string
18431                         Viscosity    uint8 // 0-7
18432                         LiqRenewable bool
18433                         FlowRange    uint8
18434                         DrownDmg     uint8
18435                         Floodable    bool
18436
18437                         DrawBox, ColBox, SelBox NodeBox
18438
18439                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18440
18441                         LegacyFaceDir bool
18442                         LegacyMounted bool
18443
18444                         DigPredict string
18445
18446                         MaxLvl uint8
18447
18448                         AlphaUse
18449                 }))(obj)).Param0).Deserialize(r)
18450         }); err != nil {
18451                 if err == io.EOF {
18452                         chk(io.EOF)
18453                 }
18454                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
18455         }
18456         {
18457                 var n uint16
18458                 {
18459                         p := &n
18460                         *p = read16(r)
18461                 }
18462                 r := &io.LimitedReader{R: r, N: int64(n)}
18463                 {
18464                         var local248 uint8
18465                         local249 := uint8(13)
18466                         {
18467                                 p := &local248
18468                                 *p = read8(r)
18469                         }
18470                         if local248 != local249 {
18471                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local248))
18472                         }
18473                 }
18474                 var local250 []uint8
18475                 var local251 uint16
18476                 {
18477                         p := &local251
18478                         *p = read16(r)
18479                 }
18480                 (local250) = make([]uint8, local251)
18481                 {
18482                         _, err := io.ReadFull(r, (local250)[:])
18483                         chk(err)
18484                 }
18485                 ((*(*(struct {
18486                         Param0 Content
18487
18488                         Name   string
18489                         Groups []Group
18490
18491                         P1Type   Param1Type
18492                         P2Type   Param2Type
18493                         DrawType DrawType
18494
18495                         Mesh  string
18496                         Scale float32
18497                         //mt:const uint8(6)
18498                         Tiles        [6]TileDef
18499                         OverlayTiles [6]TileDef
18500                         //mt:const uint8(6)
18501                         SpecialTiles [6]TileDef
18502
18503                         Color   color.NRGBA
18504                         Palette Texture
18505
18506                         Waving       WaveType
18507                         ConnectSides uint8
18508                         ConnectTo    []Content
18509                         InsideTint   color.NRGBA
18510                         Level        uint8 // Must be < 128.
18511
18512                         Translucent bool // Sunlight is scattered and becomes normal light.
18513                         Transparent bool // Sunlight isn't scattered.
18514                         LightSrc    uint8
18515
18516                         GndContent   bool
18517                         Collides     bool
18518                         Pointable    bool
18519                         Diggable     bool
18520                         Climbable    bool
18521                         Replaceable  bool
18522                         OnRightClick bool
18523
18524                         DmgPerSec int32
18525
18526                         LiquidType   LiquidType
18527                         FlowingAlt   string
18528                         SrcAlt       string
18529                         Viscosity    uint8 // 0-7
18530                         LiqRenewable bool
18531                         FlowRange    uint8
18532                         DrownDmg     uint8
18533                         Floodable    bool
18534
18535                         DrawBox, ColBox, SelBox NodeBox
18536
18537                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18538
18539                         LegacyFaceDir bool
18540                         LegacyMounted bool
18541
18542                         DigPredict string
18543
18544                         MaxLvl uint8
18545
18546                         AlphaUse
18547                 }))(obj)).Name) = string(local250)
18548                 var local252 uint16
18549                 {
18550                         p := &local252
18551                         *p = read16(r)
18552                 }
18553                 ((*(*(struct {
18554                         Param0 Content
18555
18556                         Name   string
18557                         Groups []Group
18558
18559                         P1Type   Param1Type
18560                         P2Type   Param2Type
18561                         DrawType DrawType
18562
18563                         Mesh  string
18564                         Scale float32
18565                         //mt:const uint8(6)
18566                         Tiles        [6]TileDef
18567                         OverlayTiles [6]TileDef
18568                         //mt:const uint8(6)
18569                         SpecialTiles [6]TileDef
18570
18571                         Color   color.NRGBA
18572                         Palette Texture
18573
18574                         Waving       WaveType
18575                         ConnectSides uint8
18576                         ConnectTo    []Content
18577                         InsideTint   color.NRGBA
18578                         Level        uint8 // Must be < 128.
18579
18580                         Translucent bool // Sunlight is scattered and becomes normal light.
18581                         Transparent bool // Sunlight isn't scattered.
18582                         LightSrc    uint8
18583
18584                         GndContent   bool
18585                         Collides     bool
18586                         Pointable    bool
18587                         Diggable     bool
18588                         Climbable    bool
18589                         Replaceable  bool
18590                         OnRightClick bool
18591
18592                         DmgPerSec int32
18593
18594                         LiquidType   LiquidType
18595                         FlowingAlt   string
18596                         SrcAlt       string
18597                         Viscosity    uint8 // 0-7
18598                         LiqRenewable bool
18599                         FlowRange    uint8
18600                         DrownDmg     uint8
18601                         Floodable    bool
18602
18603                         DrawBox, ColBox, SelBox NodeBox
18604
18605                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18606
18607                         LegacyFaceDir bool
18608                         LegacyMounted bool
18609
18610                         DigPredict string
18611
18612                         MaxLvl uint8
18613
18614                         AlphaUse
18615                 }))(obj)).Groups) = make([]Group, local252)
18616                 for local253 := range (*(*(struct {
18617                         Param0 Content
18618
18619                         Name   string
18620                         Groups []Group
18621
18622                         P1Type   Param1Type
18623                         P2Type   Param2Type
18624                         DrawType DrawType
18625
18626                         Mesh  string
18627                         Scale float32
18628                         //mt:const uint8(6)
18629                         Tiles        [6]TileDef
18630                         OverlayTiles [6]TileDef
18631                         //mt:const uint8(6)
18632                         SpecialTiles [6]TileDef
18633
18634                         Color   color.NRGBA
18635                         Palette Texture
18636
18637                         Waving       WaveType
18638                         ConnectSides uint8
18639                         ConnectTo    []Content
18640                         InsideTint   color.NRGBA
18641                         Level        uint8 // Must be < 128.
18642
18643                         Translucent bool // Sunlight is scattered and becomes normal light.
18644                         Transparent bool // Sunlight isn't scattered.
18645                         LightSrc    uint8
18646
18647                         GndContent   bool
18648                         Collides     bool
18649                         Pointable    bool
18650                         Diggable     bool
18651                         Climbable    bool
18652                         Replaceable  bool
18653                         OnRightClick bool
18654
18655                         DmgPerSec int32
18656
18657                         LiquidType   LiquidType
18658                         FlowingAlt   string
18659                         SrcAlt       string
18660                         Viscosity    uint8 // 0-7
18661                         LiqRenewable bool
18662                         FlowRange    uint8
18663                         DrownDmg     uint8
18664                         Floodable    bool
18665
18666                         DrawBox, ColBox, SelBox NodeBox
18667
18668                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18669
18670                         LegacyFaceDir bool
18671                         LegacyMounted bool
18672
18673                         DigPredict string
18674
18675                         MaxLvl uint8
18676
18677                         AlphaUse
18678                 }))(obj)).Groups {
18679                         if err := pcall(func() {
18680                                 (((*(*(struct {
18681                                         Param0 Content
18682
18683                                         Name   string
18684                                         Groups []Group
18685
18686                                         P1Type   Param1Type
18687                                         P2Type   Param2Type
18688                                         DrawType DrawType
18689
18690                                         Mesh  string
18691                                         Scale float32
18692                                         //mt:const uint8(6)
18693                                         Tiles        [6]TileDef
18694                                         OverlayTiles [6]TileDef
18695                                         //mt:const uint8(6)
18696                                         SpecialTiles [6]TileDef
18697
18698                                         Color   color.NRGBA
18699                                         Palette Texture
18700
18701                                         Waving       WaveType
18702                                         ConnectSides uint8
18703                                         ConnectTo    []Content
18704                                         InsideTint   color.NRGBA
18705                                         Level        uint8 // Must be < 128.
18706
18707                                         Translucent bool // Sunlight is scattered and becomes normal light.
18708                                         Transparent bool // Sunlight isn't scattered.
18709                                         LightSrc    uint8
18710
18711                                         GndContent   bool
18712                                         Collides     bool
18713                                         Pointable    bool
18714                                         Diggable     bool
18715                                         Climbable    bool
18716                                         Replaceable  bool
18717                                         OnRightClick bool
18718
18719                                         DmgPerSec int32
18720
18721                                         LiquidType   LiquidType
18722                                         FlowingAlt   string
18723                                         SrcAlt       string
18724                                         Viscosity    uint8 // 0-7
18725                                         LiqRenewable bool
18726                                         FlowRange    uint8
18727                                         DrownDmg     uint8
18728                                         Floodable    bool
18729
18730                                         DrawBox, ColBox, SelBox NodeBox
18731
18732                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18733
18734                                         LegacyFaceDir bool
18735                                         LegacyMounted bool
18736
18737                                         DigPredict string
18738
18739                                         MaxLvl uint8
18740
18741                                         AlphaUse
18742                                 }))(obj)).Groups)[local253]).Deserialize(r)
18743                         }); err != nil {
18744                                 if err == io.EOF {
18745                                         chk(io.EOF)
18746                                 }
18747                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
18748                         }
18749                 }
18750                 if err := pcall(func() {
18751                         ((*(*(struct {
18752                                 Param0 Content
18753
18754                                 Name   string
18755                                 Groups []Group
18756
18757                                 P1Type   Param1Type
18758                                 P2Type   Param2Type
18759                                 DrawType DrawType
18760
18761                                 Mesh  string
18762                                 Scale float32
18763                                 //mt:const uint8(6)
18764                                 Tiles        [6]TileDef
18765                                 OverlayTiles [6]TileDef
18766                                 //mt:const uint8(6)
18767                                 SpecialTiles [6]TileDef
18768
18769                                 Color   color.NRGBA
18770                                 Palette Texture
18771
18772                                 Waving       WaveType
18773                                 ConnectSides uint8
18774                                 ConnectTo    []Content
18775                                 InsideTint   color.NRGBA
18776                                 Level        uint8 // Must be < 128.
18777
18778                                 Translucent bool // Sunlight is scattered and becomes normal light.
18779                                 Transparent bool // Sunlight isn't scattered.
18780                                 LightSrc    uint8
18781
18782                                 GndContent   bool
18783                                 Collides     bool
18784                                 Pointable    bool
18785                                 Diggable     bool
18786                                 Climbable    bool
18787                                 Replaceable  bool
18788                                 OnRightClick bool
18789
18790                                 DmgPerSec int32
18791
18792                                 LiquidType   LiquidType
18793                                 FlowingAlt   string
18794                                 SrcAlt       string
18795                                 Viscosity    uint8 // 0-7
18796                                 LiqRenewable bool
18797                                 FlowRange    uint8
18798                                 DrownDmg     uint8
18799                                 Floodable    bool
18800
18801                                 DrawBox, ColBox, SelBox NodeBox
18802
18803                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18804
18805                                 LegacyFaceDir bool
18806                                 LegacyMounted bool
18807
18808                                 DigPredict string
18809
18810                                 MaxLvl uint8
18811
18812                                 AlphaUse
18813                         }))(obj)).P1Type).Deserialize(r)
18814                 }); err != nil {
18815                         if err == io.EOF {
18816                                 chk(io.EOF)
18817                         }
18818                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param1Type", err))
18819                 }
18820                 if err := pcall(func() {
18821                         ((*(*(struct {
18822                                 Param0 Content
18823
18824                                 Name   string
18825                                 Groups []Group
18826
18827                                 P1Type   Param1Type
18828                                 P2Type   Param2Type
18829                                 DrawType DrawType
18830
18831                                 Mesh  string
18832                                 Scale float32
18833                                 //mt:const uint8(6)
18834                                 Tiles        [6]TileDef
18835                                 OverlayTiles [6]TileDef
18836                                 //mt:const uint8(6)
18837                                 SpecialTiles [6]TileDef
18838
18839                                 Color   color.NRGBA
18840                                 Palette Texture
18841
18842                                 Waving       WaveType
18843                                 ConnectSides uint8
18844                                 ConnectTo    []Content
18845                                 InsideTint   color.NRGBA
18846                                 Level        uint8 // Must be < 128.
18847
18848                                 Translucent bool // Sunlight is scattered and becomes normal light.
18849                                 Transparent bool // Sunlight isn't scattered.
18850                                 LightSrc    uint8
18851
18852                                 GndContent   bool
18853                                 Collides     bool
18854                                 Pointable    bool
18855                                 Diggable     bool
18856                                 Climbable    bool
18857                                 Replaceable  bool
18858                                 OnRightClick bool
18859
18860                                 DmgPerSec int32
18861
18862                                 LiquidType   LiquidType
18863                                 FlowingAlt   string
18864                                 SrcAlt       string
18865                                 Viscosity    uint8 // 0-7
18866                                 LiqRenewable bool
18867                                 FlowRange    uint8
18868                                 DrownDmg     uint8
18869                                 Floodable    bool
18870
18871                                 DrawBox, ColBox, SelBox NodeBox
18872
18873                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18874
18875                                 LegacyFaceDir bool
18876                                 LegacyMounted bool
18877
18878                                 DigPredict string
18879
18880                                 MaxLvl uint8
18881
18882                                 AlphaUse
18883                         }))(obj)).P2Type).Deserialize(r)
18884                 }); err != nil {
18885                         if err == io.EOF {
18886                                 chk(io.EOF)
18887                         }
18888                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param2Type", err))
18889                 }
18890                 if err := pcall(func() {
18891                         ((*(*(struct {
18892                                 Param0 Content
18893
18894                                 Name   string
18895                                 Groups []Group
18896
18897                                 P1Type   Param1Type
18898                                 P2Type   Param2Type
18899                                 DrawType DrawType
18900
18901                                 Mesh  string
18902                                 Scale float32
18903                                 //mt:const uint8(6)
18904                                 Tiles        [6]TileDef
18905                                 OverlayTiles [6]TileDef
18906                                 //mt:const uint8(6)
18907                                 SpecialTiles [6]TileDef
18908
18909                                 Color   color.NRGBA
18910                                 Palette Texture
18911
18912                                 Waving       WaveType
18913                                 ConnectSides uint8
18914                                 ConnectTo    []Content
18915                                 InsideTint   color.NRGBA
18916                                 Level        uint8 // Must be < 128.
18917
18918                                 Translucent bool // Sunlight is scattered and becomes normal light.
18919                                 Transparent bool // Sunlight isn't scattered.
18920                                 LightSrc    uint8
18921
18922                                 GndContent   bool
18923                                 Collides     bool
18924                                 Pointable    bool
18925                                 Diggable     bool
18926                                 Climbable    bool
18927                                 Replaceable  bool
18928                                 OnRightClick bool
18929
18930                                 DmgPerSec int32
18931
18932                                 LiquidType   LiquidType
18933                                 FlowingAlt   string
18934                                 SrcAlt       string
18935                                 Viscosity    uint8 // 0-7
18936                                 LiqRenewable bool
18937                                 FlowRange    uint8
18938                                 DrownDmg     uint8
18939                                 Floodable    bool
18940
18941                                 DrawBox, ColBox, SelBox NodeBox
18942
18943                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18944
18945                                 LegacyFaceDir bool
18946                                 LegacyMounted bool
18947
18948                                 DigPredict string
18949
18950                                 MaxLvl uint8
18951
18952                                 AlphaUse
18953                         }))(obj)).DrawType).Deserialize(r)
18954                 }); err != nil {
18955                         if err == io.EOF {
18956                                 chk(io.EOF)
18957                         }
18958                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
18959                 }
18960                 var local254 []uint8
18961                 var local255 uint16
18962                 {
18963                         p := &local255
18964                         *p = read16(r)
18965                 }
18966                 (local254) = make([]uint8, local255)
18967                 {
18968                         _, err := io.ReadFull(r, (local254)[:])
18969                         chk(err)
18970                 }
18971                 ((*(*(struct {
18972                         Param0 Content
18973
18974                         Name   string
18975                         Groups []Group
18976
18977                         P1Type   Param1Type
18978                         P2Type   Param2Type
18979                         DrawType DrawType
18980
18981                         Mesh  string
18982                         Scale float32
18983                         //mt:const uint8(6)
18984                         Tiles        [6]TileDef
18985                         OverlayTiles [6]TileDef
18986                         //mt:const uint8(6)
18987                         SpecialTiles [6]TileDef
18988
18989                         Color   color.NRGBA
18990                         Palette Texture
18991
18992                         Waving       WaveType
18993                         ConnectSides uint8
18994                         ConnectTo    []Content
18995                         InsideTint   color.NRGBA
18996                         Level        uint8 // Must be < 128.
18997
18998                         Translucent bool // Sunlight is scattered and becomes normal light.
18999                         Transparent bool // Sunlight isn't scattered.
19000                         LightSrc    uint8
19001
19002                         GndContent   bool
19003                         Collides     bool
19004                         Pointable    bool
19005                         Diggable     bool
19006                         Climbable    bool
19007                         Replaceable  bool
19008                         OnRightClick bool
19009
19010                         DmgPerSec int32
19011
19012                         LiquidType   LiquidType
19013                         FlowingAlt   string
19014                         SrcAlt       string
19015                         Viscosity    uint8 // 0-7
19016                         LiqRenewable bool
19017                         FlowRange    uint8
19018                         DrownDmg     uint8
19019                         Floodable    bool
19020
19021                         DrawBox, ColBox, SelBox NodeBox
19022
19023                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19024
19025                         LegacyFaceDir bool
19026                         LegacyMounted bool
19027
19028                         DigPredict string
19029
19030                         MaxLvl uint8
19031
19032                         AlphaUse
19033                 }))(obj)).Mesh) = string(local254)
19034                 {
19035                         p := &(*(*(struct {
19036                                 Param0 Content
19037
19038                                 Name   string
19039                                 Groups []Group
19040
19041                                 P1Type   Param1Type
19042                                 P2Type   Param2Type
19043                                 DrawType DrawType
19044
19045                                 Mesh  string
19046                                 Scale float32
19047                                 //mt:const uint8(6)
19048                                 Tiles        [6]TileDef
19049                                 OverlayTiles [6]TileDef
19050                                 //mt:const uint8(6)
19051                                 SpecialTiles [6]TileDef
19052
19053                                 Color   color.NRGBA
19054                                 Palette Texture
19055
19056                                 Waving       WaveType
19057                                 ConnectSides uint8
19058                                 ConnectTo    []Content
19059                                 InsideTint   color.NRGBA
19060                                 Level        uint8 // Must be < 128.
19061
19062                                 Translucent bool // Sunlight is scattered and becomes normal light.
19063                                 Transparent bool // Sunlight isn't scattered.
19064                                 LightSrc    uint8
19065
19066                                 GndContent   bool
19067                                 Collides     bool
19068                                 Pointable    bool
19069                                 Diggable     bool
19070                                 Climbable    bool
19071                                 Replaceable  bool
19072                                 OnRightClick bool
19073
19074                                 DmgPerSec int32
19075
19076                                 LiquidType   LiquidType
19077                                 FlowingAlt   string
19078                                 SrcAlt       string
19079                                 Viscosity    uint8 // 0-7
19080                                 LiqRenewable bool
19081                                 FlowRange    uint8
19082                                 DrownDmg     uint8
19083                                 Floodable    bool
19084
19085                                 DrawBox, ColBox, SelBox NodeBox
19086
19087                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19088
19089                                 LegacyFaceDir bool
19090                                 LegacyMounted bool
19091
19092                                 DigPredict string
19093
19094                                 MaxLvl uint8
19095
19096                                 AlphaUse
19097                         }))(obj)).Scale
19098                         *p = math.Float32frombits(read32(r))
19099                 }
19100                 {
19101                         var local256 uint8
19102                         local257 := uint8(6)
19103                         {
19104                                 p := &local256
19105                                 *p = read8(r)
19106                         }
19107                         if local256 != local257 {
19108                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local256))
19109                         }
19110                 }
19111                 for local258 := range (*(*(struct {
19112                         Param0 Content
19113
19114                         Name   string
19115                         Groups []Group
19116
19117                         P1Type   Param1Type
19118                         P2Type   Param2Type
19119                         DrawType DrawType
19120
19121                         Mesh  string
19122                         Scale float32
19123                         //mt:const uint8(6)
19124                         Tiles        [6]TileDef
19125                         OverlayTiles [6]TileDef
19126                         //mt:const uint8(6)
19127                         SpecialTiles [6]TileDef
19128
19129                         Color   color.NRGBA
19130                         Palette Texture
19131
19132                         Waving       WaveType
19133                         ConnectSides uint8
19134                         ConnectTo    []Content
19135                         InsideTint   color.NRGBA
19136                         Level        uint8 // Must be < 128.
19137
19138                         Translucent bool // Sunlight is scattered and becomes normal light.
19139                         Transparent bool // Sunlight isn't scattered.
19140                         LightSrc    uint8
19141
19142                         GndContent   bool
19143                         Collides     bool
19144                         Pointable    bool
19145                         Diggable     bool
19146                         Climbable    bool
19147                         Replaceable  bool
19148                         OnRightClick bool
19149
19150                         DmgPerSec int32
19151
19152                         LiquidType   LiquidType
19153                         FlowingAlt   string
19154                         SrcAlt       string
19155                         Viscosity    uint8 // 0-7
19156                         LiqRenewable bool
19157                         FlowRange    uint8
19158                         DrownDmg     uint8
19159                         Floodable    bool
19160
19161                         DrawBox, ColBox, SelBox NodeBox
19162
19163                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19164
19165                         LegacyFaceDir bool
19166                         LegacyMounted bool
19167
19168                         DigPredict string
19169
19170                         MaxLvl uint8
19171
19172                         AlphaUse
19173                 }))(obj)).Tiles {
19174                         if err := pcall(func() {
19175                                 (((*(*(struct {
19176                                         Param0 Content
19177
19178                                         Name   string
19179                                         Groups []Group
19180
19181                                         P1Type   Param1Type
19182                                         P2Type   Param2Type
19183                                         DrawType DrawType
19184
19185                                         Mesh  string
19186                                         Scale float32
19187                                         //mt:const uint8(6)
19188                                         Tiles        [6]TileDef
19189                                         OverlayTiles [6]TileDef
19190                                         //mt:const uint8(6)
19191                                         SpecialTiles [6]TileDef
19192
19193                                         Color   color.NRGBA
19194                                         Palette Texture
19195
19196                                         Waving       WaveType
19197                                         ConnectSides uint8
19198                                         ConnectTo    []Content
19199                                         InsideTint   color.NRGBA
19200                                         Level        uint8 // Must be < 128.
19201
19202                                         Translucent bool // Sunlight is scattered and becomes normal light.
19203                                         Transparent bool // Sunlight isn't scattered.
19204                                         LightSrc    uint8
19205
19206                                         GndContent   bool
19207                                         Collides     bool
19208                                         Pointable    bool
19209                                         Diggable     bool
19210                                         Climbable    bool
19211                                         Replaceable  bool
19212                                         OnRightClick bool
19213
19214                                         DmgPerSec int32
19215
19216                                         LiquidType   LiquidType
19217                                         FlowingAlt   string
19218                                         SrcAlt       string
19219                                         Viscosity    uint8 // 0-7
19220                                         LiqRenewable bool
19221                                         FlowRange    uint8
19222                                         DrownDmg     uint8
19223                                         Floodable    bool
19224
19225                                         DrawBox, ColBox, SelBox NodeBox
19226
19227                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19228
19229                                         LegacyFaceDir bool
19230                                         LegacyMounted bool
19231
19232                                         DigPredict string
19233
19234                                         MaxLvl uint8
19235
19236                                         AlphaUse
19237                                 }))(obj)).Tiles)[local258]).Deserialize(r)
19238                         }); err != nil {
19239                                 if err == io.EOF {
19240                                         chk(io.EOF)
19241                                 }
19242                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19243                         }
19244                 }
19245                 for local259 := range (*(*(struct {
19246                         Param0 Content
19247
19248                         Name   string
19249                         Groups []Group
19250
19251                         P1Type   Param1Type
19252                         P2Type   Param2Type
19253                         DrawType DrawType
19254
19255                         Mesh  string
19256                         Scale float32
19257                         //mt:const uint8(6)
19258                         Tiles        [6]TileDef
19259                         OverlayTiles [6]TileDef
19260                         //mt:const uint8(6)
19261                         SpecialTiles [6]TileDef
19262
19263                         Color   color.NRGBA
19264                         Palette Texture
19265
19266                         Waving       WaveType
19267                         ConnectSides uint8
19268                         ConnectTo    []Content
19269                         InsideTint   color.NRGBA
19270                         Level        uint8 // Must be < 128.
19271
19272                         Translucent bool // Sunlight is scattered and becomes normal light.
19273                         Transparent bool // Sunlight isn't scattered.
19274                         LightSrc    uint8
19275
19276                         GndContent   bool
19277                         Collides     bool
19278                         Pointable    bool
19279                         Diggable     bool
19280                         Climbable    bool
19281                         Replaceable  bool
19282                         OnRightClick bool
19283
19284                         DmgPerSec int32
19285
19286                         LiquidType   LiquidType
19287                         FlowingAlt   string
19288                         SrcAlt       string
19289                         Viscosity    uint8 // 0-7
19290                         LiqRenewable bool
19291                         FlowRange    uint8
19292                         DrownDmg     uint8
19293                         Floodable    bool
19294
19295                         DrawBox, ColBox, SelBox NodeBox
19296
19297                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19298
19299                         LegacyFaceDir bool
19300                         LegacyMounted bool
19301
19302                         DigPredict string
19303
19304                         MaxLvl uint8
19305
19306                         AlphaUse
19307                 }))(obj)).OverlayTiles {
19308                         if err := pcall(func() {
19309                                 (((*(*(struct {
19310                                         Param0 Content
19311
19312                                         Name   string
19313                                         Groups []Group
19314
19315                                         P1Type   Param1Type
19316                                         P2Type   Param2Type
19317                                         DrawType DrawType
19318
19319                                         Mesh  string
19320                                         Scale float32
19321                                         //mt:const uint8(6)
19322                                         Tiles        [6]TileDef
19323                                         OverlayTiles [6]TileDef
19324                                         //mt:const uint8(6)
19325                                         SpecialTiles [6]TileDef
19326
19327                                         Color   color.NRGBA
19328                                         Palette Texture
19329
19330                                         Waving       WaveType
19331                                         ConnectSides uint8
19332                                         ConnectTo    []Content
19333                                         InsideTint   color.NRGBA
19334                                         Level        uint8 // Must be < 128.
19335
19336                                         Translucent bool // Sunlight is scattered and becomes normal light.
19337                                         Transparent bool // Sunlight isn't scattered.
19338                                         LightSrc    uint8
19339
19340                                         GndContent   bool
19341                                         Collides     bool
19342                                         Pointable    bool
19343                                         Diggable     bool
19344                                         Climbable    bool
19345                                         Replaceable  bool
19346                                         OnRightClick bool
19347
19348                                         DmgPerSec int32
19349
19350                                         LiquidType   LiquidType
19351                                         FlowingAlt   string
19352                                         SrcAlt       string
19353                                         Viscosity    uint8 // 0-7
19354                                         LiqRenewable bool
19355                                         FlowRange    uint8
19356                                         DrownDmg     uint8
19357                                         Floodable    bool
19358
19359                                         DrawBox, ColBox, SelBox NodeBox
19360
19361                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19362
19363                                         LegacyFaceDir bool
19364                                         LegacyMounted bool
19365
19366                                         DigPredict string
19367
19368                                         MaxLvl uint8
19369
19370                                         AlphaUse
19371                                 }))(obj)).OverlayTiles)[local259]).Deserialize(r)
19372                         }); err != nil {
19373                                 if err == io.EOF {
19374                                         chk(io.EOF)
19375                                 }
19376                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19377                         }
19378                 }
19379                 {
19380                         var local260 uint8
19381                         local261 := uint8(6)
19382                         {
19383                                 p := &local260
19384                                 *p = read8(r)
19385                         }
19386                         if local260 != local261 {
19387                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local260))
19388                         }
19389                 }
19390                 for local262 := range (*(*(struct {
19391                         Param0 Content
19392
19393                         Name   string
19394                         Groups []Group
19395
19396                         P1Type   Param1Type
19397                         P2Type   Param2Type
19398                         DrawType DrawType
19399
19400                         Mesh  string
19401                         Scale float32
19402                         //mt:const uint8(6)
19403                         Tiles        [6]TileDef
19404                         OverlayTiles [6]TileDef
19405                         //mt:const uint8(6)
19406                         SpecialTiles [6]TileDef
19407
19408                         Color   color.NRGBA
19409                         Palette Texture
19410
19411                         Waving       WaveType
19412                         ConnectSides uint8
19413                         ConnectTo    []Content
19414                         InsideTint   color.NRGBA
19415                         Level        uint8 // Must be < 128.
19416
19417                         Translucent bool // Sunlight is scattered and becomes normal light.
19418                         Transparent bool // Sunlight isn't scattered.
19419                         LightSrc    uint8
19420
19421                         GndContent   bool
19422                         Collides     bool
19423                         Pointable    bool
19424                         Diggable     bool
19425                         Climbable    bool
19426                         Replaceable  bool
19427                         OnRightClick bool
19428
19429                         DmgPerSec int32
19430
19431                         LiquidType   LiquidType
19432                         FlowingAlt   string
19433                         SrcAlt       string
19434                         Viscosity    uint8 // 0-7
19435                         LiqRenewable bool
19436                         FlowRange    uint8
19437                         DrownDmg     uint8
19438                         Floodable    bool
19439
19440                         DrawBox, ColBox, SelBox NodeBox
19441
19442                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19443
19444                         LegacyFaceDir bool
19445                         LegacyMounted bool
19446
19447                         DigPredict string
19448
19449                         MaxLvl uint8
19450
19451                         AlphaUse
19452                 }))(obj)).SpecialTiles {
19453                         if err := pcall(func() {
19454                                 (((*(*(struct {
19455                                         Param0 Content
19456
19457                                         Name   string
19458                                         Groups []Group
19459
19460                                         P1Type   Param1Type
19461                                         P2Type   Param2Type
19462                                         DrawType DrawType
19463
19464                                         Mesh  string
19465                                         Scale float32
19466                                         //mt:const uint8(6)
19467                                         Tiles        [6]TileDef
19468                                         OverlayTiles [6]TileDef
19469                                         //mt:const uint8(6)
19470                                         SpecialTiles [6]TileDef
19471
19472                                         Color   color.NRGBA
19473                                         Palette Texture
19474
19475                                         Waving       WaveType
19476                                         ConnectSides uint8
19477                                         ConnectTo    []Content
19478                                         InsideTint   color.NRGBA
19479                                         Level        uint8 // Must be < 128.
19480
19481                                         Translucent bool // Sunlight is scattered and becomes normal light.
19482                                         Transparent bool // Sunlight isn't scattered.
19483                                         LightSrc    uint8
19484
19485                                         GndContent   bool
19486                                         Collides     bool
19487                                         Pointable    bool
19488                                         Diggable     bool
19489                                         Climbable    bool
19490                                         Replaceable  bool
19491                                         OnRightClick bool
19492
19493                                         DmgPerSec int32
19494
19495                                         LiquidType   LiquidType
19496                                         FlowingAlt   string
19497                                         SrcAlt       string
19498                                         Viscosity    uint8 // 0-7
19499                                         LiqRenewable bool
19500                                         FlowRange    uint8
19501                                         DrownDmg     uint8
19502                                         Floodable    bool
19503
19504                                         DrawBox, ColBox, SelBox NodeBox
19505
19506                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19507
19508                                         LegacyFaceDir bool
19509                                         LegacyMounted bool
19510
19511                                         DigPredict string
19512
19513                                         MaxLvl uint8
19514
19515                                         AlphaUse
19516                                 }))(obj)).SpecialTiles)[local262]).Deserialize(r)
19517                         }); err != nil {
19518                                 if err == io.EOF {
19519                                         chk(io.EOF)
19520                                 }
19521                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19522                         }
19523                 }
19524                 {
19525                         p := &(*(*(struct {
19526                                 Param0 Content
19527
19528                                 Name   string
19529                                 Groups []Group
19530
19531                                 P1Type   Param1Type
19532                                 P2Type   Param2Type
19533                                 DrawType DrawType
19534
19535                                 Mesh  string
19536                                 Scale float32
19537                                 //mt:const uint8(6)
19538                                 Tiles        [6]TileDef
19539                                 OverlayTiles [6]TileDef
19540                                 //mt:const uint8(6)
19541                                 SpecialTiles [6]TileDef
19542
19543                                 Color   color.NRGBA
19544                                 Palette Texture
19545
19546                                 Waving       WaveType
19547                                 ConnectSides uint8
19548                                 ConnectTo    []Content
19549                                 InsideTint   color.NRGBA
19550                                 Level        uint8 // Must be < 128.
19551
19552                                 Translucent bool // Sunlight is scattered and becomes normal light.
19553                                 Transparent bool // Sunlight isn't scattered.
19554                                 LightSrc    uint8
19555
19556                                 GndContent   bool
19557                                 Collides     bool
19558                                 Pointable    bool
19559                                 Diggable     bool
19560                                 Climbable    bool
19561                                 Replaceable  bool
19562                                 OnRightClick bool
19563
19564                                 DmgPerSec int32
19565
19566                                 LiquidType   LiquidType
19567                                 FlowingAlt   string
19568                                 SrcAlt       string
19569                                 Viscosity    uint8 // 0-7
19570                                 LiqRenewable bool
19571                                 FlowRange    uint8
19572                                 DrownDmg     uint8
19573                                 Floodable    bool
19574
19575                                 DrawBox, ColBox, SelBox NodeBox
19576
19577                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19578
19579                                 LegacyFaceDir bool
19580                                 LegacyMounted bool
19581
19582                                 DigPredict string
19583
19584                                 MaxLvl uint8
19585
19586                                 AlphaUse
19587                         }))(obj)).Color
19588                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
19589                 }
19590                 if err := pcall(func() {
19591                         ((*(*(struct {
19592                                 Param0 Content
19593
19594                                 Name   string
19595                                 Groups []Group
19596
19597                                 P1Type   Param1Type
19598                                 P2Type   Param2Type
19599                                 DrawType DrawType
19600
19601                                 Mesh  string
19602                                 Scale float32
19603                                 //mt:const uint8(6)
19604                                 Tiles        [6]TileDef
19605                                 OverlayTiles [6]TileDef
19606                                 //mt:const uint8(6)
19607                                 SpecialTiles [6]TileDef
19608
19609                                 Color   color.NRGBA
19610                                 Palette Texture
19611
19612                                 Waving       WaveType
19613                                 ConnectSides uint8
19614                                 ConnectTo    []Content
19615                                 InsideTint   color.NRGBA
19616                                 Level        uint8 // Must be < 128.
19617
19618                                 Translucent bool // Sunlight is scattered and becomes normal light.
19619                                 Transparent bool // Sunlight isn't scattered.
19620                                 LightSrc    uint8
19621
19622                                 GndContent   bool
19623                                 Collides     bool
19624                                 Pointable    bool
19625                                 Diggable     bool
19626                                 Climbable    bool
19627                                 Replaceable  bool
19628                                 OnRightClick bool
19629
19630                                 DmgPerSec int32
19631
19632                                 LiquidType   LiquidType
19633                                 FlowingAlt   string
19634                                 SrcAlt       string
19635                                 Viscosity    uint8 // 0-7
19636                                 LiqRenewable bool
19637                                 FlowRange    uint8
19638                                 DrownDmg     uint8
19639                                 Floodable    bool
19640
19641                                 DrawBox, ColBox, SelBox NodeBox
19642
19643                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19644
19645                                 LegacyFaceDir bool
19646                                 LegacyMounted bool
19647
19648                                 DigPredict string
19649
19650                                 MaxLvl uint8
19651
19652                                 AlphaUse
19653                         }))(obj)).Palette).Deserialize(r)
19654                 }); err != nil {
19655                         if err == io.EOF {
19656                                 chk(io.EOF)
19657                         }
19658                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
19659                 }
19660                 if err := pcall(func() {
19661                         ((*(*(struct {
19662                                 Param0 Content
19663
19664                                 Name   string
19665                                 Groups []Group
19666
19667                                 P1Type   Param1Type
19668                                 P2Type   Param2Type
19669                                 DrawType DrawType
19670
19671                                 Mesh  string
19672                                 Scale float32
19673                                 //mt:const uint8(6)
19674                                 Tiles        [6]TileDef
19675                                 OverlayTiles [6]TileDef
19676                                 //mt:const uint8(6)
19677                                 SpecialTiles [6]TileDef
19678
19679                                 Color   color.NRGBA
19680                                 Palette Texture
19681
19682                                 Waving       WaveType
19683                                 ConnectSides uint8
19684                                 ConnectTo    []Content
19685                                 InsideTint   color.NRGBA
19686                                 Level        uint8 // Must be < 128.
19687
19688                                 Translucent bool // Sunlight is scattered and becomes normal light.
19689                                 Transparent bool // Sunlight isn't scattered.
19690                                 LightSrc    uint8
19691
19692                                 GndContent   bool
19693                                 Collides     bool
19694                                 Pointable    bool
19695                                 Diggable     bool
19696                                 Climbable    bool
19697                                 Replaceable  bool
19698                                 OnRightClick bool
19699
19700                                 DmgPerSec int32
19701
19702                                 LiquidType   LiquidType
19703                                 FlowingAlt   string
19704                                 SrcAlt       string
19705                                 Viscosity    uint8 // 0-7
19706                                 LiqRenewable bool
19707                                 FlowRange    uint8
19708                                 DrownDmg     uint8
19709                                 Floodable    bool
19710
19711                                 DrawBox, ColBox, SelBox NodeBox
19712
19713                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19714
19715                                 LegacyFaceDir bool
19716                                 LegacyMounted bool
19717
19718                                 DigPredict string
19719
19720                                 MaxLvl uint8
19721
19722                                 AlphaUse
19723                         }))(obj)).Waving).Deserialize(r)
19724                 }); err != nil {
19725                         if err == io.EOF {
19726                                 chk(io.EOF)
19727                         }
19728                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.WaveType", err))
19729                 }
19730                 {
19731                         p := &(*(*(struct {
19732                                 Param0 Content
19733
19734                                 Name   string
19735                                 Groups []Group
19736
19737                                 P1Type   Param1Type
19738                                 P2Type   Param2Type
19739                                 DrawType DrawType
19740
19741                                 Mesh  string
19742                                 Scale float32
19743                                 //mt:const uint8(6)
19744                                 Tiles        [6]TileDef
19745                                 OverlayTiles [6]TileDef
19746                                 //mt:const uint8(6)
19747                                 SpecialTiles [6]TileDef
19748
19749                                 Color   color.NRGBA
19750                                 Palette Texture
19751
19752                                 Waving       WaveType
19753                                 ConnectSides uint8
19754                                 ConnectTo    []Content
19755                                 InsideTint   color.NRGBA
19756                                 Level        uint8 // Must be < 128.
19757
19758                                 Translucent bool // Sunlight is scattered and becomes normal light.
19759                                 Transparent bool // Sunlight isn't scattered.
19760                                 LightSrc    uint8
19761
19762                                 GndContent   bool
19763                                 Collides     bool
19764                                 Pointable    bool
19765                                 Diggable     bool
19766                                 Climbable    bool
19767                                 Replaceable  bool
19768                                 OnRightClick bool
19769
19770                                 DmgPerSec int32
19771
19772                                 LiquidType   LiquidType
19773                                 FlowingAlt   string
19774                                 SrcAlt       string
19775                                 Viscosity    uint8 // 0-7
19776                                 LiqRenewable bool
19777                                 FlowRange    uint8
19778                                 DrownDmg     uint8
19779                                 Floodable    bool
19780
19781                                 DrawBox, ColBox, SelBox NodeBox
19782
19783                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19784
19785                                 LegacyFaceDir bool
19786                                 LegacyMounted bool
19787
19788                                 DigPredict string
19789
19790                                 MaxLvl uint8
19791
19792                                 AlphaUse
19793                         }))(obj)).ConnectSides
19794                         *p = read8(r)
19795                 }
19796                 var local263 uint16
19797                 {
19798                         p := &local263
19799                         *p = read16(r)
19800                 }
19801                 ((*(*(struct {
19802                         Param0 Content
19803
19804                         Name   string
19805                         Groups []Group
19806
19807                         P1Type   Param1Type
19808                         P2Type   Param2Type
19809                         DrawType DrawType
19810
19811                         Mesh  string
19812                         Scale float32
19813                         //mt:const uint8(6)
19814                         Tiles        [6]TileDef
19815                         OverlayTiles [6]TileDef
19816                         //mt:const uint8(6)
19817                         SpecialTiles [6]TileDef
19818
19819                         Color   color.NRGBA
19820                         Palette Texture
19821
19822                         Waving       WaveType
19823                         ConnectSides uint8
19824                         ConnectTo    []Content
19825                         InsideTint   color.NRGBA
19826                         Level        uint8 // Must be < 128.
19827
19828                         Translucent bool // Sunlight is scattered and becomes normal light.
19829                         Transparent bool // Sunlight isn't scattered.
19830                         LightSrc    uint8
19831
19832                         GndContent   bool
19833                         Collides     bool
19834                         Pointable    bool
19835                         Diggable     bool
19836                         Climbable    bool
19837                         Replaceable  bool
19838                         OnRightClick bool
19839
19840                         DmgPerSec int32
19841
19842                         LiquidType   LiquidType
19843                         FlowingAlt   string
19844                         SrcAlt       string
19845                         Viscosity    uint8 // 0-7
19846                         LiqRenewable bool
19847                         FlowRange    uint8
19848                         DrownDmg     uint8
19849                         Floodable    bool
19850
19851                         DrawBox, ColBox, SelBox NodeBox
19852
19853                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19854
19855                         LegacyFaceDir bool
19856                         LegacyMounted bool
19857
19858                         DigPredict string
19859
19860                         MaxLvl uint8
19861
19862                         AlphaUse
19863                 }))(obj)).ConnectTo) = make([]Content, local263)
19864                 for local264 := range (*(*(struct {
19865                         Param0 Content
19866
19867                         Name   string
19868                         Groups []Group
19869
19870                         P1Type   Param1Type
19871                         P2Type   Param2Type
19872                         DrawType DrawType
19873
19874                         Mesh  string
19875                         Scale float32
19876                         //mt:const uint8(6)
19877                         Tiles        [6]TileDef
19878                         OverlayTiles [6]TileDef
19879                         //mt:const uint8(6)
19880                         SpecialTiles [6]TileDef
19881
19882                         Color   color.NRGBA
19883                         Palette Texture
19884
19885                         Waving       WaveType
19886                         ConnectSides uint8
19887                         ConnectTo    []Content
19888                         InsideTint   color.NRGBA
19889                         Level        uint8 // Must be < 128.
19890
19891                         Translucent bool // Sunlight is scattered and becomes normal light.
19892                         Transparent bool // Sunlight isn't scattered.
19893                         LightSrc    uint8
19894
19895                         GndContent   bool
19896                         Collides     bool
19897                         Pointable    bool
19898                         Diggable     bool
19899                         Climbable    bool
19900                         Replaceable  bool
19901                         OnRightClick bool
19902
19903                         DmgPerSec int32
19904
19905                         LiquidType   LiquidType
19906                         FlowingAlt   string
19907                         SrcAlt       string
19908                         Viscosity    uint8 // 0-7
19909                         LiqRenewable bool
19910                         FlowRange    uint8
19911                         DrownDmg     uint8
19912                         Floodable    bool
19913
19914                         DrawBox, ColBox, SelBox NodeBox
19915
19916                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19917
19918                         LegacyFaceDir bool
19919                         LegacyMounted bool
19920
19921                         DigPredict string
19922
19923                         MaxLvl uint8
19924
19925                         AlphaUse
19926                 }))(obj)).ConnectTo {
19927                         if err := pcall(func() {
19928                                 (((*(*(struct {
19929                                         Param0 Content
19930
19931                                         Name   string
19932                                         Groups []Group
19933
19934                                         P1Type   Param1Type
19935                                         P2Type   Param2Type
19936                                         DrawType DrawType
19937
19938                                         Mesh  string
19939                                         Scale float32
19940                                         //mt:const uint8(6)
19941                                         Tiles        [6]TileDef
19942                                         OverlayTiles [6]TileDef
19943                                         //mt:const uint8(6)
19944                                         SpecialTiles [6]TileDef
19945
19946                                         Color   color.NRGBA
19947                                         Palette Texture
19948
19949                                         Waving       WaveType
19950                                         ConnectSides uint8
19951                                         ConnectTo    []Content
19952                                         InsideTint   color.NRGBA
19953                                         Level        uint8 // Must be < 128.
19954
19955                                         Translucent bool // Sunlight is scattered and becomes normal light.
19956                                         Transparent bool // Sunlight isn't scattered.
19957                                         LightSrc    uint8
19958
19959                                         GndContent   bool
19960                                         Collides     bool
19961                                         Pointable    bool
19962                                         Diggable     bool
19963                                         Climbable    bool
19964                                         Replaceable  bool
19965                                         OnRightClick bool
19966
19967                                         DmgPerSec int32
19968
19969                                         LiquidType   LiquidType
19970                                         FlowingAlt   string
19971                                         SrcAlt       string
19972                                         Viscosity    uint8 // 0-7
19973                                         LiqRenewable bool
19974                                         FlowRange    uint8
19975                                         DrownDmg     uint8
19976                                         Floodable    bool
19977
19978                                         DrawBox, ColBox, SelBox NodeBox
19979
19980                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19981
19982                                         LegacyFaceDir bool
19983                                         LegacyMounted bool
19984
19985                                         DigPredict string
19986
19987                                         MaxLvl uint8
19988
19989                                         AlphaUse
19990                                 }))(obj)).ConnectTo)[local264]).Deserialize(r)
19991                         }); err != nil {
19992                                 if err == io.EOF {
19993                                         chk(io.EOF)
19994                                 }
19995                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
19996                         }
19997                 }
19998                 {
19999                         p := &(*(*(struct {
20000                                 Param0 Content
20001
20002                                 Name   string
20003                                 Groups []Group
20004
20005                                 P1Type   Param1Type
20006                                 P2Type   Param2Type
20007                                 DrawType DrawType
20008
20009                                 Mesh  string
20010                                 Scale float32
20011                                 //mt:const uint8(6)
20012                                 Tiles        [6]TileDef
20013                                 OverlayTiles [6]TileDef
20014                                 //mt:const uint8(6)
20015                                 SpecialTiles [6]TileDef
20016
20017                                 Color   color.NRGBA
20018                                 Palette Texture
20019
20020                                 Waving       WaveType
20021                                 ConnectSides uint8
20022                                 ConnectTo    []Content
20023                                 InsideTint   color.NRGBA
20024                                 Level        uint8 // Must be < 128.
20025
20026                                 Translucent bool // Sunlight is scattered and becomes normal light.
20027                                 Transparent bool // Sunlight isn't scattered.
20028                                 LightSrc    uint8
20029
20030                                 GndContent   bool
20031                                 Collides     bool
20032                                 Pointable    bool
20033                                 Diggable     bool
20034                                 Climbable    bool
20035                                 Replaceable  bool
20036                                 OnRightClick bool
20037
20038                                 DmgPerSec int32
20039
20040                                 LiquidType   LiquidType
20041                                 FlowingAlt   string
20042                                 SrcAlt       string
20043                                 Viscosity    uint8 // 0-7
20044                                 LiqRenewable bool
20045                                 FlowRange    uint8
20046                                 DrownDmg     uint8
20047                                 Floodable    bool
20048
20049                                 DrawBox, ColBox, SelBox NodeBox
20050
20051                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20052
20053                                 LegacyFaceDir bool
20054                                 LegacyMounted bool
20055
20056                                 DigPredict string
20057
20058                                 MaxLvl uint8
20059
20060                                 AlphaUse
20061                         }))(obj)).InsideTint
20062                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20063                 }
20064                 {
20065                         p := &(*(*(struct {
20066                                 Param0 Content
20067
20068                                 Name   string
20069                                 Groups []Group
20070
20071                                 P1Type   Param1Type
20072                                 P2Type   Param2Type
20073                                 DrawType DrawType
20074
20075                                 Mesh  string
20076                                 Scale float32
20077                                 //mt:const uint8(6)
20078                                 Tiles        [6]TileDef
20079                                 OverlayTiles [6]TileDef
20080                                 //mt:const uint8(6)
20081                                 SpecialTiles [6]TileDef
20082
20083                                 Color   color.NRGBA
20084                                 Palette Texture
20085
20086                                 Waving       WaveType
20087                                 ConnectSides uint8
20088                                 ConnectTo    []Content
20089                                 InsideTint   color.NRGBA
20090                                 Level        uint8 // Must be < 128.
20091
20092                                 Translucent bool // Sunlight is scattered and becomes normal light.
20093                                 Transparent bool // Sunlight isn't scattered.
20094                                 LightSrc    uint8
20095
20096                                 GndContent   bool
20097                                 Collides     bool
20098                                 Pointable    bool
20099                                 Diggable     bool
20100                                 Climbable    bool
20101                                 Replaceable  bool
20102                                 OnRightClick bool
20103
20104                                 DmgPerSec int32
20105
20106                                 LiquidType   LiquidType
20107                                 FlowingAlt   string
20108                                 SrcAlt       string
20109                                 Viscosity    uint8 // 0-7
20110                                 LiqRenewable bool
20111                                 FlowRange    uint8
20112                                 DrownDmg     uint8
20113                                 Floodable    bool
20114
20115                                 DrawBox, ColBox, SelBox NodeBox
20116
20117                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20118
20119                                 LegacyFaceDir bool
20120                                 LegacyMounted bool
20121
20122                                 DigPredict string
20123
20124                                 MaxLvl uint8
20125
20126                                 AlphaUse
20127                         }))(obj)).Level
20128                         *p = read8(r)
20129                 }
20130                 {
20131                         p := &(*(*(struct {
20132                                 Param0 Content
20133
20134                                 Name   string
20135                                 Groups []Group
20136
20137                                 P1Type   Param1Type
20138                                 P2Type   Param2Type
20139                                 DrawType DrawType
20140
20141                                 Mesh  string
20142                                 Scale float32
20143                                 //mt:const uint8(6)
20144                                 Tiles        [6]TileDef
20145                                 OverlayTiles [6]TileDef
20146                                 //mt:const uint8(6)
20147                                 SpecialTiles [6]TileDef
20148
20149                                 Color   color.NRGBA
20150                                 Palette Texture
20151
20152                                 Waving       WaveType
20153                                 ConnectSides uint8
20154                                 ConnectTo    []Content
20155                                 InsideTint   color.NRGBA
20156                                 Level        uint8 // Must be < 128.
20157
20158                                 Translucent bool // Sunlight is scattered and becomes normal light.
20159                                 Transparent bool // Sunlight isn't scattered.
20160                                 LightSrc    uint8
20161
20162                                 GndContent   bool
20163                                 Collides     bool
20164                                 Pointable    bool
20165                                 Diggable     bool
20166                                 Climbable    bool
20167                                 Replaceable  bool
20168                                 OnRightClick bool
20169
20170                                 DmgPerSec int32
20171
20172                                 LiquidType   LiquidType
20173                                 FlowingAlt   string
20174                                 SrcAlt       string
20175                                 Viscosity    uint8 // 0-7
20176                                 LiqRenewable bool
20177                                 FlowRange    uint8
20178                                 DrownDmg     uint8
20179                                 Floodable    bool
20180
20181                                 DrawBox, ColBox, SelBox NodeBox
20182
20183                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20184
20185                                 LegacyFaceDir bool
20186                                 LegacyMounted bool
20187
20188                                 DigPredict string
20189
20190                                 MaxLvl uint8
20191
20192                                 AlphaUse
20193                         }))(obj)).Translucent
20194                         switch n := read8(r); n {
20195                         case 0:
20196                                 *p = false
20197                         case 1:
20198                                 *p = true
20199                         default:
20200                                 chk(fmt.Errorf("invalid bool: %d", n))
20201                         }
20202                 }
20203                 {
20204                         p := &(*(*(struct {
20205                                 Param0 Content
20206
20207                                 Name   string
20208                                 Groups []Group
20209
20210                                 P1Type   Param1Type
20211                                 P2Type   Param2Type
20212                                 DrawType DrawType
20213
20214                                 Mesh  string
20215                                 Scale float32
20216                                 //mt:const uint8(6)
20217                                 Tiles        [6]TileDef
20218                                 OverlayTiles [6]TileDef
20219                                 //mt:const uint8(6)
20220                                 SpecialTiles [6]TileDef
20221
20222                                 Color   color.NRGBA
20223                                 Palette Texture
20224
20225                                 Waving       WaveType
20226                                 ConnectSides uint8
20227                                 ConnectTo    []Content
20228                                 InsideTint   color.NRGBA
20229                                 Level        uint8 // Must be < 128.
20230
20231                                 Translucent bool // Sunlight is scattered and becomes normal light.
20232                                 Transparent bool // Sunlight isn't scattered.
20233                                 LightSrc    uint8
20234
20235                                 GndContent   bool
20236                                 Collides     bool
20237                                 Pointable    bool
20238                                 Diggable     bool
20239                                 Climbable    bool
20240                                 Replaceable  bool
20241                                 OnRightClick bool
20242
20243                                 DmgPerSec int32
20244
20245                                 LiquidType   LiquidType
20246                                 FlowingAlt   string
20247                                 SrcAlt       string
20248                                 Viscosity    uint8 // 0-7
20249                                 LiqRenewable bool
20250                                 FlowRange    uint8
20251                                 DrownDmg     uint8
20252                                 Floodable    bool
20253
20254                                 DrawBox, ColBox, SelBox NodeBox
20255
20256                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20257
20258                                 LegacyFaceDir bool
20259                                 LegacyMounted bool
20260
20261                                 DigPredict string
20262
20263                                 MaxLvl uint8
20264
20265                                 AlphaUse
20266                         }))(obj)).Transparent
20267                         switch n := read8(r); n {
20268                         case 0:
20269                                 *p = false
20270                         case 1:
20271                                 *p = true
20272                         default:
20273                                 chk(fmt.Errorf("invalid bool: %d", n))
20274                         }
20275                 }
20276                 {
20277                         p := &(*(*(struct {
20278                                 Param0 Content
20279
20280                                 Name   string
20281                                 Groups []Group
20282
20283                                 P1Type   Param1Type
20284                                 P2Type   Param2Type
20285                                 DrawType DrawType
20286
20287                                 Mesh  string
20288                                 Scale float32
20289                                 //mt:const uint8(6)
20290                                 Tiles        [6]TileDef
20291                                 OverlayTiles [6]TileDef
20292                                 //mt:const uint8(6)
20293                                 SpecialTiles [6]TileDef
20294
20295                                 Color   color.NRGBA
20296                                 Palette Texture
20297
20298                                 Waving       WaveType
20299                                 ConnectSides uint8
20300                                 ConnectTo    []Content
20301                                 InsideTint   color.NRGBA
20302                                 Level        uint8 // Must be < 128.
20303
20304                                 Translucent bool // Sunlight is scattered and becomes normal light.
20305                                 Transparent bool // Sunlight isn't scattered.
20306                                 LightSrc    uint8
20307
20308                                 GndContent   bool
20309                                 Collides     bool
20310                                 Pointable    bool
20311                                 Diggable     bool
20312                                 Climbable    bool
20313                                 Replaceable  bool
20314                                 OnRightClick bool
20315
20316                                 DmgPerSec int32
20317
20318                                 LiquidType   LiquidType
20319                                 FlowingAlt   string
20320                                 SrcAlt       string
20321                                 Viscosity    uint8 // 0-7
20322                                 LiqRenewable bool
20323                                 FlowRange    uint8
20324                                 DrownDmg     uint8
20325                                 Floodable    bool
20326
20327                                 DrawBox, ColBox, SelBox NodeBox
20328
20329                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20330
20331                                 LegacyFaceDir bool
20332                                 LegacyMounted bool
20333
20334                                 DigPredict string
20335
20336                                 MaxLvl uint8
20337
20338                                 AlphaUse
20339                         }))(obj)).LightSrc
20340                         *p = read8(r)
20341                 }
20342                 {
20343                         p := &(*(*(struct {
20344                                 Param0 Content
20345
20346                                 Name   string
20347                                 Groups []Group
20348
20349                                 P1Type   Param1Type
20350                                 P2Type   Param2Type
20351                                 DrawType DrawType
20352
20353                                 Mesh  string
20354                                 Scale float32
20355                                 //mt:const uint8(6)
20356                                 Tiles        [6]TileDef
20357                                 OverlayTiles [6]TileDef
20358                                 //mt:const uint8(6)
20359                                 SpecialTiles [6]TileDef
20360
20361                                 Color   color.NRGBA
20362                                 Palette Texture
20363
20364                                 Waving       WaveType
20365                                 ConnectSides uint8
20366                                 ConnectTo    []Content
20367                                 InsideTint   color.NRGBA
20368                                 Level        uint8 // Must be < 128.
20369
20370                                 Translucent bool // Sunlight is scattered and becomes normal light.
20371                                 Transparent bool // Sunlight isn't scattered.
20372                                 LightSrc    uint8
20373
20374                                 GndContent   bool
20375                                 Collides     bool
20376                                 Pointable    bool
20377                                 Diggable     bool
20378                                 Climbable    bool
20379                                 Replaceable  bool
20380                                 OnRightClick bool
20381
20382                                 DmgPerSec int32
20383
20384                                 LiquidType   LiquidType
20385                                 FlowingAlt   string
20386                                 SrcAlt       string
20387                                 Viscosity    uint8 // 0-7
20388                                 LiqRenewable bool
20389                                 FlowRange    uint8
20390                                 DrownDmg     uint8
20391                                 Floodable    bool
20392
20393                                 DrawBox, ColBox, SelBox NodeBox
20394
20395                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20396
20397                                 LegacyFaceDir bool
20398                                 LegacyMounted bool
20399
20400                                 DigPredict string
20401
20402                                 MaxLvl uint8
20403
20404                                 AlphaUse
20405                         }))(obj)).GndContent
20406                         switch n := read8(r); n {
20407                         case 0:
20408                                 *p = false
20409                         case 1:
20410                                 *p = true
20411                         default:
20412                                 chk(fmt.Errorf("invalid bool: %d", n))
20413                         }
20414                 }
20415                 {
20416                         p := &(*(*(struct {
20417                                 Param0 Content
20418
20419                                 Name   string
20420                                 Groups []Group
20421
20422                                 P1Type   Param1Type
20423                                 P2Type   Param2Type
20424                                 DrawType DrawType
20425
20426                                 Mesh  string
20427                                 Scale float32
20428                                 //mt:const uint8(6)
20429                                 Tiles        [6]TileDef
20430                                 OverlayTiles [6]TileDef
20431                                 //mt:const uint8(6)
20432                                 SpecialTiles [6]TileDef
20433
20434                                 Color   color.NRGBA
20435                                 Palette Texture
20436
20437                                 Waving       WaveType
20438                                 ConnectSides uint8
20439                                 ConnectTo    []Content
20440                                 InsideTint   color.NRGBA
20441                                 Level        uint8 // Must be < 128.
20442
20443                                 Translucent bool // Sunlight is scattered and becomes normal light.
20444                                 Transparent bool // Sunlight isn't scattered.
20445                                 LightSrc    uint8
20446
20447                                 GndContent   bool
20448                                 Collides     bool
20449                                 Pointable    bool
20450                                 Diggable     bool
20451                                 Climbable    bool
20452                                 Replaceable  bool
20453                                 OnRightClick bool
20454
20455                                 DmgPerSec int32
20456
20457                                 LiquidType   LiquidType
20458                                 FlowingAlt   string
20459                                 SrcAlt       string
20460                                 Viscosity    uint8 // 0-7
20461                                 LiqRenewable bool
20462                                 FlowRange    uint8
20463                                 DrownDmg     uint8
20464                                 Floodable    bool
20465
20466                                 DrawBox, ColBox, SelBox NodeBox
20467
20468                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20469
20470                                 LegacyFaceDir bool
20471                                 LegacyMounted bool
20472
20473                                 DigPredict string
20474
20475                                 MaxLvl uint8
20476
20477                                 AlphaUse
20478                         }))(obj)).Collides
20479                         switch n := read8(r); n {
20480                         case 0:
20481                                 *p = false
20482                         case 1:
20483                                 *p = true
20484                         default:
20485                                 chk(fmt.Errorf("invalid bool: %d", n))
20486                         }
20487                 }
20488                 {
20489                         p := &(*(*(struct {
20490                                 Param0 Content
20491
20492                                 Name   string
20493                                 Groups []Group
20494
20495                                 P1Type   Param1Type
20496                                 P2Type   Param2Type
20497                                 DrawType DrawType
20498
20499                                 Mesh  string
20500                                 Scale float32
20501                                 //mt:const uint8(6)
20502                                 Tiles        [6]TileDef
20503                                 OverlayTiles [6]TileDef
20504                                 //mt:const uint8(6)
20505                                 SpecialTiles [6]TileDef
20506
20507                                 Color   color.NRGBA
20508                                 Palette Texture
20509
20510                                 Waving       WaveType
20511                                 ConnectSides uint8
20512                                 ConnectTo    []Content
20513                                 InsideTint   color.NRGBA
20514                                 Level        uint8 // Must be < 128.
20515
20516                                 Translucent bool // Sunlight is scattered and becomes normal light.
20517                                 Transparent bool // Sunlight isn't scattered.
20518                                 LightSrc    uint8
20519
20520                                 GndContent   bool
20521                                 Collides     bool
20522                                 Pointable    bool
20523                                 Diggable     bool
20524                                 Climbable    bool
20525                                 Replaceable  bool
20526                                 OnRightClick bool
20527
20528                                 DmgPerSec int32
20529
20530                                 LiquidType   LiquidType
20531                                 FlowingAlt   string
20532                                 SrcAlt       string
20533                                 Viscosity    uint8 // 0-7
20534                                 LiqRenewable bool
20535                                 FlowRange    uint8
20536                                 DrownDmg     uint8
20537                                 Floodable    bool
20538
20539                                 DrawBox, ColBox, SelBox NodeBox
20540
20541                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20542
20543                                 LegacyFaceDir bool
20544                                 LegacyMounted bool
20545
20546                                 DigPredict string
20547
20548                                 MaxLvl uint8
20549
20550                                 AlphaUse
20551                         }))(obj)).Pointable
20552                         switch n := read8(r); n {
20553                         case 0:
20554                                 *p = false
20555                         case 1:
20556                                 *p = true
20557                         default:
20558                                 chk(fmt.Errorf("invalid bool: %d", n))
20559                         }
20560                 }
20561                 {
20562                         p := &(*(*(struct {
20563                                 Param0 Content
20564
20565                                 Name   string
20566                                 Groups []Group
20567
20568                                 P1Type   Param1Type
20569                                 P2Type   Param2Type
20570                                 DrawType DrawType
20571
20572                                 Mesh  string
20573                                 Scale float32
20574                                 //mt:const uint8(6)
20575                                 Tiles        [6]TileDef
20576                                 OverlayTiles [6]TileDef
20577                                 //mt:const uint8(6)
20578                                 SpecialTiles [6]TileDef
20579
20580                                 Color   color.NRGBA
20581                                 Palette Texture
20582
20583                                 Waving       WaveType
20584                                 ConnectSides uint8
20585                                 ConnectTo    []Content
20586                                 InsideTint   color.NRGBA
20587                                 Level        uint8 // Must be < 128.
20588
20589                                 Translucent bool // Sunlight is scattered and becomes normal light.
20590                                 Transparent bool // Sunlight isn't scattered.
20591                                 LightSrc    uint8
20592
20593                                 GndContent   bool
20594                                 Collides     bool
20595                                 Pointable    bool
20596                                 Diggable     bool
20597                                 Climbable    bool
20598                                 Replaceable  bool
20599                                 OnRightClick bool
20600
20601                                 DmgPerSec int32
20602
20603                                 LiquidType   LiquidType
20604                                 FlowingAlt   string
20605                                 SrcAlt       string
20606                                 Viscosity    uint8 // 0-7
20607                                 LiqRenewable bool
20608                                 FlowRange    uint8
20609                                 DrownDmg     uint8
20610                                 Floodable    bool
20611
20612                                 DrawBox, ColBox, SelBox NodeBox
20613
20614                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20615
20616                                 LegacyFaceDir bool
20617                                 LegacyMounted bool
20618
20619                                 DigPredict string
20620
20621                                 MaxLvl uint8
20622
20623                                 AlphaUse
20624                         }))(obj)).Diggable
20625                         switch n := read8(r); n {
20626                         case 0:
20627                                 *p = false
20628                         case 1:
20629                                 *p = true
20630                         default:
20631                                 chk(fmt.Errorf("invalid bool: %d", n))
20632                         }
20633                 }
20634                 {
20635                         p := &(*(*(struct {
20636                                 Param0 Content
20637
20638                                 Name   string
20639                                 Groups []Group
20640
20641                                 P1Type   Param1Type
20642                                 P2Type   Param2Type
20643                                 DrawType DrawType
20644
20645                                 Mesh  string
20646                                 Scale float32
20647                                 //mt:const uint8(6)
20648                                 Tiles        [6]TileDef
20649                                 OverlayTiles [6]TileDef
20650                                 //mt:const uint8(6)
20651                                 SpecialTiles [6]TileDef
20652
20653                                 Color   color.NRGBA
20654                                 Palette Texture
20655
20656                                 Waving       WaveType
20657                                 ConnectSides uint8
20658                                 ConnectTo    []Content
20659                                 InsideTint   color.NRGBA
20660                                 Level        uint8 // Must be < 128.
20661
20662                                 Translucent bool // Sunlight is scattered and becomes normal light.
20663                                 Transparent bool // Sunlight isn't scattered.
20664                                 LightSrc    uint8
20665
20666                                 GndContent   bool
20667                                 Collides     bool
20668                                 Pointable    bool
20669                                 Diggable     bool
20670                                 Climbable    bool
20671                                 Replaceable  bool
20672                                 OnRightClick bool
20673
20674                                 DmgPerSec int32
20675
20676                                 LiquidType   LiquidType
20677                                 FlowingAlt   string
20678                                 SrcAlt       string
20679                                 Viscosity    uint8 // 0-7
20680                                 LiqRenewable bool
20681                                 FlowRange    uint8
20682                                 DrownDmg     uint8
20683                                 Floodable    bool
20684
20685                                 DrawBox, ColBox, SelBox NodeBox
20686
20687                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20688
20689                                 LegacyFaceDir bool
20690                                 LegacyMounted bool
20691
20692                                 DigPredict string
20693
20694                                 MaxLvl uint8
20695
20696                                 AlphaUse
20697                         }))(obj)).Climbable
20698                         switch n := read8(r); n {
20699                         case 0:
20700                                 *p = false
20701                         case 1:
20702                                 *p = true
20703                         default:
20704                                 chk(fmt.Errorf("invalid bool: %d", n))
20705                         }
20706                 }
20707                 {
20708                         p := &(*(*(struct {
20709                                 Param0 Content
20710
20711                                 Name   string
20712                                 Groups []Group
20713
20714                                 P1Type   Param1Type
20715                                 P2Type   Param2Type
20716                                 DrawType DrawType
20717
20718                                 Mesh  string
20719                                 Scale float32
20720                                 //mt:const uint8(6)
20721                                 Tiles        [6]TileDef
20722                                 OverlayTiles [6]TileDef
20723                                 //mt:const uint8(6)
20724                                 SpecialTiles [6]TileDef
20725
20726                                 Color   color.NRGBA
20727                                 Palette Texture
20728
20729                                 Waving       WaveType
20730                                 ConnectSides uint8
20731                                 ConnectTo    []Content
20732                                 InsideTint   color.NRGBA
20733                                 Level        uint8 // Must be < 128.
20734
20735                                 Translucent bool // Sunlight is scattered and becomes normal light.
20736                                 Transparent bool // Sunlight isn't scattered.
20737                                 LightSrc    uint8
20738
20739                                 GndContent   bool
20740                                 Collides     bool
20741                                 Pointable    bool
20742                                 Diggable     bool
20743                                 Climbable    bool
20744                                 Replaceable  bool
20745                                 OnRightClick bool
20746
20747                                 DmgPerSec int32
20748
20749                                 LiquidType   LiquidType
20750                                 FlowingAlt   string
20751                                 SrcAlt       string
20752                                 Viscosity    uint8 // 0-7
20753                                 LiqRenewable bool
20754                                 FlowRange    uint8
20755                                 DrownDmg     uint8
20756                                 Floodable    bool
20757
20758                                 DrawBox, ColBox, SelBox NodeBox
20759
20760                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20761
20762                                 LegacyFaceDir bool
20763                                 LegacyMounted bool
20764
20765                                 DigPredict string
20766
20767                                 MaxLvl uint8
20768
20769                                 AlphaUse
20770                         }))(obj)).Replaceable
20771                         switch n := read8(r); n {
20772                         case 0:
20773                                 *p = false
20774                         case 1:
20775                                 *p = true
20776                         default:
20777                                 chk(fmt.Errorf("invalid bool: %d", n))
20778                         }
20779                 }
20780                 {
20781                         p := &(*(*(struct {
20782                                 Param0 Content
20783
20784                                 Name   string
20785                                 Groups []Group
20786
20787                                 P1Type   Param1Type
20788                                 P2Type   Param2Type
20789                                 DrawType DrawType
20790
20791                                 Mesh  string
20792                                 Scale float32
20793                                 //mt:const uint8(6)
20794                                 Tiles        [6]TileDef
20795                                 OverlayTiles [6]TileDef
20796                                 //mt:const uint8(6)
20797                                 SpecialTiles [6]TileDef
20798
20799                                 Color   color.NRGBA
20800                                 Palette Texture
20801
20802                                 Waving       WaveType
20803                                 ConnectSides uint8
20804                                 ConnectTo    []Content
20805                                 InsideTint   color.NRGBA
20806                                 Level        uint8 // Must be < 128.
20807
20808                                 Translucent bool // Sunlight is scattered and becomes normal light.
20809                                 Transparent bool // Sunlight isn't scattered.
20810                                 LightSrc    uint8
20811
20812                                 GndContent   bool
20813                                 Collides     bool
20814                                 Pointable    bool
20815                                 Diggable     bool
20816                                 Climbable    bool
20817                                 Replaceable  bool
20818                                 OnRightClick bool
20819
20820                                 DmgPerSec int32
20821
20822                                 LiquidType   LiquidType
20823                                 FlowingAlt   string
20824                                 SrcAlt       string
20825                                 Viscosity    uint8 // 0-7
20826                                 LiqRenewable bool
20827                                 FlowRange    uint8
20828                                 DrownDmg     uint8
20829                                 Floodable    bool
20830
20831                                 DrawBox, ColBox, SelBox NodeBox
20832
20833                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20834
20835                                 LegacyFaceDir bool
20836                                 LegacyMounted bool
20837
20838                                 DigPredict string
20839
20840                                 MaxLvl uint8
20841
20842                                 AlphaUse
20843                         }))(obj)).OnRightClick
20844                         switch n := read8(r); n {
20845                         case 0:
20846                                 *p = false
20847                         case 1:
20848                                 *p = true
20849                         default:
20850                                 chk(fmt.Errorf("invalid bool: %d", n))
20851                         }
20852                 }
20853                 {
20854                         p := &(*(*(struct {
20855                                 Param0 Content
20856
20857                                 Name   string
20858                                 Groups []Group
20859
20860                                 P1Type   Param1Type
20861                                 P2Type   Param2Type
20862                                 DrawType DrawType
20863
20864                                 Mesh  string
20865                                 Scale float32
20866                                 //mt:const uint8(6)
20867                                 Tiles        [6]TileDef
20868                                 OverlayTiles [6]TileDef
20869                                 //mt:const uint8(6)
20870                                 SpecialTiles [6]TileDef
20871
20872                                 Color   color.NRGBA
20873                                 Palette Texture
20874
20875                                 Waving       WaveType
20876                                 ConnectSides uint8
20877                                 ConnectTo    []Content
20878                                 InsideTint   color.NRGBA
20879                                 Level        uint8 // Must be < 128.
20880
20881                                 Translucent bool // Sunlight is scattered and becomes normal light.
20882                                 Transparent bool // Sunlight isn't scattered.
20883                                 LightSrc    uint8
20884
20885                                 GndContent   bool
20886                                 Collides     bool
20887                                 Pointable    bool
20888                                 Diggable     bool
20889                                 Climbable    bool
20890                                 Replaceable  bool
20891                                 OnRightClick bool
20892
20893                                 DmgPerSec int32
20894
20895                                 LiquidType   LiquidType
20896                                 FlowingAlt   string
20897                                 SrcAlt       string
20898                                 Viscosity    uint8 // 0-7
20899                                 LiqRenewable bool
20900                                 FlowRange    uint8
20901                                 DrownDmg     uint8
20902                                 Floodable    bool
20903
20904                                 DrawBox, ColBox, SelBox NodeBox
20905
20906                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20907
20908                                 LegacyFaceDir bool
20909                                 LegacyMounted bool
20910
20911                                 DigPredict string
20912
20913                                 MaxLvl uint8
20914
20915                                 AlphaUse
20916                         }))(obj)).DmgPerSec
20917                         *p = int32(read32(r))
20918                 }
20919                 if err := pcall(func() {
20920                         ((*(*(struct {
20921                                 Param0 Content
20922
20923                                 Name   string
20924                                 Groups []Group
20925
20926                                 P1Type   Param1Type
20927                                 P2Type   Param2Type
20928                                 DrawType DrawType
20929
20930                                 Mesh  string
20931                                 Scale float32
20932                                 //mt:const uint8(6)
20933                                 Tiles        [6]TileDef
20934                                 OverlayTiles [6]TileDef
20935                                 //mt:const uint8(6)
20936                                 SpecialTiles [6]TileDef
20937
20938                                 Color   color.NRGBA
20939                                 Palette Texture
20940
20941                                 Waving       WaveType
20942                                 ConnectSides uint8
20943                                 ConnectTo    []Content
20944                                 InsideTint   color.NRGBA
20945                                 Level        uint8 // Must be < 128.
20946
20947                                 Translucent bool // Sunlight is scattered and becomes normal light.
20948                                 Transparent bool // Sunlight isn't scattered.
20949                                 LightSrc    uint8
20950
20951                                 GndContent   bool
20952                                 Collides     bool
20953                                 Pointable    bool
20954                                 Diggable     bool
20955                                 Climbable    bool
20956                                 Replaceable  bool
20957                                 OnRightClick bool
20958
20959                                 DmgPerSec int32
20960
20961                                 LiquidType   LiquidType
20962                                 FlowingAlt   string
20963                                 SrcAlt       string
20964                                 Viscosity    uint8 // 0-7
20965                                 LiqRenewable bool
20966                                 FlowRange    uint8
20967                                 DrownDmg     uint8
20968                                 Floodable    bool
20969
20970                                 DrawBox, ColBox, SelBox NodeBox
20971
20972                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20973
20974                                 LegacyFaceDir bool
20975                                 LegacyMounted bool
20976
20977                                 DigPredict string
20978
20979                                 MaxLvl uint8
20980
20981                                 AlphaUse
20982                         }))(obj)).LiquidType).Deserialize(r)
20983                 }); err != nil {
20984                         if err == io.EOF {
20985                                 chk(io.EOF)
20986                         }
20987                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
20988                 }
20989                 var local265 []uint8
20990                 var local266 uint16
20991                 {
20992                         p := &local266
20993                         *p = read16(r)
20994                 }
20995                 (local265) = make([]uint8, local266)
20996                 {
20997                         _, err := io.ReadFull(r, (local265)[:])
20998                         chk(err)
20999                 }
21000                 ((*(*(struct {
21001                         Param0 Content
21002
21003                         Name   string
21004                         Groups []Group
21005
21006                         P1Type   Param1Type
21007                         P2Type   Param2Type
21008                         DrawType DrawType
21009
21010                         Mesh  string
21011                         Scale float32
21012                         //mt:const uint8(6)
21013                         Tiles        [6]TileDef
21014                         OverlayTiles [6]TileDef
21015                         //mt:const uint8(6)
21016                         SpecialTiles [6]TileDef
21017
21018                         Color   color.NRGBA
21019                         Palette Texture
21020
21021                         Waving       WaveType
21022                         ConnectSides uint8
21023                         ConnectTo    []Content
21024                         InsideTint   color.NRGBA
21025                         Level        uint8 // Must be < 128.
21026
21027                         Translucent bool // Sunlight is scattered and becomes normal light.
21028                         Transparent bool // Sunlight isn't scattered.
21029                         LightSrc    uint8
21030
21031                         GndContent   bool
21032                         Collides     bool
21033                         Pointable    bool
21034                         Diggable     bool
21035                         Climbable    bool
21036                         Replaceable  bool
21037                         OnRightClick bool
21038
21039                         DmgPerSec int32
21040
21041                         LiquidType   LiquidType
21042                         FlowingAlt   string
21043                         SrcAlt       string
21044                         Viscosity    uint8 // 0-7
21045                         LiqRenewable bool
21046                         FlowRange    uint8
21047                         DrownDmg     uint8
21048                         Floodable    bool
21049
21050                         DrawBox, ColBox, SelBox NodeBox
21051
21052                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21053
21054                         LegacyFaceDir bool
21055                         LegacyMounted bool
21056
21057                         DigPredict string
21058
21059                         MaxLvl uint8
21060
21061                         AlphaUse
21062                 }))(obj)).FlowingAlt) = string(local265)
21063                 var local267 []uint8
21064                 var local268 uint16
21065                 {
21066                         p := &local268
21067                         *p = read16(r)
21068                 }
21069                 (local267) = make([]uint8, local268)
21070                 {
21071                         _, err := io.ReadFull(r, (local267)[:])
21072                         chk(err)
21073                 }
21074                 ((*(*(struct {
21075                         Param0 Content
21076
21077                         Name   string
21078                         Groups []Group
21079
21080                         P1Type   Param1Type
21081                         P2Type   Param2Type
21082                         DrawType DrawType
21083
21084                         Mesh  string
21085                         Scale float32
21086                         //mt:const uint8(6)
21087                         Tiles        [6]TileDef
21088                         OverlayTiles [6]TileDef
21089                         //mt:const uint8(6)
21090                         SpecialTiles [6]TileDef
21091
21092                         Color   color.NRGBA
21093                         Palette Texture
21094
21095                         Waving       WaveType
21096                         ConnectSides uint8
21097                         ConnectTo    []Content
21098                         InsideTint   color.NRGBA
21099                         Level        uint8 // Must be < 128.
21100
21101                         Translucent bool // Sunlight is scattered and becomes normal light.
21102                         Transparent bool // Sunlight isn't scattered.
21103                         LightSrc    uint8
21104
21105                         GndContent   bool
21106                         Collides     bool
21107                         Pointable    bool
21108                         Diggable     bool
21109                         Climbable    bool
21110                         Replaceable  bool
21111                         OnRightClick bool
21112
21113                         DmgPerSec int32
21114
21115                         LiquidType   LiquidType
21116                         FlowingAlt   string
21117                         SrcAlt       string
21118                         Viscosity    uint8 // 0-7
21119                         LiqRenewable bool
21120                         FlowRange    uint8
21121                         DrownDmg     uint8
21122                         Floodable    bool
21123
21124                         DrawBox, ColBox, SelBox NodeBox
21125
21126                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21127
21128                         LegacyFaceDir bool
21129                         LegacyMounted bool
21130
21131                         DigPredict string
21132
21133                         MaxLvl uint8
21134
21135                         AlphaUse
21136                 }))(obj)).SrcAlt) = string(local267)
21137                 {
21138                         p := &(*(*(struct {
21139                                 Param0 Content
21140
21141                                 Name   string
21142                                 Groups []Group
21143
21144                                 P1Type   Param1Type
21145                                 P2Type   Param2Type
21146                                 DrawType DrawType
21147
21148                                 Mesh  string
21149                                 Scale float32
21150                                 //mt:const uint8(6)
21151                                 Tiles        [6]TileDef
21152                                 OverlayTiles [6]TileDef
21153                                 //mt:const uint8(6)
21154                                 SpecialTiles [6]TileDef
21155
21156                                 Color   color.NRGBA
21157                                 Palette Texture
21158
21159                                 Waving       WaveType
21160                                 ConnectSides uint8
21161                                 ConnectTo    []Content
21162                                 InsideTint   color.NRGBA
21163                                 Level        uint8 // Must be < 128.
21164
21165                                 Translucent bool // Sunlight is scattered and becomes normal light.
21166                                 Transparent bool // Sunlight isn't scattered.
21167                                 LightSrc    uint8
21168
21169                                 GndContent   bool
21170                                 Collides     bool
21171                                 Pointable    bool
21172                                 Diggable     bool
21173                                 Climbable    bool
21174                                 Replaceable  bool
21175                                 OnRightClick bool
21176
21177                                 DmgPerSec int32
21178
21179                                 LiquidType   LiquidType
21180                                 FlowingAlt   string
21181                                 SrcAlt       string
21182                                 Viscosity    uint8 // 0-7
21183                                 LiqRenewable bool
21184                                 FlowRange    uint8
21185                                 DrownDmg     uint8
21186                                 Floodable    bool
21187
21188                                 DrawBox, ColBox, SelBox NodeBox
21189
21190                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21191
21192                                 LegacyFaceDir bool
21193                                 LegacyMounted bool
21194
21195                                 DigPredict string
21196
21197                                 MaxLvl uint8
21198
21199                                 AlphaUse
21200                         }))(obj)).Viscosity
21201                         *p = read8(r)
21202                 }
21203                 {
21204                         p := &(*(*(struct {
21205                                 Param0 Content
21206
21207                                 Name   string
21208                                 Groups []Group
21209
21210                                 P1Type   Param1Type
21211                                 P2Type   Param2Type
21212                                 DrawType DrawType
21213
21214                                 Mesh  string
21215                                 Scale float32
21216                                 //mt:const uint8(6)
21217                                 Tiles        [6]TileDef
21218                                 OverlayTiles [6]TileDef
21219                                 //mt:const uint8(6)
21220                                 SpecialTiles [6]TileDef
21221
21222                                 Color   color.NRGBA
21223                                 Palette Texture
21224
21225                                 Waving       WaveType
21226                                 ConnectSides uint8
21227                                 ConnectTo    []Content
21228                                 InsideTint   color.NRGBA
21229                                 Level        uint8 // Must be < 128.
21230
21231                                 Translucent bool // Sunlight is scattered and becomes normal light.
21232                                 Transparent bool // Sunlight isn't scattered.
21233                                 LightSrc    uint8
21234
21235                                 GndContent   bool
21236                                 Collides     bool
21237                                 Pointable    bool
21238                                 Diggable     bool
21239                                 Climbable    bool
21240                                 Replaceable  bool
21241                                 OnRightClick bool
21242
21243                                 DmgPerSec int32
21244
21245                                 LiquidType   LiquidType
21246                                 FlowingAlt   string
21247                                 SrcAlt       string
21248                                 Viscosity    uint8 // 0-7
21249                                 LiqRenewable bool
21250                                 FlowRange    uint8
21251                                 DrownDmg     uint8
21252                                 Floodable    bool
21253
21254                                 DrawBox, ColBox, SelBox NodeBox
21255
21256                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21257
21258                                 LegacyFaceDir bool
21259                                 LegacyMounted bool
21260
21261                                 DigPredict string
21262
21263                                 MaxLvl uint8
21264
21265                                 AlphaUse
21266                         }))(obj)).LiqRenewable
21267                         switch n := read8(r); n {
21268                         case 0:
21269                                 *p = false
21270                         case 1:
21271                                 *p = true
21272                         default:
21273                                 chk(fmt.Errorf("invalid bool: %d", n))
21274                         }
21275                 }
21276                 {
21277                         p := &(*(*(struct {
21278                                 Param0 Content
21279
21280                                 Name   string
21281                                 Groups []Group
21282
21283                                 P1Type   Param1Type
21284                                 P2Type   Param2Type
21285                                 DrawType DrawType
21286
21287                                 Mesh  string
21288                                 Scale float32
21289                                 //mt:const uint8(6)
21290                                 Tiles        [6]TileDef
21291                                 OverlayTiles [6]TileDef
21292                                 //mt:const uint8(6)
21293                                 SpecialTiles [6]TileDef
21294
21295                                 Color   color.NRGBA
21296                                 Palette Texture
21297
21298                                 Waving       WaveType
21299                                 ConnectSides uint8
21300                                 ConnectTo    []Content
21301                                 InsideTint   color.NRGBA
21302                                 Level        uint8 // Must be < 128.
21303
21304                                 Translucent bool // Sunlight is scattered and becomes normal light.
21305                                 Transparent bool // Sunlight isn't scattered.
21306                                 LightSrc    uint8
21307
21308                                 GndContent   bool
21309                                 Collides     bool
21310                                 Pointable    bool
21311                                 Diggable     bool
21312                                 Climbable    bool
21313                                 Replaceable  bool
21314                                 OnRightClick bool
21315
21316                                 DmgPerSec int32
21317
21318                                 LiquidType   LiquidType
21319                                 FlowingAlt   string
21320                                 SrcAlt       string
21321                                 Viscosity    uint8 // 0-7
21322                                 LiqRenewable bool
21323                                 FlowRange    uint8
21324                                 DrownDmg     uint8
21325                                 Floodable    bool
21326
21327                                 DrawBox, ColBox, SelBox NodeBox
21328
21329                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21330
21331                                 LegacyFaceDir bool
21332                                 LegacyMounted bool
21333
21334                                 DigPredict string
21335
21336                                 MaxLvl uint8
21337
21338                                 AlphaUse
21339                         }))(obj)).FlowRange
21340                         *p = read8(r)
21341                 }
21342                 {
21343                         p := &(*(*(struct {
21344                                 Param0 Content
21345
21346                                 Name   string
21347                                 Groups []Group
21348
21349                                 P1Type   Param1Type
21350                                 P2Type   Param2Type
21351                                 DrawType DrawType
21352
21353                                 Mesh  string
21354                                 Scale float32
21355                                 //mt:const uint8(6)
21356                                 Tiles        [6]TileDef
21357                                 OverlayTiles [6]TileDef
21358                                 //mt:const uint8(6)
21359                                 SpecialTiles [6]TileDef
21360
21361                                 Color   color.NRGBA
21362                                 Palette Texture
21363
21364                                 Waving       WaveType
21365                                 ConnectSides uint8
21366                                 ConnectTo    []Content
21367                                 InsideTint   color.NRGBA
21368                                 Level        uint8 // Must be < 128.
21369
21370                                 Translucent bool // Sunlight is scattered and becomes normal light.
21371                                 Transparent bool // Sunlight isn't scattered.
21372                                 LightSrc    uint8
21373
21374                                 GndContent   bool
21375                                 Collides     bool
21376                                 Pointable    bool
21377                                 Diggable     bool
21378                                 Climbable    bool
21379                                 Replaceable  bool
21380                                 OnRightClick bool
21381
21382                                 DmgPerSec int32
21383
21384                                 LiquidType   LiquidType
21385                                 FlowingAlt   string
21386                                 SrcAlt       string
21387                                 Viscosity    uint8 // 0-7
21388                                 LiqRenewable bool
21389                                 FlowRange    uint8
21390                                 DrownDmg     uint8
21391                                 Floodable    bool
21392
21393                                 DrawBox, ColBox, SelBox NodeBox
21394
21395                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21396
21397                                 LegacyFaceDir bool
21398                                 LegacyMounted bool
21399
21400                                 DigPredict string
21401
21402                                 MaxLvl uint8
21403
21404                                 AlphaUse
21405                         }))(obj)).DrownDmg
21406                         *p = read8(r)
21407                 }
21408                 {
21409                         p := &(*(*(struct {
21410                                 Param0 Content
21411
21412                                 Name   string
21413                                 Groups []Group
21414
21415                                 P1Type   Param1Type
21416                                 P2Type   Param2Type
21417                                 DrawType DrawType
21418
21419                                 Mesh  string
21420                                 Scale float32
21421                                 //mt:const uint8(6)
21422                                 Tiles        [6]TileDef
21423                                 OverlayTiles [6]TileDef
21424                                 //mt:const uint8(6)
21425                                 SpecialTiles [6]TileDef
21426
21427                                 Color   color.NRGBA
21428                                 Palette Texture
21429
21430                                 Waving       WaveType
21431                                 ConnectSides uint8
21432                                 ConnectTo    []Content
21433                                 InsideTint   color.NRGBA
21434                                 Level        uint8 // Must be < 128.
21435
21436                                 Translucent bool // Sunlight is scattered and becomes normal light.
21437                                 Transparent bool // Sunlight isn't scattered.
21438                                 LightSrc    uint8
21439
21440                                 GndContent   bool
21441                                 Collides     bool
21442                                 Pointable    bool
21443                                 Diggable     bool
21444                                 Climbable    bool
21445                                 Replaceable  bool
21446                                 OnRightClick bool
21447
21448                                 DmgPerSec int32
21449
21450                                 LiquidType   LiquidType
21451                                 FlowingAlt   string
21452                                 SrcAlt       string
21453                                 Viscosity    uint8 // 0-7
21454                                 LiqRenewable bool
21455                                 FlowRange    uint8
21456                                 DrownDmg     uint8
21457                                 Floodable    bool
21458
21459                                 DrawBox, ColBox, SelBox NodeBox
21460
21461                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21462
21463                                 LegacyFaceDir bool
21464                                 LegacyMounted bool
21465
21466                                 DigPredict string
21467
21468                                 MaxLvl uint8
21469
21470                                 AlphaUse
21471                         }))(obj)).Floodable
21472                         switch n := read8(r); n {
21473                         case 0:
21474                                 *p = false
21475                         case 1:
21476                                 *p = true
21477                         default:
21478                                 chk(fmt.Errorf("invalid bool: %d", n))
21479                         }
21480                 }
21481                 if err := pcall(func() {
21482                         ((*(*(struct {
21483                                 Param0 Content
21484
21485                                 Name   string
21486                                 Groups []Group
21487
21488                                 P1Type   Param1Type
21489                                 P2Type   Param2Type
21490                                 DrawType DrawType
21491
21492                                 Mesh  string
21493                                 Scale float32
21494                                 //mt:const uint8(6)
21495                                 Tiles        [6]TileDef
21496                                 OverlayTiles [6]TileDef
21497                                 //mt:const uint8(6)
21498                                 SpecialTiles [6]TileDef
21499
21500                                 Color   color.NRGBA
21501                                 Palette Texture
21502
21503                                 Waving       WaveType
21504                                 ConnectSides uint8
21505                                 ConnectTo    []Content
21506                                 InsideTint   color.NRGBA
21507                                 Level        uint8 // Must be < 128.
21508
21509                                 Translucent bool // Sunlight is scattered and becomes normal light.
21510                                 Transparent bool // Sunlight isn't scattered.
21511                                 LightSrc    uint8
21512
21513                                 GndContent   bool
21514                                 Collides     bool
21515                                 Pointable    bool
21516                                 Diggable     bool
21517                                 Climbable    bool
21518                                 Replaceable  bool
21519                                 OnRightClick bool
21520
21521                                 DmgPerSec int32
21522
21523                                 LiquidType   LiquidType
21524                                 FlowingAlt   string
21525                                 SrcAlt       string
21526                                 Viscosity    uint8 // 0-7
21527                                 LiqRenewable bool
21528                                 FlowRange    uint8
21529                                 DrownDmg     uint8
21530                                 Floodable    bool
21531
21532                                 DrawBox, ColBox, SelBox NodeBox
21533
21534                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21535
21536                                 LegacyFaceDir bool
21537                                 LegacyMounted bool
21538
21539                                 DigPredict string
21540
21541                                 MaxLvl uint8
21542
21543                                 AlphaUse
21544                         }))(obj)).DrawBox).Deserialize(r)
21545                 }); err != nil {
21546                         if err == io.EOF {
21547                                 chk(io.EOF)
21548                         }
21549                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21550                 }
21551                 if err := pcall(func() {
21552                         ((*(*(struct {
21553                                 Param0 Content
21554
21555                                 Name   string
21556                                 Groups []Group
21557
21558                                 P1Type   Param1Type
21559                                 P2Type   Param2Type
21560                                 DrawType DrawType
21561
21562                                 Mesh  string
21563                                 Scale float32
21564                                 //mt:const uint8(6)
21565                                 Tiles        [6]TileDef
21566                                 OverlayTiles [6]TileDef
21567                                 //mt:const uint8(6)
21568                                 SpecialTiles [6]TileDef
21569
21570                                 Color   color.NRGBA
21571                                 Palette Texture
21572
21573                                 Waving       WaveType
21574                                 ConnectSides uint8
21575                                 ConnectTo    []Content
21576                                 InsideTint   color.NRGBA
21577                                 Level        uint8 // Must be < 128.
21578
21579                                 Translucent bool // Sunlight is scattered and becomes normal light.
21580                                 Transparent bool // Sunlight isn't scattered.
21581                                 LightSrc    uint8
21582
21583                                 GndContent   bool
21584                                 Collides     bool
21585                                 Pointable    bool
21586                                 Diggable     bool
21587                                 Climbable    bool
21588                                 Replaceable  bool
21589                                 OnRightClick bool
21590
21591                                 DmgPerSec int32
21592
21593                                 LiquidType   LiquidType
21594                                 FlowingAlt   string
21595                                 SrcAlt       string
21596                                 Viscosity    uint8 // 0-7
21597                                 LiqRenewable bool
21598                                 FlowRange    uint8
21599                                 DrownDmg     uint8
21600                                 Floodable    bool
21601
21602                                 DrawBox, ColBox, SelBox NodeBox
21603
21604                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21605
21606                                 LegacyFaceDir bool
21607                                 LegacyMounted bool
21608
21609                                 DigPredict string
21610
21611                                 MaxLvl uint8
21612
21613                                 AlphaUse
21614                         }))(obj)).ColBox).Deserialize(r)
21615                 }); err != nil {
21616                         if err == io.EOF {
21617                                 chk(io.EOF)
21618                         }
21619                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21620                 }
21621                 if err := pcall(func() {
21622                         ((*(*(struct {
21623                                 Param0 Content
21624
21625                                 Name   string
21626                                 Groups []Group
21627
21628                                 P1Type   Param1Type
21629                                 P2Type   Param2Type
21630                                 DrawType DrawType
21631
21632                                 Mesh  string
21633                                 Scale float32
21634                                 //mt:const uint8(6)
21635                                 Tiles        [6]TileDef
21636                                 OverlayTiles [6]TileDef
21637                                 //mt:const uint8(6)
21638                                 SpecialTiles [6]TileDef
21639
21640                                 Color   color.NRGBA
21641                                 Palette Texture
21642
21643                                 Waving       WaveType
21644                                 ConnectSides uint8
21645                                 ConnectTo    []Content
21646                                 InsideTint   color.NRGBA
21647                                 Level        uint8 // Must be < 128.
21648
21649                                 Translucent bool // Sunlight is scattered and becomes normal light.
21650                                 Transparent bool // Sunlight isn't scattered.
21651                                 LightSrc    uint8
21652
21653                                 GndContent   bool
21654                                 Collides     bool
21655                                 Pointable    bool
21656                                 Diggable     bool
21657                                 Climbable    bool
21658                                 Replaceable  bool
21659                                 OnRightClick bool
21660
21661                                 DmgPerSec int32
21662
21663                                 LiquidType   LiquidType
21664                                 FlowingAlt   string
21665                                 SrcAlt       string
21666                                 Viscosity    uint8 // 0-7
21667                                 LiqRenewable bool
21668                                 FlowRange    uint8
21669                                 DrownDmg     uint8
21670                                 Floodable    bool
21671
21672                                 DrawBox, ColBox, SelBox NodeBox
21673
21674                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21675
21676                                 LegacyFaceDir bool
21677                                 LegacyMounted bool
21678
21679                                 DigPredict string
21680
21681                                 MaxLvl uint8
21682
21683                                 AlphaUse
21684                         }))(obj)).SelBox).Deserialize(r)
21685                 }); err != nil {
21686                         if err == io.EOF {
21687                                 chk(io.EOF)
21688                         }
21689                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21690                 }
21691                 if err := pcall(func() {
21692                         ((*(*(struct {
21693                                 Param0 Content
21694
21695                                 Name   string
21696                                 Groups []Group
21697
21698                                 P1Type   Param1Type
21699                                 P2Type   Param2Type
21700                                 DrawType DrawType
21701
21702                                 Mesh  string
21703                                 Scale float32
21704                                 //mt:const uint8(6)
21705                                 Tiles        [6]TileDef
21706                                 OverlayTiles [6]TileDef
21707                                 //mt:const uint8(6)
21708                                 SpecialTiles [6]TileDef
21709
21710                                 Color   color.NRGBA
21711                                 Palette Texture
21712
21713                                 Waving       WaveType
21714                                 ConnectSides uint8
21715                                 ConnectTo    []Content
21716                                 InsideTint   color.NRGBA
21717                                 Level        uint8 // Must be < 128.
21718
21719                                 Translucent bool // Sunlight is scattered and becomes normal light.
21720                                 Transparent bool // Sunlight isn't scattered.
21721                                 LightSrc    uint8
21722
21723                                 GndContent   bool
21724                                 Collides     bool
21725                                 Pointable    bool
21726                                 Diggable     bool
21727                                 Climbable    bool
21728                                 Replaceable  bool
21729                                 OnRightClick bool
21730
21731                                 DmgPerSec int32
21732
21733                                 LiquidType   LiquidType
21734                                 FlowingAlt   string
21735                                 SrcAlt       string
21736                                 Viscosity    uint8 // 0-7
21737                                 LiqRenewable bool
21738                                 FlowRange    uint8
21739                                 DrownDmg     uint8
21740                                 Floodable    bool
21741
21742                                 DrawBox, ColBox, SelBox NodeBox
21743
21744                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21745
21746                                 LegacyFaceDir bool
21747                                 LegacyMounted bool
21748
21749                                 DigPredict string
21750
21751                                 MaxLvl uint8
21752
21753                                 AlphaUse
21754                         }))(obj)).FootstepSnd).Deserialize(r)
21755                 }); err != nil {
21756                         if err == io.EOF {
21757                                 chk(io.EOF)
21758                         }
21759                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
21760                 }
21761                 if err := pcall(func() {
21762                         ((*(*(struct {
21763                                 Param0 Content
21764
21765                                 Name   string
21766                                 Groups []Group
21767
21768                                 P1Type   Param1Type
21769                                 P2Type   Param2Type
21770                                 DrawType DrawType
21771
21772                                 Mesh  string
21773                                 Scale float32
21774                                 //mt:const uint8(6)
21775                                 Tiles        [6]TileDef
21776                                 OverlayTiles [6]TileDef
21777                                 //mt:const uint8(6)
21778                                 SpecialTiles [6]TileDef
21779
21780                                 Color   color.NRGBA
21781                                 Palette Texture
21782
21783                                 Waving       WaveType
21784                                 ConnectSides uint8
21785                                 ConnectTo    []Content
21786                                 InsideTint   color.NRGBA
21787                                 Level        uint8 // Must be < 128.
21788
21789                                 Translucent bool // Sunlight is scattered and becomes normal light.
21790                                 Transparent bool // Sunlight isn't scattered.
21791                                 LightSrc    uint8
21792
21793                                 GndContent   bool
21794                                 Collides     bool
21795                                 Pointable    bool
21796                                 Diggable     bool
21797                                 Climbable    bool
21798                                 Replaceable  bool
21799                                 OnRightClick bool
21800
21801                                 DmgPerSec int32
21802
21803                                 LiquidType   LiquidType
21804                                 FlowingAlt   string
21805                                 SrcAlt       string
21806                                 Viscosity    uint8 // 0-7
21807                                 LiqRenewable bool
21808                                 FlowRange    uint8
21809                                 DrownDmg     uint8
21810                                 Floodable    bool
21811
21812                                 DrawBox, ColBox, SelBox NodeBox
21813
21814                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21815
21816                                 LegacyFaceDir bool
21817                                 LegacyMounted bool
21818
21819                                 DigPredict string
21820
21821                                 MaxLvl uint8
21822
21823                                 AlphaUse
21824                         }))(obj)).DiggingSnd).Deserialize(r)
21825                 }); err != nil {
21826                         if err == io.EOF {
21827                                 chk(io.EOF)
21828                         }
21829                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
21830                 }
21831                 if err := pcall(func() {
21832                         ((*(*(struct {
21833                                 Param0 Content
21834
21835                                 Name   string
21836                                 Groups []Group
21837
21838                                 P1Type   Param1Type
21839                                 P2Type   Param2Type
21840                                 DrawType DrawType
21841
21842                                 Mesh  string
21843                                 Scale float32
21844                                 //mt:const uint8(6)
21845                                 Tiles        [6]TileDef
21846                                 OverlayTiles [6]TileDef
21847                                 //mt:const uint8(6)
21848                                 SpecialTiles [6]TileDef
21849
21850                                 Color   color.NRGBA
21851                                 Palette Texture
21852
21853                                 Waving       WaveType
21854                                 ConnectSides uint8
21855                                 ConnectTo    []Content
21856                                 InsideTint   color.NRGBA
21857                                 Level        uint8 // Must be < 128.
21858
21859                                 Translucent bool // Sunlight is scattered and becomes normal light.
21860                                 Transparent bool // Sunlight isn't scattered.
21861                                 LightSrc    uint8
21862
21863                                 GndContent   bool
21864                                 Collides     bool
21865                                 Pointable    bool
21866                                 Diggable     bool
21867                                 Climbable    bool
21868                                 Replaceable  bool
21869                                 OnRightClick bool
21870
21871                                 DmgPerSec int32
21872
21873                                 LiquidType   LiquidType
21874                                 FlowingAlt   string
21875                                 SrcAlt       string
21876                                 Viscosity    uint8 // 0-7
21877                                 LiqRenewable bool
21878                                 FlowRange    uint8
21879                                 DrownDmg     uint8
21880                                 Floodable    bool
21881
21882                                 DrawBox, ColBox, SelBox NodeBox
21883
21884                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21885
21886                                 LegacyFaceDir bool
21887                                 LegacyMounted bool
21888
21889                                 DigPredict string
21890
21891                                 MaxLvl uint8
21892
21893                                 AlphaUse
21894                         }))(obj)).DugSnd).Deserialize(r)
21895                 }); err != nil {
21896                         if err == io.EOF {
21897                                 chk(io.EOF)
21898                         }
21899                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
21900                 }
21901                 {
21902                         p := &(*(*(struct {
21903                                 Param0 Content
21904
21905                                 Name   string
21906                                 Groups []Group
21907
21908                                 P1Type   Param1Type
21909                                 P2Type   Param2Type
21910                                 DrawType DrawType
21911
21912                                 Mesh  string
21913                                 Scale float32
21914                                 //mt:const uint8(6)
21915                                 Tiles        [6]TileDef
21916                                 OverlayTiles [6]TileDef
21917                                 //mt:const uint8(6)
21918                                 SpecialTiles [6]TileDef
21919
21920                                 Color   color.NRGBA
21921                                 Palette Texture
21922
21923                                 Waving       WaveType
21924                                 ConnectSides uint8
21925                                 ConnectTo    []Content
21926                                 InsideTint   color.NRGBA
21927                                 Level        uint8 // Must be < 128.
21928
21929                                 Translucent bool // Sunlight is scattered and becomes normal light.
21930                                 Transparent bool // Sunlight isn't scattered.
21931                                 LightSrc    uint8
21932
21933                                 GndContent   bool
21934                                 Collides     bool
21935                                 Pointable    bool
21936                                 Diggable     bool
21937                                 Climbable    bool
21938                                 Replaceable  bool
21939                                 OnRightClick bool
21940
21941                                 DmgPerSec int32
21942
21943                                 LiquidType   LiquidType
21944                                 FlowingAlt   string
21945                                 SrcAlt       string
21946                                 Viscosity    uint8 // 0-7
21947                                 LiqRenewable bool
21948                                 FlowRange    uint8
21949                                 DrownDmg     uint8
21950                                 Floodable    bool
21951
21952                                 DrawBox, ColBox, SelBox NodeBox
21953
21954                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21955
21956                                 LegacyFaceDir bool
21957                                 LegacyMounted bool
21958
21959                                 DigPredict string
21960
21961                                 MaxLvl uint8
21962
21963                                 AlphaUse
21964                         }))(obj)).LegacyFaceDir
21965                         switch n := read8(r); n {
21966                         case 0:
21967                                 *p = false
21968                         case 1:
21969                                 *p = true
21970                         default:
21971                                 chk(fmt.Errorf("invalid bool: %d", n))
21972                         }
21973                 }
21974                 {
21975                         p := &(*(*(struct {
21976                                 Param0 Content
21977
21978                                 Name   string
21979                                 Groups []Group
21980
21981                                 P1Type   Param1Type
21982                                 P2Type   Param2Type
21983                                 DrawType DrawType
21984
21985                                 Mesh  string
21986                                 Scale float32
21987                                 //mt:const uint8(6)
21988                                 Tiles        [6]TileDef
21989                                 OverlayTiles [6]TileDef
21990                                 //mt:const uint8(6)
21991                                 SpecialTiles [6]TileDef
21992
21993                                 Color   color.NRGBA
21994                                 Palette Texture
21995
21996                                 Waving       WaveType
21997                                 ConnectSides uint8
21998                                 ConnectTo    []Content
21999                                 InsideTint   color.NRGBA
22000                                 Level        uint8 // Must be < 128.
22001
22002                                 Translucent bool // Sunlight is scattered and becomes normal light.
22003                                 Transparent bool // Sunlight isn't scattered.
22004                                 LightSrc    uint8
22005
22006                                 GndContent   bool
22007                                 Collides     bool
22008                                 Pointable    bool
22009                                 Diggable     bool
22010                                 Climbable    bool
22011                                 Replaceable  bool
22012                                 OnRightClick bool
22013
22014                                 DmgPerSec int32
22015
22016                                 LiquidType   LiquidType
22017                                 FlowingAlt   string
22018                                 SrcAlt       string
22019                                 Viscosity    uint8 // 0-7
22020                                 LiqRenewable bool
22021                                 FlowRange    uint8
22022                                 DrownDmg     uint8
22023                                 Floodable    bool
22024
22025                                 DrawBox, ColBox, SelBox NodeBox
22026
22027                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22028
22029                                 LegacyFaceDir bool
22030                                 LegacyMounted bool
22031
22032                                 DigPredict string
22033
22034                                 MaxLvl uint8
22035
22036                                 AlphaUse
22037                         }))(obj)).LegacyMounted
22038                         switch n := read8(r); n {
22039                         case 0:
22040                                 *p = false
22041                         case 1:
22042                                 *p = true
22043                         default:
22044                                 chk(fmt.Errorf("invalid bool: %d", n))
22045                         }
22046                 }
22047                 var local269 []uint8
22048                 var local270 uint16
22049                 {
22050                         p := &local270
22051                         *p = read16(r)
22052                 }
22053                 (local269) = make([]uint8, local270)
22054                 {
22055                         _, err := io.ReadFull(r, (local269)[:])
22056                         chk(err)
22057                 }
22058                 ((*(*(struct {
22059                         Param0 Content
22060
22061                         Name   string
22062                         Groups []Group
22063
22064                         P1Type   Param1Type
22065                         P2Type   Param2Type
22066                         DrawType DrawType
22067
22068                         Mesh  string
22069                         Scale float32
22070                         //mt:const uint8(6)
22071                         Tiles        [6]TileDef
22072                         OverlayTiles [6]TileDef
22073                         //mt:const uint8(6)
22074                         SpecialTiles [6]TileDef
22075
22076                         Color   color.NRGBA
22077                         Palette Texture
22078
22079                         Waving       WaveType
22080                         ConnectSides uint8
22081                         ConnectTo    []Content
22082                         InsideTint   color.NRGBA
22083                         Level        uint8 // Must be < 128.
22084
22085                         Translucent bool // Sunlight is scattered and becomes normal light.
22086                         Transparent bool // Sunlight isn't scattered.
22087                         LightSrc    uint8
22088
22089                         GndContent   bool
22090                         Collides     bool
22091                         Pointable    bool
22092                         Diggable     bool
22093                         Climbable    bool
22094                         Replaceable  bool
22095                         OnRightClick bool
22096
22097                         DmgPerSec int32
22098
22099                         LiquidType   LiquidType
22100                         FlowingAlt   string
22101                         SrcAlt       string
22102                         Viscosity    uint8 // 0-7
22103                         LiqRenewable bool
22104                         FlowRange    uint8
22105                         DrownDmg     uint8
22106                         Floodable    bool
22107
22108                         DrawBox, ColBox, SelBox NodeBox
22109
22110                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22111
22112                         LegacyFaceDir bool
22113                         LegacyMounted bool
22114
22115                         DigPredict string
22116
22117                         MaxLvl uint8
22118
22119                         AlphaUse
22120                 }))(obj)).DigPredict) = string(local269)
22121                 {
22122                         p := &(*(*(struct {
22123                                 Param0 Content
22124
22125                                 Name   string
22126                                 Groups []Group
22127
22128                                 P1Type   Param1Type
22129                                 P2Type   Param2Type
22130                                 DrawType DrawType
22131
22132                                 Mesh  string
22133                                 Scale float32
22134                                 //mt:const uint8(6)
22135                                 Tiles        [6]TileDef
22136                                 OverlayTiles [6]TileDef
22137                                 //mt:const uint8(6)
22138                                 SpecialTiles [6]TileDef
22139
22140                                 Color   color.NRGBA
22141                                 Palette Texture
22142
22143                                 Waving       WaveType
22144                                 ConnectSides uint8
22145                                 ConnectTo    []Content
22146                                 InsideTint   color.NRGBA
22147                                 Level        uint8 // Must be < 128.
22148
22149                                 Translucent bool // Sunlight is scattered and becomes normal light.
22150                                 Transparent bool // Sunlight isn't scattered.
22151                                 LightSrc    uint8
22152
22153                                 GndContent   bool
22154                                 Collides     bool
22155                                 Pointable    bool
22156                                 Diggable     bool
22157                                 Climbable    bool
22158                                 Replaceable  bool
22159                                 OnRightClick bool
22160
22161                                 DmgPerSec int32
22162
22163                                 LiquidType   LiquidType
22164                                 FlowingAlt   string
22165                                 SrcAlt       string
22166                                 Viscosity    uint8 // 0-7
22167                                 LiqRenewable bool
22168                                 FlowRange    uint8
22169                                 DrownDmg     uint8
22170                                 Floodable    bool
22171
22172                                 DrawBox, ColBox, SelBox NodeBox
22173
22174                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22175
22176                                 LegacyFaceDir bool
22177                                 LegacyMounted bool
22178
22179                                 DigPredict string
22180
22181                                 MaxLvl uint8
22182
22183                                 AlphaUse
22184                         }))(obj)).MaxLvl
22185                         *p = read8(r)
22186                 }
22187                 if err := pcall(func() {
22188                         ((*(*(struct {
22189                                 Param0 Content
22190
22191                                 Name   string
22192                                 Groups []Group
22193
22194                                 P1Type   Param1Type
22195                                 P2Type   Param2Type
22196                                 DrawType DrawType
22197
22198                                 Mesh  string
22199                                 Scale float32
22200                                 //mt:const uint8(6)
22201                                 Tiles        [6]TileDef
22202                                 OverlayTiles [6]TileDef
22203                                 //mt:const uint8(6)
22204                                 SpecialTiles [6]TileDef
22205
22206                                 Color   color.NRGBA
22207                                 Palette Texture
22208
22209                                 Waving       WaveType
22210                                 ConnectSides uint8
22211                                 ConnectTo    []Content
22212                                 InsideTint   color.NRGBA
22213                                 Level        uint8 // Must be < 128.
22214
22215                                 Translucent bool // Sunlight is scattered and becomes normal light.
22216                                 Transparent bool // Sunlight isn't scattered.
22217                                 LightSrc    uint8
22218
22219                                 GndContent   bool
22220                                 Collides     bool
22221                                 Pointable    bool
22222                                 Diggable     bool
22223                                 Climbable    bool
22224                                 Replaceable  bool
22225                                 OnRightClick bool
22226
22227                                 DmgPerSec int32
22228
22229                                 LiquidType   LiquidType
22230                                 FlowingAlt   string
22231                                 SrcAlt       string
22232                                 Viscosity    uint8 // 0-7
22233                                 LiqRenewable bool
22234                                 FlowRange    uint8
22235                                 DrownDmg     uint8
22236                                 Floodable    bool
22237
22238                                 DrawBox, ColBox, SelBox NodeBox
22239
22240                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22241
22242                                 LegacyFaceDir bool
22243                                 LegacyMounted bool
22244
22245                                 DigPredict string
22246
22247                                 MaxLvl uint8
22248
22249                                 AlphaUse
22250                         }))(obj)).AlphaUse).Deserialize(r)
22251                 }); err != nil {
22252                         if err == io.EOF {
22253                                 chk(io.EOF)
22254                         }
22255                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlphaUse", err))
22256                 }
22257                 if r.N > 0 {
22258                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
22259                 }
22260         }
22261 }
22262
22263 func (obj *PointedNode) Serialize(w io.Writer) {
22264         for local271 := range (*(*(struct {
22265                 Under, Above [3]int16
22266         }))(obj)).Under {
22267                 {
22268                         x := ((*(*(struct {
22269                                 Under, Above [3]int16
22270                         }))(obj)).Under)[local271]
22271                         write16(w, uint16(x))
22272                 }
22273         }
22274         for local272 := range (*(*(struct {
22275                 Under, Above [3]int16
22276         }))(obj)).Above {
22277                 {
22278                         x := ((*(*(struct {
22279                                 Under, Above [3]int16
22280                         }))(obj)).Above)[local272]
22281                         write16(w, uint16(x))
22282                 }
22283         }
22284 }
22285
22286 func (obj *PointedNode) Deserialize(r io.Reader) {
22287         for local273 := range (*(*(struct {
22288                 Under, Above [3]int16
22289         }))(obj)).Under {
22290                 {
22291                         p := &((*(*(struct {
22292                                 Under, Above [3]int16
22293                         }))(obj)).Under)[local273]
22294                         *p = int16(read16(r))
22295                 }
22296         }
22297         for local274 := range (*(*(struct {
22298                 Under, Above [3]int16
22299         }))(obj)).Above {
22300                 {
22301                         p := &((*(*(struct {
22302                                 Under, Above [3]int16
22303                         }))(obj)).Above)[local274]
22304                         *p = int16(read16(r))
22305                 }
22306         }
22307 }
22308
22309 func (obj *PointedAO) Serialize(w io.Writer) {
22310         if err := pcall(func() {
22311                 ((*(*(struct {
22312                         ID AOID
22313                 }))(obj)).ID).Serialize(w)
22314         }); err != nil {
22315                 if err == io.EOF {
22316                         chk(io.EOF)
22317                 }
22318                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
22319         }
22320 }
22321
22322 func (obj *PointedAO) Deserialize(r io.Reader) {
22323         if err := pcall(func() {
22324                 ((*(*(struct {
22325                         ID AOID
22326                 }))(obj)).ID).Deserialize(r)
22327         }); err != nil {
22328                 if err == io.EOF {
22329                         chk(io.EOF)
22330                 }
22331                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
22332         }
22333 }
22334
22335 func (obj *CompressionModes) Serialize(w io.Writer) {
22336         {
22337                 x := *(*(uint16))(obj)
22338                 write16(w, uint16(x))
22339         }
22340 }
22341
22342 func (obj *CompressionModes) Deserialize(r io.Reader) {
22343         {
22344                 p := &*(*(uint16))(obj)
22345                 *p = read16(r)
22346         }
22347 }
22348
22349 func (obj *PlayerPos) Serialize(w io.Writer) {
22350         for local275 := range (*(*(struct {
22351                 Pos100, Vel100   [3]int32
22352                 Pitch100, Yaw100 int32
22353                 Keys             Keys
22354                 FOV80            uint8
22355                 WantedRange      uint8 // in MapBlks.
22356         }))(obj)).Pos100 {
22357                 {
22358                         x := ((*(*(struct {
22359                                 Pos100, Vel100   [3]int32
22360                                 Pitch100, Yaw100 int32
22361                                 Keys             Keys
22362                                 FOV80            uint8
22363                                 WantedRange      uint8 // in MapBlks.
22364                         }))(obj)).Pos100)[local275]
22365                         write32(w, uint32(x))
22366                 }
22367         }
22368         for local276 := range (*(*(struct {
22369                 Pos100, Vel100   [3]int32
22370                 Pitch100, Yaw100 int32
22371                 Keys             Keys
22372                 FOV80            uint8
22373                 WantedRange      uint8 // in MapBlks.
22374         }))(obj)).Vel100 {
22375                 {
22376                         x := ((*(*(struct {
22377                                 Pos100, Vel100   [3]int32
22378                                 Pitch100, Yaw100 int32
22379                                 Keys             Keys
22380                                 FOV80            uint8
22381                                 WantedRange      uint8 // in MapBlks.
22382                         }))(obj)).Vel100)[local276]
22383                         write32(w, uint32(x))
22384                 }
22385         }
22386         {
22387                 x := (*(*(struct {
22388                         Pos100, Vel100   [3]int32
22389                         Pitch100, Yaw100 int32
22390                         Keys             Keys
22391                         FOV80            uint8
22392                         WantedRange      uint8 // in MapBlks.
22393                 }))(obj)).Pitch100
22394                 write32(w, uint32(x))
22395         }
22396         {
22397                 x := (*(*(struct {
22398                         Pos100, Vel100   [3]int32
22399                         Pitch100, Yaw100 int32
22400                         Keys             Keys
22401                         FOV80            uint8
22402                         WantedRange      uint8 // in MapBlks.
22403                 }))(obj)).Yaw100
22404                 write32(w, uint32(x))
22405         }
22406         if err := pcall(func() {
22407                 ((*(*(struct {
22408                         Pos100, Vel100   [3]int32
22409                         Pitch100, Yaw100 int32
22410                         Keys             Keys
22411                         FOV80            uint8
22412                         WantedRange      uint8 // in MapBlks.
22413                 }))(obj)).Keys).Serialize(w)
22414         }); err != nil {
22415                 if err == io.EOF {
22416                         chk(io.EOF)
22417                 }
22418                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Keys", err))
22419         }
22420         {
22421                 x := (*(*(struct {
22422                         Pos100, Vel100   [3]int32
22423                         Pitch100, Yaw100 int32
22424                         Keys             Keys
22425                         FOV80            uint8
22426                         WantedRange      uint8 // in MapBlks.
22427                 }))(obj)).FOV80
22428                 write8(w, uint8(x))
22429         }
22430         {
22431                 x := (*(*(struct {
22432                         Pos100, Vel100   [3]int32
22433                         Pitch100, Yaw100 int32
22434                         Keys             Keys
22435                         FOV80            uint8
22436                         WantedRange      uint8 // in MapBlks.
22437                 }))(obj)).WantedRange
22438                 write8(w, uint8(x))
22439         }
22440 }
22441
22442 func (obj *PlayerPos) Deserialize(r io.Reader) {
22443         for local277 := range (*(*(struct {
22444                 Pos100, Vel100   [3]int32
22445                 Pitch100, Yaw100 int32
22446                 Keys             Keys
22447                 FOV80            uint8
22448                 WantedRange      uint8 // in MapBlks.
22449         }))(obj)).Pos100 {
22450                 {
22451                         p := &((*(*(struct {
22452                                 Pos100, Vel100   [3]int32
22453                                 Pitch100, Yaw100 int32
22454                                 Keys             Keys
22455                                 FOV80            uint8
22456                                 WantedRange      uint8 // in MapBlks.
22457                         }))(obj)).Pos100)[local277]
22458                         *p = int32(read32(r))
22459                 }
22460         }
22461         for local278 := range (*(*(struct {
22462                 Pos100, Vel100   [3]int32
22463                 Pitch100, Yaw100 int32
22464                 Keys             Keys
22465                 FOV80            uint8
22466                 WantedRange      uint8 // in MapBlks.
22467         }))(obj)).Vel100 {
22468                 {
22469                         p := &((*(*(struct {
22470                                 Pos100, Vel100   [3]int32
22471                                 Pitch100, Yaw100 int32
22472                                 Keys             Keys
22473                                 FOV80            uint8
22474                                 WantedRange      uint8 // in MapBlks.
22475                         }))(obj)).Vel100)[local278]
22476                         *p = int32(read32(r))
22477                 }
22478         }
22479         {
22480                 p := &(*(*(struct {
22481                         Pos100, Vel100   [3]int32
22482                         Pitch100, Yaw100 int32
22483                         Keys             Keys
22484                         FOV80            uint8
22485                         WantedRange      uint8 // in MapBlks.
22486                 }))(obj)).Pitch100
22487                 *p = int32(read32(r))
22488         }
22489         {
22490                 p := &(*(*(struct {
22491                         Pos100, Vel100   [3]int32
22492                         Pitch100, Yaw100 int32
22493                         Keys             Keys
22494                         FOV80            uint8
22495                         WantedRange      uint8 // in MapBlks.
22496                 }))(obj)).Yaw100
22497                 *p = int32(read32(r))
22498         }
22499         if err := pcall(func() {
22500                 ((*(*(struct {
22501                         Pos100, Vel100   [3]int32
22502                         Pitch100, Yaw100 int32
22503                         Keys             Keys
22504                         FOV80            uint8
22505                         WantedRange      uint8 // in MapBlks.
22506                 }))(obj)).Keys).Deserialize(r)
22507         }); err != nil {
22508                 if err == io.EOF {
22509                         chk(io.EOF)
22510                 }
22511                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Keys", err))
22512         }
22513         {
22514                 p := &(*(*(struct {
22515                         Pos100, Vel100   [3]int32
22516                         Pitch100, Yaw100 int32
22517                         Keys             Keys
22518                         FOV80            uint8
22519                         WantedRange      uint8 // in MapBlks.
22520                 }))(obj)).FOV80
22521                 *p = read8(r)
22522         }
22523         {
22524                 p := &(*(*(struct {
22525                         Pos100, Vel100   [3]int32
22526                         Pitch100, Yaw100 int32
22527                         Keys             Keys
22528                         FOV80            uint8
22529                         WantedRange      uint8 // in MapBlks.
22530                 }))(obj)).WantedRange
22531                 *p = read8(r)
22532         }
22533 }
22534
22535 func (obj *Interaction) Serialize(w io.Writer) {
22536         {
22537                 x := *(*(uint8))(obj)
22538                 write8(w, uint8(x))
22539         }
22540 }
22541
22542 func (obj *Interaction) Deserialize(r io.Reader) {
22543         {
22544                 p := &*(*(uint8))(obj)
22545                 *p = read8(r)
22546         }
22547 }
22548
22549 func (obj *SoundID) Serialize(w io.Writer) {
22550         {
22551                 x := *(*(int32))(obj)
22552                 write32(w, uint32(x))
22553         }
22554 }
22555
22556 func (obj *SoundID) Deserialize(r io.Reader) {
22557         {
22558                 p := &*(*(int32))(obj)
22559                 *p = int32(read32(r))
22560         }
22561 }
22562
22563 func (obj *Field) Serialize(w io.Writer) {
22564         if len(([]byte((*(*(struct {
22565                 Name string
22566
22567                 //mt:len32
22568                 Value string
22569         }))(obj)).Name))) > math.MaxUint16 {
22570                 chk(ErrTooLong)
22571         }
22572         {
22573                 x := uint16(len(([]byte((*(*(struct {
22574                         Name string
22575
22576                         //mt:len32
22577                         Value string
22578                 }))(obj)).Name))))
22579                 write16(w, uint16(x))
22580         }
22581         {
22582                 _, err := w.Write(([]byte((*(*(struct {
22583                         Name string
22584
22585                         //mt:len32
22586                         Value string
22587                 }))(obj)).Name))[:])
22588                 chk(err)
22589         }
22590         if len(([]byte((*(*(struct {
22591                 Name string
22592
22593                 //mt:len32
22594                 Value string
22595         }))(obj)).Value))) > math.MaxUint32 {
22596                 chk(ErrTooLong)
22597         }
22598         {
22599                 x := uint32(len(([]byte((*(*(struct {
22600                         Name string
22601
22602                         //mt:len32
22603                         Value string
22604                 }))(obj)).Value))))
22605                 write32(w, uint32(x))
22606         }
22607         {
22608                 _, err := w.Write(([]byte((*(*(struct {
22609                         Name string
22610
22611                         //mt:len32
22612                         Value string
22613                 }))(obj)).Value))[:])
22614                 chk(err)
22615         }
22616 }
22617
22618 func (obj *Field) Deserialize(r io.Reader) {
22619         var local279 []uint8
22620         var local280 uint16
22621         {
22622                 p := &local280
22623                 *p = read16(r)
22624         }
22625         (local279) = make([]uint8, local280)
22626         {
22627                 _, err := io.ReadFull(r, (local279)[:])
22628                 chk(err)
22629         }
22630         ((*(*(struct {
22631                 Name string
22632
22633                 //mt:len32
22634                 Value string
22635         }))(obj)).Name) = string(local279)
22636         var local281 []uint8
22637         var local282 uint32
22638         {
22639                 p := &local282
22640                 *p = read32(r)
22641         }
22642         (local281) = make([]uint8, local282)
22643         {
22644                 _, err := io.ReadFull(r, (local281)[:])
22645                 chk(err)
22646         }
22647         ((*(*(struct {
22648                 Name string
22649
22650                 //mt:len32
22651                 Value string
22652         }))(obj)).Value) = string(local281)
22653 }
22654
22655 func (obj *AuthMethods) Serialize(w io.Writer) {
22656         {
22657                 x := *(*(uint32))(obj)
22658                 write32(w, uint32(x))
22659         }
22660 }
22661
22662 func (obj *AuthMethods) Deserialize(r io.Reader) {
22663         {
22664                 p := &*(*(uint32))(obj)
22665                 *p = read32(r)
22666         }
22667 }
22668
22669 func (obj *Pos) Serialize(w io.Writer) {
22670         if err := pcall(func() {
22671                 (*(*(Vec))(obj)).Serialize(w)
22672         }); err != nil {
22673                 if err == io.EOF {
22674                         chk(io.EOF)
22675                 }
22676                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
22677         }
22678 }
22679
22680 func (obj *Pos) Deserialize(r io.Reader) {
22681         if err := pcall(func() {
22682                 (*(*(Vec))(obj)).Deserialize(r)
22683         }); err != nil {
22684                 if err == io.EOF {
22685                         chk(io.EOF)
22686                 }
22687                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
22688         }
22689 }
22690
22691 func (obj *KickReason) Serialize(w io.Writer) {
22692         {
22693                 x := *(*(uint8))(obj)
22694                 write8(w, uint8(x))
22695         }
22696 }
22697
22698 func (obj *KickReason) Deserialize(r io.Reader) {
22699         {
22700                 p := &*(*(uint8))(obj)
22701                 *p = read8(r)
22702         }
22703 }
22704
22705 func (obj *MapBlk) Serialize(w io.Writer) {
22706         if err := pcall(func() {
22707                 ((*(*(struct {
22708                         Flags   MapBlkFlags
22709                         LitFrom LitFromBlks
22710
22711                         //mt:zlib
22712                         Param0 [4096]Content
22713                         Param1 [4096]uint8
22714                         Param2 [4096]uint8
22715
22716                         NodeMetas map[uint16]*NodeMeta
22717                 }))(obj)).Flags).Serialize(w)
22718         }); err != nil {
22719                 if err == io.EOF {
22720                         chk(io.EOF)
22721                 }
22722                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlkFlags", err))
22723         }
22724         if err := pcall(func() {
22725                 ((*(*(struct {
22726                         Flags   MapBlkFlags
22727                         LitFrom LitFromBlks
22728
22729                         //mt:zlib
22730                         Param0 [4096]Content
22731                         Param1 [4096]uint8
22732                         Param2 [4096]uint8
22733
22734                         NodeMetas map[uint16]*NodeMeta
22735                 }))(obj)).LitFrom).Serialize(w)
22736         }); err != nil {
22737                 if err == io.EOF {
22738                         chk(io.EOF)
22739                 }
22740                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
22741         }
22742         {
22743                 local283 := uint8(2) // Size of param0 in bytes.
22744                 {
22745                         x := local283
22746                         write8(w, uint8(x))
22747                 }
22748         }
22749         {
22750                 local284 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
22751                 {
22752                         x := local284
22753                         write8(w, uint8(x))
22754                 }
22755         }
22756         {
22757                 w := zlib.NewWriter(w)
22758                 for local285 := range (*(*(struct {
22759                         Flags   MapBlkFlags
22760                         LitFrom LitFromBlks
22761
22762                         //mt:zlib
22763                         Param0 [4096]Content
22764                         Param1 [4096]uint8
22765                         Param2 [4096]uint8
22766
22767                         NodeMetas map[uint16]*NodeMeta
22768                 }))(obj)).Param0 {
22769                         if err := pcall(func() {
22770                                 (((*(*(struct {
22771                                         Flags   MapBlkFlags
22772                                         LitFrom LitFromBlks
22773
22774                                         //mt:zlib
22775                                         Param0 [4096]Content
22776                                         Param1 [4096]uint8
22777                                         Param2 [4096]uint8
22778
22779                                         NodeMetas map[uint16]*NodeMeta
22780                                 }))(obj)).Param0)[local285]).Serialize(w)
22781                         }); err != nil {
22782                                 if err == io.EOF {
22783                                         chk(io.EOF)
22784                                 }
22785                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
22786                         }
22787                 }
22788                 {
22789                         _, err := w.Write(((*(*(struct {
22790                                 Flags   MapBlkFlags
22791                                 LitFrom LitFromBlks
22792
22793                                 //mt:zlib
22794                                 Param0 [4096]Content
22795                                 Param1 [4096]uint8
22796                                 Param2 [4096]uint8
22797
22798                                 NodeMetas map[uint16]*NodeMeta
22799                         }))(obj)).Param1)[:])
22800                         chk(err)
22801                 }
22802                 {
22803                         _, err := w.Write(((*(*(struct {
22804                                 Flags   MapBlkFlags
22805                                 LitFrom LitFromBlks
22806
22807                                 //mt:zlib
22808                                 Param0 [4096]Content
22809                                 Param1 [4096]uint8
22810                                 Param2 [4096]uint8
22811
22812                                 NodeMetas map[uint16]*NodeMeta
22813                         }))(obj)).Param2)[:])
22814                         chk(err)
22815                 }
22816                 chk(w.Close())
22817         }
22818         {
22819                 x := (*(*(struct {
22820                         Flags   MapBlkFlags
22821                         LitFrom LitFromBlks
22822
22823                         //mt:zlib
22824                         Param0 [4096]Content
22825                         Param1 [4096]uint8
22826                         Param2 [4096]uint8
22827
22828                         NodeMetas map[uint16]*NodeMeta
22829                 }))(obj)).NodeMetas
22830                 {
22831                         w := zlib.NewWriter(w)
22832                         if x == nil {
22833                                 write8(w, 0)
22834                         } else {
22835                                 write8(w, 2)
22836                                 // len(map[uint16]...) always < math.MaxUint16
22837                                 write16(w, uint16(len(x)))
22838                                 keys := make([]uint16, 0, len(x))
22839                                 for key := range x {
22840                                         keys = append(keys, key)
22841                                 }
22842                                 sort.Slice(keys, func(i, j int) bool {
22843                                         i2pos := func(i int) [3]int16 {
22844                                                 return Blkpos2Pos([3]int16{}, keys[i])
22845                                         }
22846                                         p, q := i2pos(i), i2pos(j)
22847                                         for i := range p {
22848                                                 switch {
22849                                                 case p[i] < q[i]:
22850                                                         return true
22851                                                 case p[i] > q[i]:
22852                                                         return false
22853                                                 }
22854                                         }
22855                                         return false
22856                                 })
22857                                 for _, key := range keys {
22858                                         write16(w, key)
22859                                         chk(serialize(w, x[key]))
22860                                 }
22861                         }
22862                         chk(w.Close())
22863                 }
22864         }
22865         {
22866                 local286 := uint8(2) // version
22867                 {
22868                         x := local286
22869                         write8(w, uint8(x))
22870                 }
22871         }
22872 }
22873
22874 func (obj *MapBlk) Deserialize(r io.Reader) {
22875         if err := pcall(func() {
22876                 ((*(*(struct {
22877                         Flags   MapBlkFlags
22878                         LitFrom LitFromBlks
22879
22880                         //mt:zlib
22881                         Param0 [4096]Content
22882                         Param1 [4096]uint8
22883                         Param2 [4096]uint8
22884
22885                         NodeMetas map[uint16]*NodeMeta
22886                 }))(obj)).Flags).Deserialize(r)
22887         }); err != nil {
22888                 if err == io.EOF {
22889                         chk(io.EOF)
22890                 }
22891                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlkFlags", err))
22892         }
22893         if err := pcall(func() {
22894                 ((*(*(struct {
22895                         Flags   MapBlkFlags
22896                         LitFrom LitFromBlks
22897
22898                         //mt:zlib
22899                         Param0 [4096]Content
22900                         Param1 [4096]uint8
22901                         Param2 [4096]uint8
22902
22903                         NodeMetas map[uint16]*NodeMeta
22904                 }))(obj)).LitFrom).Deserialize(r)
22905         }); err != nil {
22906                 if err == io.EOF {
22907                         chk(io.EOF)
22908                 }
22909                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
22910         }
22911         {
22912                 var local287 uint8
22913                 local288 := uint8(2) // Size of param0 in bytes.
22914                 {
22915                         p := &local287
22916                         *p = read8(r)
22917                 }
22918                 if local287 != local288 {
22919                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local287))
22920                 }
22921         }
22922         {
22923                 var local289 uint8
22924                 local290 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
22925                 {
22926                         p := &local289
22927                         *p = read8(r)
22928                 }
22929                 if local289 != local290 {
22930                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local289))
22931                 }
22932         }
22933         {
22934                 r, err := zlib.NewReader(byteReader{r})
22935                 chk(err)
22936                 for local291 := range (*(*(struct {
22937                         Flags   MapBlkFlags
22938                         LitFrom LitFromBlks
22939
22940                         //mt:zlib
22941                         Param0 [4096]Content
22942                         Param1 [4096]uint8
22943                         Param2 [4096]uint8
22944
22945                         NodeMetas map[uint16]*NodeMeta
22946                 }))(obj)).Param0 {
22947                         if err := pcall(func() {
22948                                 (((*(*(struct {
22949                                         Flags   MapBlkFlags
22950                                         LitFrom LitFromBlks
22951
22952                                         //mt:zlib
22953                                         Param0 [4096]Content
22954                                         Param1 [4096]uint8
22955                                         Param2 [4096]uint8
22956
22957                                         NodeMetas map[uint16]*NodeMeta
22958                                 }))(obj)).Param0)[local291]).Deserialize(r)
22959                         }); err != nil {
22960                                 if err == io.EOF {
22961                                         chk(io.EOF)
22962                                 }
22963                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
22964                         }
22965                 }
22966                 {
22967                         _, err := io.ReadFull(r, ((*(*(struct {
22968                                 Flags   MapBlkFlags
22969                                 LitFrom LitFromBlks
22970
22971                                 //mt:zlib
22972                                 Param0 [4096]Content
22973                                 Param1 [4096]uint8
22974                                 Param2 [4096]uint8
22975
22976                                 NodeMetas map[uint16]*NodeMeta
22977                         }))(obj)).Param1)[:])
22978                         chk(err)
22979                 }
22980                 {
22981                         _, err := io.ReadFull(r, ((*(*(struct {
22982                                 Flags   MapBlkFlags
22983                                 LitFrom LitFromBlks
22984
22985                                 //mt:zlib
22986                                 Param0 [4096]Content
22987                                 Param1 [4096]uint8
22988                                 Param2 [4096]uint8
22989
22990                                 NodeMetas map[uint16]*NodeMeta
22991                         }))(obj)).Param2)[:])
22992                         chk(err)
22993                 }
22994                 chk(r.Close())
22995         }
22996         {
22997                 p := &(*(*(struct {
22998                         Flags   MapBlkFlags
22999                         LitFrom LitFromBlks
23000
23001                         //mt:zlib
23002                         Param0 [4096]Content
23003                         Param1 [4096]uint8
23004                         Param2 [4096]uint8
23005
23006                         NodeMetas map[uint16]*NodeMeta
23007                 }))(obj)).NodeMetas
23008                 {
23009                         r, err := zlib.NewReader(byteReader{r})
23010                         chk(err)
23011                         switch ver := read8(r); ver {
23012                         case 0:
23013                                 *p = nil
23014                         case 2:
23015                                 n := read16(r)
23016                                 *p = make(map[uint16]*NodeMeta, n)
23017                                 for ; n > 0; n-- {
23018                                         pos := read16(r)
23019                                         nm := new(NodeMeta)
23020                                         chk(deserialize(r, nm))
23021                                         (*p)[pos] = nm
23022                                 }
23023                         default:
23024                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
23025                         }
23026                         chk(r.Close())
23027                 }
23028         }
23029         {
23030                 var local292 uint8
23031                 local293 := uint8(2) // version
23032                 {
23033                         p := &local292
23034                         *p = read8(r)
23035                 }
23036                 if local292 != local293 {
23037                         chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local292))
23038                 }
23039         }
23040 }
23041
23042 func (obj *Node) Serialize(w io.Writer) {
23043         if err := pcall(func() {
23044                 ((*(*(struct {
23045                         Param0         Content
23046                         Param1, Param2 uint8
23047                 }))(obj)).Param0).Serialize(w)
23048         }); err != nil {
23049                 if err == io.EOF {
23050                         chk(io.EOF)
23051                 }
23052                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23053         }
23054         {
23055                 x := (*(*(struct {
23056                         Param0         Content
23057                         Param1, Param2 uint8
23058                 }))(obj)).Param1
23059                 write8(w, uint8(x))
23060         }
23061         {
23062                 x := (*(*(struct {
23063                         Param0         Content
23064                         Param1, Param2 uint8
23065                 }))(obj)).Param2
23066                 write8(w, uint8(x))
23067         }
23068 }
23069
23070 func (obj *Node) Deserialize(r io.Reader) {
23071         if err := pcall(func() {
23072                 ((*(*(struct {
23073                         Param0         Content
23074                         Param1, Param2 uint8
23075                 }))(obj)).Param0).Deserialize(r)
23076         }); err != nil {
23077                 if err == io.EOF {
23078                         chk(io.EOF)
23079                 }
23080                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23081         }
23082         {
23083                 p := &(*(*(struct {
23084                         Param0         Content
23085                         Param1, Param2 uint8
23086                 }))(obj)).Param1
23087                 *p = read8(r)
23088         }
23089         {
23090                 p := &(*(*(struct {
23091                         Param0         Content
23092                         Param1, Param2 uint8
23093                 }))(obj)).Param2
23094                 *p = read8(r)
23095         }
23096 }
23097
23098 func (obj *CSMRestrictionFlags) Serialize(w io.Writer) {
23099         {
23100                 x := *(*(uint64))(obj)
23101                 write64(w, uint64(x))
23102         }
23103 }
23104
23105 func (obj *CSMRestrictionFlags) Deserialize(r io.Reader) {
23106         {
23107                 p := &*(*(uint64))(obj)
23108                 *p = read64(r)
23109         }
23110 }
23111
23112 func (obj *Vec) Serialize(w io.Writer) {
23113         for local294 := range *(*([3]float32))(obj) {
23114                 {
23115                         x := (*(*([3]float32))(obj))[local294]
23116                         write32(w, math.Float32bits(x))
23117                 }
23118         }
23119 }
23120
23121 func (obj *Vec) Deserialize(r io.Reader) {
23122         for local295 := range *(*([3]float32))(obj) {
23123                 {
23124                         p := &(*(*([3]float32))(obj))[local295]
23125                         *p = math.Float32frombits(read32(r))
23126                 }
23127         }
23128 }
23129
23130 func (obj *ChatMsgType) Serialize(w io.Writer) {
23131         {
23132                 x := *(*(uint8))(obj)
23133                 write8(w, uint8(x))
23134         }
23135 }
23136
23137 func (obj *ChatMsgType) Deserialize(r io.Reader) {
23138         {
23139                 p := &*(*(uint8))(obj)
23140                 *p = read8(r)
23141         }
23142 }
23143
23144 func (obj *AOID) Serialize(w io.Writer) {
23145         {
23146                 x := *(*(uint16))(obj)
23147                 write16(w, uint16(x))
23148         }
23149 }
23150
23151 func (obj *AOID) Deserialize(r io.Reader) {
23152         {
23153                 p := &*(*(uint16))(obj)
23154                 *p = read16(r)
23155         }
23156 }
23157
23158 func (obj *AOAdd) Serialize(w io.Writer) {
23159         if err := pcall(func() {
23160                 ((*(*(struct {
23161                         ID AOID
23162                         //mt:const genericCAO
23163                         //mt:lenhdr 32
23164                         InitData AOInitData
23165                 }))(obj)).ID).Serialize(w)
23166         }); err != nil {
23167                 if err == io.EOF {
23168                         chk(io.EOF)
23169                 }
23170                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23171         }
23172         {
23173                 local296 := genericCAO
23174                 if err := pcall(func() {
23175                         (local296).Serialize(w)
23176                 }); err != nil {
23177                         if err == io.EOF {
23178                                 chk(io.EOF)
23179                         }
23180                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
23181                 }
23182         }
23183         {
23184                 ow := w
23185                 w := new(bytes.Buffer)
23186                 if err := pcall(func() {
23187                         ((*(*(struct {
23188                                 ID AOID
23189                                 //mt:const genericCAO
23190                                 //mt:lenhdr 32
23191                                 InitData AOInitData
23192                         }))(obj)).InitData).Serialize(w)
23193                 }); err != nil {
23194                         if err == io.EOF {
23195                                 chk(io.EOF)
23196                         }
23197                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
23198                 }
23199                 {
23200                         buf := w
23201                         w := ow
23202                         if len((buf.Bytes())) > math.MaxUint32 {
23203                                 chk(ErrTooLong)
23204                         }
23205                         {
23206                                 x := uint32(len((buf.Bytes())))
23207                                 write32(w, uint32(x))
23208                         }
23209                         {
23210                                 _, err := w.Write((buf.Bytes())[:])
23211                                 chk(err)
23212                         }
23213                 }
23214         }
23215 }
23216
23217 func (obj *AOAdd) Deserialize(r io.Reader) {
23218         if err := pcall(func() {
23219                 ((*(*(struct {
23220                         ID AOID
23221                         //mt:const genericCAO
23222                         //mt:lenhdr 32
23223                         InitData AOInitData
23224                 }))(obj)).ID).Deserialize(r)
23225         }); err != nil {
23226                 if err == io.EOF {
23227                         chk(io.EOF)
23228                 }
23229                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23230         }
23231         {
23232                 var local297 aoType
23233                 local298 := genericCAO
23234                 if err := pcall(func() {
23235                         (local297).Deserialize(r)
23236                 }); err != nil {
23237                         if err == io.EOF {
23238                                 chk(io.EOF)
23239                         }
23240                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
23241                 }
23242                 if local297 != local298 {
23243                         chk(fmt.Errorf("const %v: %v", "genericCAO", local297))
23244                 }
23245         }
23246         {
23247                 var n uint32
23248                 {
23249                         p := &n
23250                         *p = read32(r)
23251                 }
23252                 r := &io.LimitedReader{R: r, N: int64(n)}
23253                 if err := pcall(func() {
23254                         ((*(*(struct {
23255                                 ID AOID
23256                                 //mt:const genericCAO
23257                                 //mt:lenhdr 32
23258                                 InitData AOInitData
23259                         }))(obj)).InitData).Deserialize(r)
23260                 }); err != nil {
23261                         if err == io.EOF {
23262                                 chk(io.EOF)
23263                         }
23264                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
23265                 }
23266                 if r.N > 0 {
23267                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23268                 }
23269         }
23270 }
23271
23272 func (obj *IDAOMsg) Serialize(w io.Writer) {
23273         if err := pcall(func() {
23274                 ((*(*(struct {
23275                         ID AOID
23276                         //mt:lenhdr 16
23277                         Msg AOMsg
23278                 }))(obj)).ID).Serialize(w)
23279         }); err != nil {
23280                 if err == io.EOF {
23281                         chk(io.EOF)
23282                 }
23283                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23284         }
23285         {
23286                 ow := w
23287                 w := new(bytes.Buffer)
23288                 {
23289                         x := (*(*(struct {
23290                                 ID AOID
23291                                 //mt:lenhdr 16
23292                                 Msg AOMsg
23293                         }))(obj)).Msg
23294                         writeAOMsg(w, x)
23295                 }
23296                 {
23297                         buf := w
23298                         w := ow
23299                         if len((buf.Bytes())) > math.MaxUint16 {
23300                                 chk(ErrTooLong)
23301                         }
23302                         {
23303                                 x := uint16(len((buf.Bytes())))
23304                                 write16(w, uint16(x))
23305                         }
23306                         {
23307                                 _, err := w.Write((buf.Bytes())[:])
23308                                 chk(err)
23309                         }
23310                 }
23311         }
23312 }
23313
23314 func (obj *IDAOMsg) Deserialize(r io.Reader) {
23315         if err := pcall(func() {
23316                 ((*(*(struct {
23317                         ID AOID
23318                         //mt:lenhdr 16
23319                         Msg AOMsg
23320                 }))(obj)).ID).Deserialize(r)
23321         }); err != nil {
23322                 if err == io.EOF {
23323                         chk(io.EOF)
23324                 }
23325                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23326         }
23327         {
23328                 var n uint16
23329                 {
23330                         p := &n
23331                         *p = read16(r)
23332                 }
23333                 r := &io.LimitedReader{R: r, N: int64(n)}
23334                 {
23335                         p := &(*(*(struct {
23336                                 ID AOID
23337                                 //mt:lenhdr 16
23338                                 Msg AOMsg
23339                         }))(obj)).Msg
23340                         {
23341                                 var err error
23342                                 *p, err = readAOMsg(r)
23343                                 chk(err)
23344                         }
23345                 }
23346                 if r.N > 0 {
23347                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23348                 }
23349         }
23350 }
23351
23352 func (obj *ItemDef) Serialize(w io.Writer) {
23353         {
23354                 ow := w
23355                 w := new(bytes.Buffer)
23356                 {
23357                         local299 := uint8(6)
23358                         {
23359                                 x := local299
23360                                 write8(w, uint8(x))
23361                         }
23362                 }
23363                 if err := pcall(func() {
23364                         ((*(*(struct {
23365                                 Type ItemType
23366
23367                                 Name, Desc string
23368
23369                                 InvImg, WieldImg Texture
23370                                 WieldScale       [3]float32
23371
23372                                 StackMax uint16
23373
23374                                 Usable          bool
23375                                 CanPointLiquids bool
23376
23377                                 ToolCaps ToolCaps
23378
23379                                 Groups []Group
23380
23381                                 PlacePredict string
23382
23383                                 PlaceSnd, PlaceFailSnd SoundDef
23384
23385                                 PointRange float32
23386
23387                                 // Set index in Palette with "palette_index" item meta field,
23388                                 // this overrides Color.
23389                                 Palette Texture
23390                                 Color   color.NRGBA
23391
23392                                 // Texture overlays.
23393                                 InvOverlay, WieldOverlay Texture
23394
23395                                 ShortDesc string
23396                         }))(obj)).Type).Serialize(w)
23397                 }); err != nil {
23398                         if err == io.EOF {
23399                                 chk(io.EOF)
23400                         }
23401                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
23402                 }
23403                 if len(([]byte((*(*(struct {
23404                         Type ItemType
23405
23406                         Name, Desc string
23407
23408                         InvImg, WieldImg Texture
23409                         WieldScale       [3]float32
23410
23411                         StackMax uint16
23412
23413                         Usable          bool
23414                         CanPointLiquids bool
23415
23416                         ToolCaps ToolCaps
23417
23418                         Groups []Group
23419
23420                         PlacePredict string
23421
23422                         PlaceSnd, PlaceFailSnd SoundDef
23423
23424                         PointRange float32
23425
23426                         // Set index in Palette with "palette_index" item meta field,
23427                         // this overrides Color.
23428                         Palette Texture
23429                         Color   color.NRGBA
23430
23431                         // Texture overlays.
23432                         InvOverlay, WieldOverlay Texture
23433
23434                         ShortDesc string
23435                 }))(obj)).Name))) > math.MaxUint16 {
23436                         chk(ErrTooLong)
23437                 }
23438                 {
23439                         x := uint16(len(([]byte((*(*(struct {
23440                                 Type ItemType
23441
23442                                 Name, Desc string
23443
23444                                 InvImg, WieldImg Texture
23445                                 WieldScale       [3]float32
23446
23447                                 StackMax uint16
23448
23449                                 Usable          bool
23450                                 CanPointLiquids bool
23451
23452                                 ToolCaps ToolCaps
23453
23454                                 Groups []Group
23455
23456                                 PlacePredict string
23457
23458                                 PlaceSnd, PlaceFailSnd SoundDef
23459
23460                                 PointRange float32
23461
23462                                 // Set index in Palette with "palette_index" item meta field,
23463                                 // this overrides Color.
23464                                 Palette Texture
23465                                 Color   color.NRGBA
23466
23467                                 // Texture overlays.
23468                                 InvOverlay, WieldOverlay Texture
23469
23470                                 ShortDesc string
23471                         }))(obj)).Name))))
23472                         write16(w, uint16(x))
23473                 }
23474                 {
23475                         _, err := w.Write(([]byte((*(*(struct {
23476                                 Type ItemType
23477
23478                                 Name, Desc string
23479
23480                                 InvImg, WieldImg Texture
23481                                 WieldScale       [3]float32
23482
23483                                 StackMax uint16
23484
23485                                 Usable          bool
23486                                 CanPointLiquids bool
23487
23488                                 ToolCaps ToolCaps
23489
23490                                 Groups []Group
23491
23492                                 PlacePredict string
23493
23494                                 PlaceSnd, PlaceFailSnd SoundDef
23495
23496                                 PointRange float32
23497
23498                                 // Set index in Palette with "palette_index" item meta field,
23499                                 // this overrides Color.
23500                                 Palette Texture
23501                                 Color   color.NRGBA
23502
23503                                 // Texture overlays.
23504                                 InvOverlay, WieldOverlay Texture
23505
23506                                 ShortDesc string
23507                         }))(obj)).Name))[:])
23508                         chk(err)
23509                 }
23510                 if len(([]byte((*(*(struct {
23511                         Type ItemType
23512
23513                         Name, Desc string
23514
23515                         InvImg, WieldImg Texture
23516                         WieldScale       [3]float32
23517
23518                         StackMax uint16
23519
23520                         Usable          bool
23521                         CanPointLiquids bool
23522
23523                         ToolCaps ToolCaps
23524
23525                         Groups []Group
23526
23527                         PlacePredict string
23528
23529                         PlaceSnd, PlaceFailSnd SoundDef
23530
23531                         PointRange float32
23532
23533                         // Set index in Palette with "palette_index" item meta field,
23534                         // this overrides Color.
23535                         Palette Texture
23536                         Color   color.NRGBA
23537
23538                         // Texture overlays.
23539                         InvOverlay, WieldOverlay Texture
23540
23541                         ShortDesc string
23542                 }))(obj)).Desc))) > math.MaxUint16 {
23543                         chk(ErrTooLong)
23544                 }
23545                 {
23546                         x := uint16(len(([]byte((*(*(struct {
23547                                 Type ItemType
23548
23549                                 Name, Desc string
23550
23551                                 InvImg, WieldImg Texture
23552                                 WieldScale       [3]float32
23553
23554                                 StackMax uint16
23555
23556                                 Usable          bool
23557                                 CanPointLiquids bool
23558
23559                                 ToolCaps ToolCaps
23560
23561                                 Groups []Group
23562
23563                                 PlacePredict string
23564
23565                                 PlaceSnd, PlaceFailSnd SoundDef
23566
23567                                 PointRange float32
23568
23569                                 // Set index in Palette with "palette_index" item meta field,
23570                                 // this overrides Color.
23571                                 Palette Texture
23572                                 Color   color.NRGBA
23573
23574                                 // Texture overlays.
23575                                 InvOverlay, WieldOverlay Texture
23576
23577                                 ShortDesc string
23578                         }))(obj)).Desc))))
23579                         write16(w, uint16(x))
23580                 }
23581                 {
23582                         _, err := w.Write(([]byte((*(*(struct {
23583                                 Type ItemType
23584
23585                                 Name, Desc string
23586
23587                                 InvImg, WieldImg Texture
23588                                 WieldScale       [3]float32
23589
23590                                 StackMax uint16
23591
23592                                 Usable          bool
23593                                 CanPointLiquids bool
23594
23595                                 ToolCaps ToolCaps
23596
23597                                 Groups []Group
23598
23599                                 PlacePredict string
23600
23601                                 PlaceSnd, PlaceFailSnd SoundDef
23602
23603                                 PointRange float32
23604
23605                                 // Set index in Palette with "palette_index" item meta field,
23606                                 // this overrides Color.
23607                                 Palette Texture
23608                                 Color   color.NRGBA
23609
23610                                 // Texture overlays.
23611                                 InvOverlay, WieldOverlay Texture
23612
23613                                 ShortDesc string
23614                         }))(obj)).Desc))[:])
23615                         chk(err)
23616                 }
23617                 if err := pcall(func() {
23618                         ((*(*(struct {
23619                                 Type ItemType
23620
23621                                 Name, Desc string
23622
23623                                 InvImg, WieldImg Texture
23624                                 WieldScale       [3]float32
23625
23626                                 StackMax uint16
23627
23628                                 Usable          bool
23629                                 CanPointLiquids bool
23630
23631                                 ToolCaps ToolCaps
23632
23633                                 Groups []Group
23634
23635                                 PlacePredict string
23636
23637                                 PlaceSnd, PlaceFailSnd SoundDef
23638
23639                                 PointRange float32
23640
23641                                 // Set index in Palette with "palette_index" item meta field,
23642                                 // this overrides Color.
23643                                 Palette Texture
23644                                 Color   color.NRGBA
23645
23646                                 // Texture overlays.
23647                                 InvOverlay, WieldOverlay Texture
23648
23649                                 ShortDesc string
23650                         }))(obj)).InvImg).Serialize(w)
23651                 }); err != nil {
23652                         if err == io.EOF {
23653                                 chk(io.EOF)
23654                         }
23655                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
23656                 }
23657                 if err := pcall(func() {
23658                         ((*(*(struct {
23659                                 Type ItemType
23660
23661                                 Name, Desc string
23662
23663                                 InvImg, WieldImg Texture
23664                                 WieldScale       [3]float32
23665
23666                                 StackMax uint16
23667
23668                                 Usable          bool
23669                                 CanPointLiquids bool
23670
23671                                 ToolCaps ToolCaps
23672
23673                                 Groups []Group
23674
23675                                 PlacePredict string
23676
23677                                 PlaceSnd, PlaceFailSnd SoundDef
23678
23679                                 PointRange float32
23680
23681                                 // Set index in Palette with "palette_index" item meta field,
23682                                 // this overrides Color.
23683                                 Palette Texture
23684                                 Color   color.NRGBA
23685
23686                                 // Texture overlays.
23687                                 InvOverlay, WieldOverlay Texture
23688
23689                                 ShortDesc string
23690                         }))(obj)).WieldImg).Serialize(w)
23691                 }); err != nil {
23692                         if err == io.EOF {
23693                                 chk(io.EOF)
23694                         }
23695                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
23696                 }
23697                 for local300 := range (*(*(struct {
23698                         Type ItemType
23699
23700                         Name, Desc string
23701
23702                         InvImg, WieldImg Texture
23703                         WieldScale       [3]float32
23704
23705                         StackMax uint16
23706
23707                         Usable          bool
23708                         CanPointLiquids bool
23709
23710                         ToolCaps ToolCaps
23711
23712                         Groups []Group
23713
23714                         PlacePredict string
23715
23716                         PlaceSnd, PlaceFailSnd SoundDef
23717
23718                         PointRange float32
23719
23720                         // Set index in Palette with "palette_index" item meta field,
23721                         // this overrides Color.
23722                         Palette Texture
23723                         Color   color.NRGBA
23724
23725                         // Texture overlays.
23726                         InvOverlay, WieldOverlay Texture
23727
23728                         ShortDesc string
23729                 }))(obj)).WieldScale {
23730                         {
23731                                 x := ((*(*(struct {
23732                                         Type ItemType
23733
23734                                         Name, Desc string
23735
23736                                         InvImg, WieldImg Texture
23737                                         WieldScale       [3]float32
23738
23739                                         StackMax uint16
23740
23741                                         Usable          bool
23742                                         CanPointLiquids bool
23743
23744                                         ToolCaps ToolCaps
23745
23746                                         Groups []Group
23747
23748                                         PlacePredict string
23749
23750                                         PlaceSnd, PlaceFailSnd SoundDef
23751
23752                                         PointRange float32
23753
23754                                         // Set index in Palette with "palette_index" item meta field,
23755                                         // this overrides Color.
23756                                         Palette Texture
23757                                         Color   color.NRGBA
23758
23759                                         // Texture overlays.
23760                                         InvOverlay, WieldOverlay Texture
23761
23762                                         ShortDesc string
23763                                 }))(obj)).WieldScale)[local300]
23764                                 write32(w, math.Float32bits(x))
23765                         }
23766                 }
23767                 {
23768                         x := (*(*(struct {
23769                                 Type ItemType
23770
23771                                 Name, Desc string
23772
23773                                 InvImg, WieldImg Texture
23774                                 WieldScale       [3]float32
23775
23776                                 StackMax uint16
23777
23778                                 Usable          bool
23779                                 CanPointLiquids bool
23780
23781                                 ToolCaps ToolCaps
23782
23783                                 Groups []Group
23784
23785                                 PlacePredict string
23786
23787                                 PlaceSnd, PlaceFailSnd SoundDef
23788
23789                                 PointRange float32
23790
23791                                 // Set index in Palette with "palette_index" item meta field,
23792                                 // this overrides Color.
23793                                 Palette Texture
23794                                 Color   color.NRGBA
23795
23796                                 // Texture overlays.
23797                                 InvOverlay, WieldOverlay Texture
23798
23799                                 ShortDesc string
23800                         }))(obj)).StackMax
23801                         write16(w, uint16(x))
23802                 }
23803                 {
23804                         x := (*(*(struct {
23805                                 Type ItemType
23806
23807                                 Name, Desc string
23808
23809                                 InvImg, WieldImg Texture
23810                                 WieldScale       [3]float32
23811
23812                                 StackMax uint16
23813
23814                                 Usable          bool
23815                                 CanPointLiquids bool
23816
23817                                 ToolCaps ToolCaps
23818
23819                                 Groups []Group
23820
23821                                 PlacePredict string
23822
23823                                 PlaceSnd, PlaceFailSnd SoundDef
23824
23825                                 PointRange float32
23826
23827                                 // Set index in Palette with "palette_index" item meta field,
23828                                 // this overrides Color.
23829                                 Palette Texture
23830                                 Color   color.NRGBA
23831
23832                                 // Texture overlays.
23833                                 InvOverlay, WieldOverlay Texture
23834
23835                                 ShortDesc string
23836                         }))(obj)).Usable
23837                         if x {
23838                                 write8(w, 1)
23839                         } else {
23840                                 write8(w, 0)
23841                         }
23842                 }
23843                 {
23844                         x := (*(*(struct {
23845                                 Type ItemType
23846
23847                                 Name, Desc string
23848
23849                                 InvImg, WieldImg Texture
23850                                 WieldScale       [3]float32
23851
23852                                 StackMax uint16
23853
23854                                 Usable          bool
23855                                 CanPointLiquids bool
23856
23857                                 ToolCaps ToolCaps
23858
23859                                 Groups []Group
23860
23861                                 PlacePredict string
23862
23863                                 PlaceSnd, PlaceFailSnd SoundDef
23864
23865                                 PointRange float32
23866
23867                                 // Set index in Palette with "palette_index" item meta field,
23868                                 // this overrides Color.
23869                                 Palette Texture
23870                                 Color   color.NRGBA
23871
23872                                 // Texture overlays.
23873                                 InvOverlay, WieldOverlay Texture
23874
23875                                 ShortDesc string
23876                         }))(obj)).CanPointLiquids
23877                         if x {
23878                                 write8(w, 1)
23879                         } else {
23880                                 write8(w, 0)
23881                         }
23882                 }
23883                 if err := pcall(func() {
23884                         ((*(*(struct {
23885                                 Type ItemType
23886
23887                                 Name, Desc string
23888
23889                                 InvImg, WieldImg Texture
23890                                 WieldScale       [3]float32
23891
23892                                 StackMax uint16
23893
23894                                 Usable          bool
23895                                 CanPointLiquids bool
23896
23897                                 ToolCaps ToolCaps
23898
23899                                 Groups []Group
23900
23901                                 PlacePredict string
23902
23903                                 PlaceSnd, PlaceFailSnd SoundDef
23904
23905                                 PointRange float32
23906
23907                                 // Set index in Palette with "palette_index" item meta field,
23908                                 // this overrides Color.
23909                                 Palette Texture
23910                                 Color   color.NRGBA
23911
23912                                 // Texture overlays.
23913                                 InvOverlay, WieldOverlay Texture
23914
23915                                 ShortDesc string
23916                         }))(obj)).ToolCaps).Serialize(w)
23917                 }); err != nil {
23918                         if err == io.EOF {
23919                                 chk(io.EOF)
23920                         }
23921                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
23922                 }
23923                 if len(((*(*(struct {
23924                         Type ItemType
23925
23926                         Name, Desc string
23927
23928                         InvImg, WieldImg Texture
23929                         WieldScale       [3]float32
23930
23931                         StackMax uint16
23932
23933                         Usable          bool
23934                         CanPointLiquids bool
23935
23936                         ToolCaps ToolCaps
23937
23938                         Groups []Group
23939
23940                         PlacePredict string
23941
23942                         PlaceSnd, PlaceFailSnd SoundDef
23943
23944                         PointRange float32
23945
23946                         // Set index in Palette with "palette_index" item meta field,
23947                         // this overrides Color.
23948                         Palette Texture
23949                         Color   color.NRGBA
23950
23951                         // Texture overlays.
23952                         InvOverlay, WieldOverlay Texture
23953
23954                         ShortDesc string
23955                 }))(obj)).Groups)) > math.MaxUint16 {
23956                         chk(ErrTooLong)
23957                 }
23958                 {
23959                         x := uint16(len(((*(*(struct {
23960                                 Type ItemType
23961
23962                                 Name, Desc string
23963
23964                                 InvImg, WieldImg Texture
23965                                 WieldScale       [3]float32
23966
23967                                 StackMax uint16
23968
23969                                 Usable          bool
23970                                 CanPointLiquids bool
23971
23972                                 ToolCaps ToolCaps
23973
23974                                 Groups []Group
23975
23976                                 PlacePredict string
23977
23978                                 PlaceSnd, PlaceFailSnd SoundDef
23979
23980                                 PointRange float32
23981
23982                                 // Set index in Palette with "palette_index" item meta field,
23983                                 // this overrides Color.
23984                                 Palette Texture
23985                                 Color   color.NRGBA
23986
23987                                 // Texture overlays.
23988                                 InvOverlay, WieldOverlay Texture
23989
23990                                 ShortDesc string
23991                         }))(obj)).Groups)))
23992                         write16(w, uint16(x))
23993                 }
23994                 for local301 := range (*(*(struct {
23995                         Type ItemType
23996
23997                         Name, Desc string
23998
23999                         InvImg, WieldImg Texture
24000                         WieldScale       [3]float32
24001
24002                         StackMax uint16
24003
24004                         Usable          bool
24005                         CanPointLiquids bool
24006
24007                         ToolCaps ToolCaps
24008
24009                         Groups []Group
24010
24011                         PlacePredict string
24012
24013                         PlaceSnd, PlaceFailSnd SoundDef
24014
24015                         PointRange float32
24016
24017                         // Set index in Palette with "palette_index" item meta field,
24018                         // this overrides Color.
24019                         Palette Texture
24020                         Color   color.NRGBA
24021
24022                         // Texture overlays.
24023                         InvOverlay, WieldOverlay Texture
24024
24025                         ShortDesc string
24026                 }))(obj)).Groups {
24027                         if err := pcall(func() {
24028                                 (((*(*(struct {
24029                                         Type ItemType
24030
24031                                         Name, Desc string
24032
24033                                         InvImg, WieldImg Texture
24034                                         WieldScale       [3]float32
24035
24036                                         StackMax uint16
24037
24038                                         Usable          bool
24039                                         CanPointLiquids bool
24040
24041                                         ToolCaps ToolCaps
24042
24043                                         Groups []Group
24044
24045                                         PlacePredict string
24046
24047                                         PlaceSnd, PlaceFailSnd SoundDef
24048
24049                                         PointRange float32
24050
24051                                         // Set index in Palette with "palette_index" item meta field,
24052                                         // this overrides Color.
24053                                         Palette Texture
24054                                         Color   color.NRGBA
24055
24056                                         // Texture overlays.
24057                                         InvOverlay, WieldOverlay Texture
24058
24059                                         ShortDesc string
24060                                 }))(obj)).Groups)[local301]).Serialize(w)
24061                         }); err != nil {
24062                                 if err == io.EOF {
24063                                         chk(io.EOF)
24064                                 }
24065                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
24066                         }
24067                 }
24068                 if len(([]byte((*(*(struct {
24069                         Type ItemType
24070
24071                         Name, Desc string
24072
24073                         InvImg, WieldImg Texture
24074                         WieldScale       [3]float32
24075
24076                         StackMax uint16
24077
24078                         Usable          bool
24079                         CanPointLiquids bool
24080
24081                         ToolCaps ToolCaps
24082
24083                         Groups []Group
24084
24085                         PlacePredict string
24086
24087                         PlaceSnd, PlaceFailSnd SoundDef
24088
24089                         PointRange float32
24090
24091                         // Set index in Palette with "palette_index" item meta field,
24092                         // this overrides Color.
24093                         Palette Texture
24094                         Color   color.NRGBA
24095
24096                         // Texture overlays.
24097                         InvOverlay, WieldOverlay Texture
24098
24099                         ShortDesc string
24100                 }))(obj)).PlacePredict))) > math.MaxUint16 {
24101                         chk(ErrTooLong)
24102                 }
24103                 {
24104                         x := uint16(len(([]byte((*(*(struct {
24105                                 Type ItemType
24106
24107                                 Name, Desc string
24108
24109                                 InvImg, WieldImg Texture
24110                                 WieldScale       [3]float32
24111
24112                                 StackMax uint16
24113
24114                                 Usable          bool
24115                                 CanPointLiquids bool
24116
24117                                 ToolCaps ToolCaps
24118
24119                                 Groups []Group
24120
24121                                 PlacePredict string
24122
24123                                 PlaceSnd, PlaceFailSnd SoundDef
24124
24125                                 PointRange float32
24126
24127                                 // Set index in Palette with "palette_index" item meta field,
24128                                 // this overrides Color.
24129                                 Palette Texture
24130                                 Color   color.NRGBA
24131
24132                                 // Texture overlays.
24133                                 InvOverlay, WieldOverlay Texture
24134
24135                                 ShortDesc string
24136                         }))(obj)).PlacePredict))))
24137                         write16(w, uint16(x))
24138                 }
24139                 {
24140                         _, err := w.Write(([]byte((*(*(struct {
24141                                 Type ItemType
24142
24143                                 Name, Desc string
24144
24145                                 InvImg, WieldImg Texture
24146                                 WieldScale       [3]float32
24147
24148                                 StackMax uint16
24149
24150                                 Usable          bool
24151                                 CanPointLiquids bool
24152
24153                                 ToolCaps ToolCaps
24154
24155                                 Groups []Group
24156
24157                                 PlacePredict string
24158
24159                                 PlaceSnd, PlaceFailSnd SoundDef
24160
24161                                 PointRange float32
24162
24163                                 // Set index in Palette with "palette_index" item meta field,
24164                                 // this overrides Color.
24165                                 Palette Texture
24166                                 Color   color.NRGBA
24167
24168                                 // Texture overlays.
24169                                 InvOverlay, WieldOverlay Texture
24170
24171                                 ShortDesc string
24172                         }))(obj)).PlacePredict))[:])
24173                         chk(err)
24174                 }
24175                 if err := pcall(func() {
24176                         ((*(*(struct {
24177                                 Type ItemType
24178
24179                                 Name, Desc string
24180
24181                                 InvImg, WieldImg Texture
24182                                 WieldScale       [3]float32
24183
24184                                 StackMax uint16
24185
24186                                 Usable          bool
24187                                 CanPointLiquids bool
24188
24189                                 ToolCaps ToolCaps
24190
24191                                 Groups []Group
24192
24193                                 PlacePredict string
24194
24195                                 PlaceSnd, PlaceFailSnd SoundDef
24196
24197                                 PointRange float32
24198
24199                                 // Set index in Palette with "palette_index" item meta field,
24200                                 // this overrides Color.
24201                                 Palette Texture
24202                                 Color   color.NRGBA
24203
24204                                 // Texture overlays.
24205                                 InvOverlay, WieldOverlay Texture
24206
24207                                 ShortDesc string
24208                         }))(obj)).PlaceSnd).Serialize(w)
24209                 }); err != nil {
24210                         if err == io.EOF {
24211                                 chk(io.EOF)
24212                         }
24213                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
24214                 }
24215                 if err := pcall(func() {
24216                         ((*(*(struct {
24217                                 Type ItemType
24218
24219                                 Name, Desc string
24220
24221                                 InvImg, WieldImg Texture
24222                                 WieldScale       [3]float32
24223
24224                                 StackMax uint16
24225
24226                                 Usable          bool
24227                                 CanPointLiquids bool
24228
24229                                 ToolCaps ToolCaps
24230
24231                                 Groups []Group
24232
24233                                 PlacePredict string
24234
24235                                 PlaceSnd, PlaceFailSnd SoundDef
24236
24237                                 PointRange float32
24238
24239                                 // Set index in Palette with "palette_index" item meta field,
24240                                 // this overrides Color.
24241                                 Palette Texture
24242                                 Color   color.NRGBA
24243
24244                                 // Texture overlays.
24245                                 InvOverlay, WieldOverlay Texture
24246
24247                                 ShortDesc string
24248                         }))(obj)).PlaceFailSnd).Serialize(w)
24249                 }); err != nil {
24250                         if err == io.EOF {
24251                                 chk(io.EOF)
24252                         }
24253                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
24254                 }
24255                 {
24256                         x := (*(*(struct {
24257                                 Type ItemType
24258
24259                                 Name, Desc string
24260
24261                                 InvImg, WieldImg Texture
24262                                 WieldScale       [3]float32
24263
24264                                 StackMax uint16
24265
24266                                 Usable          bool
24267                                 CanPointLiquids bool
24268
24269                                 ToolCaps ToolCaps
24270
24271                                 Groups []Group
24272
24273                                 PlacePredict string
24274
24275                                 PlaceSnd, PlaceFailSnd SoundDef
24276
24277                                 PointRange float32
24278
24279                                 // Set index in Palette with "palette_index" item meta field,
24280                                 // this overrides Color.
24281                                 Palette Texture
24282                                 Color   color.NRGBA
24283
24284                                 // Texture overlays.
24285                                 InvOverlay, WieldOverlay Texture
24286
24287                                 ShortDesc string
24288                         }))(obj)).PointRange
24289                         write32(w, math.Float32bits(x))
24290                 }
24291                 if err := pcall(func() {
24292                         ((*(*(struct {
24293                                 Type ItemType
24294
24295                                 Name, Desc string
24296
24297                                 InvImg, WieldImg Texture
24298                                 WieldScale       [3]float32
24299
24300                                 StackMax uint16
24301
24302                                 Usable          bool
24303                                 CanPointLiquids bool
24304
24305                                 ToolCaps ToolCaps
24306
24307                                 Groups []Group
24308
24309                                 PlacePredict string
24310
24311                                 PlaceSnd, PlaceFailSnd SoundDef
24312
24313                                 PointRange float32
24314
24315                                 // Set index in Palette with "palette_index" item meta field,
24316                                 // this overrides Color.
24317                                 Palette Texture
24318                                 Color   color.NRGBA
24319
24320                                 // Texture overlays.
24321                                 InvOverlay, WieldOverlay Texture
24322
24323                                 ShortDesc string
24324                         }))(obj)).Palette).Serialize(w)
24325                 }); err != nil {
24326                         if err == io.EOF {
24327                                 chk(io.EOF)
24328                         }
24329                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24330                 }
24331                 {
24332                         x := (*(*(struct {
24333                                 Type ItemType
24334
24335                                 Name, Desc string
24336
24337                                 InvImg, WieldImg Texture
24338                                 WieldScale       [3]float32
24339
24340                                 StackMax uint16
24341
24342                                 Usable          bool
24343                                 CanPointLiquids bool
24344
24345                                 ToolCaps ToolCaps
24346
24347                                 Groups []Group
24348
24349                                 PlacePredict string
24350
24351                                 PlaceSnd, PlaceFailSnd SoundDef
24352
24353                                 PointRange float32
24354
24355                                 // Set index in Palette with "palette_index" item meta field,
24356                                 // this overrides Color.
24357                                 Palette Texture
24358                                 Color   color.NRGBA
24359
24360                                 // Texture overlays.
24361                                 InvOverlay, WieldOverlay Texture
24362
24363                                 ShortDesc string
24364                         }))(obj)).Color
24365                         w.Write([]byte{x.A, x.R, x.G, x.B})
24366                 }
24367                 if err := pcall(func() {
24368                         ((*(*(struct {
24369                                 Type ItemType
24370
24371                                 Name, Desc string
24372
24373                                 InvImg, WieldImg Texture
24374                                 WieldScale       [3]float32
24375
24376                                 StackMax uint16
24377
24378                                 Usable          bool
24379                                 CanPointLiquids bool
24380
24381                                 ToolCaps ToolCaps
24382
24383                                 Groups []Group
24384
24385                                 PlacePredict string
24386
24387                                 PlaceSnd, PlaceFailSnd SoundDef
24388
24389                                 PointRange float32
24390
24391                                 // Set index in Palette with "palette_index" item meta field,
24392                                 // this overrides Color.
24393                                 Palette Texture
24394                                 Color   color.NRGBA
24395
24396                                 // Texture overlays.
24397                                 InvOverlay, WieldOverlay Texture
24398
24399                                 ShortDesc string
24400                         }))(obj)).InvOverlay).Serialize(w)
24401                 }); err != nil {
24402                         if err == io.EOF {
24403                                 chk(io.EOF)
24404                         }
24405                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24406                 }
24407                 if err := pcall(func() {
24408                         ((*(*(struct {
24409                                 Type ItemType
24410
24411                                 Name, Desc string
24412
24413                                 InvImg, WieldImg Texture
24414                                 WieldScale       [3]float32
24415
24416                                 StackMax uint16
24417
24418                                 Usable          bool
24419                                 CanPointLiquids bool
24420
24421                                 ToolCaps ToolCaps
24422
24423                                 Groups []Group
24424
24425                                 PlacePredict string
24426
24427                                 PlaceSnd, PlaceFailSnd SoundDef
24428
24429                                 PointRange float32
24430
24431                                 // Set index in Palette with "palette_index" item meta field,
24432                                 // this overrides Color.
24433                                 Palette Texture
24434                                 Color   color.NRGBA
24435
24436                                 // Texture overlays.
24437                                 InvOverlay, WieldOverlay Texture
24438
24439                                 ShortDesc string
24440                         }))(obj)).WieldOverlay).Serialize(w)
24441                 }); err != nil {
24442                         if err == io.EOF {
24443                                 chk(io.EOF)
24444                         }
24445                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24446                 }
24447                 if len(([]byte((*(*(struct {
24448                         Type ItemType
24449
24450                         Name, Desc string
24451
24452                         InvImg, WieldImg Texture
24453                         WieldScale       [3]float32
24454
24455                         StackMax uint16
24456
24457                         Usable          bool
24458                         CanPointLiquids bool
24459
24460                         ToolCaps ToolCaps
24461
24462                         Groups []Group
24463
24464                         PlacePredict string
24465
24466                         PlaceSnd, PlaceFailSnd SoundDef
24467
24468                         PointRange float32
24469
24470                         // Set index in Palette with "palette_index" item meta field,
24471                         // this overrides Color.
24472                         Palette Texture
24473                         Color   color.NRGBA
24474
24475                         // Texture overlays.
24476                         InvOverlay, WieldOverlay Texture
24477
24478                         ShortDesc string
24479                 }))(obj)).ShortDesc))) > math.MaxUint16 {
24480                         chk(ErrTooLong)
24481                 }
24482                 {
24483                         x := uint16(len(([]byte((*(*(struct {
24484                                 Type ItemType
24485
24486                                 Name, Desc string
24487
24488                                 InvImg, WieldImg Texture
24489                                 WieldScale       [3]float32
24490
24491                                 StackMax uint16
24492
24493                                 Usable          bool
24494                                 CanPointLiquids bool
24495
24496                                 ToolCaps ToolCaps
24497
24498                                 Groups []Group
24499
24500                                 PlacePredict string
24501
24502                                 PlaceSnd, PlaceFailSnd SoundDef
24503
24504                                 PointRange float32
24505
24506                                 // Set index in Palette with "palette_index" item meta field,
24507                                 // this overrides Color.
24508                                 Palette Texture
24509                                 Color   color.NRGBA
24510
24511                                 // Texture overlays.
24512                                 InvOverlay, WieldOverlay Texture
24513
24514                                 ShortDesc string
24515                         }))(obj)).ShortDesc))))
24516                         write16(w, uint16(x))
24517                 }
24518                 {
24519                         _, err := w.Write(([]byte((*(*(struct {
24520                                 Type ItemType
24521
24522                                 Name, Desc string
24523
24524                                 InvImg, WieldImg Texture
24525                                 WieldScale       [3]float32
24526
24527                                 StackMax uint16
24528
24529                                 Usable          bool
24530                                 CanPointLiquids bool
24531
24532                                 ToolCaps ToolCaps
24533
24534                                 Groups []Group
24535
24536                                 PlacePredict string
24537
24538                                 PlaceSnd, PlaceFailSnd SoundDef
24539
24540                                 PointRange float32
24541
24542                                 // Set index in Palette with "palette_index" item meta field,
24543                                 // this overrides Color.
24544                                 Palette Texture
24545                                 Color   color.NRGBA
24546
24547                                 // Texture overlays.
24548                                 InvOverlay, WieldOverlay Texture
24549
24550                                 ShortDesc string
24551                         }))(obj)).ShortDesc))[:])
24552                         chk(err)
24553                 }
24554                 {
24555                         buf := w
24556                         w := ow
24557                         if len((buf.Bytes())) > math.MaxUint16 {
24558                                 chk(ErrTooLong)
24559                         }
24560                         {
24561                                 x := uint16(len((buf.Bytes())))
24562                                 write16(w, uint16(x))
24563                         }
24564                         {
24565                                 _, err := w.Write((buf.Bytes())[:])
24566                                 chk(err)
24567                         }
24568                 }
24569         }
24570 }
24571
24572 func (obj *ItemDef) Deserialize(r io.Reader) {
24573         {
24574                 var n uint16
24575                 {
24576                         p := &n
24577                         *p = read16(r)
24578                 }
24579                 r := &io.LimitedReader{R: r, N: int64(n)}
24580                 {
24581                         var local302 uint8
24582                         local303 := uint8(6)
24583                         {
24584                                 p := &local302
24585                                 *p = read8(r)
24586                         }
24587                         if local302 != local303 {
24588                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local302))
24589                         }
24590                 }
24591                 if err := pcall(func() {
24592                         ((*(*(struct {
24593                                 Type ItemType
24594
24595                                 Name, Desc string
24596
24597                                 InvImg, WieldImg Texture
24598                                 WieldScale       [3]float32
24599
24600                                 StackMax uint16
24601
24602                                 Usable          bool
24603                                 CanPointLiquids bool
24604
24605                                 ToolCaps ToolCaps
24606
24607                                 Groups []Group
24608
24609                                 PlacePredict string
24610
24611                                 PlaceSnd, PlaceFailSnd SoundDef
24612
24613                                 PointRange float32
24614
24615                                 // Set index in Palette with "palette_index" item meta field,
24616                                 // this overrides Color.
24617                                 Palette Texture
24618                                 Color   color.NRGBA
24619
24620                                 // Texture overlays.
24621                                 InvOverlay, WieldOverlay Texture
24622
24623                                 ShortDesc string
24624                         }))(obj)).Type).Deserialize(r)
24625                 }); err != nil {
24626                         if err == io.EOF {
24627                                 chk(io.EOF)
24628                         }
24629                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
24630                 }
24631                 var local304 []uint8
24632                 var local305 uint16
24633                 {
24634                         p := &local305
24635                         *p = read16(r)
24636                 }
24637                 (local304) = make([]uint8, local305)
24638                 {
24639                         _, err := io.ReadFull(r, (local304)[:])
24640                         chk(err)
24641                 }
24642                 ((*(*(struct {
24643                         Type ItemType
24644
24645                         Name, Desc string
24646
24647                         InvImg, WieldImg Texture
24648                         WieldScale       [3]float32
24649
24650                         StackMax uint16
24651
24652                         Usable          bool
24653                         CanPointLiquids bool
24654
24655                         ToolCaps ToolCaps
24656
24657                         Groups []Group
24658
24659                         PlacePredict string
24660
24661                         PlaceSnd, PlaceFailSnd SoundDef
24662
24663                         PointRange float32
24664
24665                         // Set index in Palette with "palette_index" item meta field,
24666                         // this overrides Color.
24667                         Palette Texture
24668                         Color   color.NRGBA
24669
24670                         // Texture overlays.
24671                         InvOverlay, WieldOverlay Texture
24672
24673                         ShortDesc string
24674                 }))(obj)).Name) = string(local304)
24675                 var local306 []uint8
24676                 var local307 uint16
24677                 {
24678                         p := &local307
24679                         *p = read16(r)
24680                 }
24681                 (local306) = make([]uint8, local307)
24682                 {
24683                         _, err := io.ReadFull(r, (local306)[:])
24684                         chk(err)
24685                 }
24686                 ((*(*(struct {
24687                         Type ItemType
24688
24689                         Name, Desc string
24690
24691                         InvImg, WieldImg Texture
24692                         WieldScale       [3]float32
24693
24694                         StackMax uint16
24695
24696                         Usable          bool
24697                         CanPointLiquids bool
24698
24699                         ToolCaps ToolCaps
24700
24701                         Groups []Group
24702
24703                         PlacePredict string
24704
24705                         PlaceSnd, PlaceFailSnd SoundDef
24706
24707                         PointRange float32
24708
24709                         // Set index in Palette with "palette_index" item meta field,
24710                         // this overrides Color.
24711                         Palette Texture
24712                         Color   color.NRGBA
24713
24714                         // Texture overlays.
24715                         InvOverlay, WieldOverlay Texture
24716
24717                         ShortDesc string
24718                 }))(obj)).Desc) = string(local306)
24719                 if err := pcall(func() {
24720                         ((*(*(struct {
24721                                 Type ItemType
24722
24723                                 Name, Desc string
24724
24725                                 InvImg, WieldImg Texture
24726                                 WieldScale       [3]float32
24727
24728                                 StackMax uint16
24729
24730                                 Usable          bool
24731                                 CanPointLiquids bool
24732
24733                                 ToolCaps ToolCaps
24734
24735                                 Groups []Group
24736
24737                                 PlacePredict string
24738
24739                                 PlaceSnd, PlaceFailSnd SoundDef
24740
24741                                 PointRange float32
24742
24743                                 // Set index in Palette with "palette_index" item meta field,
24744                                 // this overrides Color.
24745                                 Palette Texture
24746                                 Color   color.NRGBA
24747
24748                                 // Texture overlays.
24749                                 InvOverlay, WieldOverlay Texture
24750
24751                                 ShortDesc string
24752                         }))(obj)).InvImg).Deserialize(r)
24753                 }); err != nil {
24754                         if err == io.EOF {
24755                                 chk(io.EOF)
24756                         }
24757                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24758                 }
24759                 if err := pcall(func() {
24760                         ((*(*(struct {
24761                                 Type ItemType
24762
24763                                 Name, Desc string
24764
24765                                 InvImg, WieldImg Texture
24766                                 WieldScale       [3]float32
24767
24768                                 StackMax uint16
24769
24770                                 Usable          bool
24771                                 CanPointLiquids bool
24772
24773                                 ToolCaps ToolCaps
24774
24775                                 Groups []Group
24776
24777                                 PlacePredict string
24778
24779                                 PlaceSnd, PlaceFailSnd SoundDef
24780
24781                                 PointRange float32
24782
24783                                 // Set index in Palette with "palette_index" item meta field,
24784                                 // this overrides Color.
24785                                 Palette Texture
24786                                 Color   color.NRGBA
24787
24788                                 // Texture overlays.
24789                                 InvOverlay, WieldOverlay Texture
24790
24791                                 ShortDesc string
24792                         }))(obj)).WieldImg).Deserialize(r)
24793                 }); err != nil {
24794                         if err == io.EOF {
24795                                 chk(io.EOF)
24796                         }
24797                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24798                 }
24799                 for local308 := range (*(*(struct {
24800                         Type ItemType
24801
24802                         Name, Desc string
24803
24804                         InvImg, WieldImg Texture
24805                         WieldScale       [3]float32
24806
24807                         StackMax uint16
24808
24809                         Usable          bool
24810                         CanPointLiquids bool
24811
24812                         ToolCaps ToolCaps
24813
24814                         Groups []Group
24815
24816                         PlacePredict string
24817
24818                         PlaceSnd, PlaceFailSnd SoundDef
24819
24820                         PointRange float32
24821
24822                         // Set index in Palette with "palette_index" item meta field,
24823                         // this overrides Color.
24824                         Palette Texture
24825                         Color   color.NRGBA
24826
24827                         // Texture overlays.
24828                         InvOverlay, WieldOverlay Texture
24829
24830                         ShortDesc string
24831                 }))(obj)).WieldScale {
24832                         {
24833                                 p := &((*(*(struct {
24834                                         Type ItemType
24835
24836                                         Name, Desc string
24837
24838                                         InvImg, WieldImg Texture
24839                                         WieldScale       [3]float32
24840
24841                                         StackMax uint16
24842
24843                                         Usable          bool
24844                                         CanPointLiquids bool
24845
24846                                         ToolCaps ToolCaps
24847
24848                                         Groups []Group
24849
24850                                         PlacePredict string
24851
24852                                         PlaceSnd, PlaceFailSnd SoundDef
24853
24854                                         PointRange float32
24855
24856                                         // Set index in Palette with "palette_index" item meta field,
24857                                         // this overrides Color.
24858                                         Palette Texture
24859                                         Color   color.NRGBA
24860
24861                                         // Texture overlays.
24862                                         InvOverlay, WieldOverlay Texture
24863
24864                                         ShortDesc string
24865                                 }))(obj)).WieldScale)[local308]
24866                                 *p = math.Float32frombits(read32(r))
24867                         }
24868                 }
24869                 {
24870                         p := &(*(*(struct {
24871                                 Type ItemType
24872
24873                                 Name, Desc string
24874
24875                                 InvImg, WieldImg Texture
24876                                 WieldScale       [3]float32
24877
24878                                 StackMax uint16
24879
24880                                 Usable          bool
24881                                 CanPointLiquids bool
24882
24883                                 ToolCaps ToolCaps
24884
24885                                 Groups []Group
24886
24887                                 PlacePredict string
24888
24889                                 PlaceSnd, PlaceFailSnd SoundDef
24890
24891                                 PointRange float32
24892
24893                                 // Set index in Palette with "palette_index" item meta field,
24894                                 // this overrides Color.
24895                                 Palette Texture
24896                                 Color   color.NRGBA
24897
24898                                 // Texture overlays.
24899                                 InvOverlay, WieldOverlay Texture
24900
24901                                 ShortDesc string
24902                         }))(obj)).StackMax
24903                         *p = read16(r)
24904                 }
24905                 {
24906                         p := &(*(*(struct {
24907                                 Type ItemType
24908
24909                                 Name, Desc string
24910
24911                                 InvImg, WieldImg Texture
24912                                 WieldScale       [3]float32
24913
24914                                 StackMax uint16
24915
24916                                 Usable          bool
24917                                 CanPointLiquids bool
24918
24919                                 ToolCaps ToolCaps
24920
24921                                 Groups []Group
24922
24923                                 PlacePredict string
24924
24925                                 PlaceSnd, PlaceFailSnd SoundDef
24926
24927                                 PointRange float32
24928
24929                                 // Set index in Palette with "palette_index" item meta field,
24930                                 // this overrides Color.
24931                                 Palette Texture
24932                                 Color   color.NRGBA
24933
24934                                 // Texture overlays.
24935                                 InvOverlay, WieldOverlay Texture
24936
24937                                 ShortDesc string
24938                         }))(obj)).Usable
24939                         switch n := read8(r); n {
24940                         case 0:
24941                                 *p = false
24942                         case 1:
24943                                 *p = true
24944                         default:
24945                                 chk(fmt.Errorf("invalid bool: %d", n))
24946                         }
24947                 }
24948                 {
24949                         p := &(*(*(struct {
24950                                 Type ItemType
24951
24952                                 Name, Desc string
24953
24954                                 InvImg, WieldImg Texture
24955                                 WieldScale       [3]float32
24956
24957                                 StackMax uint16
24958
24959                                 Usable          bool
24960                                 CanPointLiquids bool
24961
24962                                 ToolCaps ToolCaps
24963
24964                                 Groups []Group
24965
24966                                 PlacePredict string
24967
24968                                 PlaceSnd, PlaceFailSnd SoundDef
24969
24970                                 PointRange float32
24971
24972                                 // Set index in Palette with "palette_index" item meta field,
24973                                 // this overrides Color.
24974                                 Palette Texture
24975                                 Color   color.NRGBA
24976
24977                                 // Texture overlays.
24978                                 InvOverlay, WieldOverlay Texture
24979
24980                                 ShortDesc string
24981                         }))(obj)).CanPointLiquids
24982                         switch n := read8(r); n {
24983                         case 0:
24984                                 *p = false
24985                         case 1:
24986                                 *p = true
24987                         default:
24988                                 chk(fmt.Errorf("invalid bool: %d", n))
24989                         }
24990                 }
24991                 if err := pcall(func() {
24992                         ((*(*(struct {
24993                                 Type ItemType
24994
24995                                 Name, Desc string
24996
24997                                 InvImg, WieldImg Texture
24998                                 WieldScale       [3]float32
24999
25000                                 StackMax uint16
25001
25002                                 Usable          bool
25003                                 CanPointLiquids bool
25004
25005                                 ToolCaps ToolCaps
25006
25007                                 Groups []Group
25008
25009                                 PlacePredict string
25010
25011                                 PlaceSnd, PlaceFailSnd SoundDef
25012
25013                                 PointRange float32
25014
25015                                 // Set index in Palette with "palette_index" item meta field,
25016                                 // this overrides Color.
25017                                 Palette Texture
25018                                 Color   color.NRGBA
25019
25020                                 // Texture overlays.
25021                                 InvOverlay, WieldOverlay Texture
25022
25023                                 ShortDesc string
25024                         }))(obj)).ToolCaps).Deserialize(r)
25025                 }); err != nil {
25026                         if err == io.EOF {
25027                                 chk(io.EOF)
25028                         }
25029                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
25030                 }
25031                 var local309 uint16
25032                 {
25033                         p := &local309
25034                         *p = read16(r)
25035                 }
25036                 ((*(*(struct {
25037                         Type ItemType
25038
25039                         Name, Desc string
25040
25041                         InvImg, WieldImg Texture
25042                         WieldScale       [3]float32
25043
25044                         StackMax uint16
25045
25046                         Usable          bool
25047                         CanPointLiquids bool
25048
25049                         ToolCaps ToolCaps
25050
25051                         Groups []Group
25052
25053                         PlacePredict string
25054
25055                         PlaceSnd, PlaceFailSnd SoundDef
25056
25057                         PointRange float32
25058
25059                         // Set index in Palette with "palette_index" item meta field,
25060                         // this overrides Color.
25061                         Palette Texture
25062                         Color   color.NRGBA
25063
25064                         // Texture overlays.
25065                         InvOverlay, WieldOverlay Texture
25066
25067                         ShortDesc string
25068                 }))(obj)).Groups) = make([]Group, local309)
25069                 for local310 := range (*(*(struct {
25070                         Type ItemType
25071
25072                         Name, Desc string
25073
25074                         InvImg, WieldImg Texture
25075                         WieldScale       [3]float32
25076
25077                         StackMax uint16
25078
25079                         Usable          bool
25080                         CanPointLiquids bool
25081
25082                         ToolCaps ToolCaps
25083
25084                         Groups []Group
25085
25086                         PlacePredict string
25087
25088                         PlaceSnd, PlaceFailSnd SoundDef
25089
25090                         PointRange float32
25091
25092                         // Set index in Palette with "palette_index" item meta field,
25093                         // this overrides Color.
25094                         Palette Texture
25095                         Color   color.NRGBA
25096
25097                         // Texture overlays.
25098                         InvOverlay, WieldOverlay Texture
25099
25100                         ShortDesc string
25101                 }))(obj)).Groups {
25102                         if err := pcall(func() {
25103                                 (((*(*(struct {
25104                                         Type ItemType
25105
25106                                         Name, Desc string
25107
25108                                         InvImg, WieldImg Texture
25109                                         WieldScale       [3]float32
25110
25111                                         StackMax uint16
25112
25113                                         Usable          bool
25114                                         CanPointLiquids bool
25115
25116                                         ToolCaps ToolCaps
25117
25118                                         Groups []Group
25119
25120                                         PlacePredict string
25121
25122                                         PlaceSnd, PlaceFailSnd SoundDef
25123
25124                                         PointRange float32
25125
25126                                         // Set index in Palette with "palette_index" item meta field,
25127                                         // this overrides Color.
25128                                         Palette Texture
25129                                         Color   color.NRGBA
25130
25131                                         // Texture overlays.
25132                                         InvOverlay, WieldOverlay Texture
25133
25134                                         ShortDesc string
25135                                 }))(obj)).Groups)[local310]).Deserialize(r)
25136                         }); err != nil {
25137                                 if err == io.EOF {
25138                                         chk(io.EOF)
25139                                 }
25140                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
25141                         }
25142                 }
25143                 var local311 []uint8
25144                 var local312 uint16
25145                 {
25146                         p := &local312
25147                         *p = read16(r)
25148                 }
25149                 (local311) = make([]uint8, local312)
25150                 {
25151                         _, err := io.ReadFull(r, (local311)[:])
25152                         chk(err)
25153                 }
25154                 ((*(*(struct {
25155                         Type ItemType
25156
25157                         Name, Desc string
25158
25159                         InvImg, WieldImg Texture
25160                         WieldScale       [3]float32
25161
25162                         StackMax uint16
25163
25164                         Usable          bool
25165                         CanPointLiquids bool
25166
25167                         ToolCaps ToolCaps
25168
25169                         Groups []Group
25170
25171                         PlacePredict string
25172
25173                         PlaceSnd, PlaceFailSnd SoundDef
25174
25175                         PointRange float32
25176
25177                         // Set index in Palette with "palette_index" item meta field,
25178                         // this overrides Color.
25179                         Palette Texture
25180                         Color   color.NRGBA
25181
25182                         // Texture overlays.
25183                         InvOverlay, WieldOverlay Texture
25184
25185                         ShortDesc string
25186                 }))(obj)).PlacePredict) = string(local311)
25187                 if err := pcall(func() {
25188                         ((*(*(struct {
25189                                 Type ItemType
25190
25191                                 Name, Desc string
25192
25193                                 InvImg, WieldImg Texture
25194                                 WieldScale       [3]float32
25195
25196                                 StackMax uint16
25197
25198                                 Usable          bool
25199                                 CanPointLiquids bool
25200
25201                                 ToolCaps ToolCaps
25202
25203                                 Groups []Group
25204
25205                                 PlacePredict string
25206
25207                                 PlaceSnd, PlaceFailSnd SoundDef
25208
25209                                 PointRange float32
25210
25211                                 // Set index in Palette with "palette_index" item meta field,
25212                                 // this overrides Color.
25213                                 Palette Texture
25214                                 Color   color.NRGBA
25215
25216                                 // Texture overlays.
25217                                 InvOverlay, WieldOverlay Texture
25218
25219                                 ShortDesc string
25220                         }))(obj)).PlaceSnd).Deserialize(r)
25221                 }); err != nil {
25222                         if err == io.EOF {
25223                                 chk(io.EOF)
25224                         }
25225                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25226                 }
25227                 if err := pcall(func() {
25228                         ((*(*(struct {
25229                                 Type ItemType
25230
25231                                 Name, Desc string
25232
25233                                 InvImg, WieldImg Texture
25234                                 WieldScale       [3]float32
25235
25236                                 StackMax uint16
25237
25238                                 Usable          bool
25239                                 CanPointLiquids bool
25240
25241                                 ToolCaps ToolCaps
25242
25243                                 Groups []Group
25244
25245                                 PlacePredict string
25246
25247                                 PlaceSnd, PlaceFailSnd SoundDef
25248
25249                                 PointRange float32
25250
25251                                 // Set index in Palette with "palette_index" item meta field,
25252                                 // this overrides Color.
25253                                 Palette Texture
25254                                 Color   color.NRGBA
25255
25256                                 // Texture overlays.
25257                                 InvOverlay, WieldOverlay Texture
25258
25259                                 ShortDesc string
25260                         }))(obj)).PlaceFailSnd).Deserialize(r)
25261                 }); err != nil {
25262                         if err == io.EOF {
25263                                 chk(io.EOF)
25264                         }
25265                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25266                 }
25267                 {
25268                         p := &(*(*(struct {
25269                                 Type ItemType
25270
25271                                 Name, Desc string
25272
25273                                 InvImg, WieldImg Texture
25274                                 WieldScale       [3]float32
25275
25276                                 StackMax uint16
25277
25278                                 Usable          bool
25279                                 CanPointLiquids bool
25280
25281                                 ToolCaps ToolCaps
25282
25283                                 Groups []Group
25284
25285                                 PlacePredict string
25286
25287                                 PlaceSnd, PlaceFailSnd SoundDef
25288
25289                                 PointRange float32
25290
25291                                 // Set index in Palette with "palette_index" item meta field,
25292                                 // this overrides Color.
25293                                 Palette Texture
25294                                 Color   color.NRGBA
25295
25296                                 // Texture overlays.
25297                                 InvOverlay, WieldOverlay Texture
25298
25299                                 ShortDesc string
25300                         }))(obj)).PointRange
25301                         *p = math.Float32frombits(read32(r))
25302                 }
25303                 if err := pcall(func() {
25304                         ((*(*(struct {
25305                                 Type ItemType
25306
25307                                 Name, Desc string
25308
25309                                 InvImg, WieldImg Texture
25310                                 WieldScale       [3]float32
25311
25312                                 StackMax uint16
25313
25314                                 Usable          bool
25315                                 CanPointLiquids bool
25316
25317                                 ToolCaps ToolCaps
25318
25319                                 Groups []Group
25320
25321                                 PlacePredict string
25322
25323                                 PlaceSnd, PlaceFailSnd SoundDef
25324
25325                                 PointRange float32
25326
25327                                 // Set index in Palette with "palette_index" item meta field,
25328                                 // this overrides Color.
25329                                 Palette Texture
25330                                 Color   color.NRGBA
25331
25332                                 // Texture overlays.
25333                                 InvOverlay, WieldOverlay Texture
25334
25335                                 ShortDesc string
25336                         }))(obj)).Palette).Deserialize(r)
25337                 }); err != nil {
25338                         if err == io.EOF {
25339                                 chk(io.EOF)
25340                         }
25341                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25342                 }
25343                 {
25344                         p := &(*(*(struct {
25345                                 Type ItemType
25346
25347                                 Name, Desc string
25348
25349                                 InvImg, WieldImg Texture
25350                                 WieldScale       [3]float32
25351
25352                                 StackMax uint16
25353
25354                                 Usable          bool
25355                                 CanPointLiquids bool
25356
25357                                 ToolCaps ToolCaps
25358
25359                                 Groups []Group
25360
25361                                 PlacePredict string
25362
25363                                 PlaceSnd, PlaceFailSnd SoundDef
25364
25365                                 PointRange float32
25366
25367                                 // Set index in Palette with "palette_index" item meta field,
25368                                 // this overrides Color.
25369                                 Palette Texture
25370                                 Color   color.NRGBA
25371
25372                                 // Texture overlays.
25373                                 InvOverlay, WieldOverlay Texture
25374
25375                                 ShortDesc string
25376                         }))(obj)).Color
25377                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
25378                 }
25379                 if err := pcall(func() {
25380                         ((*(*(struct {
25381                                 Type ItemType
25382
25383                                 Name, Desc string
25384
25385                                 InvImg, WieldImg Texture
25386                                 WieldScale       [3]float32
25387
25388                                 StackMax uint16
25389
25390                                 Usable          bool
25391                                 CanPointLiquids bool
25392
25393                                 ToolCaps ToolCaps
25394
25395                                 Groups []Group
25396
25397                                 PlacePredict string
25398
25399                                 PlaceSnd, PlaceFailSnd SoundDef
25400
25401                                 PointRange float32
25402
25403                                 // Set index in Palette with "palette_index" item meta field,
25404                                 // this overrides Color.
25405                                 Palette Texture
25406                                 Color   color.NRGBA
25407
25408                                 // Texture overlays.
25409                                 InvOverlay, WieldOverlay Texture
25410
25411                                 ShortDesc string
25412                         }))(obj)).InvOverlay).Deserialize(r)
25413                 }); err != nil {
25414                         if err == io.EOF {
25415                                 chk(io.EOF)
25416                         }
25417                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25418                 }
25419                 if err := pcall(func() {
25420                         ((*(*(struct {
25421                                 Type ItemType
25422
25423                                 Name, Desc string
25424
25425                                 InvImg, WieldImg Texture
25426                                 WieldScale       [3]float32
25427
25428                                 StackMax uint16
25429
25430                                 Usable          bool
25431                                 CanPointLiquids bool
25432
25433                                 ToolCaps ToolCaps
25434
25435                                 Groups []Group
25436
25437                                 PlacePredict string
25438
25439                                 PlaceSnd, PlaceFailSnd SoundDef
25440
25441                                 PointRange float32
25442
25443                                 // Set index in Palette with "palette_index" item meta field,
25444                                 // this overrides Color.
25445                                 Palette Texture
25446                                 Color   color.NRGBA
25447
25448                                 // Texture overlays.
25449                                 InvOverlay, WieldOverlay Texture
25450
25451                                 ShortDesc string
25452                         }))(obj)).WieldOverlay).Deserialize(r)
25453                 }); err != nil {
25454                         if err == io.EOF {
25455                                 chk(io.EOF)
25456                         }
25457                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25458                 }
25459                 var local313 []uint8
25460                 var local314 uint16
25461                 {
25462                         p := &local314
25463                         *p = read16(r)
25464                 }
25465                 (local313) = make([]uint8, local314)
25466                 {
25467                         _, err := io.ReadFull(r, (local313)[:])
25468                         chk(err)
25469                 }
25470                 ((*(*(struct {
25471                         Type ItemType
25472
25473                         Name, Desc string
25474
25475                         InvImg, WieldImg Texture
25476                         WieldScale       [3]float32
25477
25478                         StackMax uint16
25479
25480                         Usable          bool
25481                         CanPointLiquids bool
25482
25483                         ToolCaps ToolCaps
25484
25485                         Groups []Group
25486
25487                         PlacePredict string
25488
25489                         PlaceSnd, PlaceFailSnd SoundDef
25490
25491                         PointRange float32
25492
25493                         // Set index in Palette with "palette_index" item meta field,
25494                         // this overrides Color.
25495                         Palette Texture
25496                         Color   color.NRGBA
25497
25498                         // Texture overlays.
25499                         InvOverlay, WieldOverlay Texture
25500
25501                         ShortDesc string
25502                 }))(obj)).ShortDesc) = string(local313)
25503                 if r.N > 0 {
25504                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
25505                 }
25506         }
25507 }
25508
25509 func (obj *SoundSrcType) Serialize(w io.Writer) {
25510         {
25511                 x := *(*(uint8))(obj)
25512                 write8(w, uint8(x))
25513         }
25514 }
25515
25516 func (obj *SoundSrcType) Deserialize(r io.Reader) {
25517         {
25518                 p := &*(*(uint8))(obj)
25519                 *p = read8(r)
25520         }
25521 }
25522
25523 func (obj *TileAnim) Serialize(w io.Writer) {
25524         if err := pcall(func() {
25525                 ((*(*(struct {
25526                         Type AnimType
25527
25528                         //mt:if %s.Type == SpriteSheetAnim
25529                         AspectRatio [2]uint8
25530
25531                         //mt:if %s.Type == VerticalFrameAnim
25532                         NFrames [2]uint16
25533
25534                         //mt:if %s.Type != NoAnim
25535                         Duration float32 // in seconds
25536
25537                 }))(obj)).Type).Serialize(w)
25538         }); err != nil {
25539                 if err == io.EOF {
25540                         chk(io.EOF)
25541                 }
25542                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
25543         }
25544         if !((*(*(struct {
25545                 Type AnimType
25546
25547                 //mt:if %s.Type == SpriteSheetAnim
25548                 AspectRatio [2]uint8
25549
25550                 //mt:if %s.Type == VerticalFrameAnim
25551                 NFrames [2]uint16
25552
25553                 //mt:if %s.Type != NoAnim
25554                 Duration float32 // in seconds
25555
25556         }))(obj)).Type < maxAnim) {
25557                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25558         }
25559         if (*(*(struct {
25560                 Type AnimType
25561
25562                 //mt:if %s.Type == SpriteSheetAnim
25563                 AspectRatio [2]uint8
25564
25565                 //mt:if %s.Type == VerticalFrameAnim
25566                 NFrames [2]uint16
25567
25568                 //mt:if %s.Type != NoAnim
25569                 Duration float32 // in seconds
25570
25571         }))(obj)).Type == SpriteSheetAnim {
25572                 {
25573                         _, err := w.Write(((*(*(struct {
25574                                 Type AnimType
25575
25576                                 //mt:if %s.Type == SpriteSheetAnim
25577                                 AspectRatio [2]uint8
25578
25579                                 //mt:if %s.Type == VerticalFrameAnim
25580                                 NFrames [2]uint16
25581
25582                                 //mt:if %s.Type != NoAnim
25583                                 Duration float32 // in seconds
25584
25585                         }))(obj)).AspectRatio)[:])
25586                         chk(err)
25587                 }
25588         }
25589         if (*(*(struct {
25590                 Type AnimType
25591
25592                 //mt:if %s.Type == SpriteSheetAnim
25593                 AspectRatio [2]uint8
25594
25595                 //mt:if %s.Type == VerticalFrameAnim
25596                 NFrames [2]uint16
25597
25598                 //mt:if %s.Type != NoAnim
25599                 Duration float32 // in seconds
25600
25601         }))(obj)).Type == VerticalFrameAnim {
25602                 for local315 := range (*(*(struct {
25603                         Type AnimType
25604
25605                         //mt:if %s.Type == SpriteSheetAnim
25606                         AspectRatio [2]uint8
25607
25608                         //mt:if %s.Type == VerticalFrameAnim
25609                         NFrames [2]uint16
25610
25611                         //mt:if %s.Type != NoAnim
25612                         Duration float32 // in seconds
25613
25614                 }))(obj)).NFrames {
25615                         {
25616                                 x := ((*(*(struct {
25617                                         Type AnimType
25618
25619                                         //mt:if %s.Type == SpriteSheetAnim
25620                                         AspectRatio [2]uint8
25621
25622                                         //mt:if %s.Type == VerticalFrameAnim
25623                                         NFrames [2]uint16
25624
25625                                         //mt:if %s.Type != NoAnim
25626                                         Duration float32 // in seconds
25627
25628                                 }))(obj)).NFrames)[local315]
25629                                 write16(w, uint16(x))
25630                         }
25631                 }
25632         }
25633         if (*(*(struct {
25634                 Type AnimType
25635
25636                 //mt:if %s.Type == SpriteSheetAnim
25637                 AspectRatio [2]uint8
25638
25639                 //mt:if %s.Type == VerticalFrameAnim
25640                 NFrames [2]uint16
25641
25642                 //mt:if %s.Type != NoAnim
25643                 Duration float32 // in seconds
25644
25645         }))(obj)).Type != NoAnim {
25646                 {
25647                         x := (*(*(struct {
25648                                 Type AnimType
25649
25650                                 //mt:if %s.Type == SpriteSheetAnim
25651                                 AspectRatio [2]uint8
25652
25653                                 //mt:if %s.Type == VerticalFrameAnim
25654                                 NFrames [2]uint16
25655
25656                                 //mt:if %s.Type != NoAnim
25657                                 Duration float32 // in seconds
25658
25659                         }))(obj)).Duration
25660                         write32(w, math.Float32bits(x))
25661                 }
25662         }
25663 }
25664
25665 func (obj *TileAnim) Deserialize(r io.Reader) {
25666         if err := pcall(func() {
25667                 ((*(*(struct {
25668                         Type AnimType
25669
25670                         //mt:if %s.Type == SpriteSheetAnim
25671                         AspectRatio [2]uint8
25672
25673                         //mt:if %s.Type == VerticalFrameAnim
25674                         NFrames [2]uint16
25675
25676                         //mt:if %s.Type != NoAnim
25677                         Duration float32 // in seconds
25678
25679                 }))(obj)).Type).Deserialize(r)
25680         }); err != nil {
25681                 if err == io.EOF {
25682                         chk(io.EOF)
25683                 }
25684                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
25685         }
25686         if !((*(*(struct {
25687                 Type AnimType
25688
25689                 //mt:if %s.Type == SpriteSheetAnim
25690                 AspectRatio [2]uint8
25691
25692                 //mt:if %s.Type == VerticalFrameAnim
25693                 NFrames [2]uint16
25694
25695                 //mt:if %s.Type != NoAnim
25696                 Duration float32 // in seconds
25697
25698         }))(obj)).Type < maxAnim) {
25699                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25700         }
25701         if (*(*(struct {
25702                 Type AnimType
25703
25704                 //mt:if %s.Type == SpriteSheetAnim
25705                 AspectRatio [2]uint8
25706
25707                 //mt:if %s.Type == VerticalFrameAnim
25708                 NFrames [2]uint16
25709
25710                 //mt:if %s.Type != NoAnim
25711                 Duration float32 // in seconds
25712
25713         }))(obj)).Type == SpriteSheetAnim {
25714                 {
25715                         _, err := io.ReadFull(r, ((*(*(struct {
25716                                 Type AnimType
25717
25718                                 //mt:if %s.Type == SpriteSheetAnim
25719                                 AspectRatio [2]uint8
25720
25721                                 //mt:if %s.Type == VerticalFrameAnim
25722                                 NFrames [2]uint16
25723
25724                                 //mt:if %s.Type != NoAnim
25725                                 Duration float32 // in seconds
25726
25727                         }))(obj)).AspectRatio)[:])
25728                         chk(err)
25729                 }
25730         }
25731         if (*(*(struct {
25732                 Type AnimType
25733
25734                 //mt:if %s.Type == SpriteSheetAnim
25735                 AspectRatio [2]uint8
25736
25737                 //mt:if %s.Type == VerticalFrameAnim
25738                 NFrames [2]uint16
25739
25740                 //mt:if %s.Type != NoAnim
25741                 Duration float32 // in seconds
25742
25743         }))(obj)).Type == VerticalFrameAnim {
25744                 for local316 := range (*(*(struct {
25745                         Type AnimType
25746
25747                         //mt:if %s.Type == SpriteSheetAnim
25748                         AspectRatio [2]uint8
25749
25750                         //mt:if %s.Type == VerticalFrameAnim
25751                         NFrames [2]uint16
25752
25753                         //mt:if %s.Type != NoAnim
25754                         Duration float32 // in seconds
25755
25756                 }))(obj)).NFrames {
25757                         {
25758                                 p := &((*(*(struct {
25759                                         Type AnimType
25760
25761                                         //mt:if %s.Type == SpriteSheetAnim
25762                                         AspectRatio [2]uint8
25763
25764                                         //mt:if %s.Type == VerticalFrameAnim
25765                                         NFrames [2]uint16
25766
25767                                         //mt:if %s.Type != NoAnim
25768                                         Duration float32 // in seconds
25769
25770                                 }))(obj)).NFrames)[local316]
25771                                 *p = read16(r)
25772                         }
25773                 }
25774         }
25775         if (*(*(struct {
25776                 Type AnimType
25777
25778                 //mt:if %s.Type == SpriteSheetAnim
25779                 AspectRatio [2]uint8
25780
25781                 //mt:if %s.Type == VerticalFrameAnim
25782                 NFrames [2]uint16
25783
25784                 //mt:if %s.Type != NoAnim
25785                 Duration float32 // in seconds
25786
25787         }))(obj)).Type != NoAnim {
25788                 {
25789                         p := &(*(*(struct {
25790                                 Type AnimType
25791
25792                                 //mt:if %s.Type == SpriteSheetAnim
25793                                 AspectRatio [2]uint8
25794
25795                                 //mt:if %s.Type == VerticalFrameAnim
25796                                 NFrames [2]uint16
25797
25798                                 //mt:if %s.Type != NoAnim
25799                                 Duration float32 // in seconds
25800
25801                         }))(obj)).Duration
25802                         *p = math.Float32frombits(read32(r))
25803                 }
25804         }
25805 }
25806
25807 func (obj *Content) Serialize(w io.Writer) {
25808         {
25809                 x := *(*(uint16))(obj)
25810                 write16(w, uint16(x))
25811         }
25812 }
25813
25814 func (obj *Content) Deserialize(r io.Reader) {
25815         {
25816                 p := &*(*(uint16))(obj)
25817                 *p = read16(r)
25818         }
25819 }
25820
25821 func (obj *ParticleSpawnerID) Serialize(w io.Writer) {
25822         {
25823                 x := *(*(uint32))(obj)
25824                 write32(w, uint32(x))
25825         }
25826 }
25827
25828 func (obj *ParticleSpawnerID) Deserialize(r io.Reader) {
25829         {
25830                 p := &*(*(uint32))(obj)
25831                 *p = read32(r)
25832         }
25833 }
25834
25835 func (obj *HUDID) Serialize(w io.Writer) {
25836         {
25837                 x := *(*(uint32))(obj)
25838                 write32(w, uint32(x))
25839         }
25840 }
25841
25842 func (obj *HUDID) Deserialize(r io.Reader) {
25843         {
25844                 p := &*(*(uint32))(obj)
25845                 *p = read32(r)
25846         }
25847 }
25848
25849 func (obj *HUD) Serialize(w io.Writer) {
25850         if err := pcall(func() {
25851                 ((*(*(struct {
25852                         Type HUDType
25853
25854                         Pos      [2]float32
25855                         Name     string
25856                         Scale    [2]float32
25857                         Text     string
25858                         Number   uint32
25859                         Item     uint32
25860                         Dir      uint32
25861                         Align    [2]float32
25862                         Offset   [2]float32
25863                         WorldPos Pos
25864                         Size     [2]int32
25865                         ZIndex   int16
25866                         Text2    string
25867                 }))(obj)).Type).Serialize(w)
25868         }); err != nil {
25869                 if err == io.EOF {
25870                         chk(io.EOF)
25871                 }
25872                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
25873         }
25874         for local317 := range (*(*(struct {
25875                 Type HUDType
25876
25877                 Pos      [2]float32
25878                 Name     string
25879                 Scale    [2]float32
25880                 Text     string
25881                 Number   uint32
25882                 Item     uint32
25883                 Dir      uint32
25884                 Align    [2]float32
25885                 Offset   [2]float32
25886                 WorldPos Pos
25887                 Size     [2]int32
25888                 ZIndex   int16
25889                 Text2    string
25890         }))(obj)).Pos {
25891                 {
25892                         x := ((*(*(struct {
25893                                 Type HUDType
25894
25895                                 Pos      [2]float32
25896                                 Name     string
25897                                 Scale    [2]float32
25898                                 Text     string
25899                                 Number   uint32
25900                                 Item     uint32
25901                                 Dir      uint32
25902                                 Align    [2]float32
25903                                 Offset   [2]float32
25904                                 WorldPos Pos
25905                                 Size     [2]int32
25906                                 ZIndex   int16
25907                                 Text2    string
25908                         }))(obj)).Pos)[local317]
25909                         write32(w, math.Float32bits(x))
25910                 }
25911         }
25912         if len(([]byte((*(*(struct {
25913                 Type HUDType
25914
25915                 Pos      [2]float32
25916                 Name     string
25917                 Scale    [2]float32
25918                 Text     string
25919                 Number   uint32
25920                 Item     uint32
25921                 Dir      uint32
25922                 Align    [2]float32
25923                 Offset   [2]float32
25924                 WorldPos Pos
25925                 Size     [2]int32
25926                 ZIndex   int16
25927                 Text2    string
25928         }))(obj)).Name))) > math.MaxUint16 {
25929                 chk(ErrTooLong)
25930         }
25931         {
25932                 x := uint16(len(([]byte((*(*(struct {
25933                         Type HUDType
25934
25935                         Pos      [2]float32
25936                         Name     string
25937                         Scale    [2]float32
25938                         Text     string
25939                         Number   uint32
25940                         Item     uint32
25941                         Dir      uint32
25942                         Align    [2]float32
25943                         Offset   [2]float32
25944                         WorldPos Pos
25945                         Size     [2]int32
25946                         ZIndex   int16
25947                         Text2    string
25948                 }))(obj)).Name))))
25949                 write16(w, uint16(x))
25950         }
25951         {
25952                 _, err := w.Write(([]byte((*(*(struct {
25953                         Type HUDType
25954
25955                         Pos      [2]float32
25956                         Name     string
25957                         Scale    [2]float32
25958                         Text     string
25959                         Number   uint32
25960                         Item     uint32
25961                         Dir      uint32
25962                         Align    [2]float32
25963                         Offset   [2]float32
25964                         WorldPos Pos
25965                         Size     [2]int32
25966                         ZIndex   int16
25967                         Text2    string
25968                 }))(obj)).Name))[:])
25969                 chk(err)
25970         }
25971         for local318 := range (*(*(struct {
25972                 Type HUDType
25973
25974                 Pos      [2]float32
25975                 Name     string
25976                 Scale    [2]float32
25977                 Text     string
25978                 Number   uint32
25979                 Item     uint32
25980                 Dir      uint32
25981                 Align    [2]float32
25982                 Offset   [2]float32
25983                 WorldPos Pos
25984                 Size     [2]int32
25985                 ZIndex   int16
25986                 Text2    string
25987         }))(obj)).Scale {
25988                 {
25989                         x := ((*(*(struct {
25990                                 Type HUDType
25991
25992                                 Pos      [2]float32
25993                                 Name     string
25994                                 Scale    [2]float32
25995                                 Text     string
25996                                 Number   uint32
25997                                 Item     uint32
25998                                 Dir      uint32
25999                                 Align    [2]float32
26000                                 Offset   [2]float32
26001                                 WorldPos Pos
26002                                 Size     [2]int32
26003                                 ZIndex   int16
26004                                 Text2    string
26005                         }))(obj)).Scale)[local318]
26006                         write32(w, math.Float32bits(x))
26007                 }
26008         }
26009         if len(([]byte((*(*(struct {
26010                 Type HUDType
26011
26012                 Pos      [2]float32
26013                 Name     string
26014                 Scale    [2]float32
26015                 Text     string
26016                 Number   uint32
26017                 Item     uint32
26018                 Dir      uint32
26019                 Align    [2]float32
26020                 Offset   [2]float32
26021                 WorldPos Pos
26022                 Size     [2]int32
26023                 ZIndex   int16
26024                 Text2    string
26025         }))(obj)).Text))) > math.MaxUint16 {
26026                 chk(ErrTooLong)
26027         }
26028         {
26029                 x := uint16(len(([]byte((*(*(struct {
26030                         Type HUDType
26031
26032                         Pos      [2]float32
26033                         Name     string
26034                         Scale    [2]float32
26035                         Text     string
26036                         Number   uint32
26037                         Item     uint32
26038                         Dir      uint32
26039                         Align    [2]float32
26040                         Offset   [2]float32
26041                         WorldPos Pos
26042                         Size     [2]int32
26043                         ZIndex   int16
26044                         Text2    string
26045                 }))(obj)).Text))))
26046                 write16(w, uint16(x))
26047         }
26048         {
26049                 _, err := w.Write(([]byte((*(*(struct {
26050                         Type HUDType
26051
26052                         Pos      [2]float32
26053                         Name     string
26054                         Scale    [2]float32
26055                         Text     string
26056                         Number   uint32
26057                         Item     uint32
26058                         Dir      uint32
26059                         Align    [2]float32
26060                         Offset   [2]float32
26061                         WorldPos Pos
26062                         Size     [2]int32
26063                         ZIndex   int16
26064                         Text2    string
26065                 }))(obj)).Text))[:])
26066                 chk(err)
26067         }
26068         {
26069                 x := (*(*(struct {
26070                         Type HUDType
26071
26072                         Pos      [2]float32
26073                         Name     string
26074                         Scale    [2]float32
26075                         Text     string
26076                         Number   uint32
26077                         Item     uint32
26078                         Dir      uint32
26079                         Align    [2]float32
26080                         Offset   [2]float32
26081                         WorldPos Pos
26082                         Size     [2]int32
26083                         ZIndex   int16
26084                         Text2    string
26085                 }))(obj)).Number
26086                 write32(w, uint32(x))
26087         }
26088         {
26089                 x := (*(*(struct {
26090                         Type HUDType
26091
26092                         Pos      [2]float32
26093                         Name     string
26094                         Scale    [2]float32
26095                         Text     string
26096                         Number   uint32
26097                         Item     uint32
26098                         Dir      uint32
26099                         Align    [2]float32
26100                         Offset   [2]float32
26101                         WorldPos Pos
26102                         Size     [2]int32
26103                         ZIndex   int16
26104                         Text2    string
26105                 }))(obj)).Item
26106                 write32(w, uint32(x))
26107         }
26108         {
26109                 x := (*(*(struct {
26110                         Type HUDType
26111
26112                         Pos      [2]float32
26113                         Name     string
26114                         Scale    [2]float32
26115                         Text     string
26116                         Number   uint32
26117                         Item     uint32
26118                         Dir      uint32
26119                         Align    [2]float32
26120                         Offset   [2]float32
26121                         WorldPos Pos
26122                         Size     [2]int32
26123                         ZIndex   int16
26124                         Text2    string
26125                 }))(obj)).Dir
26126                 write32(w, uint32(x))
26127         }
26128         for local319 := range (*(*(struct {
26129                 Type HUDType
26130
26131                 Pos      [2]float32
26132                 Name     string
26133                 Scale    [2]float32
26134                 Text     string
26135                 Number   uint32
26136                 Item     uint32
26137                 Dir      uint32
26138                 Align    [2]float32
26139                 Offset   [2]float32
26140                 WorldPos Pos
26141                 Size     [2]int32
26142                 ZIndex   int16
26143                 Text2    string
26144         }))(obj)).Align {
26145                 {
26146                         x := ((*(*(struct {
26147                                 Type HUDType
26148
26149                                 Pos      [2]float32
26150                                 Name     string
26151                                 Scale    [2]float32
26152                                 Text     string
26153                                 Number   uint32
26154                                 Item     uint32
26155                                 Dir      uint32
26156                                 Align    [2]float32
26157                                 Offset   [2]float32
26158                                 WorldPos Pos
26159                                 Size     [2]int32
26160                                 ZIndex   int16
26161                                 Text2    string
26162                         }))(obj)).Align)[local319]
26163                         write32(w, math.Float32bits(x))
26164                 }
26165         }
26166         for local320 := range (*(*(struct {
26167                 Type HUDType
26168
26169                 Pos      [2]float32
26170                 Name     string
26171                 Scale    [2]float32
26172                 Text     string
26173                 Number   uint32
26174                 Item     uint32
26175                 Dir      uint32
26176                 Align    [2]float32
26177                 Offset   [2]float32
26178                 WorldPos Pos
26179                 Size     [2]int32
26180                 ZIndex   int16
26181                 Text2    string
26182         }))(obj)).Offset {
26183                 {
26184                         x := ((*(*(struct {
26185                                 Type HUDType
26186
26187                                 Pos      [2]float32
26188                                 Name     string
26189                                 Scale    [2]float32
26190                                 Text     string
26191                                 Number   uint32
26192                                 Item     uint32
26193                                 Dir      uint32
26194                                 Align    [2]float32
26195                                 Offset   [2]float32
26196                                 WorldPos Pos
26197                                 Size     [2]int32
26198                                 ZIndex   int16
26199                                 Text2    string
26200                         }))(obj)).Offset)[local320]
26201                         write32(w, math.Float32bits(x))
26202                 }
26203         }
26204         if err := pcall(func() {
26205                 ((*(*(struct {
26206                         Type HUDType
26207
26208                         Pos      [2]float32
26209                         Name     string
26210                         Scale    [2]float32
26211                         Text     string
26212                         Number   uint32
26213                         Item     uint32
26214                         Dir      uint32
26215                         Align    [2]float32
26216                         Offset   [2]float32
26217                         WorldPos Pos
26218                         Size     [2]int32
26219                         ZIndex   int16
26220                         Text2    string
26221                 }))(obj)).WorldPos).Serialize(w)
26222         }); err != nil {
26223                 if err == io.EOF {
26224                         chk(io.EOF)
26225                 }
26226                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
26227         }
26228         for local321 := range (*(*(struct {
26229                 Type HUDType
26230
26231                 Pos      [2]float32
26232                 Name     string
26233                 Scale    [2]float32
26234                 Text     string
26235                 Number   uint32
26236                 Item     uint32
26237                 Dir      uint32
26238                 Align    [2]float32
26239                 Offset   [2]float32
26240                 WorldPos Pos
26241                 Size     [2]int32
26242                 ZIndex   int16
26243                 Text2    string
26244         }))(obj)).Size {
26245                 {
26246                         x := ((*(*(struct {
26247                                 Type HUDType
26248
26249                                 Pos      [2]float32
26250                                 Name     string
26251                                 Scale    [2]float32
26252                                 Text     string
26253                                 Number   uint32
26254                                 Item     uint32
26255                                 Dir      uint32
26256                                 Align    [2]float32
26257                                 Offset   [2]float32
26258                                 WorldPos Pos
26259                                 Size     [2]int32
26260                                 ZIndex   int16
26261                                 Text2    string
26262                         }))(obj)).Size)[local321]
26263                         write32(w, uint32(x))
26264                 }
26265         }
26266         {
26267                 x := (*(*(struct {
26268                         Type HUDType
26269
26270                         Pos      [2]float32
26271                         Name     string
26272                         Scale    [2]float32
26273                         Text     string
26274                         Number   uint32
26275                         Item     uint32
26276                         Dir      uint32
26277                         Align    [2]float32
26278                         Offset   [2]float32
26279                         WorldPos Pos
26280                         Size     [2]int32
26281                         ZIndex   int16
26282                         Text2    string
26283                 }))(obj)).ZIndex
26284                 write16(w, uint16(x))
26285         }
26286         if len(([]byte((*(*(struct {
26287                 Type HUDType
26288
26289                 Pos      [2]float32
26290                 Name     string
26291                 Scale    [2]float32
26292                 Text     string
26293                 Number   uint32
26294                 Item     uint32
26295                 Dir      uint32
26296                 Align    [2]float32
26297                 Offset   [2]float32
26298                 WorldPos Pos
26299                 Size     [2]int32
26300                 ZIndex   int16
26301                 Text2    string
26302         }))(obj)).Text2))) > math.MaxUint16 {
26303                 chk(ErrTooLong)
26304         }
26305         {
26306                 x := uint16(len(([]byte((*(*(struct {
26307                         Type HUDType
26308
26309                         Pos      [2]float32
26310                         Name     string
26311                         Scale    [2]float32
26312                         Text     string
26313                         Number   uint32
26314                         Item     uint32
26315                         Dir      uint32
26316                         Align    [2]float32
26317                         Offset   [2]float32
26318                         WorldPos Pos
26319                         Size     [2]int32
26320                         ZIndex   int16
26321                         Text2    string
26322                 }))(obj)).Text2))))
26323                 write16(w, uint16(x))
26324         }
26325         {
26326                 _, err := w.Write(([]byte((*(*(struct {
26327                         Type HUDType
26328
26329                         Pos      [2]float32
26330                         Name     string
26331                         Scale    [2]float32
26332                         Text     string
26333                         Number   uint32
26334                         Item     uint32
26335                         Dir      uint32
26336                         Align    [2]float32
26337                         Offset   [2]float32
26338                         WorldPos Pos
26339                         Size     [2]int32
26340                         ZIndex   int16
26341                         Text2    string
26342                 }))(obj)).Text2))[:])
26343                 chk(err)
26344         }
26345 }
26346
26347 func (obj *HUD) Deserialize(r io.Reader) {
26348         if err := pcall(func() {
26349                 ((*(*(struct {
26350                         Type HUDType
26351
26352                         Pos      [2]float32
26353                         Name     string
26354                         Scale    [2]float32
26355                         Text     string
26356                         Number   uint32
26357                         Item     uint32
26358                         Dir      uint32
26359                         Align    [2]float32
26360                         Offset   [2]float32
26361                         WorldPos Pos
26362                         Size     [2]int32
26363                         ZIndex   int16
26364                         Text2    string
26365                 }))(obj)).Type).Deserialize(r)
26366         }); err != nil {
26367                 if err == io.EOF {
26368                         chk(io.EOF)
26369                 }
26370                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
26371         }
26372         for local322 := range (*(*(struct {
26373                 Type HUDType
26374
26375                 Pos      [2]float32
26376                 Name     string
26377                 Scale    [2]float32
26378                 Text     string
26379                 Number   uint32
26380                 Item     uint32
26381                 Dir      uint32
26382                 Align    [2]float32
26383                 Offset   [2]float32
26384                 WorldPos Pos
26385                 Size     [2]int32
26386                 ZIndex   int16
26387                 Text2    string
26388         }))(obj)).Pos {
26389                 {
26390                         p := &((*(*(struct {
26391                                 Type HUDType
26392
26393                                 Pos      [2]float32
26394                                 Name     string
26395                                 Scale    [2]float32
26396                                 Text     string
26397                                 Number   uint32
26398                                 Item     uint32
26399                                 Dir      uint32
26400                                 Align    [2]float32
26401                                 Offset   [2]float32
26402                                 WorldPos Pos
26403                                 Size     [2]int32
26404                                 ZIndex   int16
26405                                 Text2    string
26406                         }))(obj)).Pos)[local322]
26407                         *p = math.Float32frombits(read32(r))
26408                 }
26409         }
26410         var local323 []uint8
26411         var local324 uint16
26412         {
26413                 p := &local324
26414                 *p = read16(r)
26415         }
26416         (local323) = make([]uint8, local324)
26417         {
26418                 _, err := io.ReadFull(r, (local323)[:])
26419                 chk(err)
26420         }
26421         ((*(*(struct {
26422                 Type HUDType
26423
26424                 Pos      [2]float32
26425                 Name     string
26426                 Scale    [2]float32
26427                 Text     string
26428                 Number   uint32
26429                 Item     uint32
26430                 Dir      uint32
26431                 Align    [2]float32
26432                 Offset   [2]float32
26433                 WorldPos Pos
26434                 Size     [2]int32
26435                 ZIndex   int16
26436                 Text2    string
26437         }))(obj)).Name) = string(local323)
26438         for local325 := range (*(*(struct {
26439                 Type HUDType
26440
26441                 Pos      [2]float32
26442                 Name     string
26443                 Scale    [2]float32
26444                 Text     string
26445                 Number   uint32
26446                 Item     uint32
26447                 Dir      uint32
26448                 Align    [2]float32
26449                 Offset   [2]float32
26450                 WorldPos Pos
26451                 Size     [2]int32
26452                 ZIndex   int16
26453                 Text2    string
26454         }))(obj)).Scale {
26455                 {
26456                         p := &((*(*(struct {
26457                                 Type HUDType
26458
26459                                 Pos      [2]float32
26460                                 Name     string
26461                                 Scale    [2]float32
26462                                 Text     string
26463                                 Number   uint32
26464                                 Item     uint32
26465                                 Dir      uint32
26466                                 Align    [2]float32
26467                                 Offset   [2]float32
26468                                 WorldPos Pos
26469                                 Size     [2]int32
26470                                 ZIndex   int16
26471                                 Text2    string
26472                         }))(obj)).Scale)[local325]
26473                         *p = math.Float32frombits(read32(r))
26474                 }
26475         }
26476         var local326 []uint8
26477         var local327 uint16
26478         {
26479                 p := &local327
26480                 *p = read16(r)
26481         }
26482         (local326) = make([]uint8, local327)
26483         {
26484                 _, err := io.ReadFull(r, (local326)[:])
26485                 chk(err)
26486         }
26487         ((*(*(struct {
26488                 Type HUDType
26489
26490                 Pos      [2]float32
26491                 Name     string
26492                 Scale    [2]float32
26493                 Text     string
26494                 Number   uint32
26495                 Item     uint32
26496                 Dir      uint32
26497                 Align    [2]float32
26498                 Offset   [2]float32
26499                 WorldPos Pos
26500                 Size     [2]int32
26501                 ZIndex   int16
26502                 Text2    string
26503         }))(obj)).Text) = string(local326)
26504         {
26505                 p := &(*(*(struct {
26506                         Type HUDType
26507
26508                         Pos      [2]float32
26509                         Name     string
26510                         Scale    [2]float32
26511                         Text     string
26512                         Number   uint32
26513                         Item     uint32
26514                         Dir      uint32
26515                         Align    [2]float32
26516                         Offset   [2]float32
26517                         WorldPos Pos
26518                         Size     [2]int32
26519                         ZIndex   int16
26520                         Text2    string
26521                 }))(obj)).Number
26522                 *p = read32(r)
26523         }
26524         {
26525                 p := &(*(*(struct {
26526                         Type HUDType
26527
26528                         Pos      [2]float32
26529                         Name     string
26530                         Scale    [2]float32
26531                         Text     string
26532                         Number   uint32
26533                         Item     uint32
26534                         Dir      uint32
26535                         Align    [2]float32
26536                         Offset   [2]float32
26537                         WorldPos Pos
26538                         Size     [2]int32
26539                         ZIndex   int16
26540                         Text2    string
26541                 }))(obj)).Item
26542                 *p = read32(r)
26543         }
26544         {
26545                 p := &(*(*(struct {
26546                         Type HUDType
26547
26548                         Pos      [2]float32
26549                         Name     string
26550                         Scale    [2]float32
26551                         Text     string
26552                         Number   uint32
26553                         Item     uint32
26554                         Dir      uint32
26555                         Align    [2]float32
26556                         Offset   [2]float32
26557                         WorldPos Pos
26558                         Size     [2]int32
26559                         ZIndex   int16
26560                         Text2    string
26561                 }))(obj)).Dir
26562                 *p = read32(r)
26563         }
26564         for local328 := range (*(*(struct {
26565                 Type HUDType
26566
26567                 Pos      [2]float32
26568                 Name     string
26569                 Scale    [2]float32
26570                 Text     string
26571                 Number   uint32
26572                 Item     uint32
26573                 Dir      uint32
26574                 Align    [2]float32
26575                 Offset   [2]float32
26576                 WorldPos Pos
26577                 Size     [2]int32
26578                 ZIndex   int16
26579                 Text2    string
26580         }))(obj)).Align {
26581                 {
26582                         p := &((*(*(struct {
26583                                 Type HUDType
26584
26585                                 Pos      [2]float32
26586                                 Name     string
26587                                 Scale    [2]float32
26588                                 Text     string
26589                                 Number   uint32
26590                                 Item     uint32
26591                                 Dir      uint32
26592                                 Align    [2]float32
26593                                 Offset   [2]float32
26594                                 WorldPos Pos
26595                                 Size     [2]int32
26596                                 ZIndex   int16
26597                                 Text2    string
26598                         }))(obj)).Align)[local328]
26599                         *p = math.Float32frombits(read32(r))
26600                 }
26601         }
26602         for local329 := range (*(*(struct {
26603                 Type HUDType
26604
26605                 Pos      [2]float32
26606                 Name     string
26607                 Scale    [2]float32
26608                 Text     string
26609                 Number   uint32
26610                 Item     uint32
26611                 Dir      uint32
26612                 Align    [2]float32
26613                 Offset   [2]float32
26614                 WorldPos Pos
26615                 Size     [2]int32
26616                 ZIndex   int16
26617                 Text2    string
26618         }))(obj)).Offset {
26619                 {
26620                         p := &((*(*(struct {
26621                                 Type HUDType
26622
26623                                 Pos      [2]float32
26624                                 Name     string
26625                                 Scale    [2]float32
26626                                 Text     string
26627                                 Number   uint32
26628                                 Item     uint32
26629                                 Dir      uint32
26630                                 Align    [2]float32
26631                                 Offset   [2]float32
26632                                 WorldPos Pos
26633                                 Size     [2]int32
26634                                 ZIndex   int16
26635                                 Text2    string
26636                         }))(obj)).Offset)[local329]
26637                         *p = math.Float32frombits(read32(r))
26638                 }
26639         }
26640         if err := pcall(func() {
26641                 ((*(*(struct {
26642                         Type HUDType
26643
26644                         Pos      [2]float32
26645                         Name     string
26646                         Scale    [2]float32
26647                         Text     string
26648                         Number   uint32
26649                         Item     uint32
26650                         Dir      uint32
26651                         Align    [2]float32
26652                         Offset   [2]float32
26653                         WorldPos Pos
26654                         Size     [2]int32
26655                         ZIndex   int16
26656                         Text2    string
26657                 }))(obj)).WorldPos).Deserialize(r)
26658         }); err != nil {
26659                 if err == io.EOF {
26660                         chk(io.EOF)
26661                 }
26662                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
26663         }
26664         for local330 := range (*(*(struct {
26665                 Type HUDType
26666
26667                 Pos      [2]float32
26668                 Name     string
26669                 Scale    [2]float32
26670                 Text     string
26671                 Number   uint32
26672                 Item     uint32
26673                 Dir      uint32
26674                 Align    [2]float32
26675                 Offset   [2]float32
26676                 WorldPos Pos
26677                 Size     [2]int32
26678                 ZIndex   int16
26679                 Text2    string
26680         }))(obj)).Size {
26681                 {
26682                         p := &((*(*(struct {
26683                                 Type HUDType
26684
26685                                 Pos      [2]float32
26686                                 Name     string
26687                                 Scale    [2]float32
26688                                 Text     string
26689                                 Number   uint32
26690                                 Item     uint32
26691                                 Dir      uint32
26692                                 Align    [2]float32
26693                                 Offset   [2]float32
26694                                 WorldPos Pos
26695                                 Size     [2]int32
26696                                 ZIndex   int16
26697                                 Text2    string
26698                         }))(obj)).Size)[local330]
26699                         *p = int32(read32(r))
26700                 }
26701         }
26702         {
26703                 p := &(*(*(struct {
26704                         Type HUDType
26705
26706                         Pos      [2]float32
26707                         Name     string
26708                         Scale    [2]float32
26709                         Text     string
26710                         Number   uint32
26711                         Item     uint32
26712                         Dir      uint32
26713                         Align    [2]float32
26714                         Offset   [2]float32
26715                         WorldPos Pos
26716                         Size     [2]int32
26717                         ZIndex   int16
26718                         Text2    string
26719                 }))(obj)).ZIndex
26720                 *p = int16(read16(r))
26721         }
26722         var local331 []uint8
26723         var local332 uint16
26724         {
26725                 p := &local332
26726                 *p = read16(r)
26727         }
26728         (local331) = make([]uint8, local332)
26729         {
26730                 _, err := io.ReadFull(r, (local331)[:])
26731                 chk(err)
26732         }
26733         ((*(*(struct {
26734                 Type HUDType
26735
26736                 Pos      [2]float32
26737                 Name     string
26738                 Scale    [2]float32
26739                 Text     string
26740                 Number   uint32
26741                 Item     uint32
26742                 Dir      uint32
26743                 Align    [2]float32
26744                 Offset   [2]float32
26745                 WorldPos Pos
26746                 Size     [2]int32
26747                 ZIndex   int16
26748                 Text2    string
26749         }))(obj)).Text2) = string(local331)
26750 }
26751
26752 func (obj *HUDField) Serialize(w io.Writer) {
26753         {
26754                 x := *(*(uint8))(obj)
26755                 write8(w, uint8(x))
26756         }
26757 }
26758
26759 func (obj *HUDField) Deserialize(r io.Reader) {
26760         {
26761                 p := &*(*(uint8))(obj)
26762                 *p = read8(r)
26763         }
26764 }
26765
26766 func (obj *HUDFlags) Serialize(w io.Writer) {
26767         {
26768                 x := *(*(uint32))(obj)
26769                 write32(w, uint32(x))
26770         }
26771 }
26772
26773 func (obj *HUDFlags) Deserialize(r io.Reader) {
26774         {
26775                 p := &*(*(uint32))(obj)
26776                 *p = read32(r)
26777         }
26778 }
26779
26780 func (obj *HotbarParam) Serialize(w io.Writer) {
26781         {
26782                 x := *(*(uint16))(obj)
26783                 write16(w, uint16(x))
26784         }
26785 }
26786
26787 func (obj *HotbarParam) Deserialize(r io.Reader) {
26788         {
26789                 p := &*(*(uint16))(obj)
26790                 *p = read16(r)
26791         }
26792 }
26793
26794 func (obj *Texture) Serialize(w io.Writer) {
26795         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
26796                 chk(ErrTooLong)
26797         }
26798         {
26799                 x := uint16(len(([]byte(*(*(string))(obj)))))
26800                 write16(w, uint16(x))
26801         }
26802         {
26803                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
26804                 chk(err)
26805         }
26806 }
26807
26808 func (obj *Texture) Deserialize(r io.Reader) {
26809         var local333 []uint8
26810         var local334 uint16
26811         {
26812                 p := &local334
26813                 *p = read16(r)
26814         }
26815         (local333) = make([]uint8, local334)
26816         {
26817                 _, err := io.ReadFull(r, (local333)[:])
26818                 chk(err)
26819         }
26820         (*(*(string))(obj)) = string(local333)
26821 }
26822
26823 func (obj *PlayerListUpdateType) Serialize(w io.Writer) {
26824         {
26825                 x := *(*(uint8))(obj)
26826                 write8(w, uint8(x))
26827         }
26828 }
26829
26830 func (obj *PlayerListUpdateType) Deserialize(r io.Reader) {
26831         {
26832                 p := &*(*(uint8))(obj)
26833                 *p = read8(r)
26834         }
26835 }
26836
26837 func (obj *ModChanSig) Serialize(w io.Writer) {
26838         {
26839                 x := *(*(uint8))(obj)
26840                 write8(w, uint8(x))
26841         }
26842 }
26843
26844 func (obj *ModChanSig) Deserialize(r io.Reader) {
26845         {
26846                 p := &*(*(uint8))(obj)
26847                 *p = read8(r)
26848         }
26849 }
26850
26851 func (obj *AOProps) Serialize(w io.Writer) {
26852         {
26853                 local335 := uint8(4)
26854                 {
26855                         x := local335
26856                         write8(w, uint8(x))
26857                 }
26858         }
26859         {
26860                 x := (*(*(struct {
26861                         MaxHP            uint16 // Player only.
26862                         CollideWithNodes bool
26863                         Weight           float32 // deprecated
26864                         ColBox, SelBox   Box
26865                         Pointable        bool
26866                         Visual           string
26867                         VisualSize       [3]float32
26868                         Textures         []Texture
26869                         SpriteSheetSize  [2]int16 // in sprites.
26870                         SpritePos        [2]int16 // in sprite sheet.
26871                         Visible          bool
26872                         MakeFootstepSnds bool
26873                         RotateSpeed      float32 // in radians per second.
26874                         Mesh             string
26875                         Colors           []color.NRGBA
26876                         CollideWithAOs   bool
26877                         StepHeight       float32
26878                         FaceRotateDir    bool
26879                         FaceRotateDirOff float32 // in degrees.
26880                         BackfaceCull     bool
26881                         Nametag          string
26882                         NametagColor     color.NRGBA
26883                         FaceRotateSpeed  float32 // in degrees per second.
26884                         Infotext         string
26885                         Itemstring       string
26886                         Glow             int8
26887                         MaxBreath        uint16  // Player only.
26888                         EyeHeight        float32 // Player only.
26889                         ZoomFOV          float32 // in degrees. Player only.
26890                         UseTextureAlpha  bool
26891                         DmgTextureMod    Texture // suffix
26892                         Shaded           bool
26893                         ShowOnMinimap    bool
26894                         NametagBG        color.NRGBA
26895                 }))(obj)).MaxHP
26896                 write16(w, uint16(x))
26897         }
26898         {
26899                 x := (*(*(struct {
26900                         MaxHP            uint16 // Player only.
26901                         CollideWithNodes bool
26902                         Weight           float32 // deprecated
26903                         ColBox, SelBox   Box
26904                         Pointable        bool
26905                         Visual           string
26906                         VisualSize       [3]float32
26907                         Textures         []Texture
26908                         SpriteSheetSize  [2]int16 // in sprites.
26909                         SpritePos        [2]int16 // in sprite sheet.
26910                         Visible          bool
26911                         MakeFootstepSnds bool
26912                         RotateSpeed      float32 // in radians per second.
26913                         Mesh             string
26914                         Colors           []color.NRGBA
26915                         CollideWithAOs   bool
26916                         StepHeight       float32
26917                         FaceRotateDir    bool
26918                         FaceRotateDirOff float32 // in degrees.
26919                         BackfaceCull     bool
26920                         Nametag          string
26921                         NametagColor     color.NRGBA
26922                         FaceRotateSpeed  float32 // in degrees per second.
26923                         Infotext         string
26924                         Itemstring       string
26925                         Glow             int8
26926                         MaxBreath        uint16  // Player only.
26927                         EyeHeight        float32 // Player only.
26928                         ZoomFOV          float32 // in degrees. Player only.
26929                         UseTextureAlpha  bool
26930                         DmgTextureMod    Texture // suffix
26931                         Shaded           bool
26932                         ShowOnMinimap    bool
26933                         NametagBG        color.NRGBA
26934                 }))(obj)).CollideWithNodes
26935                 if x {
26936                         write8(w, 1)
26937                 } else {
26938                         write8(w, 0)
26939                 }
26940         }
26941         {
26942                 x := (*(*(struct {
26943                         MaxHP            uint16 // Player only.
26944                         CollideWithNodes bool
26945                         Weight           float32 // deprecated
26946                         ColBox, SelBox   Box
26947                         Pointable        bool
26948                         Visual           string
26949                         VisualSize       [3]float32
26950                         Textures         []Texture
26951                         SpriteSheetSize  [2]int16 // in sprites.
26952                         SpritePos        [2]int16 // in sprite sheet.
26953                         Visible          bool
26954                         MakeFootstepSnds bool
26955                         RotateSpeed      float32 // in radians per second.
26956                         Mesh             string
26957                         Colors           []color.NRGBA
26958                         CollideWithAOs   bool
26959                         StepHeight       float32
26960                         FaceRotateDir    bool
26961                         FaceRotateDirOff float32 // in degrees.
26962                         BackfaceCull     bool
26963                         Nametag          string
26964                         NametagColor     color.NRGBA
26965                         FaceRotateSpeed  float32 // in degrees per second.
26966                         Infotext         string
26967                         Itemstring       string
26968                         Glow             int8
26969                         MaxBreath        uint16  // Player only.
26970                         EyeHeight        float32 // Player only.
26971                         ZoomFOV          float32 // in degrees. Player only.
26972                         UseTextureAlpha  bool
26973                         DmgTextureMod    Texture // suffix
26974                         Shaded           bool
26975                         ShowOnMinimap    bool
26976                         NametagBG        color.NRGBA
26977                 }))(obj)).Weight
26978                 write32(w, math.Float32bits(x))
26979         }
26980         if err := pcall(func() {
26981                 ((*(*(struct {
26982                         MaxHP            uint16 // Player only.
26983                         CollideWithNodes bool
26984                         Weight           float32 // deprecated
26985                         ColBox, SelBox   Box
26986                         Pointable        bool
26987                         Visual           string
26988                         VisualSize       [3]float32
26989                         Textures         []Texture
26990                         SpriteSheetSize  [2]int16 // in sprites.
26991                         SpritePos        [2]int16 // in sprite sheet.
26992                         Visible          bool
26993                         MakeFootstepSnds bool
26994                         RotateSpeed      float32 // in radians per second.
26995                         Mesh             string
26996                         Colors           []color.NRGBA
26997                         CollideWithAOs   bool
26998                         StepHeight       float32
26999                         FaceRotateDir    bool
27000                         FaceRotateDirOff float32 // in degrees.
27001                         BackfaceCull     bool
27002                         Nametag          string
27003                         NametagColor     color.NRGBA
27004                         FaceRotateSpeed  float32 // in degrees per second.
27005                         Infotext         string
27006                         Itemstring       string
27007                         Glow             int8
27008                         MaxBreath        uint16  // Player only.
27009                         EyeHeight        float32 // Player only.
27010                         ZoomFOV          float32 // in degrees. Player only.
27011                         UseTextureAlpha  bool
27012                         DmgTextureMod    Texture // suffix
27013                         Shaded           bool
27014                         ShowOnMinimap    bool
27015                         NametagBG        color.NRGBA
27016                 }))(obj)).ColBox).Serialize(w)
27017         }); err != nil {
27018                 if err == io.EOF {
27019                         chk(io.EOF)
27020                 }
27021                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27022         }
27023         if err := pcall(func() {
27024                 ((*(*(struct {
27025                         MaxHP            uint16 // Player only.
27026                         CollideWithNodes bool
27027                         Weight           float32 // deprecated
27028                         ColBox, SelBox   Box
27029                         Pointable        bool
27030                         Visual           string
27031                         VisualSize       [3]float32
27032                         Textures         []Texture
27033                         SpriteSheetSize  [2]int16 // in sprites.
27034                         SpritePos        [2]int16 // in sprite sheet.
27035                         Visible          bool
27036                         MakeFootstepSnds bool
27037                         RotateSpeed      float32 // in radians per second.
27038                         Mesh             string
27039                         Colors           []color.NRGBA
27040                         CollideWithAOs   bool
27041                         StepHeight       float32
27042                         FaceRotateDir    bool
27043                         FaceRotateDirOff float32 // in degrees.
27044                         BackfaceCull     bool
27045                         Nametag          string
27046                         NametagColor     color.NRGBA
27047                         FaceRotateSpeed  float32 // in degrees per second.
27048                         Infotext         string
27049                         Itemstring       string
27050                         Glow             int8
27051                         MaxBreath        uint16  // Player only.
27052                         EyeHeight        float32 // Player only.
27053                         ZoomFOV          float32 // in degrees. Player only.
27054                         UseTextureAlpha  bool
27055                         DmgTextureMod    Texture // suffix
27056                         Shaded           bool
27057                         ShowOnMinimap    bool
27058                         NametagBG        color.NRGBA
27059                 }))(obj)).SelBox).Serialize(w)
27060         }); err != nil {
27061                 if err == io.EOF {
27062                         chk(io.EOF)
27063                 }
27064                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27065         }
27066         {
27067                 x := (*(*(struct {
27068                         MaxHP            uint16 // Player only.
27069                         CollideWithNodes bool
27070                         Weight           float32 // deprecated
27071                         ColBox, SelBox   Box
27072                         Pointable        bool
27073                         Visual           string
27074                         VisualSize       [3]float32
27075                         Textures         []Texture
27076                         SpriteSheetSize  [2]int16 // in sprites.
27077                         SpritePos        [2]int16 // in sprite sheet.
27078                         Visible          bool
27079                         MakeFootstepSnds bool
27080                         RotateSpeed      float32 // in radians per second.
27081                         Mesh             string
27082                         Colors           []color.NRGBA
27083                         CollideWithAOs   bool
27084                         StepHeight       float32
27085                         FaceRotateDir    bool
27086                         FaceRotateDirOff float32 // in degrees.
27087                         BackfaceCull     bool
27088                         Nametag          string
27089                         NametagColor     color.NRGBA
27090                         FaceRotateSpeed  float32 // in degrees per second.
27091                         Infotext         string
27092                         Itemstring       string
27093                         Glow             int8
27094                         MaxBreath        uint16  // Player only.
27095                         EyeHeight        float32 // Player only.
27096                         ZoomFOV          float32 // in degrees. Player only.
27097                         UseTextureAlpha  bool
27098                         DmgTextureMod    Texture // suffix
27099                         Shaded           bool
27100                         ShowOnMinimap    bool
27101                         NametagBG        color.NRGBA
27102                 }))(obj)).Pointable
27103                 if x {
27104                         write8(w, 1)
27105                 } else {
27106                         write8(w, 0)
27107                 }
27108         }
27109         if len(([]byte((*(*(struct {
27110                 MaxHP            uint16 // Player only.
27111                 CollideWithNodes bool
27112                 Weight           float32 // deprecated
27113                 ColBox, SelBox   Box
27114                 Pointable        bool
27115                 Visual           string
27116                 VisualSize       [3]float32
27117                 Textures         []Texture
27118                 SpriteSheetSize  [2]int16 // in sprites.
27119                 SpritePos        [2]int16 // in sprite sheet.
27120                 Visible          bool
27121                 MakeFootstepSnds bool
27122                 RotateSpeed      float32 // in radians per second.
27123                 Mesh             string
27124                 Colors           []color.NRGBA
27125                 CollideWithAOs   bool
27126                 StepHeight       float32
27127                 FaceRotateDir    bool
27128                 FaceRotateDirOff float32 // in degrees.
27129                 BackfaceCull     bool
27130                 Nametag          string
27131                 NametagColor     color.NRGBA
27132                 FaceRotateSpeed  float32 // in degrees per second.
27133                 Infotext         string
27134                 Itemstring       string
27135                 Glow             int8
27136                 MaxBreath        uint16  // Player only.
27137                 EyeHeight        float32 // Player only.
27138                 ZoomFOV          float32 // in degrees. Player only.
27139                 UseTextureAlpha  bool
27140                 DmgTextureMod    Texture // suffix
27141                 Shaded           bool
27142                 ShowOnMinimap    bool
27143                 NametagBG        color.NRGBA
27144         }))(obj)).Visual))) > math.MaxUint16 {
27145                 chk(ErrTooLong)
27146         }
27147         {
27148                 x := uint16(len(([]byte((*(*(struct {
27149                         MaxHP            uint16 // Player only.
27150                         CollideWithNodes bool
27151                         Weight           float32 // deprecated
27152                         ColBox, SelBox   Box
27153                         Pointable        bool
27154                         Visual           string
27155                         VisualSize       [3]float32
27156                         Textures         []Texture
27157                         SpriteSheetSize  [2]int16 // in sprites.
27158                         SpritePos        [2]int16 // in sprite sheet.
27159                         Visible          bool
27160                         MakeFootstepSnds bool
27161                         RotateSpeed      float32 // in radians per second.
27162                         Mesh             string
27163                         Colors           []color.NRGBA
27164                         CollideWithAOs   bool
27165                         StepHeight       float32
27166                         FaceRotateDir    bool
27167                         FaceRotateDirOff float32 // in degrees.
27168                         BackfaceCull     bool
27169                         Nametag          string
27170                         NametagColor     color.NRGBA
27171                         FaceRotateSpeed  float32 // in degrees per second.
27172                         Infotext         string
27173                         Itemstring       string
27174                         Glow             int8
27175                         MaxBreath        uint16  // Player only.
27176                         EyeHeight        float32 // Player only.
27177                         ZoomFOV          float32 // in degrees. Player only.
27178                         UseTextureAlpha  bool
27179                         DmgTextureMod    Texture // suffix
27180                         Shaded           bool
27181                         ShowOnMinimap    bool
27182                         NametagBG        color.NRGBA
27183                 }))(obj)).Visual))))
27184                 write16(w, uint16(x))
27185         }
27186         {
27187                 _, err := w.Write(([]byte((*(*(struct {
27188                         MaxHP            uint16 // Player only.
27189                         CollideWithNodes bool
27190                         Weight           float32 // deprecated
27191                         ColBox, SelBox   Box
27192                         Pointable        bool
27193                         Visual           string
27194                         VisualSize       [3]float32
27195                         Textures         []Texture
27196                         SpriteSheetSize  [2]int16 // in sprites.
27197                         SpritePos        [2]int16 // in sprite sheet.
27198                         Visible          bool
27199                         MakeFootstepSnds bool
27200                         RotateSpeed      float32 // in radians per second.
27201                         Mesh             string
27202                         Colors           []color.NRGBA
27203                         CollideWithAOs   bool
27204                         StepHeight       float32
27205                         FaceRotateDir    bool
27206                         FaceRotateDirOff float32 // in degrees.
27207                         BackfaceCull     bool
27208                         Nametag          string
27209                         NametagColor     color.NRGBA
27210                         FaceRotateSpeed  float32 // in degrees per second.
27211                         Infotext         string
27212                         Itemstring       string
27213                         Glow             int8
27214                         MaxBreath        uint16  // Player only.
27215                         EyeHeight        float32 // Player only.
27216                         ZoomFOV          float32 // in degrees. Player only.
27217                         UseTextureAlpha  bool
27218                         DmgTextureMod    Texture // suffix
27219                         Shaded           bool
27220                         ShowOnMinimap    bool
27221                         NametagBG        color.NRGBA
27222                 }))(obj)).Visual))[:])
27223                 chk(err)
27224         }
27225         for local336 := range (*(*(struct {
27226                 MaxHP            uint16 // Player only.
27227                 CollideWithNodes bool
27228                 Weight           float32 // deprecated
27229                 ColBox, SelBox   Box
27230                 Pointable        bool
27231                 Visual           string
27232                 VisualSize       [3]float32
27233                 Textures         []Texture
27234                 SpriteSheetSize  [2]int16 // in sprites.
27235                 SpritePos        [2]int16 // in sprite sheet.
27236                 Visible          bool
27237                 MakeFootstepSnds bool
27238                 RotateSpeed      float32 // in radians per second.
27239                 Mesh             string
27240                 Colors           []color.NRGBA
27241                 CollideWithAOs   bool
27242                 StepHeight       float32
27243                 FaceRotateDir    bool
27244                 FaceRotateDirOff float32 // in degrees.
27245                 BackfaceCull     bool
27246                 Nametag          string
27247                 NametagColor     color.NRGBA
27248                 FaceRotateSpeed  float32 // in degrees per second.
27249                 Infotext         string
27250                 Itemstring       string
27251                 Glow             int8
27252                 MaxBreath        uint16  // Player only.
27253                 EyeHeight        float32 // Player only.
27254                 ZoomFOV          float32 // in degrees. Player only.
27255                 UseTextureAlpha  bool
27256                 DmgTextureMod    Texture // suffix
27257                 Shaded           bool
27258                 ShowOnMinimap    bool
27259                 NametagBG        color.NRGBA
27260         }))(obj)).VisualSize {
27261                 {
27262                         x := ((*(*(struct {
27263                                 MaxHP            uint16 // Player only.
27264                                 CollideWithNodes bool
27265                                 Weight           float32 // deprecated
27266                                 ColBox, SelBox   Box
27267                                 Pointable        bool
27268                                 Visual           string
27269                                 VisualSize       [3]float32
27270                                 Textures         []Texture
27271                                 SpriteSheetSize  [2]int16 // in sprites.
27272                                 SpritePos        [2]int16 // in sprite sheet.
27273                                 Visible          bool
27274                                 MakeFootstepSnds bool
27275                                 RotateSpeed      float32 // in radians per second.
27276                                 Mesh             string
27277                                 Colors           []color.NRGBA
27278                                 CollideWithAOs   bool
27279                                 StepHeight       float32
27280                                 FaceRotateDir    bool
27281                                 FaceRotateDirOff float32 // in degrees.
27282                                 BackfaceCull     bool
27283                                 Nametag          string
27284                                 NametagColor     color.NRGBA
27285                                 FaceRotateSpeed  float32 // in degrees per second.
27286                                 Infotext         string
27287                                 Itemstring       string
27288                                 Glow             int8
27289                                 MaxBreath        uint16  // Player only.
27290                                 EyeHeight        float32 // Player only.
27291                                 ZoomFOV          float32 // in degrees. Player only.
27292                                 UseTextureAlpha  bool
27293                                 DmgTextureMod    Texture // suffix
27294                                 Shaded           bool
27295                                 ShowOnMinimap    bool
27296                                 NametagBG        color.NRGBA
27297                         }))(obj)).VisualSize)[local336]
27298                         write32(w, math.Float32bits(x))
27299                 }
27300         }
27301         if len(((*(*(struct {
27302                 MaxHP            uint16 // Player only.
27303                 CollideWithNodes bool
27304                 Weight           float32 // deprecated
27305                 ColBox, SelBox   Box
27306                 Pointable        bool
27307                 Visual           string
27308                 VisualSize       [3]float32
27309                 Textures         []Texture
27310                 SpriteSheetSize  [2]int16 // in sprites.
27311                 SpritePos        [2]int16 // in sprite sheet.
27312                 Visible          bool
27313                 MakeFootstepSnds bool
27314                 RotateSpeed      float32 // in radians per second.
27315                 Mesh             string
27316                 Colors           []color.NRGBA
27317                 CollideWithAOs   bool
27318                 StepHeight       float32
27319                 FaceRotateDir    bool
27320                 FaceRotateDirOff float32 // in degrees.
27321                 BackfaceCull     bool
27322                 Nametag          string
27323                 NametagColor     color.NRGBA
27324                 FaceRotateSpeed  float32 // in degrees per second.
27325                 Infotext         string
27326                 Itemstring       string
27327                 Glow             int8
27328                 MaxBreath        uint16  // Player only.
27329                 EyeHeight        float32 // Player only.
27330                 ZoomFOV          float32 // in degrees. Player only.
27331                 UseTextureAlpha  bool
27332                 DmgTextureMod    Texture // suffix
27333                 Shaded           bool
27334                 ShowOnMinimap    bool
27335                 NametagBG        color.NRGBA
27336         }))(obj)).Textures)) > math.MaxUint16 {
27337                 chk(ErrTooLong)
27338         }
27339         {
27340                 x := uint16(len(((*(*(struct {
27341                         MaxHP            uint16 // Player only.
27342                         CollideWithNodes bool
27343                         Weight           float32 // deprecated
27344                         ColBox, SelBox   Box
27345                         Pointable        bool
27346                         Visual           string
27347                         VisualSize       [3]float32
27348                         Textures         []Texture
27349                         SpriteSheetSize  [2]int16 // in sprites.
27350                         SpritePos        [2]int16 // in sprite sheet.
27351                         Visible          bool
27352                         MakeFootstepSnds bool
27353                         RotateSpeed      float32 // in radians per second.
27354                         Mesh             string
27355                         Colors           []color.NRGBA
27356                         CollideWithAOs   bool
27357                         StepHeight       float32
27358                         FaceRotateDir    bool
27359                         FaceRotateDirOff float32 // in degrees.
27360                         BackfaceCull     bool
27361                         Nametag          string
27362                         NametagColor     color.NRGBA
27363                         FaceRotateSpeed  float32 // in degrees per second.
27364                         Infotext         string
27365                         Itemstring       string
27366                         Glow             int8
27367                         MaxBreath        uint16  // Player only.
27368                         EyeHeight        float32 // Player only.
27369                         ZoomFOV          float32 // in degrees. Player only.
27370                         UseTextureAlpha  bool
27371                         DmgTextureMod    Texture // suffix
27372                         Shaded           bool
27373                         ShowOnMinimap    bool
27374                         NametagBG        color.NRGBA
27375                 }))(obj)).Textures)))
27376                 write16(w, uint16(x))
27377         }
27378         for local337 := range (*(*(struct {
27379                 MaxHP            uint16 // Player only.
27380                 CollideWithNodes bool
27381                 Weight           float32 // deprecated
27382                 ColBox, SelBox   Box
27383                 Pointable        bool
27384                 Visual           string
27385                 VisualSize       [3]float32
27386                 Textures         []Texture
27387                 SpriteSheetSize  [2]int16 // in sprites.
27388                 SpritePos        [2]int16 // in sprite sheet.
27389                 Visible          bool
27390                 MakeFootstepSnds bool
27391                 RotateSpeed      float32 // in radians per second.
27392                 Mesh             string
27393                 Colors           []color.NRGBA
27394                 CollideWithAOs   bool
27395                 StepHeight       float32
27396                 FaceRotateDir    bool
27397                 FaceRotateDirOff float32 // in degrees.
27398                 BackfaceCull     bool
27399                 Nametag          string
27400                 NametagColor     color.NRGBA
27401                 FaceRotateSpeed  float32 // in degrees per second.
27402                 Infotext         string
27403                 Itemstring       string
27404                 Glow             int8
27405                 MaxBreath        uint16  // Player only.
27406                 EyeHeight        float32 // Player only.
27407                 ZoomFOV          float32 // in degrees. Player only.
27408                 UseTextureAlpha  bool
27409                 DmgTextureMod    Texture // suffix
27410                 Shaded           bool
27411                 ShowOnMinimap    bool
27412                 NametagBG        color.NRGBA
27413         }))(obj)).Textures {
27414                 if err := pcall(func() {
27415                         (((*(*(struct {
27416                                 MaxHP            uint16 // Player only.
27417                                 CollideWithNodes bool
27418                                 Weight           float32 // deprecated
27419                                 ColBox, SelBox   Box
27420                                 Pointable        bool
27421                                 Visual           string
27422                                 VisualSize       [3]float32
27423                                 Textures         []Texture
27424                                 SpriteSheetSize  [2]int16 // in sprites.
27425                                 SpritePos        [2]int16 // in sprite sheet.
27426                                 Visible          bool
27427                                 MakeFootstepSnds bool
27428                                 RotateSpeed      float32 // in radians per second.
27429                                 Mesh             string
27430                                 Colors           []color.NRGBA
27431                                 CollideWithAOs   bool
27432                                 StepHeight       float32
27433                                 FaceRotateDir    bool
27434                                 FaceRotateDirOff float32 // in degrees.
27435                                 BackfaceCull     bool
27436                                 Nametag          string
27437                                 NametagColor     color.NRGBA
27438                                 FaceRotateSpeed  float32 // in degrees per second.
27439                                 Infotext         string
27440                                 Itemstring       string
27441                                 Glow             int8
27442                                 MaxBreath        uint16  // Player only.
27443                                 EyeHeight        float32 // Player only.
27444                                 ZoomFOV          float32 // in degrees. Player only.
27445                                 UseTextureAlpha  bool
27446                                 DmgTextureMod    Texture // suffix
27447                                 Shaded           bool
27448                                 ShowOnMinimap    bool
27449                                 NametagBG        color.NRGBA
27450                         }))(obj)).Textures)[local337]).Serialize(w)
27451                 }); err != nil {
27452                         if err == io.EOF {
27453                                 chk(io.EOF)
27454                         }
27455                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
27456                 }
27457         }
27458         for local338 := range (*(*(struct {
27459                 MaxHP            uint16 // Player only.
27460                 CollideWithNodes bool
27461                 Weight           float32 // deprecated
27462                 ColBox, SelBox   Box
27463                 Pointable        bool
27464                 Visual           string
27465                 VisualSize       [3]float32
27466                 Textures         []Texture
27467                 SpriteSheetSize  [2]int16 // in sprites.
27468                 SpritePos        [2]int16 // in sprite sheet.
27469                 Visible          bool
27470                 MakeFootstepSnds bool
27471                 RotateSpeed      float32 // in radians per second.
27472                 Mesh             string
27473                 Colors           []color.NRGBA
27474                 CollideWithAOs   bool
27475                 StepHeight       float32
27476                 FaceRotateDir    bool
27477                 FaceRotateDirOff float32 // in degrees.
27478                 BackfaceCull     bool
27479                 Nametag          string
27480                 NametagColor     color.NRGBA
27481                 FaceRotateSpeed  float32 // in degrees per second.
27482                 Infotext         string
27483                 Itemstring       string
27484                 Glow             int8
27485                 MaxBreath        uint16  // Player only.
27486                 EyeHeight        float32 // Player only.
27487                 ZoomFOV          float32 // in degrees. Player only.
27488                 UseTextureAlpha  bool
27489                 DmgTextureMod    Texture // suffix
27490                 Shaded           bool
27491                 ShowOnMinimap    bool
27492                 NametagBG        color.NRGBA
27493         }))(obj)).SpriteSheetSize {
27494                 {
27495                         x := ((*(*(struct {
27496                                 MaxHP            uint16 // Player only.
27497                                 CollideWithNodes bool
27498                                 Weight           float32 // deprecated
27499                                 ColBox, SelBox   Box
27500                                 Pointable        bool
27501                                 Visual           string
27502                                 VisualSize       [3]float32
27503                                 Textures         []Texture
27504                                 SpriteSheetSize  [2]int16 // in sprites.
27505                                 SpritePos        [2]int16 // in sprite sheet.
27506                                 Visible          bool
27507                                 MakeFootstepSnds bool
27508                                 RotateSpeed      float32 // in radians per second.
27509                                 Mesh             string
27510                                 Colors           []color.NRGBA
27511                                 CollideWithAOs   bool
27512                                 StepHeight       float32
27513                                 FaceRotateDir    bool
27514                                 FaceRotateDirOff float32 // in degrees.
27515                                 BackfaceCull     bool
27516                                 Nametag          string
27517                                 NametagColor     color.NRGBA
27518                                 FaceRotateSpeed  float32 // in degrees per second.
27519                                 Infotext         string
27520                                 Itemstring       string
27521                                 Glow             int8
27522                                 MaxBreath        uint16  // Player only.
27523                                 EyeHeight        float32 // Player only.
27524                                 ZoomFOV          float32 // in degrees. Player only.
27525                                 UseTextureAlpha  bool
27526                                 DmgTextureMod    Texture // suffix
27527                                 Shaded           bool
27528                                 ShowOnMinimap    bool
27529                                 NametagBG        color.NRGBA
27530                         }))(obj)).SpriteSheetSize)[local338]
27531                         write16(w, uint16(x))
27532                 }
27533         }
27534         for local339 := range (*(*(struct {
27535                 MaxHP            uint16 // Player only.
27536                 CollideWithNodes bool
27537                 Weight           float32 // deprecated
27538                 ColBox, SelBox   Box
27539                 Pointable        bool
27540                 Visual           string
27541                 VisualSize       [3]float32
27542                 Textures         []Texture
27543                 SpriteSheetSize  [2]int16 // in sprites.
27544                 SpritePos        [2]int16 // in sprite sheet.
27545                 Visible          bool
27546                 MakeFootstepSnds bool
27547                 RotateSpeed      float32 // in radians per second.
27548                 Mesh             string
27549                 Colors           []color.NRGBA
27550                 CollideWithAOs   bool
27551                 StepHeight       float32
27552                 FaceRotateDir    bool
27553                 FaceRotateDirOff float32 // in degrees.
27554                 BackfaceCull     bool
27555                 Nametag          string
27556                 NametagColor     color.NRGBA
27557                 FaceRotateSpeed  float32 // in degrees per second.
27558                 Infotext         string
27559                 Itemstring       string
27560                 Glow             int8
27561                 MaxBreath        uint16  // Player only.
27562                 EyeHeight        float32 // Player only.
27563                 ZoomFOV          float32 // in degrees. Player only.
27564                 UseTextureAlpha  bool
27565                 DmgTextureMod    Texture // suffix
27566                 Shaded           bool
27567                 ShowOnMinimap    bool
27568                 NametagBG        color.NRGBA
27569         }))(obj)).SpritePos {
27570                 {
27571                         x := ((*(*(struct {
27572                                 MaxHP            uint16 // Player only.
27573                                 CollideWithNodes bool
27574                                 Weight           float32 // deprecated
27575                                 ColBox, SelBox   Box
27576                                 Pointable        bool
27577                                 Visual           string
27578                                 VisualSize       [3]float32
27579                                 Textures         []Texture
27580                                 SpriteSheetSize  [2]int16 // in sprites.
27581                                 SpritePos        [2]int16 // in sprite sheet.
27582                                 Visible          bool
27583                                 MakeFootstepSnds bool
27584                                 RotateSpeed      float32 // in radians per second.
27585                                 Mesh             string
27586                                 Colors           []color.NRGBA
27587                                 CollideWithAOs   bool
27588                                 StepHeight       float32
27589                                 FaceRotateDir    bool
27590                                 FaceRotateDirOff float32 // in degrees.
27591                                 BackfaceCull     bool
27592                                 Nametag          string
27593                                 NametagColor     color.NRGBA
27594                                 FaceRotateSpeed  float32 // in degrees per second.
27595                                 Infotext         string
27596                                 Itemstring       string
27597                                 Glow             int8
27598                                 MaxBreath        uint16  // Player only.
27599                                 EyeHeight        float32 // Player only.
27600                                 ZoomFOV          float32 // in degrees. Player only.
27601                                 UseTextureAlpha  bool
27602                                 DmgTextureMod    Texture // suffix
27603                                 Shaded           bool
27604                                 ShowOnMinimap    bool
27605                                 NametagBG        color.NRGBA
27606                         }))(obj)).SpritePos)[local339]
27607                         write16(w, uint16(x))
27608                 }
27609         }
27610         {
27611                 x := (*(*(struct {
27612                         MaxHP            uint16 // Player only.
27613                         CollideWithNodes bool
27614                         Weight           float32 // deprecated
27615                         ColBox, SelBox   Box
27616                         Pointable        bool
27617                         Visual           string
27618                         VisualSize       [3]float32
27619                         Textures         []Texture
27620                         SpriteSheetSize  [2]int16 // in sprites.
27621                         SpritePos        [2]int16 // in sprite sheet.
27622                         Visible          bool
27623                         MakeFootstepSnds bool
27624                         RotateSpeed      float32 // in radians per second.
27625                         Mesh             string
27626                         Colors           []color.NRGBA
27627                         CollideWithAOs   bool
27628                         StepHeight       float32
27629                         FaceRotateDir    bool
27630                         FaceRotateDirOff float32 // in degrees.
27631                         BackfaceCull     bool
27632                         Nametag          string
27633                         NametagColor     color.NRGBA
27634                         FaceRotateSpeed  float32 // in degrees per second.
27635                         Infotext         string
27636                         Itemstring       string
27637                         Glow             int8
27638                         MaxBreath        uint16  // Player only.
27639                         EyeHeight        float32 // Player only.
27640                         ZoomFOV          float32 // in degrees. Player only.
27641                         UseTextureAlpha  bool
27642                         DmgTextureMod    Texture // suffix
27643                         Shaded           bool
27644                         ShowOnMinimap    bool
27645                         NametagBG        color.NRGBA
27646                 }))(obj)).Visible
27647                 if x {
27648                         write8(w, 1)
27649                 } else {
27650                         write8(w, 0)
27651                 }
27652         }
27653         {
27654                 x := (*(*(struct {
27655                         MaxHP            uint16 // Player only.
27656                         CollideWithNodes bool
27657                         Weight           float32 // deprecated
27658                         ColBox, SelBox   Box
27659                         Pointable        bool
27660                         Visual           string
27661                         VisualSize       [3]float32
27662                         Textures         []Texture
27663                         SpriteSheetSize  [2]int16 // in sprites.
27664                         SpritePos        [2]int16 // in sprite sheet.
27665                         Visible          bool
27666                         MakeFootstepSnds bool
27667                         RotateSpeed      float32 // in radians per second.
27668                         Mesh             string
27669                         Colors           []color.NRGBA
27670                         CollideWithAOs   bool
27671                         StepHeight       float32
27672                         FaceRotateDir    bool
27673                         FaceRotateDirOff float32 // in degrees.
27674                         BackfaceCull     bool
27675                         Nametag          string
27676                         NametagColor     color.NRGBA
27677                         FaceRotateSpeed  float32 // in degrees per second.
27678                         Infotext         string
27679                         Itemstring       string
27680                         Glow             int8
27681                         MaxBreath        uint16  // Player only.
27682                         EyeHeight        float32 // Player only.
27683                         ZoomFOV          float32 // in degrees. Player only.
27684                         UseTextureAlpha  bool
27685                         DmgTextureMod    Texture // suffix
27686                         Shaded           bool
27687                         ShowOnMinimap    bool
27688                         NametagBG        color.NRGBA
27689                 }))(obj)).MakeFootstepSnds
27690                 if x {
27691                         write8(w, 1)
27692                 } else {
27693                         write8(w, 0)
27694                 }
27695         }
27696         {
27697                 x := (*(*(struct {
27698                         MaxHP            uint16 // Player only.
27699                         CollideWithNodes bool
27700                         Weight           float32 // deprecated
27701                         ColBox, SelBox   Box
27702                         Pointable        bool
27703                         Visual           string
27704                         VisualSize       [3]float32
27705                         Textures         []Texture
27706                         SpriteSheetSize  [2]int16 // in sprites.
27707                         SpritePos        [2]int16 // in sprite sheet.
27708                         Visible          bool
27709                         MakeFootstepSnds bool
27710                         RotateSpeed      float32 // in radians per second.
27711                         Mesh             string
27712                         Colors           []color.NRGBA
27713                         CollideWithAOs   bool
27714                         StepHeight       float32
27715                         FaceRotateDir    bool
27716                         FaceRotateDirOff float32 // in degrees.
27717                         BackfaceCull     bool
27718                         Nametag          string
27719                         NametagColor     color.NRGBA
27720                         FaceRotateSpeed  float32 // in degrees per second.
27721                         Infotext         string
27722                         Itemstring       string
27723                         Glow             int8
27724                         MaxBreath        uint16  // Player only.
27725                         EyeHeight        float32 // Player only.
27726                         ZoomFOV          float32 // in degrees. Player only.
27727                         UseTextureAlpha  bool
27728                         DmgTextureMod    Texture // suffix
27729                         Shaded           bool
27730                         ShowOnMinimap    bool
27731                         NametagBG        color.NRGBA
27732                 }))(obj)).RotateSpeed
27733                 write32(w, math.Float32bits(x))
27734         }
27735         if len(([]byte((*(*(struct {
27736                 MaxHP            uint16 // Player only.
27737                 CollideWithNodes bool
27738                 Weight           float32 // deprecated
27739                 ColBox, SelBox   Box
27740                 Pointable        bool
27741                 Visual           string
27742                 VisualSize       [3]float32
27743                 Textures         []Texture
27744                 SpriteSheetSize  [2]int16 // in sprites.
27745                 SpritePos        [2]int16 // in sprite sheet.
27746                 Visible          bool
27747                 MakeFootstepSnds bool
27748                 RotateSpeed      float32 // in radians per second.
27749                 Mesh             string
27750                 Colors           []color.NRGBA
27751                 CollideWithAOs   bool
27752                 StepHeight       float32
27753                 FaceRotateDir    bool
27754                 FaceRotateDirOff float32 // in degrees.
27755                 BackfaceCull     bool
27756                 Nametag          string
27757                 NametagColor     color.NRGBA
27758                 FaceRotateSpeed  float32 // in degrees per second.
27759                 Infotext         string
27760                 Itemstring       string
27761                 Glow             int8
27762                 MaxBreath        uint16  // Player only.
27763                 EyeHeight        float32 // Player only.
27764                 ZoomFOV          float32 // in degrees. Player only.
27765                 UseTextureAlpha  bool
27766                 DmgTextureMod    Texture // suffix
27767                 Shaded           bool
27768                 ShowOnMinimap    bool
27769                 NametagBG        color.NRGBA
27770         }))(obj)).Mesh))) > math.MaxUint16 {
27771                 chk(ErrTooLong)
27772         }
27773         {
27774                 x := uint16(len(([]byte((*(*(struct {
27775                         MaxHP            uint16 // Player only.
27776                         CollideWithNodes bool
27777                         Weight           float32 // deprecated
27778                         ColBox, SelBox   Box
27779                         Pointable        bool
27780                         Visual           string
27781                         VisualSize       [3]float32
27782                         Textures         []Texture
27783                         SpriteSheetSize  [2]int16 // in sprites.
27784                         SpritePos        [2]int16 // in sprite sheet.
27785                         Visible          bool
27786                         MakeFootstepSnds bool
27787                         RotateSpeed      float32 // in radians per second.
27788                         Mesh             string
27789                         Colors           []color.NRGBA
27790                         CollideWithAOs   bool
27791                         StepHeight       float32
27792                         FaceRotateDir    bool
27793                         FaceRotateDirOff float32 // in degrees.
27794                         BackfaceCull     bool
27795                         Nametag          string
27796                         NametagColor     color.NRGBA
27797                         FaceRotateSpeed  float32 // in degrees per second.
27798                         Infotext         string
27799                         Itemstring       string
27800                         Glow             int8
27801                         MaxBreath        uint16  // Player only.
27802                         EyeHeight        float32 // Player only.
27803                         ZoomFOV          float32 // in degrees. Player only.
27804                         UseTextureAlpha  bool
27805                         DmgTextureMod    Texture // suffix
27806                         Shaded           bool
27807                         ShowOnMinimap    bool
27808                         NametagBG        color.NRGBA
27809                 }))(obj)).Mesh))))
27810                 write16(w, uint16(x))
27811         }
27812         {
27813                 _, err := w.Write(([]byte((*(*(struct {
27814                         MaxHP            uint16 // Player only.
27815                         CollideWithNodes bool
27816                         Weight           float32 // deprecated
27817                         ColBox, SelBox   Box
27818                         Pointable        bool
27819                         Visual           string
27820                         VisualSize       [3]float32
27821                         Textures         []Texture
27822                         SpriteSheetSize  [2]int16 // in sprites.
27823                         SpritePos        [2]int16 // in sprite sheet.
27824                         Visible          bool
27825                         MakeFootstepSnds bool
27826                         RotateSpeed      float32 // in radians per second.
27827                         Mesh             string
27828                         Colors           []color.NRGBA
27829                         CollideWithAOs   bool
27830                         StepHeight       float32
27831                         FaceRotateDir    bool
27832                         FaceRotateDirOff float32 // in degrees.
27833                         BackfaceCull     bool
27834                         Nametag          string
27835                         NametagColor     color.NRGBA
27836                         FaceRotateSpeed  float32 // in degrees per second.
27837                         Infotext         string
27838                         Itemstring       string
27839                         Glow             int8
27840                         MaxBreath        uint16  // Player only.
27841                         EyeHeight        float32 // Player only.
27842                         ZoomFOV          float32 // in degrees. Player only.
27843                         UseTextureAlpha  bool
27844                         DmgTextureMod    Texture // suffix
27845                         Shaded           bool
27846                         ShowOnMinimap    bool
27847                         NametagBG        color.NRGBA
27848                 }))(obj)).Mesh))[:])
27849                 chk(err)
27850         }
27851         if len(((*(*(struct {
27852                 MaxHP            uint16 // Player only.
27853                 CollideWithNodes bool
27854                 Weight           float32 // deprecated
27855                 ColBox, SelBox   Box
27856                 Pointable        bool
27857                 Visual           string
27858                 VisualSize       [3]float32
27859                 Textures         []Texture
27860                 SpriteSheetSize  [2]int16 // in sprites.
27861                 SpritePos        [2]int16 // in sprite sheet.
27862                 Visible          bool
27863                 MakeFootstepSnds bool
27864                 RotateSpeed      float32 // in radians per second.
27865                 Mesh             string
27866                 Colors           []color.NRGBA
27867                 CollideWithAOs   bool
27868                 StepHeight       float32
27869                 FaceRotateDir    bool
27870                 FaceRotateDirOff float32 // in degrees.
27871                 BackfaceCull     bool
27872                 Nametag          string
27873                 NametagColor     color.NRGBA
27874                 FaceRotateSpeed  float32 // in degrees per second.
27875                 Infotext         string
27876                 Itemstring       string
27877                 Glow             int8
27878                 MaxBreath        uint16  // Player only.
27879                 EyeHeight        float32 // Player only.
27880                 ZoomFOV          float32 // in degrees. Player only.
27881                 UseTextureAlpha  bool
27882                 DmgTextureMod    Texture // suffix
27883                 Shaded           bool
27884                 ShowOnMinimap    bool
27885                 NametagBG        color.NRGBA
27886         }))(obj)).Colors)) > math.MaxUint16 {
27887                 chk(ErrTooLong)
27888         }
27889         {
27890                 x := uint16(len(((*(*(struct {
27891                         MaxHP            uint16 // Player only.
27892                         CollideWithNodes bool
27893                         Weight           float32 // deprecated
27894                         ColBox, SelBox   Box
27895                         Pointable        bool
27896                         Visual           string
27897                         VisualSize       [3]float32
27898                         Textures         []Texture
27899                         SpriteSheetSize  [2]int16 // in sprites.
27900                         SpritePos        [2]int16 // in sprite sheet.
27901                         Visible          bool
27902                         MakeFootstepSnds bool
27903                         RotateSpeed      float32 // in radians per second.
27904                         Mesh             string
27905                         Colors           []color.NRGBA
27906                         CollideWithAOs   bool
27907                         StepHeight       float32
27908                         FaceRotateDir    bool
27909                         FaceRotateDirOff float32 // in degrees.
27910                         BackfaceCull     bool
27911                         Nametag          string
27912                         NametagColor     color.NRGBA
27913                         FaceRotateSpeed  float32 // in degrees per second.
27914                         Infotext         string
27915                         Itemstring       string
27916                         Glow             int8
27917                         MaxBreath        uint16  // Player only.
27918                         EyeHeight        float32 // Player only.
27919                         ZoomFOV          float32 // in degrees. Player only.
27920                         UseTextureAlpha  bool
27921                         DmgTextureMod    Texture // suffix
27922                         Shaded           bool
27923                         ShowOnMinimap    bool
27924                         NametagBG        color.NRGBA
27925                 }))(obj)).Colors)))
27926                 write16(w, uint16(x))
27927         }
27928         for local340 := range (*(*(struct {
27929                 MaxHP            uint16 // Player only.
27930                 CollideWithNodes bool
27931                 Weight           float32 // deprecated
27932                 ColBox, SelBox   Box
27933                 Pointable        bool
27934                 Visual           string
27935                 VisualSize       [3]float32
27936                 Textures         []Texture
27937                 SpriteSheetSize  [2]int16 // in sprites.
27938                 SpritePos        [2]int16 // in sprite sheet.
27939                 Visible          bool
27940                 MakeFootstepSnds bool
27941                 RotateSpeed      float32 // in radians per second.
27942                 Mesh             string
27943                 Colors           []color.NRGBA
27944                 CollideWithAOs   bool
27945                 StepHeight       float32
27946                 FaceRotateDir    bool
27947                 FaceRotateDirOff float32 // in degrees.
27948                 BackfaceCull     bool
27949                 Nametag          string
27950                 NametagColor     color.NRGBA
27951                 FaceRotateSpeed  float32 // in degrees per second.
27952                 Infotext         string
27953                 Itemstring       string
27954                 Glow             int8
27955                 MaxBreath        uint16  // Player only.
27956                 EyeHeight        float32 // Player only.
27957                 ZoomFOV          float32 // in degrees. Player only.
27958                 UseTextureAlpha  bool
27959                 DmgTextureMod    Texture // suffix
27960                 Shaded           bool
27961                 ShowOnMinimap    bool
27962                 NametagBG        color.NRGBA
27963         }))(obj)).Colors {
27964                 {
27965                         x := ((*(*(struct {
27966                                 MaxHP            uint16 // Player only.
27967                                 CollideWithNodes bool
27968                                 Weight           float32 // deprecated
27969                                 ColBox, SelBox   Box
27970                                 Pointable        bool
27971                                 Visual           string
27972                                 VisualSize       [3]float32
27973                                 Textures         []Texture
27974                                 SpriteSheetSize  [2]int16 // in sprites.
27975                                 SpritePos        [2]int16 // in sprite sheet.
27976                                 Visible          bool
27977                                 MakeFootstepSnds bool
27978                                 RotateSpeed      float32 // in radians per second.
27979                                 Mesh             string
27980                                 Colors           []color.NRGBA
27981                                 CollideWithAOs   bool
27982                                 StepHeight       float32
27983                                 FaceRotateDir    bool
27984                                 FaceRotateDirOff float32 // in degrees.
27985                                 BackfaceCull     bool
27986                                 Nametag          string
27987                                 NametagColor     color.NRGBA
27988                                 FaceRotateSpeed  float32 // in degrees per second.
27989                                 Infotext         string
27990                                 Itemstring       string
27991                                 Glow             int8
27992                                 MaxBreath        uint16  // Player only.
27993                                 EyeHeight        float32 // Player only.
27994                                 ZoomFOV          float32 // in degrees. Player only.
27995                                 UseTextureAlpha  bool
27996                                 DmgTextureMod    Texture // suffix
27997                                 Shaded           bool
27998                                 ShowOnMinimap    bool
27999                                 NametagBG        color.NRGBA
28000                         }))(obj)).Colors)[local340]
28001                         w.Write([]byte{x.A, x.R, x.G, x.B})
28002                 }
28003         }
28004         {
28005                 x := (*(*(struct {
28006                         MaxHP            uint16 // Player only.
28007                         CollideWithNodes bool
28008                         Weight           float32 // deprecated
28009                         ColBox, SelBox   Box
28010                         Pointable        bool
28011                         Visual           string
28012                         VisualSize       [3]float32
28013                         Textures         []Texture
28014                         SpriteSheetSize  [2]int16 // in sprites.
28015                         SpritePos        [2]int16 // in sprite sheet.
28016                         Visible          bool
28017                         MakeFootstepSnds bool
28018                         RotateSpeed      float32 // in radians per second.
28019                         Mesh             string
28020                         Colors           []color.NRGBA
28021                         CollideWithAOs   bool
28022                         StepHeight       float32
28023                         FaceRotateDir    bool
28024                         FaceRotateDirOff float32 // in degrees.
28025                         BackfaceCull     bool
28026                         Nametag          string
28027                         NametagColor     color.NRGBA
28028                         FaceRotateSpeed  float32 // in degrees per second.
28029                         Infotext         string
28030                         Itemstring       string
28031                         Glow             int8
28032                         MaxBreath        uint16  // Player only.
28033                         EyeHeight        float32 // Player only.
28034                         ZoomFOV          float32 // in degrees. Player only.
28035                         UseTextureAlpha  bool
28036                         DmgTextureMod    Texture // suffix
28037                         Shaded           bool
28038                         ShowOnMinimap    bool
28039                         NametagBG        color.NRGBA
28040                 }))(obj)).CollideWithAOs
28041                 if x {
28042                         write8(w, 1)
28043                 } else {
28044                         write8(w, 0)
28045                 }
28046         }
28047         {
28048                 x := (*(*(struct {
28049                         MaxHP            uint16 // Player only.
28050                         CollideWithNodes bool
28051                         Weight           float32 // deprecated
28052                         ColBox, SelBox   Box
28053                         Pointable        bool
28054                         Visual           string
28055                         VisualSize       [3]float32
28056                         Textures         []Texture
28057                         SpriteSheetSize  [2]int16 // in sprites.
28058                         SpritePos        [2]int16 // in sprite sheet.
28059                         Visible          bool
28060                         MakeFootstepSnds bool
28061                         RotateSpeed      float32 // in radians per second.
28062                         Mesh             string
28063                         Colors           []color.NRGBA
28064                         CollideWithAOs   bool
28065                         StepHeight       float32
28066                         FaceRotateDir    bool
28067                         FaceRotateDirOff float32 // in degrees.
28068                         BackfaceCull     bool
28069                         Nametag          string
28070                         NametagColor     color.NRGBA
28071                         FaceRotateSpeed  float32 // in degrees per second.
28072                         Infotext         string
28073                         Itemstring       string
28074                         Glow             int8
28075                         MaxBreath        uint16  // Player only.
28076                         EyeHeight        float32 // Player only.
28077                         ZoomFOV          float32 // in degrees. Player only.
28078                         UseTextureAlpha  bool
28079                         DmgTextureMod    Texture // suffix
28080                         Shaded           bool
28081                         ShowOnMinimap    bool
28082                         NametagBG        color.NRGBA
28083                 }))(obj)).StepHeight
28084                 write32(w, math.Float32bits(x))
28085         }
28086         {
28087                 x := (*(*(struct {
28088                         MaxHP            uint16 // Player only.
28089                         CollideWithNodes bool
28090                         Weight           float32 // deprecated
28091                         ColBox, SelBox   Box
28092                         Pointable        bool
28093                         Visual           string
28094                         VisualSize       [3]float32
28095                         Textures         []Texture
28096                         SpriteSheetSize  [2]int16 // in sprites.
28097                         SpritePos        [2]int16 // in sprite sheet.
28098                         Visible          bool
28099                         MakeFootstepSnds bool
28100                         RotateSpeed      float32 // in radians per second.
28101                         Mesh             string
28102                         Colors           []color.NRGBA
28103                         CollideWithAOs   bool
28104                         StepHeight       float32
28105                         FaceRotateDir    bool
28106                         FaceRotateDirOff float32 // in degrees.
28107                         BackfaceCull     bool
28108                         Nametag          string
28109                         NametagColor     color.NRGBA
28110                         FaceRotateSpeed  float32 // in degrees per second.
28111                         Infotext         string
28112                         Itemstring       string
28113                         Glow             int8
28114                         MaxBreath        uint16  // Player only.
28115                         EyeHeight        float32 // Player only.
28116                         ZoomFOV          float32 // in degrees. Player only.
28117                         UseTextureAlpha  bool
28118                         DmgTextureMod    Texture // suffix
28119                         Shaded           bool
28120                         ShowOnMinimap    bool
28121                         NametagBG        color.NRGBA
28122                 }))(obj)).FaceRotateDir
28123                 if x {
28124                         write8(w, 1)
28125                 } else {
28126                         write8(w, 0)
28127                 }
28128         }
28129         {
28130                 x := (*(*(struct {
28131                         MaxHP            uint16 // Player only.
28132                         CollideWithNodes bool
28133                         Weight           float32 // deprecated
28134                         ColBox, SelBox   Box
28135                         Pointable        bool
28136                         Visual           string
28137                         VisualSize       [3]float32
28138                         Textures         []Texture
28139                         SpriteSheetSize  [2]int16 // in sprites.
28140                         SpritePos        [2]int16 // in sprite sheet.
28141                         Visible          bool
28142                         MakeFootstepSnds bool
28143                         RotateSpeed      float32 // in radians per second.
28144                         Mesh             string
28145                         Colors           []color.NRGBA
28146                         CollideWithAOs   bool
28147                         StepHeight       float32
28148                         FaceRotateDir    bool
28149                         FaceRotateDirOff float32 // in degrees.
28150                         BackfaceCull     bool
28151                         Nametag          string
28152                         NametagColor     color.NRGBA
28153                         FaceRotateSpeed  float32 // in degrees per second.
28154                         Infotext         string
28155                         Itemstring       string
28156                         Glow             int8
28157                         MaxBreath        uint16  // Player only.
28158                         EyeHeight        float32 // Player only.
28159                         ZoomFOV          float32 // in degrees. Player only.
28160                         UseTextureAlpha  bool
28161                         DmgTextureMod    Texture // suffix
28162                         Shaded           bool
28163                         ShowOnMinimap    bool
28164                         NametagBG        color.NRGBA
28165                 }))(obj)).FaceRotateDirOff
28166                 write32(w, math.Float32bits(x))
28167         }
28168         {
28169                 x := (*(*(struct {
28170                         MaxHP            uint16 // Player only.
28171                         CollideWithNodes bool
28172                         Weight           float32 // deprecated
28173                         ColBox, SelBox   Box
28174                         Pointable        bool
28175                         Visual           string
28176                         VisualSize       [3]float32
28177                         Textures         []Texture
28178                         SpriteSheetSize  [2]int16 // in sprites.
28179                         SpritePos        [2]int16 // in sprite sheet.
28180                         Visible          bool
28181                         MakeFootstepSnds bool
28182                         RotateSpeed      float32 // in radians per second.
28183                         Mesh             string
28184                         Colors           []color.NRGBA
28185                         CollideWithAOs   bool
28186                         StepHeight       float32
28187                         FaceRotateDir    bool
28188                         FaceRotateDirOff float32 // in degrees.
28189                         BackfaceCull     bool
28190                         Nametag          string
28191                         NametagColor     color.NRGBA
28192                         FaceRotateSpeed  float32 // in degrees per second.
28193                         Infotext         string
28194                         Itemstring       string
28195                         Glow             int8
28196                         MaxBreath        uint16  // Player only.
28197                         EyeHeight        float32 // Player only.
28198                         ZoomFOV          float32 // in degrees. Player only.
28199                         UseTextureAlpha  bool
28200                         DmgTextureMod    Texture // suffix
28201                         Shaded           bool
28202                         ShowOnMinimap    bool
28203                         NametagBG        color.NRGBA
28204                 }))(obj)).BackfaceCull
28205                 if x {
28206                         write8(w, 1)
28207                 } else {
28208                         write8(w, 0)
28209                 }
28210         }
28211         if len(([]byte((*(*(struct {
28212                 MaxHP            uint16 // Player only.
28213                 CollideWithNodes bool
28214                 Weight           float32 // deprecated
28215                 ColBox, SelBox   Box
28216                 Pointable        bool
28217                 Visual           string
28218                 VisualSize       [3]float32
28219                 Textures         []Texture
28220                 SpriteSheetSize  [2]int16 // in sprites.
28221                 SpritePos        [2]int16 // in sprite sheet.
28222                 Visible          bool
28223                 MakeFootstepSnds bool
28224                 RotateSpeed      float32 // in radians per second.
28225                 Mesh             string
28226                 Colors           []color.NRGBA
28227                 CollideWithAOs   bool
28228                 StepHeight       float32
28229                 FaceRotateDir    bool
28230                 FaceRotateDirOff float32 // in degrees.
28231                 BackfaceCull     bool
28232                 Nametag          string
28233                 NametagColor     color.NRGBA
28234                 FaceRotateSpeed  float32 // in degrees per second.
28235                 Infotext         string
28236                 Itemstring       string
28237                 Glow             int8
28238                 MaxBreath        uint16  // Player only.
28239                 EyeHeight        float32 // Player only.
28240                 ZoomFOV          float32 // in degrees. Player only.
28241                 UseTextureAlpha  bool
28242                 DmgTextureMod    Texture // suffix
28243                 Shaded           bool
28244                 ShowOnMinimap    bool
28245                 NametagBG        color.NRGBA
28246         }))(obj)).Nametag))) > math.MaxUint16 {
28247                 chk(ErrTooLong)
28248         }
28249         {
28250                 x := uint16(len(([]byte((*(*(struct {
28251                         MaxHP            uint16 // Player only.
28252                         CollideWithNodes bool
28253                         Weight           float32 // deprecated
28254                         ColBox, SelBox   Box
28255                         Pointable        bool
28256                         Visual           string
28257                         VisualSize       [3]float32
28258                         Textures         []Texture
28259                         SpriteSheetSize  [2]int16 // in sprites.
28260                         SpritePos        [2]int16 // in sprite sheet.
28261                         Visible          bool
28262                         MakeFootstepSnds bool
28263                         RotateSpeed      float32 // in radians per second.
28264                         Mesh             string
28265                         Colors           []color.NRGBA
28266                         CollideWithAOs   bool
28267                         StepHeight       float32
28268                         FaceRotateDir    bool
28269                         FaceRotateDirOff float32 // in degrees.
28270                         BackfaceCull     bool
28271                         Nametag          string
28272                         NametagColor     color.NRGBA
28273                         FaceRotateSpeed  float32 // in degrees per second.
28274                         Infotext         string
28275                         Itemstring       string
28276                         Glow             int8
28277                         MaxBreath        uint16  // Player only.
28278                         EyeHeight        float32 // Player only.
28279                         ZoomFOV          float32 // in degrees. Player only.
28280                         UseTextureAlpha  bool
28281                         DmgTextureMod    Texture // suffix
28282                         Shaded           bool
28283                         ShowOnMinimap    bool
28284                         NametagBG        color.NRGBA
28285                 }))(obj)).Nametag))))
28286                 write16(w, uint16(x))
28287         }
28288         {
28289                 _, err := w.Write(([]byte((*(*(struct {
28290                         MaxHP            uint16 // Player only.
28291                         CollideWithNodes bool
28292                         Weight           float32 // deprecated
28293                         ColBox, SelBox   Box
28294                         Pointable        bool
28295                         Visual           string
28296                         VisualSize       [3]float32
28297                         Textures         []Texture
28298                         SpriteSheetSize  [2]int16 // in sprites.
28299                         SpritePos        [2]int16 // in sprite sheet.
28300                         Visible          bool
28301                         MakeFootstepSnds bool
28302                         RotateSpeed      float32 // in radians per second.
28303                         Mesh             string
28304                         Colors           []color.NRGBA
28305                         CollideWithAOs   bool
28306                         StepHeight       float32
28307                         FaceRotateDir    bool
28308                         FaceRotateDirOff float32 // in degrees.
28309                         BackfaceCull     bool
28310                         Nametag          string
28311                         NametagColor     color.NRGBA
28312                         FaceRotateSpeed  float32 // in degrees per second.
28313                         Infotext         string
28314                         Itemstring       string
28315                         Glow             int8
28316                         MaxBreath        uint16  // Player only.
28317                         EyeHeight        float32 // Player only.
28318                         ZoomFOV          float32 // in degrees. Player only.
28319                         UseTextureAlpha  bool
28320                         DmgTextureMod    Texture // suffix
28321                         Shaded           bool
28322                         ShowOnMinimap    bool
28323                         NametagBG        color.NRGBA
28324                 }))(obj)).Nametag))[:])
28325                 chk(err)
28326         }
28327         {
28328                 x := (*(*(struct {
28329                         MaxHP            uint16 // Player only.
28330                         CollideWithNodes bool
28331                         Weight           float32 // deprecated
28332                         ColBox, SelBox   Box
28333                         Pointable        bool
28334                         Visual           string
28335                         VisualSize       [3]float32
28336                         Textures         []Texture
28337                         SpriteSheetSize  [2]int16 // in sprites.
28338                         SpritePos        [2]int16 // in sprite sheet.
28339                         Visible          bool
28340                         MakeFootstepSnds bool
28341                         RotateSpeed      float32 // in radians per second.
28342                         Mesh             string
28343                         Colors           []color.NRGBA
28344                         CollideWithAOs   bool
28345                         StepHeight       float32
28346                         FaceRotateDir    bool
28347                         FaceRotateDirOff float32 // in degrees.
28348                         BackfaceCull     bool
28349                         Nametag          string
28350                         NametagColor     color.NRGBA
28351                         FaceRotateSpeed  float32 // in degrees per second.
28352                         Infotext         string
28353                         Itemstring       string
28354                         Glow             int8
28355                         MaxBreath        uint16  // Player only.
28356                         EyeHeight        float32 // Player only.
28357                         ZoomFOV          float32 // in degrees. Player only.
28358                         UseTextureAlpha  bool
28359                         DmgTextureMod    Texture // suffix
28360                         Shaded           bool
28361                         ShowOnMinimap    bool
28362                         NametagBG        color.NRGBA
28363                 }))(obj)).NametagColor
28364                 w.Write([]byte{x.A, x.R, x.G, x.B})
28365         }
28366         {
28367                 x := (*(*(struct {
28368                         MaxHP            uint16 // Player only.
28369                         CollideWithNodes bool
28370                         Weight           float32 // deprecated
28371                         ColBox, SelBox   Box
28372                         Pointable        bool
28373                         Visual           string
28374                         VisualSize       [3]float32
28375                         Textures         []Texture
28376                         SpriteSheetSize  [2]int16 // in sprites.
28377                         SpritePos        [2]int16 // in sprite sheet.
28378                         Visible          bool
28379                         MakeFootstepSnds bool
28380                         RotateSpeed      float32 // in radians per second.
28381                         Mesh             string
28382                         Colors           []color.NRGBA
28383                         CollideWithAOs   bool
28384                         StepHeight       float32
28385                         FaceRotateDir    bool
28386                         FaceRotateDirOff float32 // in degrees.
28387                         BackfaceCull     bool
28388                         Nametag          string
28389                         NametagColor     color.NRGBA
28390                         FaceRotateSpeed  float32 // in degrees per second.
28391                         Infotext         string
28392                         Itemstring       string
28393                         Glow             int8
28394                         MaxBreath        uint16  // Player only.
28395                         EyeHeight        float32 // Player only.
28396                         ZoomFOV          float32 // in degrees. Player only.
28397                         UseTextureAlpha  bool
28398                         DmgTextureMod    Texture // suffix
28399                         Shaded           bool
28400                         ShowOnMinimap    bool
28401                         NametagBG        color.NRGBA
28402                 }))(obj)).FaceRotateSpeed
28403                 write32(w, math.Float32bits(x))
28404         }
28405         if len(([]byte((*(*(struct {
28406                 MaxHP            uint16 // Player only.
28407                 CollideWithNodes bool
28408                 Weight           float32 // deprecated
28409                 ColBox, SelBox   Box
28410                 Pointable        bool
28411                 Visual           string
28412                 VisualSize       [3]float32
28413                 Textures         []Texture
28414                 SpriteSheetSize  [2]int16 // in sprites.
28415                 SpritePos        [2]int16 // in sprite sheet.
28416                 Visible          bool
28417                 MakeFootstepSnds bool
28418                 RotateSpeed      float32 // in radians per second.
28419                 Mesh             string
28420                 Colors           []color.NRGBA
28421                 CollideWithAOs   bool
28422                 StepHeight       float32
28423                 FaceRotateDir    bool
28424                 FaceRotateDirOff float32 // in degrees.
28425                 BackfaceCull     bool
28426                 Nametag          string
28427                 NametagColor     color.NRGBA
28428                 FaceRotateSpeed  float32 // in degrees per second.
28429                 Infotext         string
28430                 Itemstring       string
28431                 Glow             int8
28432                 MaxBreath        uint16  // Player only.
28433                 EyeHeight        float32 // Player only.
28434                 ZoomFOV          float32 // in degrees. Player only.
28435                 UseTextureAlpha  bool
28436                 DmgTextureMod    Texture // suffix
28437                 Shaded           bool
28438                 ShowOnMinimap    bool
28439                 NametagBG        color.NRGBA
28440         }))(obj)).Infotext))) > math.MaxUint16 {
28441                 chk(ErrTooLong)
28442         }
28443         {
28444                 x := uint16(len(([]byte((*(*(struct {
28445                         MaxHP            uint16 // Player only.
28446                         CollideWithNodes bool
28447                         Weight           float32 // deprecated
28448                         ColBox, SelBox   Box
28449                         Pointable        bool
28450                         Visual           string
28451                         VisualSize       [3]float32
28452                         Textures         []Texture
28453                         SpriteSheetSize  [2]int16 // in sprites.
28454                         SpritePos        [2]int16 // in sprite sheet.
28455                         Visible          bool
28456                         MakeFootstepSnds bool
28457                         RotateSpeed      float32 // in radians per second.
28458                         Mesh             string
28459                         Colors           []color.NRGBA
28460                         CollideWithAOs   bool
28461                         StepHeight       float32
28462                         FaceRotateDir    bool
28463                         FaceRotateDirOff float32 // in degrees.
28464                         BackfaceCull     bool
28465                         Nametag          string
28466                         NametagColor     color.NRGBA
28467                         FaceRotateSpeed  float32 // in degrees per second.
28468                         Infotext         string
28469                         Itemstring       string
28470                         Glow             int8
28471                         MaxBreath        uint16  // Player only.
28472                         EyeHeight        float32 // Player only.
28473                         ZoomFOV          float32 // in degrees. Player only.
28474                         UseTextureAlpha  bool
28475                         DmgTextureMod    Texture // suffix
28476                         Shaded           bool
28477                         ShowOnMinimap    bool
28478                         NametagBG        color.NRGBA
28479                 }))(obj)).Infotext))))
28480                 write16(w, uint16(x))
28481         }
28482         {
28483                 _, err := w.Write(([]byte((*(*(struct {
28484                         MaxHP            uint16 // Player only.
28485                         CollideWithNodes bool
28486                         Weight           float32 // deprecated
28487                         ColBox, SelBox   Box
28488                         Pointable        bool
28489                         Visual           string
28490                         VisualSize       [3]float32
28491                         Textures         []Texture
28492                         SpriteSheetSize  [2]int16 // in sprites.
28493                         SpritePos        [2]int16 // in sprite sheet.
28494                         Visible          bool
28495                         MakeFootstepSnds bool
28496                         RotateSpeed      float32 // in radians per second.
28497                         Mesh             string
28498                         Colors           []color.NRGBA
28499                         CollideWithAOs   bool
28500                         StepHeight       float32
28501                         FaceRotateDir    bool
28502                         FaceRotateDirOff float32 // in degrees.
28503                         BackfaceCull     bool
28504                         Nametag          string
28505                         NametagColor     color.NRGBA
28506                         FaceRotateSpeed  float32 // in degrees per second.
28507                         Infotext         string
28508                         Itemstring       string
28509                         Glow             int8
28510                         MaxBreath        uint16  // Player only.
28511                         EyeHeight        float32 // Player only.
28512                         ZoomFOV          float32 // in degrees. Player only.
28513                         UseTextureAlpha  bool
28514                         DmgTextureMod    Texture // suffix
28515                         Shaded           bool
28516                         ShowOnMinimap    bool
28517                         NametagBG        color.NRGBA
28518                 }))(obj)).Infotext))[:])
28519                 chk(err)
28520         }
28521         if len(([]byte((*(*(struct {
28522                 MaxHP            uint16 // Player only.
28523                 CollideWithNodes bool
28524                 Weight           float32 // deprecated
28525                 ColBox, SelBox   Box
28526                 Pointable        bool
28527                 Visual           string
28528                 VisualSize       [3]float32
28529                 Textures         []Texture
28530                 SpriteSheetSize  [2]int16 // in sprites.
28531                 SpritePos        [2]int16 // in sprite sheet.
28532                 Visible          bool
28533                 MakeFootstepSnds bool
28534                 RotateSpeed      float32 // in radians per second.
28535                 Mesh             string
28536                 Colors           []color.NRGBA
28537                 CollideWithAOs   bool
28538                 StepHeight       float32
28539                 FaceRotateDir    bool
28540                 FaceRotateDirOff float32 // in degrees.
28541                 BackfaceCull     bool
28542                 Nametag          string
28543                 NametagColor     color.NRGBA
28544                 FaceRotateSpeed  float32 // in degrees per second.
28545                 Infotext         string
28546                 Itemstring       string
28547                 Glow             int8
28548                 MaxBreath        uint16  // Player only.
28549                 EyeHeight        float32 // Player only.
28550                 ZoomFOV          float32 // in degrees. Player only.
28551                 UseTextureAlpha  bool
28552                 DmgTextureMod    Texture // suffix
28553                 Shaded           bool
28554                 ShowOnMinimap    bool
28555                 NametagBG        color.NRGBA
28556         }))(obj)).Itemstring))) > math.MaxUint16 {
28557                 chk(ErrTooLong)
28558         }
28559         {
28560                 x := uint16(len(([]byte((*(*(struct {
28561                         MaxHP            uint16 // Player only.
28562                         CollideWithNodes bool
28563                         Weight           float32 // deprecated
28564                         ColBox, SelBox   Box
28565                         Pointable        bool
28566                         Visual           string
28567                         VisualSize       [3]float32
28568                         Textures         []Texture
28569                         SpriteSheetSize  [2]int16 // in sprites.
28570                         SpritePos        [2]int16 // in sprite sheet.
28571                         Visible          bool
28572                         MakeFootstepSnds bool
28573                         RotateSpeed      float32 // in radians per second.
28574                         Mesh             string
28575                         Colors           []color.NRGBA
28576                         CollideWithAOs   bool
28577                         StepHeight       float32
28578                         FaceRotateDir    bool
28579                         FaceRotateDirOff float32 // in degrees.
28580                         BackfaceCull     bool
28581                         Nametag          string
28582                         NametagColor     color.NRGBA
28583                         FaceRotateSpeed  float32 // in degrees per second.
28584                         Infotext         string
28585                         Itemstring       string
28586                         Glow             int8
28587                         MaxBreath        uint16  // Player only.
28588                         EyeHeight        float32 // Player only.
28589                         ZoomFOV          float32 // in degrees. Player only.
28590                         UseTextureAlpha  bool
28591                         DmgTextureMod    Texture // suffix
28592                         Shaded           bool
28593                         ShowOnMinimap    bool
28594                         NametagBG        color.NRGBA
28595                 }))(obj)).Itemstring))))
28596                 write16(w, uint16(x))
28597         }
28598         {
28599                 _, err := w.Write(([]byte((*(*(struct {
28600                         MaxHP            uint16 // Player only.
28601                         CollideWithNodes bool
28602                         Weight           float32 // deprecated
28603                         ColBox, SelBox   Box
28604                         Pointable        bool
28605                         Visual           string
28606                         VisualSize       [3]float32
28607                         Textures         []Texture
28608                         SpriteSheetSize  [2]int16 // in sprites.
28609                         SpritePos        [2]int16 // in sprite sheet.
28610                         Visible          bool
28611                         MakeFootstepSnds bool
28612                         RotateSpeed      float32 // in radians per second.
28613                         Mesh             string
28614                         Colors           []color.NRGBA
28615                         CollideWithAOs   bool
28616                         StepHeight       float32
28617                         FaceRotateDir    bool
28618                         FaceRotateDirOff float32 // in degrees.
28619                         BackfaceCull     bool
28620                         Nametag          string
28621                         NametagColor     color.NRGBA
28622                         FaceRotateSpeed  float32 // in degrees per second.
28623                         Infotext         string
28624                         Itemstring       string
28625                         Glow             int8
28626                         MaxBreath        uint16  // Player only.
28627                         EyeHeight        float32 // Player only.
28628                         ZoomFOV          float32 // in degrees. Player only.
28629                         UseTextureAlpha  bool
28630                         DmgTextureMod    Texture // suffix
28631                         Shaded           bool
28632                         ShowOnMinimap    bool
28633                         NametagBG        color.NRGBA
28634                 }))(obj)).Itemstring))[:])
28635                 chk(err)
28636         }
28637         {
28638                 x := (*(*(struct {
28639                         MaxHP            uint16 // Player only.
28640                         CollideWithNodes bool
28641                         Weight           float32 // deprecated
28642                         ColBox, SelBox   Box
28643                         Pointable        bool
28644                         Visual           string
28645                         VisualSize       [3]float32
28646                         Textures         []Texture
28647                         SpriteSheetSize  [2]int16 // in sprites.
28648                         SpritePos        [2]int16 // in sprite sheet.
28649                         Visible          bool
28650                         MakeFootstepSnds bool
28651                         RotateSpeed      float32 // in radians per second.
28652                         Mesh             string
28653                         Colors           []color.NRGBA
28654                         CollideWithAOs   bool
28655                         StepHeight       float32
28656                         FaceRotateDir    bool
28657                         FaceRotateDirOff float32 // in degrees.
28658                         BackfaceCull     bool
28659                         Nametag          string
28660                         NametagColor     color.NRGBA
28661                         FaceRotateSpeed  float32 // in degrees per second.
28662                         Infotext         string
28663                         Itemstring       string
28664                         Glow             int8
28665                         MaxBreath        uint16  // Player only.
28666                         EyeHeight        float32 // Player only.
28667                         ZoomFOV          float32 // in degrees. Player only.
28668                         UseTextureAlpha  bool
28669                         DmgTextureMod    Texture // suffix
28670                         Shaded           bool
28671                         ShowOnMinimap    bool
28672                         NametagBG        color.NRGBA
28673                 }))(obj)).Glow
28674                 write8(w, uint8(x))
28675         }
28676         {
28677                 x := (*(*(struct {
28678                         MaxHP            uint16 // Player only.
28679                         CollideWithNodes bool
28680                         Weight           float32 // deprecated
28681                         ColBox, SelBox   Box
28682                         Pointable        bool
28683                         Visual           string
28684                         VisualSize       [3]float32
28685                         Textures         []Texture
28686                         SpriteSheetSize  [2]int16 // in sprites.
28687                         SpritePos        [2]int16 // in sprite sheet.
28688                         Visible          bool
28689                         MakeFootstepSnds bool
28690                         RotateSpeed      float32 // in radians per second.
28691                         Mesh             string
28692                         Colors           []color.NRGBA
28693                         CollideWithAOs   bool
28694                         StepHeight       float32
28695                         FaceRotateDir    bool
28696                         FaceRotateDirOff float32 // in degrees.
28697                         BackfaceCull     bool
28698                         Nametag          string
28699                         NametagColor     color.NRGBA
28700                         FaceRotateSpeed  float32 // in degrees per second.
28701                         Infotext         string
28702                         Itemstring       string
28703                         Glow             int8
28704                         MaxBreath        uint16  // Player only.
28705                         EyeHeight        float32 // Player only.
28706                         ZoomFOV          float32 // in degrees. Player only.
28707                         UseTextureAlpha  bool
28708                         DmgTextureMod    Texture // suffix
28709                         Shaded           bool
28710                         ShowOnMinimap    bool
28711                         NametagBG        color.NRGBA
28712                 }))(obj)).MaxBreath
28713                 write16(w, uint16(x))
28714         }
28715         {
28716                 x := (*(*(struct {
28717                         MaxHP            uint16 // Player only.
28718                         CollideWithNodes bool
28719                         Weight           float32 // deprecated
28720                         ColBox, SelBox   Box
28721                         Pointable        bool
28722                         Visual           string
28723                         VisualSize       [3]float32
28724                         Textures         []Texture
28725                         SpriteSheetSize  [2]int16 // in sprites.
28726                         SpritePos        [2]int16 // in sprite sheet.
28727                         Visible          bool
28728                         MakeFootstepSnds bool
28729                         RotateSpeed      float32 // in radians per second.
28730                         Mesh             string
28731                         Colors           []color.NRGBA
28732                         CollideWithAOs   bool
28733                         StepHeight       float32
28734                         FaceRotateDir    bool
28735                         FaceRotateDirOff float32 // in degrees.
28736                         BackfaceCull     bool
28737                         Nametag          string
28738                         NametagColor     color.NRGBA
28739                         FaceRotateSpeed  float32 // in degrees per second.
28740                         Infotext         string
28741                         Itemstring       string
28742                         Glow             int8
28743                         MaxBreath        uint16  // Player only.
28744                         EyeHeight        float32 // Player only.
28745                         ZoomFOV          float32 // in degrees. Player only.
28746                         UseTextureAlpha  bool
28747                         DmgTextureMod    Texture // suffix
28748                         Shaded           bool
28749                         ShowOnMinimap    bool
28750                         NametagBG        color.NRGBA
28751                 }))(obj)).EyeHeight
28752                 write32(w, math.Float32bits(x))
28753         }
28754         {
28755                 x := (*(*(struct {
28756                         MaxHP            uint16 // Player only.
28757                         CollideWithNodes bool
28758                         Weight           float32 // deprecated
28759                         ColBox, SelBox   Box
28760                         Pointable        bool
28761                         Visual           string
28762                         VisualSize       [3]float32
28763                         Textures         []Texture
28764                         SpriteSheetSize  [2]int16 // in sprites.
28765                         SpritePos        [2]int16 // in sprite sheet.
28766                         Visible          bool
28767                         MakeFootstepSnds bool
28768                         RotateSpeed      float32 // in radians per second.
28769                         Mesh             string
28770                         Colors           []color.NRGBA
28771                         CollideWithAOs   bool
28772                         StepHeight       float32
28773                         FaceRotateDir    bool
28774                         FaceRotateDirOff float32 // in degrees.
28775                         BackfaceCull     bool
28776                         Nametag          string
28777                         NametagColor     color.NRGBA
28778                         FaceRotateSpeed  float32 // in degrees per second.
28779                         Infotext         string
28780                         Itemstring       string
28781                         Glow             int8
28782                         MaxBreath        uint16  // Player only.
28783                         EyeHeight        float32 // Player only.
28784                         ZoomFOV          float32 // in degrees. Player only.
28785                         UseTextureAlpha  bool
28786                         DmgTextureMod    Texture // suffix
28787                         Shaded           bool
28788                         ShowOnMinimap    bool
28789                         NametagBG        color.NRGBA
28790                 }))(obj)).ZoomFOV
28791                 write32(w, math.Float32bits(x))
28792         }
28793         {
28794                 x := (*(*(struct {
28795                         MaxHP            uint16 // Player only.
28796                         CollideWithNodes bool
28797                         Weight           float32 // deprecated
28798                         ColBox, SelBox   Box
28799                         Pointable        bool
28800                         Visual           string
28801                         VisualSize       [3]float32
28802                         Textures         []Texture
28803                         SpriteSheetSize  [2]int16 // in sprites.
28804                         SpritePos        [2]int16 // in sprite sheet.
28805                         Visible          bool
28806                         MakeFootstepSnds bool
28807                         RotateSpeed      float32 // in radians per second.
28808                         Mesh             string
28809                         Colors           []color.NRGBA
28810                         CollideWithAOs   bool
28811                         StepHeight       float32
28812                         FaceRotateDir    bool
28813                         FaceRotateDirOff float32 // in degrees.
28814                         BackfaceCull     bool
28815                         Nametag          string
28816                         NametagColor     color.NRGBA
28817                         FaceRotateSpeed  float32 // in degrees per second.
28818                         Infotext         string
28819                         Itemstring       string
28820                         Glow             int8
28821                         MaxBreath        uint16  // Player only.
28822                         EyeHeight        float32 // Player only.
28823                         ZoomFOV          float32 // in degrees. Player only.
28824                         UseTextureAlpha  bool
28825                         DmgTextureMod    Texture // suffix
28826                         Shaded           bool
28827                         ShowOnMinimap    bool
28828                         NametagBG        color.NRGBA
28829                 }))(obj)).UseTextureAlpha
28830                 if x {
28831                         write8(w, 1)
28832                 } else {
28833                         write8(w, 0)
28834                 }
28835         }
28836         if err := pcall(func() {
28837                 ((*(*(struct {
28838                         MaxHP            uint16 // Player only.
28839                         CollideWithNodes bool
28840                         Weight           float32 // deprecated
28841                         ColBox, SelBox   Box
28842                         Pointable        bool
28843                         Visual           string
28844                         VisualSize       [3]float32
28845                         Textures         []Texture
28846                         SpriteSheetSize  [2]int16 // in sprites.
28847                         SpritePos        [2]int16 // in sprite sheet.
28848                         Visible          bool
28849                         MakeFootstepSnds bool
28850                         RotateSpeed      float32 // in radians per second.
28851                         Mesh             string
28852                         Colors           []color.NRGBA
28853                         CollideWithAOs   bool
28854                         StepHeight       float32
28855                         FaceRotateDir    bool
28856                         FaceRotateDirOff float32 // in degrees.
28857                         BackfaceCull     bool
28858                         Nametag          string
28859                         NametagColor     color.NRGBA
28860                         FaceRotateSpeed  float32 // in degrees per second.
28861                         Infotext         string
28862                         Itemstring       string
28863                         Glow             int8
28864                         MaxBreath        uint16  // Player only.
28865                         EyeHeight        float32 // Player only.
28866                         ZoomFOV          float32 // in degrees. Player only.
28867                         UseTextureAlpha  bool
28868                         DmgTextureMod    Texture // suffix
28869                         Shaded           bool
28870                         ShowOnMinimap    bool
28871                         NametagBG        color.NRGBA
28872                 }))(obj)).DmgTextureMod).Serialize(w)
28873         }); err != nil {
28874                 if err == io.EOF {
28875                         chk(io.EOF)
28876                 }
28877                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
28878         }
28879         {
28880                 x := (*(*(struct {
28881                         MaxHP            uint16 // Player only.
28882                         CollideWithNodes bool
28883                         Weight           float32 // deprecated
28884                         ColBox, SelBox   Box
28885                         Pointable        bool
28886                         Visual           string
28887                         VisualSize       [3]float32
28888                         Textures         []Texture
28889                         SpriteSheetSize  [2]int16 // in sprites.
28890                         SpritePos        [2]int16 // in sprite sheet.
28891                         Visible          bool
28892                         MakeFootstepSnds bool
28893                         RotateSpeed      float32 // in radians per second.
28894                         Mesh             string
28895                         Colors           []color.NRGBA
28896                         CollideWithAOs   bool
28897                         StepHeight       float32
28898                         FaceRotateDir    bool
28899                         FaceRotateDirOff float32 // in degrees.
28900                         BackfaceCull     bool
28901                         Nametag          string
28902                         NametagColor     color.NRGBA
28903                         FaceRotateSpeed  float32 // in degrees per second.
28904                         Infotext         string
28905                         Itemstring       string
28906                         Glow             int8
28907                         MaxBreath        uint16  // Player only.
28908                         EyeHeight        float32 // Player only.
28909                         ZoomFOV          float32 // in degrees. Player only.
28910                         UseTextureAlpha  bool
28911                         DmgTextureMod    Texture // suffix
28912                         Shaded           bool
28913                         ShowOnMinimap    bool
28914                         NametagBG        color.NRGBA
28915                 }))(obj)).Shaded
28916                 if x {
28917                         write8(w, 1)
28918                 } else {
28919                         write8(w, 0)
28920                 }
28921         }
28922         {
28923                 x := (*(*(struct {
28924                         MaxHP            uint16 // Player only.
28925                         CollideWithNodes bool
28926                         Weight           float32 // deprecated
28927                         ColBox, SelBox   Box
28928                         Pointable        bool
28929                         Visual           string
28930                         VisualSize       [3]float32
28931                         Textures         []Texture
28932                         SpriteSheetSize  [2]int16 // in sprites.
28933                         SpritePos        [2]int16 // in sprite sheet.
28934                         Visible          bool
28935                         MakeFootstepSnds bool
28936                         RotateSpeed      float32 // in radians per second.
28937                         Mesh             string
28938                         Colors           []color.NRGBA
28939                         CollideWithAOs   bool
28940                         StepHeight       float32
28941                         FaceRotateDir    bool
28942                         FaceRotateDirOff float32 // in degrees.
28943                         BackfaceCull     bool
28944                         Nametag          string
28945                         NametagColor     color.NRGBA
28946                         FaceRotateSpeed  float32 // in degrees per second.
28947                         Infotext         string
28948                         Itemstring       string
28949                         Glow             int8
28950                         MaxBreath        uint16  // Player only.
28951                         EyeHeight        float32 // Player only.
28952                         ZoomFOV          float32 // in degrees. Player only.
28953                         UseTextureAlpha  bool
28954                         DmgTextureMod    Texture // suffix
28955                         Shaded           bool
28956                         ShowOnMinimap    bool
28957                         NametagBG        color.NRGBA
28958                 }))(obj)).ShowOnMinimap
28959                 if x {
28960                         write8(w, 1)
28961                 } else {
28962                         write8(w, 0)
28963                 }
28964         }
28965         {
28966                 x := (*(*(struct {
28967                         MaxHP            uint16 // Player only.
28968                         CollideWithNodes bool
28969                         Weight           float32 // deprecated
28970                         ColBox, SelBox   Box
28971                         Pointable        bool
28972                         Visual           string
28973                         VisualSize       [3]float32
28974                         Textures         []Texture
28975                         SpriteSheetSize  [2]int16 // in sprites.
28976                         SpritePos        [2]int16 // in sprite sheet.
28977                         Visible          bool
28978                         MakeFootstepSnds bool
28979                         RotateSpeed      float32 // in radians per second.
28980                         Mesh             string
28981                         Colors           []color.NRGBA
28982                         CollideWithAOs   bool
28983                         StepHeight       float32
28984                         FaceRotateDir    bool
28985                         FaceRotateDirOff float32 // in degrees.
28986                         BackfaceCull     bool
28987                         Nametag          string
28988                         NametagColor     color.NRGBA
28989                         FaceRotateSpeed  float32 // in degrees per second.
28990                         Infotext         string
28991                         Itemstring       string
28992                         Glow             int8
28993                         MaxBreath        uint16  // Player only.
28994                         EyeHeight        float32 // Player only.
28995                         ZoomFOV          float32 // in degrees. Player only.
28996                         UseTextureAlpha  bool
28997                         DmgTextureMod    Texture // suffix
28998                         Shaded           bool
28999                         ShowOnMinimap    bool
29000                         NametagBG        color.NRGBA
29001                 }))(obj)).NametagBG
29002                 w.Write([]byte{x.A, x.R, x.G, x.B})
29003         }
29004 }
29005
29006 func (obj *AOProps) Deserialize(r io.Reader) {
29007         {
29008                 var local341 uint8
29009                 local342 := uint8(4)
29010                 {
29011                         p := &local341
29012                         *p = read8(r)
29013                 }
29014                 if local341 != local342 {
29015                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local341))
29016                 }
29017         }
29018         {
29019                 p := &(*(*(struct {
29020                         MaxHP            uint16 // Player only.
29021                         CollideWithNodes bool
29022                         Weight           float32 // deprecated
29023                         ColBox, SelBox   Box
29024                         Pointable        bool
29025                         Visual           string
29026                         VisualSize       [3]float32
29027                         Textures         []Texture
29028                         SpriteSheetSize  [2]int16 // in sprites.
29029                         SpritePos        [2]int16 // in sprite sheet.
29030                         Visible          bool
29031                         MakeFootstepSnds bool
29032                         RotateSpeed      float32 // in radians per second.
29033                         Mesh             string
29034                         Colors           []color.NRGBA
29035                         CollideWithAOs   bool
29036                         StepHeight       float32
29037                         FaceRotateDir    bool
29038                         FaceRotateDirOff float32 // in degrees.
29039                         BackfaceCull     bool
29040                         Nametag          string
29041                         NametagColor     color.NRGBA
29042                         FaceRotateSpeed  float32 // in degrees per second.
29043                         Infotext         string
29044                         Itemstring       string
29045                         Glow             int8
29046                         MaxBreath        uint16  // Player only.
29047                         EyeHeight        float32 // Player only.
29048                         ZoomFOV          float32 // in degrees. Player only.
29049                         UseTextureAlpha  bool
29050                         DmgTextureMod    Texture // suffix
29051                         Shaded           bool
29052                         ShowOnMinimap    bool
29053                         NametagBG        color.NRGBA
29054                 }))(obj)).MaxHP
29055                 *p = read16(r)
29056         }
29057         {
29058                 p := &(*(*(struct {
29059                         MaxHP            uint16 // Player only.
29060                         CollideWithNodes bool
29061                         Weight           float32 // deprecated
29062                         ColBox, SelBox   Box
29063                         Pointable        bool
29064                         Visual           string
29065                         VisualSize       [3]float32
29066                         Textures         []Texture
29067                         SpriteSheetSize  [2]int16 // in sprites.
29068                         SpritePos        [2]int16 // in sprite sheet.
29069                         Visible          bool
29070                         MakeFootstepSnds bool
29071                         RotateSpeed      float32 // in radians per second.
29072                         Mesh             string
29073                         Colors           []color.NRGBA
29074                         CollideWithAOs   bool
29075                         StepHeight       float32
29076                         FaceRotateDir    bool
29077                         FaceRotateDirOff float32 // in degrees.
29078                         BackfaceCull     bool
29079                         Nametag          string
29080                         NametagColor     color.NRGBA
29081                         FaceRotateSpeed  float32 // in degrees per second.
29082                         Infotext         string
29083                         Itemstring       string
29084                         Glow             int8
29085                         MaxBreath        uint16  // Player only.
29086                         EyeHeight        float32 // Player only.
29087                         ZoomFOV          float32 // in degrees. Player only.
29088                         UseTextureAlpha  bool
29089                         DmgTextureMod    Texture // suffix
29090                         Shaded           bool
29091                         ShowOnMinimap    bool
29092                         NametagBG        color.NRGBA
29093                 }))(obj)).CollideWithNodes
29094                 switch n := read8(r); n {
29095                 case 0:
29096                         *p = false
29097                 case 1:
29098                         *p = true
29099                 default:
29100                         chk(fmt.Errorf("invalid bool: %d", n))
29101                 }
29102         }
29103         {
29104                 p := &(*(*(struct {
29105                         MaxHP            uint16 // Player only.
29106                         CollideWithNodes bool
29107                         Weight           float32 // deprecated
29108                         ColBox, SelBox   Box
29109                         Pointable        bool
29110                         Visual           string
29111                         VisualSize       [3]float32
29112                         Textures         []Texture
29113                         SpriteSheetSize  [2]int16 // in sprites.
29114                         SpritePos        [2]int16 // in sprite sheet.
29115                         Visible          bool
29116                         MakeFootstepSnds bool
29117                         RotateSpeed      float32 // in radians per second.
29118                         Mesh             string
29119                         Colors           []color.NRGBA
29120                         CollideWithAOs   bool
29121                         StepHeight       float32
29122                         FaceRotateDir    bool
29123                         FaceRotateDirOff float32 // in degrees.
29124                         BackfaceCull     bool
29125                         Nametag          string
29126                         NametagColor     color.NRGBA
29127                         FaceRotateSpeed  float32 // in degrees per second.
29128                         Infotext         string
29129                         Itemstring       string
29130                         Glow             int8
29131                         MaxBreath        uint16  // Player only.
29132                         EyeHeight        float32 // Player only.
29133                         ZoomFOV          float32 // in degrees. Player only.
29134                         UseTextureAlpha  bool
29135                         DmgTextureMod    Texture // suffix
29136                         Shaded           bool
29137                         ShowOnMinimap    bool
29138                         NametagBG        color.NRGBA
29139                 }))(obj)).Weight
29140                 *p = math.Float32frombits(read32(r))
29141         }
29142         if err := pcall(func() {
29143                 ((*(*(struct {
29144                         MaxHP            uint16 // Player only.
29145                         CollideWithNodes bool
29146                         Weight           float32 // deprecated
29147                         ColBox, SelBox   Box
29148                         Pointable        bool
29149                         Visual           string
29150                         VisualSize       [3]float32
29151                         Textures         []Texture
29152                         SpriteSheetSize  [2]int16 // in sprites.
29153                         SpritePos        [2]int16 // in sprite sheet.
29154                         Visible          bool
29155                         MakeFootstepSnds bool
29156                         RotateSpeed      float32 // in radians per second.
29157                         Mesh             string
29158                         Colors           []color.NRGBA
29159                         CollideWithAOs   bool
29160                         StepHeight       float32
29161                         FaceRotateDir    bool
29162                         FaceRotateDirOff float32 // in degrees.
29163                         BackfaceCull     bool
29164                         Nametag          string
29165                         NametagColor     color.NRGBA
29166                         FaceRotateSpeed  float32 // in degrees per second.
29167                         Infotext         string
29168                         Itemstring       string
29169                         Glow             int8
29170                         MaxBreath        uint16  // Player only.
29171                         EyeHeight        float32 // Player only.
29172                         ZoomFOV          float32 // in degrees. Player only.
29173                         UseTextureAlpha  bool
29174                         DmgTextureMod    Texture // suffix
29175                         Shaded           bool
29176                         ShowOnMinimap    bool
29177                         NametagBG        color.NRGBA
29178                 }))(obj)).ColBox).Deserialize(r)
29179         }); err != nil {
29180                 if err == io.EOF {
29181                         chk(io.EOF)
29182                 }
29183                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29184         }
29185         if err := pcall(func() {
29186                 ((*(*(struct {
29187                         MaxHP            uint16 // Player only.
29188                         CollideWithNodes bool
29189                         Weight           float32 // deprecated
29190                         ColBox, SelBox   Box
29191                         Pointable        bool
29192                         Visual           string
29193                         VisualSize       [3]float32
29194                         Textures         []Texture
29195                         SpriteSheetSize  [2]int16 // in sprites.
29196                         SpritePos        [2]int16 // in sprite sheet.
29197                         Visible          bool
29198                         MakeFootstepSnds bool
29199                         RotateSpeed      float32 // in radians per second.
29200                         Mesh             string
29201                         Colors           []color.NRGBA
29202                         CollideWithAOs   bool
29203                         StepHeight       float32
29204                         FaceRotateDir    bool
29205                         FaceRotateDirOff float32 // in degrees.
29206                         BackfaceCull     bool
29207                         Nametag          string
29208                         NametagColor     color.NRGBA
29209                         FaceRotateSpeed  float32 // in degrees per second.
29210                         Infotext         string
29211                         Itemstring       string
29212                         Glow             int8
29213                         MaxBreath        uint16  // Player only.
29214                         EyeHeight        float32 // Player only.
29215                         ZoomFOV          float32 // in degrees. Player only.
29216                         UseTextureAlpha  bool
29217                         DmgTextureMod    Texture // suffix
29218                         Shaded           bool
29219                         ShowOnMinimap    bool
29220                         NametagBG        color.NRGBA
29221                 }))(obj)).SelBox).Deserialize(r)
29222         }); err != nil {
29223                 if err == io.EOF {
29224                         chk(io.EOF)
29225                 }
29226                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29227         }
29228         {
29229                 p := &(*(*(struct {
29230                         MaxHP            uint16 // Player only.
29231                         CollideWithNodes bool
29232                         Weight           float32 // deprecated
29233                         ColBox, SelBox   Box
29234                         Pointable        bool
29235                         Visual           string
29236                         VisualSize       [3]float32
29237                         Textures         []Texture
29238                         SpriteSheetSize  [2]int16 // in sprites.
29239                         SpritePos        [2]int16 // in sprite sheet.
29240                         Visible          bool
29241                         MakeFootstepSnds bool
29242                         RotateSpeed      float32 // in radians per second.
29243                         Mesh             string
29244                         Colors           []color.NRGBA
29245                         CollideWithAOs   bool
29246                         StepHeight       float32
29247                         FaceRotateDir    bool
29248                         FaceRotateDirOff float32 // in degrees.
29249                         BackfaceCull     bool
29250                         Nametag          string
29251                         NametagColor     color.NRGBA
29252                         FaceRotateSpeed  float32 // in degrees per second.
29253                         Infotext         string
29254                         Itemstring       string
29255                         Glow             int8
29256                         MaxBreath        uint16  // Player only.
29257                         EyeHeight        float32 // Player only.
29258                         ZoomFOV          float32 // in degrees. Player only.
29259                         UseTextureAlpha  bool
29260                         DmgTextureMod    Texture // suffix
29261                         Shaded           bool
29262                         ShowOnMinimap    bool
29263                         NametagBG        color.NRGBA
29264                 }))(obj)).Pointable
29265                 switch n := read8(r); n {
29266                 case 0:
29267                         *p = false
29268                 case 1:
29269                         *p = true
29270                 default:
29271                         chk(fmt.Errorf("invalid bool: %d", n))
29272                 }
29273         }
29274         var local343 []uint8
29275         var local344 uint16
29276         {
29277                 p := &local344
29278                 *p = read16(r)
29279         }
29280         (local343) = make([]uint8, local344)
29281         {
29282                 _, err := io.ReadFull(r, (local343)[:])
29283                 chk(err)
29284         }
29285         ((*(*(struct {
29286                 MaxHP            uint16 // Player only.
29287                 CollideWithNodes bool
29288                 Weight           float32 // deprecated
29289                 ColBox, SelBox   Box
29290                 Pointable        bool
29291                 Visual           string
29292                 VisualSize       [3]float32
29293                 Textures         []Texture
29294                 SpriteSheetSize  [2]int16 // in sprites.
29295                 SpritePos        [2]int16 // in sprite sheet.
29296                 Visible          bool
29297                 MakeFootstepSnds bool
29298                 RotateSpeed      float32 // in radians per second.
29299                 Mesh             string
29300                 Colors           []color.NRGBA
29301                 CollideWithAOs   bool
29302                 StepHeight       float32
29303                 FaceRotateDir    bool
29304                 FaceRotateDirOff float32 // in degrees.
29305                 BackfaceCull     bool
29306                 Nametag          string
29307                 NametagColor     color.NRGBA
29308                 FaceRotateSpeed  float32 // in degrees per second.
29309                 Infotext         string
29310                 Itemstring       string
29311                 Glow             int8
29312                 MaxBreath        uint16  // Player only.
29313                 EyeHeight        float32 // Player only.
29314                 ZoomFOV          float32 // in degrees. Player only.
29315                 UseTextureAlpha  bool
29316                 DmgTextureMod    Texture // suffix
29317                 Shaded           bool
29318                 ShowOnMinimap    bool
29319                 NametagBG        color.NRGBA
29320         }))(obj)).Visual) = string(local343)
29321         for local345 := range (*(*(struct {
29322                 MaxHP            uint16 // Player only.
29323                 CollideWithNodes bool
29324                 Weight           float32 // deprecated
29325                 ColBox, SelBox   Box
29326                 Pointable        bool
29327                 Visual           string
29328                 VisualSize       [3]float32
29329                 Textures         []Texture
29330                 SpriteSheetSize  [2]int16 // in sprites.
29331                 SpritePos        [2]int16 // in sprite sheet.
29332                 Visible          bool
29333                 MakeFootstepSnds bool
29334                 RotateSpeed      float32 // in radians per second.
29335                 Mesh             string
29336                 Colors           []color.NRGBA
29337                 CollideWithAOs   bool
29338                 StepHeight       float32
29339                 FaceRotateDir    bool
29340                 FaceRotateDirOff float32 // in degrees.
29341                 BackfaceCull     bool
29342                 Nametag          string
29343                 NametagColor     color.NRGBA
29344                 FaceRotateSpeed  float32 // in degrees per second.
29345                 Infotext         string
29346                 Itemstring       string
29347                 Glow             int8
29348                 MaxBreath        uint16  // Player only.
29349                 EyeHeight        float32 // Player only.
29350                 ZoomFOV          float32 // in degrees. Player only.
29351                 UseTextureAlpha  bool
29352                 DmgTextureMod    Texture // suffix
29353                 Shaded           bool
29354                 ShowOnMinimap    bool
29355                 NametagBG        color.NRGBA
29356         }))(obj)).VisualSize {
29357                 {
29358                         p := &((*(*(struct {
29359                                 MaxHP            uint16 // Player only.
29360                                 CollideWithNodes bool
29361                                 Weight           float32 // deprecated
29362                                 ColBox, SelBox   Box
29363                                 Pointable        bool
29364                                 Visual           string
29365                                 VisualSize       [3]float32
29366                                 Textures         []Texture
29367                                 SpriteSheetSize  [2]int16 // in sprites.
29368                                 SpritePos        [2]int16 // in sprite sheet.
29369                                 Visible          bool
29370                                 MakeFootstepSnds bool
29371                                 RotateSpeed      float32 // in radians per second.
29372                                 Mesh             string
29373                                 Colors           []color.NRGBA
29374                                 CollideWithAOs   bool
29375                                 StepHeight       float32
29376                                 FaceRotateDir    bool
29377                                 FaceRotateDirOff float32 // in degrees.
29378                                 BackfaceCull     bool
29379                                 Nametag          string
29380                                 NametagColor     color.NRGBA
29381                                 FaceRotateSpeed  float32 // in degrees per second.
29382                                 Infotext         string
29383                                 Itemstring       string
29384                                 Glow             int8
29385                                 MaxBreath        uint16  // Player only.
29386                                 EyeHeight        float32 // Player only.
29387                                 ZoomFOV          float32 // in degrees. Player only.
29388                                 UseTextureAlpha  bool
29389                                 DmgTextureMod    Texture // suffix
29390                                 Shaded           bool
29391                                 ShowOnMinimap    bool
29392                                 NametagBG        color.NRGBA
29393                         }))(obj)).VisualSize)[local345]
29394                         *p = math.Float32frombits(read32(r))
29395                 }
29396         }
29397         var local346 uint16
29398         {
29399                 p := &local346
29400                 *p = read16(r)
29401         }
29402         ((*(*(struct {
29403                 MaxHP            uint16 // Player only.
29404                 CollideWithNodes bool
29405                 Weight           float32 // deprecated
29406                 ColBox, SelBox   Box
29407                 Pointable        bool
29408                 Visual           string
29409                 VisualSize       [3]float32
29410                 Textures         []Texture
29411                 SpriteSheetSize  [2]int16 // in sprites.
29412                 SpritePos        [2]int16 // in sprite sheet.
29413                 Visible          bool
29414                 MakeFootstepSnds bool
29415                 RotateSpeed      float32 // in radians per second.
29416                 Mesh             string
29417                 Colors           []color.NRGBA
29418                 CollideWithAOs   bool
29419                 StepHeight       float32
29420                 FaceRotateDir    bool
29421                 FaceRotateDirOff float32 // in degrees.
29422                 BackfaceCull     bool
29423                 Nametag          string
29424                 NametagColor     color.NRGBA
29425                 FaceRotateSpeed  float32 // in degrees per second.
29426                 Infotext         string
29427                 Itemstring       string
29428                 Glow             int8
29429                 MaxBreath        uint16  // Player only.
29430                 EyeHeight        float32 // Player only.
29431                 ZoomFOV          float32 // in degrees. Player only.
29432                 UseTextureAlpha  bool
29433                 DmgTextureMod    Texture // suffix
29434                 Shaded           bool
29435                 ShowOnMinimap    bool
29436                 NametagBG        color.NRGBA
29437         }))(obj)).Textures) = make([]Texture, local346)
29438         for local347 := range (*(*(struct {
29439                 MaxHP            uint16 // Player only.
29440                 CollideWithNodes bool
29441                 Weight           float32 // deprecated
29442                 ColBox, SelBox   Box
29443                 Pointable        bool
29444                 Visual           string
29445                 VisualSize       [3]float32
29446                 Textures         []Texture
29447                 SpriteSheetSize  [2]int16 // in sprites.
29448                 SpritePos        [2]int16 // in sprite sheet.
29449                 Visible          bool
29450                 MakeFootstepSnds bool
29451                 RotateSpeed      float32 // in radians per second.
29452                 Mesh             string
29453                 Colors           []color.NRGBA
29454                 CollideWithAOs   bool
29455                 StepHeight       float32
29456                 FaceRotateDir    bool
29457                 FaceRotateDirOff float32 // in degrees.
29458                 BackfaceCull     bool
29459                 Nametag          string
29460                 NametagColor     color.NRGBA
29461                 FaceRotateSpeed  float32 // in degrees per second.
29462                 Infotext         string
29463                 Itemstring       string
29464                 Glow             int8
29465                 MaxBreath        uint16  // Player only.
29466                 EyeHeight        float32 // Player only.
29467                 ZoomFOV          float32 // in degrees. Player only.
29468                 UseTextureAlpha  bool
29469                 DmgTextureMod    Texture // suffix
29470                 Shaded           bool
29471                 ShowOnMinimap    bool
29472                 NametagBG        color.NRGBA
29473         }))(obj)).Textures {
29474                 if err := pcall(func() {
29475                         (((*(*(struct {
29476                                 MaxHP            uint16 // Player only.
29477                                 CollideWithNodes bool
29478                                 Weight           float32 // deprecated
29479                                 ColBox, SelBox   Box
29480                                 Pointable        bool
29481                                 Visual           string
29482                                 VisualSize       [3]float32
29483                                 Textures         []Texture
29484                                 SpriteSheetSize  [2]int16 // in sprites.
29485                                 SpritePos        [2]int16 // in sprite sheet.
29486                                 Visible          bool
29487                                 MakeFootstepSnds bool
29488                                 RotateSpeed      float32 // in radians per second.
29489                                 Mesh             string
29490                                 Colors           []color.NRGBA
29491                                 CollideWithAOs   bool
29492                                 StepHeight       float32
29493                                 FaceRotateDir    bool
29494                                 FaceRotateDirOff float32 // in degrees.
29495                                 BackfaceCull     bool
29496                                 Nametag          string
29497                                 NametagColor     color.NRGBA
29498                                 FaceRotateSpeed  float32 // in degrees per second.
29499                                 Infotext         string
29500                                 Itemstring       string
29501                                 Glow             int8
29502                                 MaxBreath        uint16  // Player only.
29503                                 EyeHeight        float32 // Player only.
29504                                 ZoomFOV          float32 // in degrees. Player only.
29505                                 UseTextureAlpha  bool
29506                                 DmgTextureMod    Texture // suffix
29507                                 Shaded           bool
29508                                 ShowOnMinimap    bool
29509                                 NametagBG        color.NRGBA
29510                         }))(obj)).Textures)[local347]).Deserialize(r)
29511                 }); err != nil {
29512                         if err == io.EOF {
29513                                 chk(io.EOF)
29514                         }
29515                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
29516                 }
29517         }
29518         for local348 := range (*(*(struct {
29519                 MaxHP            uint16 // Player only.
29520                 CollideWithNodes bool
29521                 Weight           float32 // deprecated
29522                 ColBox, SelBox   Box
29523                 Pointable        bool
29524                 Visual           string
29525                 VisualSize       [3]float32
29526                 Textures         []Texture
29527                 SpriteSheetSize  [2]int16 // in sprites.
29528                 SpritePos        [2]int16 // in sprite sheet.
29529                 Visible          bool
29530                 MakeFootstepSnds bool
29531                 RotateSpeed      float32 // in radians per second.
29532                 Mesh             string
29533                 Colors           []color.NRGBA
29534                 CollideWithAOs   bool
29535                 StepHeight       float32
29536                 FaceRotateDir    bool
29537                 FaceRotateDirOff float32 // in degrees.
29538                 BackfaceCull     bool
29539                 Nametag          string
29540                 NametagColor     color.NRGBA
29541                 FaceRotateSpeed  float32 // in degrees per second.
29542                 Infotext         string
29543                 Itemstring       string
29544                 Glow             int8
29545                 MaxBreath        uint16  // Player only.
29546                 EyeHeight        float32 // Player only.
29547                 ZoomFOV          float32 // in degrees. Player only.
29548                 UseTextureAlpha  bool
29549                 DmgTextureMod    Texture // suffix
29550                 Shaded           bool
29551                 ShowOnMinimap    bool
29552                 NametagBG        color.NRGBA
29553         }))(obj)).SpriteSheetSize {
29554                 {
29555                         p := &((*(*(struct {
29556                                 MaxHP            uint16 // Player only.
29557                                 CollideWithNodes bool
29558                                 Weight           float32 // deprecated
29559                                 ColBox, SelBox   Box
29560                                 Pointable        bool
29561                                 Visual           string
29562                                 VisualSize       [3]float32
29563                                 Textures         []Texture
29564                                 SpriteSheetSize  [2]int16 // in sprites.
29565                                 SpritePos        [2]int16 // in sprite sheet.
29566                                 Visible          bool
29567                                 MakeFootstepSnds bool
29568                                 RotateSpeed      float32 // in radians per second.
29569                                 Mesh             string
29570                                 Colors           []color.NRGBA
29571                                 CollideWithAOs   bool
29572                                 StepHeight       float32
29573                                 FaceRotateDir    bool
29574                                 FaceRotateDirOff float32 // in degrees.
29575                                 BackfaceCull     bool
29576                                 Nametag          string
29577                                 NametagColor     color.NRGBA
29578                                 FaceRotateSpeed  float32 // in degrees per second.
29579                                 Infotext         string
29580                                 Itemstring       string
29581                                 Glow             int8
29582                                 MaxBreath        uint16  // Player only.
29583                                 EyeHeight        float32 // Player only.
29584                                 ZoomFOV          float32 // in degrees. Player only.
29585                                 UseTextureAlpha  bool
29586                                 DmgTextureMod    Texture // suffix
29587                                 Shaded           bool
29588                                 ShowOnMinimap    bool
29589                                 NametagBG        color.NRGBA
29590                         }))(obj)).SpriteSheetSize)[local348]
29591                         *p = int16(read16(r))
29592                 }
29593         }
29594         for local349 := range (*(*(struct {
29595                 MaxHP            uint16 // Player only.
29596                 CollideWithNodes bool
29597                 Weight           float32 // deprecated
29598                 ColBox, SelBox   Box
29599                 Pointable        bool
29600                 Visual           string
29601                 VisualSize       [3]float32
29602                 Textures         []Texture
29603                 SpriteSheetSize  [2]int16 // in sprites.
29604                 SpritePos        [2]int16 // in sprite sheet.
29605                 Visible          bool
29606                 MakeFootstepSnds bool
29607                 RotateSpeed      float32 // in radians per second.
29608                 Mesh             string
29609                 Colors           []color.NRGBA
29610                 CollideWithAOs   bool
29611                 StepHeight       float32
29612                 FaceRotateDir    bool
29613                 FaceRotateDirOff float32 // in degrees.
29614                 BackfaceCull     bool
29615                 Nametag          string
29616                 NametagColor     color.NRGBA
29617                 FaceRotateSpeed  float32 // in degrees per second.
29618                 Infotext         string
29619                 Itemstring       string
29620                 Glow             int8
29621                 MaxBreath        uint16  // Player only.
29622                 EyeHeight        float32 // Player only.
29623                 ZoomFOV          float32 // in degrees. Player only.
29624                 UseTextureAlpha  bool
29625                 DmgTextureMod    Texture // suffix
29626                 Shaded           bool
29627                 ShowOnMinimap    bool
29628                 NametagBG        color.NRGBA
29629         }))(obj)).SpritePos {
29630                 {
29631                         p := &((*(*(struct {
29632                                 MaxHP            uint16 // Player only.
29633                                 CollideWithNodes bool
29634                                 Weight           float32 // deprecated
29635                                 ColBox, SelBox   Box
29636                                 Pointable        bool
29637                                 Visual           string
29638                                 VisualSize       [3]float32
29639                                 Textures         []Texture
29640                                 SpriteSheetSize  [2]int16 // in sprites.
29641                                 SpritePos        [2]int16 // in sprite sheet.
29642                                 Visible          bool
29643                                 MakeFootstepSnds bool
29644                                 RotateSpeed      float32 // in radians per second.
29645                                 Mesh             string
29646                                 Colors           []color.NRGBA
29647                                 CollideWithAOs   bool
29648                                 StepHeight       float32
29649                                 FaceRotateDir    bool
29650                                 FaceRotateDirOff float32 // in degrees.
29651                                 BackfaceCull     bool
29652                                 Nametag          string
29653                                 NametagColor     color.NRGBA
29654                                 FaceRotateSpeed  float32 // in degrees per second.
29655                                 Infotext         string
29656                                 Itemstring       string
29657                                 Glow             int8
29658                                 MaxBreath        uint16  // Player only.
29659                                 EyeHeight        float32 // Player only.
29660                                 ZoomFOV          float32 // in degrees. Player only.
29661                                 UseTextureAlpha  bool
29662                                 DmgTextureMod    Texture // suffix
29663                                 Shaded           bool
29664                                 ShowOnMinimap    bool
29665                                 NametagBG        color.NRGBA
29666                         }))(obj)).SpritePos)[local349]
29667                         *p = int16(read16(r))
29668                 }
29669         }
29670         {
29671                 p := &(*(*(struct {
29672                         MaxHP            uint16 // Player only.
29673                         CollideWithNodes bool
29674                         Weight           float32 // deprecated
29675                         ColBox, SelBox   Box
29676                         Pointable        bool
29677                         Visual           string
29678                         VisualSize       [3]float32
29679                         Textures         []Texture
29680                         SpriteSheetSize  [2]int16 // in sprites.
29681                         SpritePos        [2]int16 // in sprite sheet.
29682                         Visible          bool
29683                         MakeFootstepSnds bool
29684                         RotateSpeed      float32 // in radians per second.
29685                         Mesh             string
29686                         Colors           []color.NRGBA
29687                         CollideWithAOs   bool
29688                         StepHeight       float32
29689                         FaceRotateDir    bool
29690                         FaceRotateDirOff float32 // in degrees.
29691                         BackfaceCull     bool
29692                         Nametag          string
29693                         NametagColor     color.NRGBA
29694                         FaceRotateSpeed  float32 // in degrees per second.
29695                         Infotext         string
29696                         Itemstring       string
29697                         Glow             int8
29698                         MaxBreath        uint16  // Player only.
29699                         EyeHeight        float32 // Player only.
29700                         ZoomFOV          float32 // in degrees. Player only.
29701                         UseTextureAlpha  bool
29702                         DmgTextureMod    Texture // suffix
29703                         Shaded           bool
29704                         ShowOnMinimap    bool
29705                         NametagBG        color.NRGBA
29706                 }))(obj)).Visible
29707                 switch n := read8(r); n {
29708                 case 0:
29709                         *p = false
29710                 case 1:
29711                         *p = true
29712                 default:
29713                         chk(fmt.Errorf("invalid bool: %d", n))
29714                 }
29715         }
29716         {
29717                 p := &(*(*(struct {
29718                         MaxHP            uint16 // Player only.
29719                         CollideWithNodes bool
29720                         Weight           float32 // deprecated
29721                         ColBox, SelBox   Box
29722                         Pointable        bool
29723                         Visual           string
29724                         VisualSize       [3]float32
29725                         Textures         []Texture
29726                         SpriteSheetSize  [2]int16 // in sprites.
29727                         SpritePos        [2]int16 // in sprite sheet.
29728                         Visible          bool
29729                         MakeFootstepSnds bool
29730                         RotateSpeed      float32 // in radians per second.
29731                         Mesh             string
29732                         Colors           []color.NRGBA
29733                         CollideWithAOs   bool
29734                         StepHeight       float32
29735                         FaceRotateDir    bool
29736                         FaceRotateDirOff float32 // in degrees.
29737                         BackfaceCull     bool
29738                         Nametag          string
29739                         NametagColor     color.NRGBA
29740                         FaceRotateSpeed  float32 // in degrees per second.
29741                         Infotext         string
29742                         Itemstring       string
29743                         Glow             int8
29744                         MaxBreath        uint16  // Player only.
29745                         EyeHeight        float32 // Player only.
29746                         ZoomFOV          float32 // in degrees. Player only.
29747                         UseTextureAlpha  bool
29748                         DmgTextureMod    Texture // suffix
29749                         Shaded           bool
29750                         ShowOnMinimap    bool
29751                         NametagBG        color.NRGBA
29752                 }))(obj)).MakeFootstepSnds
29753                 switch n := read8(r); n {
29754                 case 0:
29755                         *p = false
29756                 case 1:
29757                         *p = true
29758                 default:
29759                         chk(fmt.Errorf("invalid bool: %d", n))
29760                 }
29761         }
29762         {
29763                 p := &(*(*(struct {
29764                         MaxHP            uint16 // Player only.
29765                         CollideWithNodes bool
29766                         Weight           float32 // deprecated
29767                         ColBox, SelBox   Box
29768                         Pointable        bool
29769                         Visual           string
29770                         VisualSize       [3]float32
29771                         Textures         []Texture
29772                         SpriteSheetSize  [2]int16 // in sprites.
29773                         SpritePos        [2]int16 // in sprite sheet.
29774                         Visible          bool
29775                         MakeFootstepSnds bool
29776                         RotateSpeed      float32 // in radians per second.
29777                         Mesh             string
29778                         Colors           []color.NRGBA
29779                         CollideWithAOs   bool
29780                         StepHeight       float32
29781                         FaceRotateDir    bool
29782                         FaceRotateDirOff float32 // in degrees.
29783                         BackfaceCull     bool
29784                         Nametag          string
29785                         NametagColor     color.NRGBA
29786                         FaceRotateSpeed  float32 // in degrees per second.
29787                         Infotext         string
29788                         Itemstring       string
29789                         Glow             int8
29790                         MaxBreath        uint16  // Player only.
29791                         EyeHeight        float32 // Player only.
29792                         ZoomFOV          float32 // in degrees. Player only.
29793                         UseTextureAlpha  bool
29794                         DmgTextureMod    Texture // suffix
29795                         Shaded           bool
29796                         ShowOnMinimap    bool
29797                         NametagBG        color.NRGBA
29798                 }))(obj)).RotateSpeed
29799                 *p = math.Float32frombits(read32(r))
29800         }
29801         var local350 []uint8
29802         var local351 uint16
29803         {
29804                 p := &local351
29805                 *p = read16(r)
29806         }
29807         (local350) = make([]uint8, local351)
29808         {
29809                 _, err := io.ReadFull(r, (local350)[:])
29810                 chk(err)
29811         }
29812         ((*(*(struct {
29813                 MaxHP            uint16 // Player only.
29814                 CollideWithNodes bool
29815                 Weight           float32 // deprecated
29816                 ColBox, SelBox   Box
29817                 Pointable        bool
29818                 Visual           string
29819                 VisualSize       [3]float32
29820                 Textures         []Texture
29821                 SpriteSheetSize  [2]int16 // in sprites.
29822                 SpritePos        [2]int16 // in sprite sheet.
29823                 Visible          bool
29824                 MakeFootstepSnds bool
29825                 RotateSpeed      float32 // in radians per second.
29826                 Mesh             string
29827                 Colors           []color.NRGBA
29828                 CollideWithAOs   bool
29829                 StepHeight       float32
29830                 FaceRotateDir    bool
29831                 FaceRotateDirOff float32 // in degrees.
29832                 BackfaceCull     bool
29833                 Nametag          string
29834                 NametagColor     color.NRGBA
29835                 FaceRotateSpeed  float32 // in degrees per second.
29836                 Infotext         string
29837                 Itemstring       string
29838                 Glow             int8
29839                 MaxBreath        uint16  // Player only.
29840                 EyeHeight        float32 // Player only.
29841                 ZoomFOV          float32 // in degrees. Player only.
29842                 UseTextureAlpha  bool
29843                 DmgTextureMod    Texture // suffix
29844                 Shaded           bool
29845                 ShowOnMinimap    bool
29846                 NametagBG        color.NRGBA
29847         }))(obj)).Mesh) = string(local350)
29848         var local352 uint16
29849         {
29850                 p := &local352
29851                 *p = read16(r)
29852         }
29853         ((*(*(struct {
29854                 MaxHP            uint16 // Player only.
29855                 CollideWithNodes bool
29856                 Weight           float32 // deprecated
29857                 ColBox, SelBox   Box
29858                 Pointable        bool
29859                 Visual           string
29860                 VisualSize       [3]float32
29861                 Textures         []Texture
29862                 SpriteSheetSize  [2]int16 // in sprites.
29863                 SpritePos        [2]int16 // in sprite sheet.
29864                 Visible          bool
29865                 MakeFootstepSnds bool
29866                 RotateSpeed      float32 // in radians per second.
29867                 Mesh             string
29868                 Colors           []color.NRGBA
29869                 CollideWithAOs   bool
29870                 StepHeight       float32
29871                 FaceRotateDir    bool
29872                 FaceRotateDirOff float32 // in degrees.
29873                 BackfaceCull     bool
29874                 Nametag          string
29875                 NametagColor     color.NRGBA
29876                 FaceRotateSpeed  float32 // in degrees per second.
29877                 Infotext         string
29878                 Itemstring       string
29879                 Glow             int8
29880                 MaxBreath        uint16  // Player only.
29881                 EyeHeight        float32 // Player only.
29882                 ZoomFOV          float32 // in degrees. Player only.
29883                 UseTextureAlpha  bool
29884                 DmgTextureMod    Texture // suffix
29885                 Shaded           bool
29886                 ShowOnMinimap    bool
29887                 NametagBG        color.NRGBA
29888         }))(obj)).Colors) = make([]color.NRGBA, local352)
29889         for local353 := range (*(*(struct {
29890                 MaxHP            uint16 // Player only.
29891                 CollideWithNodes bool
29892                 Weight           float32 // deprecated
29893                 ColBox, SelBox   Box
29894                 Pointable        bool
29895                 Visual           string
29896                 VisualSize       [3]float32
29897                 Textures         []Texture
29898                 SpriteSheetSize  [2]int16 // in sprites.
29899                 SpritePos        [2]int16 // in sprite sheet.
29900                 Visible          bool
29901                 MakeFootstepSnds bool
29902                 RotateSpeed      float32 // in radians per second.
29903                 Mesh             string
29904                 Colors           []color.NRGBA
29905                 CollideWithAOs   bool
29906                 StepHeight       float32
29907                 FaceRotateDir    bool
29908                 FaceRotateDirOff float32 // in degrees.
29909                 BackfaceCull     bool
29910                 Nametag          string
29911                 NametagColor     color.NRGBA
29912                 FaceRotateSpeed  float32 // in degrees per second.
29913                 Infotext         string
29914                 Itemstring       string
29915                 Glow             int8
29916                 MaxBreath        uint16  // Player only.
29917                 EyeHeight        float32 // Player only.
29918                 ZoomFOV          float32 // in degrees. Player only.
29919                 UseTextureAlpha  bool
29920                 DmgTextureMod    Texture // suffix
29921                 Shaded           bool
29922                 ShowOnMinimap    bool
29923                 NametagBG        color.NRGBA
29924         }))(obj)).Colors {
29925                 {
29926                         p := &((*(*(struct {
29927                                 MaxHP            uint16 // Player only.
29928                                 CollideWithNodes bool
29929                                 Weight           float32 // deprecated
29930                                 ColBox, SelBox   Box
29931                                 Pointable        bool
29932                                 Visual           string
29933                                 VisualSize       [3]float32
29934                                 Textures         []Texture
29935                                 SpriteSheetSize  [2]int16 // in sprites.
29936                                 SpritePos        [2]int16 // in sprite sheet.
29937                                 Visible          bool
29938                                 MakeFootstepSnds bool
29939                                 RotateSpeed      float32 // in radians per second.
29940                                 Mesh             string
29941                                 Colors           []color.NRGBA
29942                                 CollideWithAOs   bool
29943                                 StepHeight       float32
29944                                 FaceRotateDir    bool
29945                                 FaceRotateDirOff float32 // in degrees.
29946                                 BackfaceCull     bool
29947                                 Nametag          string
29948                                 NametagColor     color.NRGBA
29949                                 FaceRotateSpeed  float32 // in degrees per second.
29950                                 Infotext         string
29951                                 Itemstring       string
29952                                 Glow             int8
29953                                 MaxBreath        uint16  // Player only.
29954                                 EyeHeight        float32 // Player only.
29955                                 ZoomFOV          float32 // in degrees. Player only.
29956                                 UseTextureAlpha  bool
29957                                 DmgTextureMod    Texture // suffix
29958                                 Shaded           bool
29959                                 ShowOnMinimap    bool
29960                                 NametagBG        color.NRGBA
29961                         }))(obj)).Colors)[local353]
29962                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
29963                 }
29964         }
29965         {
29966                 p := &(*(*(struct {
29967                         MaxHP            uint16 // Player only.
29968                         CollideWithNodes bool
29969                         Weight           float32 // deprecated
29970                         ColBox, SelBox   Box
29971                         Pointable        bool
29972                         Visual           string
29973                         VisualSize       [3]float32
29974                         Textures         []Texture
29975                         SpriteSheetSize  [2]int16 // in sprites.
29976                         SpritePos        [2]int16 // in sprite sheet.
29977                         Visible          bool
29978                         MakeFootstepSnds bool
29979                         RotateSpeed      float32 // in radians per second.
29980                         Mesh             string
29981                         Colors           []color.NRGBA
29982                         CollideWithAOs   bool
29983                         StepHeight       float32
29984                         FaceRotateDir    bool
29985                         FaceRotateDirOff float32 // in degrees.
29986                         BackfaceCull     bool
29987                         Nametag          string
29988                         NametagColor     color.NRGBA
29989                         FaceRotateSpeed  float32 // in degrees per second.
29990                         Infotext         string
29991                         Itemstring       string
29992                         Glow             int8
29993                         MaxBreath        uint16  // Player only.
29994                         EyeHeight        float32 // Player only.
29995                         ZoomFOV          float32 // in degrees. Player only.
29996                         UseTextureAlpha  bool
29997                         DmgTextureMod    Texture // suffix
29998                         Shaded           bool
29999                         ShowOnMinimap    bool
30000                         NametagBG        color.NRGBA
30001                 }))(obj)).CollideWithAOs
30002                 switch n := read8(r); n {
30003                 case 0:
30004                         *p = false
30005                 case 1:
30006                         *p = true
30007                 default:
30008                         chk(fmt.Errorf("invalid bool: %d", n))
30009                 }
30010         }
30011         {
30012                 p := &(*(*(struct {
30013                         MaxHP            uint16 // Player only.
30014                         CollideWithNodes bool
30015                         Weight           float32 // deprecated
30016                         ColBox, SelBox   Box
30017                         Pointable        bool
30018                         Visual           string
30019                         VisualSize       [3]float32
30020                         Textures         []Texture
30021                         SpriteSheetSize  [2]int16 // in sprites.
30022                         SpritePos        [2]int16 // in sprite sheet.
30023                         Visible          bool
30024                         MakeFootstepSnds bool
30025                         RotateSpeed      float32 // in radians per second.
30026                         Mesh             string
30027                         Colors           []color.NRGBA
30028                         CollideWithAOs   bool
30029                         StepHeight       float32
30030                         FaceRotateDir    bool
30031                         FaceRotateDirOff float32 // in degrees.
30032                         BackfaceCull     bool
30033                         Nametag          string
30034                         NametagColor     color.NRGBA
30035                         FaceRotateSpeed  float32 // in degrees per second.
30036                         Infotext         string
30037                         Itemstring       string
30038                         Glow             int8
30039                         MaxBreath        uint16  // Player only.
30040                         EyeHeight        float32 // Player only.
30041                         ZoomFOV          float32 // in degrees. Player only.
30042                         UseTextureAlpha  bool
30043                         DmgTextureMod    Texture // suffix
30044                         Shaded           bool
30045                         ShowOnMinimap    bool
30046                         NametagBG        color.NRGBA
30047                 }))(obj)).StepHeight
30048                 *p = math.Float32frombits(read32(r))
30049         }
30050         {
30051                 p := &(*(*(struct {
30052                         MaxHP            uint16 // Player only.
30053                         CollideWithNodes bool
30054                         Weight           float32 // deprecated
30055                         ColBox, SelBox   Box
30056                         Pointable        bool
30057                         Visual           string
30058                         VisualSize       [3]float32
30059                         Textures         []Texture
30060                         SpriteSheetSize  [2]int16 // in sprites.
30061                         SpritePos        [2]int16 // in sprite sheet.
30062                         Visible          bool
30063                         MakeFootstepSnds bool
30064                         RotateSpeed      float32 // in radians per second.
30065                         Mesh             string
30066                         Colors           []color.NRGBA
30067                         CollideWithAOs   bool
30068                         StepHeight       float32
30069                         FaceRotateDir    bool
30070                         FaceRotateDirOff float32 // in degrees.
30071                         BackfaceCull     bool
30072                         Nametag          string
30073                         NametagColor     color.NRGBA
30074                         FaceRotateSpeed  float32 // in degrees per second.
30075                         Infotext         string
30076                         Itemstring       string
30077                         Glow             int8
30078                         MaxBreath        uint16  // Player only.
30079                         EyeHeight        float32 // Player only.
30080                         ZoomFOV          float32 // in degrees. Player only.
30081                         UseTextureAlpha  bool
30082                         DmgTextureMod    Texture // suffix
30083                         Shaded           bool
30084                         ShowOnMinimap    bool
30085                         NametagBG        color.NRGBA
30086                 }))(obj)).FaceRotateDir
30087                 switch n := read8(r); n {
30088                 case 0:
30089                         *p = false
30090                 case 1:
30091                         *p = true
30092                 default:
30093                         chk(fmt.Errorf("invalid bool: %d", n))
30094                 }
30095         }
30096         {
30097                 p := &(*(*(struct {
30098                         MaxHP            uint16 // Player only.
30099                         CollideWithNodes bool
30100                         Weight           float32 // deprecated
30101                         ColBox, SelBox   Box
30102                         Pointable        bool
30103                         Visual           string
30104                         VisualSize       [3]float32
30105                         Textures         []Texture
30106                         SpriteSheetSize  [2]int16 // in sprites.
30107                         SpritePos        [2]int16 // in sprite sheet.
30108                         Visible          bool
30109                         MakeFootstepSnds bool
30110                         RotateSpeed      float32 // in radians per second.
30111                         Mesh             string
30112                         Colors           []color.NRGBA
30113                         CollideWithAOs   bool
30114                         StepHeight       float32
30115                         FaceRotateDir    bool
30116                         FaceRotateDirOff float32 // in degrees.
30117                         BackfaceCull     bool
30118                         Nametag          string
30119                         NametagColor     color.NRGBA
30120                         FaceRotateSpeed  float32 // in degrees per second.
30121                         Infotext         string
30122                         Itemstring       string
30123                         Glow             int8
30124                         MaxBreath        uint16  // Player only.
30125                         EyeHeight        float32 // Player only.
30126                         ZoomFOV          float32 // in degrees. Player only.
30127                         UseTextureAlpha  bool
30128                         DmgTextureMod    Texture // suffix
30129                         Shaded           bool
30130                         ShowOnMinimap    bool
30131                         NametagBG        color.NRGBA
30132                 }))(obj)).FaceRotateDirOff
30133                 *p = math.Float32frombits(read32(r))
30134         }
30135         {
30136                 p := &(*(*(struct {
30137                         MaxHP            uint16 // Player only.
30138                         CollideWithNodes bool
30139                         Weight           float32 // deprecated
30140                         ColBox, SelBox   Box
30141                         Pointable        bool
30142                         Visual           string
30143                         VisualSize       [3]float32
30144                         Textures         []Texture
30145                         SpriteSheetSize  [2]int16 // in sprites.
30146                         SpritePos        [2]int16 // in sprite sheet.
30147                         Visible          bool
30148                         MakeFootstepSnds bool
30149                         RotateSpeed      float32 // in radians per second.
30150                         Mesh             string
30151                         Colors           []color.NRGBA
30152                         CollideWithAOs   bool
30153                         StepHeight       float32
30154                         FaceRotateDir    bool
30155                         FaceRotateDirOff float32 // in degrees.
30156                         BackfaceCull     bool
30157                         Nametag          string
30158                         NametagColor     color.NRGBA
30159                         FaceRotateSpeed  float32 // in degrees per second.
30160                         Infotext         string
30161                         Itemstring       string
30162                         Glow             int8
30163                         MaxBreath        uint16  // Player only.
30164                         EyeHeight        float32 // Player only.
30165                         ZoomFOV          float32 // in degrees. Player only.
30166                         UseTextureAlpha  bool
30167                         DmgTextureMod    Texture // suffix
30168                         Shaded           bool
30169                         ShowOnMinimap    bool
30170                         NametagBG        color.NRGBA
30171                 }))(obj)).BackfaceCull
30172                 switch n := read8(r); n {
30173                 case 0:
30174                         *p = false
30175                 case 1:
30176                         *p = true
30177                 default:
30178                         chk(fmt.Errorf("invalid bool: %d", n))
30179                 }
30180         }
30181         var local354 []uint8
30182         var local355 uint16
30183         {
30184                 p := &local355
30185                 *p = read16(r)
30186         }
30187         (local354) = make([]uint8, local355)
30188         {
30189                 _, err := io.ReadFull(r, (local354)[:])
30190                 chk(err)
30191         }
30192         ((*(*(struct {
30193                 MaxHP            uint16 // Player only.
30194                 CollideWithNodes bool
30195                 Weight           float32 // deprecated
30196                 ColBox, SelBox   Box
30197                 Pointable        bool
30198                 Visual           string
30199                 VisualSize       [3]float32
30200                 Textures         []Texture
30201                 SpriteSheetSize  [2]int16 // in sprites.
30202                 SpritePos        [2]int16 // in sprite sheet.
30203                 Visible          bool
30204                 MakeFootstepSnds bool
30205                 RotateSpeed      float32 // in radians per second.
30206                 Mesh             string
30207                 Colors           []color.NRGBA
30208                 CollideWithAOs   bool
30209                 StepHeight       float32
30210                 FaceRotateDir    bool
30211                 FaceRotateDirOff float32 // in degrees.
30212                 BackfaceCull     bool
30213                 Nametag          string
30214                 NametagColor     color.NRGBA
30215                 FaceRotateSpeed  float32 // in degrees per second.
30216                 Infotext         string
30217                 Itemstring       string
30218                 Glow             int8
30219                 MaxBreath        uint16  // Player only.
30220                 EyeHeight        float32 // Player only.
30221                 ZoomFOV          float32 // in degrees. Player only.
30222                 UseTextureAlpha  bool
30223                 DmgTextureMod    Texture // suffix
30224                 Shaded           bool
30225                 ShowOnMinimap    bool
30226                 NametagBG        color.NRGBA
30227         }))(obj)).Nametag) = string(local354)
30228         {
30229                 p := &(*(*(struct {
30230                         MaxHP            uint16 // Player only.
30231                         CollideWithNodes bool
30232                         Weight           float32 // deprecated
30233                         ColBox, SelBox   Box
30234                         Pointable        bool
30235                         Visual           string
30236                         VisualSize       [3]float32
30237                         Textures         []Texture
30238                         SpriteSheetSize  [2]int16 // in sprites.
30239                         SpritePos        [2]int16 // in sprite sheet.
30240                         Visible          bool
30241                         MakeFootstepSnds bool
30242                         RotateSpeed      float32 // in radians per second.
30243                         Mesh             string
30244                         Colors           []color.NRGBA
30245                         CollideWithAOs   bool
30246                         StepHeight       float32
30247                         FaceRotateDir    bool
30248                         FaceRotateDirOff float32 // in degrees.
30249                         BackfaceCull     bool
30250                         Nametag          string
30251                         NametagColor     color.NRGBA
30252                         FaceRotateSpeed  float32 // in degrees per second.
30253                         Infotext         string
30254                         Itemstring       string
30255                         Glow             int8
30256                         MaxBreath        uint16  // Player only.
30257                         EyeHeight        float32 // Player only.
30258                         ZoomFOV          float32 // in degrees. Player only.
30259                         UseTextureAlpha  bool
30260                         DmgTextureMod    Texture // suffix
30261                         Shaded           bool
30262                         ShowOnMinimap    bool
30263                         NametagBG        color.NRGBA
30264                 }))(obj)).NametagColor
30265                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30266         }
30267         {
30268                 p := &(*(*(struct {
30269                         MaxHP            uint16 // Player only.
30270                         CollideWithNodes bool
30271                         Weight           float32 // deprecated
30272                         ColBox, SelBox   Box
30273                         Pointable        bool
30274                         Visual           string
30275                         VisualSize       [3]float32
30276                         Textures         []Texture
30277                         SpriteSheetSize  [2]int16 // in sprites.
30278                         SpritePos        [2]int16 // in sprite sheet.
30279                         Visible          bool
30280                         MakeFootstepSnds bool
30281                         RotateSpeed      float32 // in radians per second.
30282                         Mesh             string
30283                         Colors           []color.NRGBA
30284                         CollideWithAOs   bool
30285                         StepHeight       float32
30286                         FaceRotateDir    bool
30287                         FaceRotateDirOff float32 // in degrees.
30288                         BackfaceCull     bool
30289                         Nametag          string
30290                         NametagColor     color.NRGBA
30291                         FaceRotateSpeed  float32 // in degrees per second.
30292                         Infotext         string
30293                         Itemstring       string
30294                         Glow             int8
30295                         MaxBreath        uint16  // Player only.
30296                         EyeHeight        float32 // Player only.
30297                         ZoomFOV          float32 // in degrees. Player only.
30298                         UseTextureAlpha  bool
30299                         DmgTextureMod    Texture // suffix
30300                         Shaded           bool
30301                         ShowOnMinimap    bool
30302                         NametagBG        color.NRGBA
30303                 }))(obj)).FaceRotateSpeed
30304                 *p = math.Float32frombits(read32(r))
30305         }
30306         var local356 []uint8
30307         var local357 uint16
30308         {
30309                 p := &local357
30310                 *p = read16(r)
30311         }
30312         (local356) = make([]uint8, local357)
30313         {
30314                 _, err := io.ReadFull(r, (local356)[:])
30315                 chk(err)
30316         }
30317         ((*(*(struct {
30318                 MaxHP            uint16 // Player only.
30319                 CollideWithNodes bool
30320                 Weight           float32 // deprecated
30321                 ColBox, SelBox   Box
30322                 Pointable        bool
30323                 Visual           string
30324                 VisualSize       [3]float32
30325                 Textures         []Texture
30326                 SpriteSheetSize  [2]int16 // in sprites.
30327                 SpritePos        [2]int16 // in sprite sheet.
30328                 Visible          bool
30329                 MakeFootstepSnds bool
30330                 RotateSpeed      float32 // in radians per second.
30331                 Mesh             string
30332                 Colors           []color.NRGBA
30333                 CollideWithAOs   bool
30334                 StepHeight       float32
30335                 FaceRotateDir    bool
30336                 FaceRotateDirOff float32 // in degrees.
30337                 BackfaceCull     bool
30338                 Nametag          string
30339                 NametagColor     color.NRGBA
30340                 FaceRotateSpeed  float32 // in degrees per second.
30341                 Infotext         string
30342                 Itemstring       string
30343                 Glow             int8
30344                 MaxBreath        uint16  // Player only.
30345                 EyeHeight        float32 // Player only.
30346                 ZoomFOV          float32 // in degrees. Player only.
30347                 UseTextureAlpha  bool
30348                 DmgTextureMod    Texture // suffix
30349                 Shaded           bool
30350                 ShowOnMinimap    bool
30351                 NametagBG        color.NRGBA
30352         }))(obj)).Infotext) = string(local356)
30353         var local358 []uint8
30354         var local359 uint16
30355         {
30356                 p := &local359
30357                 *p = read16(r)
30358         }
30359         (local358) = make([]uint8, local359)
30360         {
30361                 _, err := io.ReadFull(r, (local358)[:])
30362                 chk(err)
30363         }
30364         ((*(*(struct {
30365                 MaxHP            uint16 // Player only.
30366                 CollideWithNodes bool
30367                 Weight           float32 // deprecated
30368                 ColBox, SelBox   Box
30369                 Pointable        bool
30370                 Visual           string
30371                 VisualSize       [3]float32
30372                 Textures         []Texture
30373                 SpriteSheetSize  [2]int16 // in sprites.
30374                 SpritePos        [2]int16 // in sprite sheet.
30375                 Visible          bool
30376                 MakeFootstepSnds bool
30377                 RotateSpeed      float32 // in radians per second.
30378                 Mesh             string
30379                 Colors           []color.NRGBA
30380                 CollideWithAOs   bool
30381                 StepHeight       float32
30382                 FaceRotateDir    bool
30383                 FaceRotateDirOff float32 // in degrees.
30384                 BackfaceCull     bool
30385                 Nametag          string
30386                 NametagColor     color.NRGBA
30387                 FaceRotateSpeed  float32 // in degrees per second.
30388                 Infotext         string
30389                 Itemstring       string
30390                 Glow             int8
30391                 MaxBreath        uint16  // Player only.
30392                 EyeHeight        float32 // Player only.
30393                 ZoomFOV          float32 // in degrees. Player only.
30394                 UseTextureAlpha  bool
30395                 DmgTextureMod    Texture // suffix
30396                 Shaded           bool
30397                 ShowOnMinimap    bool
30398                 NametagBG        color.NRGBA
30399         }))(obj)).Itemstring) = string(local358)
30400         {
30401                 p := &(*(*(struct {
30402                         MaxHP            uint16 // Player only.
30403                         CollideWithNodes bool
30404                         Weight           float32 // deprecated
30405                         ColBox, SelBox   Box
30406                         Pointable        bool
30407                         Visual           string
30408                         VisualSize       [3]float32
30409                         Textures         []Texture
30410                         SpriteSheetSize  [2]int16 // in sprites.
30411                         SpritePos        [2]int16 // in sprite sheet.
30412                         Visible          bool
30413                         MakeFootstepSnds bool
30414                         RotateSpeed      float32 // in radians per second.
30415                         Mesh             string
30416                         Colors           []color.NRGBA
30417                         CollideWithAOs   bool
30418                         StepHeight       float32
30419                         FaceRotateDir    bool
30420                         FaceRotateDirOff float32 // in degrees.
30421                         BackfaceCull     bool
30422                         Nametag          string
30423                         NametagColor     color.NRGBA
30424                         FaceRotateSpeed  float32 // in degrees per second.
30425                         Infotext         string
30426                         Itemstring       string
30427                         Glow             int8
30428                         MaxBreath        uint16  // Player only.
30429                         EyeHeight        float32 // Player only.
30430                         ZoomFOV          float32 // in degrees. Player only.
30431                         UseTextureAlpha  bool
30432                         DmgTextureMod    Texture // suffix
30433                         Shaded           bool
30434                         ShowOnMinimap    bool
30435                         NametagBG        color.NRGBA
30436                 }))(obj)).Glow
30437                 *p = int8(read8(r))
30438         }
30439         {
30440                 p := &(*(*(struct {
30441                         MaxHP            uint16 // Player only.
30442                         CollideWithNodes bool
30443                         Weight           float32 // deprecated
30444                         ColBox, SelBox   Box
30445                         Pointable        bool
30446                         Visual           string
30447                         VisualSize       [3]float32
30448                         Textures         []Texture
30449                         SpriteSheetSize  [2]int16 // in sprites.
30450                         SpritePos        [2]int16 // in sprite sheet.
30451                         Visible          bool
30452                         MakeFootstepSnds bool
30453                         RotateSpeed      float32 // in radians per second.
30454                         Mesh             string
30455                         Colors           []color.NRGBA
30456                         CollideWithAOs   bool
30457                         StepHeight       float32
30458                         FaceRotateDir    bool
30459                         FaceRotateDirOff float32 // in degrees.
30460                         BackfaceCull     bool
30461                         Nametag          string
30462                         NametagColor     color.NRGBA
30463                         FaceRotateSpeed  float32 // in degrees per second.
30464                         Infotext         string
30465                         Itemstring       string
30466                         Glow             int8
30467                         MaxBreath        uint16  // Player only.
30468                         EyeHeight        float32 // Player only.
30469                         ZoomFOV          float32 // in degrees. Player only.
30470                         UseTextureAlpha  bool
30471                         DmgTextureMod    Texture // suffix
30472                         Shaded           bool
30473                         ShowOnMinimap    bool
30474                         NametagBG        color.NRGBA
30475                 }))(obj)).MaxBreath
30476                 *p = read16(r)
30477         }
30478         {
30479                 p := &(*(*(struct {
30480                         MaxHP            uint16 // Player only.
30481                         CollideWithNodes bool
30482                         Weight           float32 // deprecated
30483                         ColBox, SelBox   Box
30484                         Pointable        bool
30485                         Visual           string
30486                         VisualSize       [3]float32
30487                         Textures         []Texture
30488                         SpriteSheetSize  [2]int16 // in sprites.
30489                         SpritePos        [2]int16 // in sprite sheet.
30490                         Visible          bool
30491                         MakeFootstepSnds bool
30492                         RotateSpeed      float32 // in radians per second.
30493                         Mesh             string
30494                         Colors           []color.NRGBA
30495                         CollideWithAOs   bool
30496                         StepHeight       float32
30497                         FaceRotateDir    bool
30498                         FaceRotateDirOff float32 // in degrees.
30499                         BackfaceCull     bool
30500                         Nametag          string
30501                         NametagColor     color.NRGBA
30502                         FaceRotateSpeed  float32 // in degrees per second.
30503                         Infotext         string
30504                         Itemstring       string
30505                         Glow             int8
30506                         MaxBreath        uint16  // Player only.
30507                         EyeHeight        float32 // Player only.
30508                         ZoomFOV          float32 // in degrees. Player only.
30509                         UseTextureAlpha  bool
30510                         DmgTextureMod    Texture // suffix
30511                         Shaded           bool
30512                         ShowOnMinimap    bool
30513                         NametagBG        color.NRGBA
30514                 }))(obj)).EyeHeight
30515                 *p = math.Float32frombits(read32(r))
30516         }
30517         {
30518                 p := &(*(*(struct {
30519                         MaxHP            uint16 // Player only.
30520                         CollideWithNodes bool
30521                         Weight           float32 // deprecated
30522                         ColBox, SelBox   Box
30523                         Pointable        bool
30524                         Visual           string
30525                         VisualSize       [3]float32
30526                         Textures         []Texture
30527                         SpriteSheetSize  [2]int16 // in sprites.
30528                         SpritePos        [2]int16 // in sprite sheet.
30529                         Visible          bool
30530                         MakeFootstepSnds bool
30531                         RotateSpeed      float32 // in radians per second.
30532                         Mesh             string
30533                         Colors           []color.NRGBA
30534                         CollideWithAOs   bool
30535                         StepHeight       float32
30536                         FaceRotateDir    bool
30537                         FaceRotateDirOff float32 // in degrees.
30538                         BackfaceCull     bool
30539                         Nametag          string
30540                         NametagColor     color.NRGBA
30541                         FaceRotateSpeed  float32 // in degrees per second.
30542                         Infotext         string
30543                         Itemstring       string
30544                         Glow             int8
30545                         MaxBreath        uint16  // Player only.
30546                         EyeHeight        float32 // Player only.
30547                         ZoomFOV          float32 // in degrees. Player only.
30548                         UseTextureAlpha  bool
30549                         DmgTextureMod    Texture // suffix
30550                         Shaded           bool
30551                         ShowOnMinimap    bool
30552                         NametagBG        color.NRGBA
30553                 }))(obj)).ZoomFOV
30554                 *p = math.Float32frombits(read32(r))
30555         }
30556         {
30557                 p := &(*(*(struct {
30558                         MaxHP            uint16 // Player only.
30559                         CollideWithNodes bool
30560                         Weight           float32 // deprecated
30561                         ColBox, SelBox   Box
30562                         Pointable        bool
30563                         Visual           string
30564                         VisualSize       [3]float32
30565                         Textures         []Texture
30566                         SpriteSheetSize  [2]int16 // in sprites.
30567                         SpritePos        [2]int16 // in sprite sheet.
30568                         Visible          bool
30569                         MakeFootstepSnds bool
30570                         RotateSpeed      float32 // in radians per second.
30571                         Mesh             string
30572                         Colors           []color.NRGBA
30573                         CollideWithAOs   bool
30574                         StepHeight       float32
30575                         FaceRotateDir    bool
30576                         FaceRotateDirOff float32 // in degrees.
30577                         BackfaceCull     bool
30578                         Nametag          string
30579                         NametagColor     color.NRGBA
30580                         FaceRotateSpeed  float32 // in degrees per second.
30581                         Infotext         string
30582                         Itemstring       string
30583                         Glow             int8
30584                         MaxBreath        uint16  // Player only.
30585                         EyeHeight        float32 // Player only.
30586                         ZoomFOV          float32 // in degrees. Player only.
30587                         UseTextureAlpha  bool
30588                         DmgTextureMod    Texture // suffix
30589                         Shaded           bool
30590                         ShowOnMinimap    bool
30591                         NametagBG        color.NRGBA
30592                 }))(obj)).UseTextureAlpha
30593                 switch n := read8(r); n {
30594                 case 0:
30595                         *p = false
30596                 case 1:
30597                         *p = true
30598                 default:
30599                         chk(fmt.Errorf("invalid bool: %d", n))
30600                 }
30601         }
30602         if err := pcall(func() {
30603                 ((*(*(struct {
30604                         MaxHP            uint16 // Player only.
30605                         CollideWithNodes bool
30606                         Weight           float32 // deprecated
30607                         ColBox, SelBox   Box
30608                         Pointable        bool
30609                         Visual           string
30610                         VisualSize       [3]float32
30611                         Textures         []Texture
30612                         SpriteSheetSize  [2]int16 // in sprites.
30613                         SpritePos        [2]int16 // in sprite sheet.
30614                         Visible          bool
30615                         MakeFootstepSnds bool
30616                         RotateSpeed      float32 // in radians per second.
30617                         Mesh             string
30618                         Colors           []color.NRGBA
30619                         CollideWithAOs   bool
30620                         StepHeight       float32
30621                         FaceRotateDir    bool
30622                         FaceRotateDirOff float32 // in degrees.
30623                         BackfaceCull     bool
30624                         Nametag          string
30625                         NametagColor     color.NRGBA
30626                         FaceRotateSpeed  float32 // in degrees per second.
30627                         Infotext         string
30628                         Itemstring       string
30629                         Glow             int8
30630                         MaxBreath        uint16  // Player only.
30631                         EyeHeight        float32 // Player only.
30632                         ZoomFOV          float32 // in degrees. Player only.
30633                         UseTextureAlpha  bool
30634                         DmgTextureMod    Texture // suffix
30635                         Shaded           bool
30636                         ShowOnMinimap    bool
30637                         NametagBG        color.NRGBA
30638                 }))(obj)).DmgTextureMod).Deserialize(r)
30639         }); err != nil {
30640                 if err == io.EOF {
30641                         chk(io.EOF)
30642                 }
30643                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
30644         }
30645         {
30646                 p := &(*(*(struct {
30647                         MaxHP            uint16 // Player only.
30648                         CollideWithNodes bool
30649                         Weight           float32 // deprecated
30650                         ColBox, SelBox   Box
30651                         Pointable        bool
30652                         Visual           string
30653                         VisualSize       [3]float32
30654                         Textures         []Texture
30655                         SpriteSheetSize  [2]int16 // in sprites.
30656                         SpritePos        [2]int16 // in sprite sheet.
30657                         Visible          bool
30658                         MakeFootstepSnds bool
30659                         RotateSpeed      float32 // in radians per second.
30660                         Mesh             string
30661                         Colors           []color.NRGBA
30662                         CollideWithAOs   bool
30663                         StepHeight       float32
30664                         FaceRotateDir    bool
30665                         FaceRotateDirOff float32 // in degrees.
30666                         BackfaceCull     bool
30667                         Nametag          string
30668                         NametagColor     color.NRGBA
30669                         FaceRotateSpeed  float32 // in degrees per second.
30670                         Infotext         string
30671                         Itemstring       string
30672                         Glow             int8
30673                         MaxBreath        uint16  // Player only.
30674                         EyeHeight        float32 // Player only.
30675                         ZoomFOV          float32 // in degrees. Player only.
30676                         UseTextureAlpha  bool
30677                         DmgTextureMod    Texture // suffix
30678                         Shaded           bool
30679                         ShowOnMinimap    bool
30680                         NametagBG        color.NRGBA
30681                 }))(obj)).Shaded
30682                 switch n := read8(r); n {
30683                 case 0:
30684                         *p = false
30685                 case 1:
30686                         *p = true
30687                 default:
30688                         chk(fmt.Errorf("invalid bool: %d", n))
30689                 }
30690         }
30691         {
30692                 p := &(*(*(struct {
30693                         MaxHP            uint16 // Player only.
30694                         CollideWithNodes bool
30695                         Weight           float32 // deprecated
30696                         ColBox, SelBox   Box
30697                         Pointable        bool
30698                         Visual           string
30699                         VisualSize       [3]float32
30700                         Textures         []Texture
30701                         SpriteSheetSize  [2]int16 // in sprites.
30702                         SpritePos        [2]int16 // in sprite sheet.
30703                         Visible          bool
30704                         MakeFootstepSnds bool
30705                         RotateSpeed      float32 // in radians per second.
30706                         Mesh             string
30707                         Colors           []color.NRGBA
30708                         CollideWithAOs   bool
30709                         StepHeight       float32
30710                         FaceRotateDir    bool
30711                         FaceRotateDirOff float32 // in degrees.
30712                         BackfaceCull     bool
30713                         Nametag          string
30714                         NametagColor     color.NRGBA
30715                         FaceRotateSpeed  float32 // in degrees per second.
30716                         Infotext         string
30717                         Itemstring       string
30718                         Glow             int8
30719                         MaxBreath        uint16  // Player only.
30720                         EyeHeight        float32 // Player only.
30721                         ZoomFOV          float32 // in degrees. Player only.
30722                         UseTextureAlpha  bool
30723                         DmgTextureMod    Texture // suffix
30724                         Shaded           bool
30725                         ShowOnMinimap    bool
30726                         NametagBG        color.NRGBA
30727                 }))(obj)).ShowOnMinimap
30728                 switch n := read8(r); n {
30729                 case 0:
30730                         *p = false
30731                 case 1:
30732                         *p = true
30733                 default:
30734                         chk(fmt.Errorf("invalid bool: %d", n))
30735                 }
30736         }
30737         {
30738                 p := &(*(*(struct {
30739                         MaxHP            uint16 // Player only.
30740                         CollideWithNodes bool
30741                         Weight           float32 // deprecated
30742                         ColBox, SelBox   Box
30743                         Pointable        bool
30744                         Visual           string
30745                         VisualSize       [3]float32
30746                         Textures         []Texture
30747                         SpriteSheetSize  [2]int16 // in sprites.
30748                         SpritePos        [2]int16 // in sprite sheet.
30749                         Visible          bool
30750                         MakeFootstepSnds bool
30751                         RotateSpeed      float32 // in radians per second.
30752                         Mesh             string
30753                         Colors           []color.NRGBA
30754                         CollideWithAOs   bool
30755                         StepHeight       float32
30756                         FaceRotateDir    bool
30757                         FaceRotateDirOff float32 // in degrees.
30758                         BackfaceCull     bool
30759                         Nametag          string
30760                         NametagColor     color.NRGBA
30761                         FaceRotateSpeed  float32 // in degrees per second.
30762                         Infotext         string
30763                         Itemstring       string
30764                         Glow             int8
30765                         MaxBreath        uint16  // Player only.
30766                         EyeHeight        float32 // Player only.
30767                         ZoomFOV          float32 // in degrees. Player only.
30768                         UseTextureAlpha  bool
30769                         DmgTextureMod    Texture // suffix
30770                         Shaded           bool
30771                         ShowOnMinimap    bool
30772                         NametagBG        color.NRGBA
30773                 }))(obj)).NametagBG
30774                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30775         }
30776 }
30777
30778 func (obj *AOPos) Serialize(w io.Writer) {
30779         if err := pcall(func() {
30780                 ((*(*(struct {
30781                         Pos
30782                         Vel, Acc Vec
30783                         Rot      [3]float32
30784
30785                         Interpolate    bool
30786                         End            bool
30787                         UpdateInterval float32
30788                 }))(obj)).Pos).Serialize(w)
30789         }); err != nil {
30790                 if err == io.EOF {
30791                         chk(io.EOF)
30792                 }
30793                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
30794         }
30795         if err := pcall(func() {
30796                 ((*(*(struct {
30797                         Pos
30798                         Vel, Acc Vec
30799                         Rot      [3]float32
30800
30801                         Interpolate    bool
30802                         End            bool
30803                         UpdateInterval float32
30804                 }))(obj)).Vel).Serialize(w)
30805         }); err != nil {
30806                 if err == io.EOF {
30807                         chk(io.EOF)
30808                 }
30809                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30810         }
30811         if err := pcall(func() {
30812                 ((*(*(struct {
30813                         Pos
30814                         Vel, Acc Vec
30815                         Rot      [3]float32
30816
30817                         Interpolate    bool
30818                         End            bool
30819                         UpdateInterval float32
30820                 }))(obj)).Acc).Serialize(w)
30821         }); err != nil {
30822                 if err == io.EOF {
30823                         chk(io.EOF)
30824                 }
30825                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30826         }
30827         for local360 := range (*(*(struct {
30828                 Pos
30829                 Vel, Acc Vec
30830                 Rot      [3]float32
30831
30832                 Interpolate    bool
30833                 End            bool
30834                 UpdateInterval float32
30835         }))(obj)).Rot {
30836                 {
30837                         x := ((*(*(struct {
30838                                 Pos
30839                                 Vel, Acc Vec
30840                                 Rot      [3]float32
30841
30842                                 Interpolate    bool
30843                                 End            bool
30844                                 UpdateInterval float32
30845                         }))(obj)).Rot)[local360]
30846                         write32(w, math.Float32bits(x))
30847                 }
30848         }
30849         {
30850                 x := (*(*(struct {
30851                         Pos
30852                         Vel, Acc Vec
30853                         Rot      [3]float32
30854
30855                         Interpolate    bool
30856                         End            bool
30857                         UpdateInterval float32
30858                 }))(obj)).Interpolate
30859                 if x {
30860                         write8(w, 1)
30861                 } else {
30862                         write8(w, 0)
30863                 }
30864         }
30865         {
30866                 x := (*(*(struct {
30867                         Pos
30868                         Vel, Acc Vec
30869                         Rot      [3]float32
30870
30871                         Interpolate    bool
30872                         End            bool
30873                         UpdateInterval float32
30874                 }))(obj)).End
30875                 if x {
30876                         write8(w, 1)
30877                 } else {
30878                         write8(w, 0)
30879                 }
30880         }
30881         {
30882                 x := (*(*(struct {
30883                         Pos
30884                         Vel, Acc Vec
30885                         Rot      [3]float32
30886
30887                         Interpolate    bool
30888                         End            bool
30889                         UpdateInterval float32
30890                 }))(obj)).UpdateInterval
30891                 write32(w, math.Float32bits(x))
30892         }
30893 }
30894
30895 func (obj *AOPos) Deserialize(r io.Reader) {
30896         if err := pcall(func() {
30897                 ((*(*(struct {
30898                         Pos
30899                         Vel, Acc Vec
30900                         Rot      [3]float32
30901
30902                         Interpolate    bool
30903                         End            bool
30904                         UpdateInterval float32
30905                 }))(obj)).Pos).Deserialize(r)
30906         }); err != nil {
30907                 if err == io.EOF {
30908                         chk(io.EOF)
30909                 }
30910                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
30911         }
30912         if err := pcall(func() {
30913                 ((*(*(struct {
30914                         Pos
30915                         Vel, Acc Vec
30916                         Rot      [3]float32
30917
30918                         Interpolate    bool
30919                         End            bool
30920                         UpdateInterval float32
30921                 }))(obj)).Vel).Deserialize(r)
30922         }); err != nil {
30923                 if err == io.EOF {
30924                         chk(io.EOF)
30925                 }
30926                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30927         }
30928         if err := pcall(func() {
30929                 ((*(*(struct {
30930                         Pos
30931                         Vel, Acc Vec
30932                         Rot      [3]float32
30933
30934                         Interpolate    bool
30935                         End            bool
30936                         UpdateInterval float32
30937                 }))(obj)).Acc).Deserialize(r)
30938         }); err != nil {
30939                 if err == io.EOF {
30940                         chk(io.EOF)
30941                 }
30942                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30943         }
30944         for local361 := range (*(*(struct {
30945                 Pos
30946                 Vel, Acc Vec
30947                 Rot      [3]float32
30948
30949                 Interpolate    bool
30950                 End            bool
30951                 UpdateInterval float32
30952         }))(obj)).Rot {
30953                 {
30954                         p := &((*(*(struct {
30955                                 Pos
30956                                 Vel, Acc Vec
30957                                 Rot      [3]float32
30958
30959                                 Interpolate    bool
30960                                 End            bool
30961                                 UpdateInterval float32
30962                         }))(obj)).Rot)[local361]
30963                         *p = math.Float32frombits(read32(r))
30964                 }
30965         }
30966         {
30967                 p := &(*(*(struct {
30968                         Pos
30969                         Vel, Acc Vec
30970                         Rot      [3]float32
30971
30972                         Interpolate    bool
30973                         End            bool
30974                         UpdateInterval float32
30975                 }))(obj)).Interpolate
30976                 switch n := read8(r); n {
30977                 case 0:
30978                         *p = false
30979                 case 1:
30980                         *p = true
30981                 default:
30982                         chk(fmt.Errorf("invalid bool: %d", n))
30983                 }
30984         }
30985         {
30986                 p := &(*(*(struct {
30987                         Pos
30988                         Vel, Acc Vec
30989                         Rot      [3]float32
30990
30991                         Interpolate    bool
30992                         End            bool
30993                         UpdateInterval float32
30994                 }))(obj)).End
30995                 switch n := read8(r); n {
30996                 case 0:
30997                         *p = false
30998                 case 1:
30999                         *p = true
31000                 default:
31001                         chk(fmt.Errorf("invalid bool: %d", n))
31002                 }
31003         }
31004         {
31005                 p := &(*(*(struct {
31006                         Pos
31007                         Vel, Acc Vec
31008                         Rot      [3]float32
31009
31010                         Interpolate    bool
31011                         End            bool
31012                         UpdateInterval float32
31013                 }))(obj)).UpdateInterval
31014                 *p = math.Float32frombits(read32(r))
31015         }
31016 }
31017
31018 func (obj *AOSprite) Serialize(w io.Writer) {
31019         for local362 := range (*(*(struct {
31020                 Frame0          [2]int16
31021                 Frames          uint16
31022                 FrameDuration   float32
31023                 ViewAngleFrames bool
31024         }))(obj)).Frame0 {
31025                 {
31026                         x := ((*(*(struct {
31027                                 Frame0          [2]int16
31028                                 Frames          uint16
31029                                 FrameDuration   float32
31030                                 ViewAngleFrames bool
31031                         }))(obj)).Frame0)[local362]
31032                         write16(w, uint16(x))
31033                 }
31034         }
31035         {
31036                 x := (*(*(struct {
31037                         Frame0          [2]int16
31038                         Frames          uint16
31039                         FrameDuration   float32
31040                         ViewAngleFrames bool
31041                 }))(obj)).Frames
31042                 write16(w, uint16(x))
31043         }
31044         {
31045                 x := (*(*(struct {
31046                         Frame0          [2]int16
31047                         Frames          uint16
31048                         FrameDuration   float32
31049                         ViewAngleFrames bool
31050                 }))(obj)).FrameDuration
31051                 write32(w, math.Float32bits(x))
31052         }
31053         {
31054                 x := (*(*(struct {
31055                         Frame0          [2]int16
31056                         Frames          uint16
31057                         FrameDuration   float32
31058                         ViewAngleFrames bool
31059                 }))(obj)).ViewAngleFrames
31060                 if x {
31061                         write8(w, 1)
31062                 } else {
31063                         write8(w, 0)
31064                 }
31065         }
31066 }
31067
31068 func (obj *AOSprite) Deserialize(r io.Reader) {
31069         for local363 := range (*(*(struct {
31070                 Frame0          [2]int16
31071                 Frames          uint16
31072                 FrameDuration   float32
31073                 ViewAngleFrames bool
31074         }))(obj)).Frame0 {
31075                 {
31076                         p := &((*(*(struct {
31077                                 Frame0          [2]int16
31078                                 Frames          uint16
31079                                 FrameDuration   float32
31080                                 ViewAngleFrames bool
31081                         }))(obj)).Frame0)[local363]
31082                         *p = int16(read16(r))
31083                 }
31084         }
31085         {
31086                 p := &(*(*(struct {
31087                         Frame0          [2]int16
31088                         Frames          uint16
31089                         FrameDuration   float32
31090                         ViewAngleFrames bool
31091                 }))(obj)).Frames
31092                 *p = read16(r)
31093         }
31094         {
31095                 p := &(*(*(struct {
31096                         Frame0          [2]int16
31097                         Frames          uint16
31098                         FrameDuration   float32
31099                         ViewAngleFrames bool
31100                 }))(obj)).FrameDuration
31101                 *p = math.Float32frombits(read32(r))
31102         }
31103         {
31104                 p := &(*(*(struct {
31105                         Frame0          [2]int16
31106                         Frames          uint16
31107                         FrameDuration   float32
31108                         ViewAngleFrames bool
31109                 }))(obj)).ViewAngleFrames
31110                 switch n := read8(r); n {
31111                 case 0:
31112                         *p = false
31113                 case 1:
31114                         *p = true
31115                 default:
31116                         chk(fmt.Errorf("invalid bool: %d", n))
31117                 }
31118         }
31119 }
31120
31121 func (obj *Group) Serialize(w io.Writer) {
31122         if len(([]byte((*(*(struct {
31123                 Name   string
31124                 Rating int16
31125         }))(obj)).Name))) > math.MaxUint16 {
31126                 chk(ErrTooLong)
31127         }
31128         {
31129                 x := uint16(len(([]byte((*(*(struct {
31130                         Name   string
31131                         Rating int16
31132                 }))(obj)).Name))))
31133                 write16(w, uint16(x))
31134         }
31135         {
31136                 _, err := w.Write(([]byte((*(*(struct {
31137                         Name   string
31138                         Rating int16
31139                 }))(obj)).Name))[:])
31140                 chk(err)
31141         }
31142         {
31143                 x := (*(*(struct {
31144                         Name   string
31145                         Rating int16
31146                 }))(obj)).Rating
31147                 write16(w, uint16(x))
31148         }
31149 }
31150
31151 func (obj *Group) Deserialize(r io.Reader) {
31152         var local364 []uint8
31153         var local365 uint16
31154         {
31155                 p := &local365
31156                 *p = read16(r)
31157         }
31158         (local364) = make([]uint8, local365)
31159         {
31160                 _, err := io.ReadFull(r, (local364)[:])
31161                 chk(err)
31162         }
31163         ((*(*(struct {
31164                 Name   string
31165                 Rating int16
31166         }))(obj)).Name) = string(local364)
31167         {
31168                 p := &(*(*(struct {
31169                         Name   string
31170                         Rating int16
31171                 }))(obj)).Rating
31172                 *p = int16(read16(r))
31173         }
31174 }
31175
31176 func (obj *AOAnim) Serialize(w io.Writer) {
31177         for local366 := range (*(*(struct {
31178                 Frames [2]int32
31179                 Speed  float32
31180                 Blend  float32
31181                 NoLoop bool
31182         }))(obj)).Frames {
31183                 {
31184                         x := ((*(*(struct {
31185                                 Frames [2]int32
31186                                 Speed  float32
31187                                 Blend  float32
31188                                 NoLoop bool
31189                         }))(obj)).Frames)[local366]
31190                         write32(w, uint32(x))
31191                 }
31192         }
31193         {
31194                 x := (*(*(struct {
31195                         Frames [2]int32
31196                         Speed  float32
31197                         Blend  float32
31198                         NoLoop bool
31199                 }))(obj)).Speed
31200                 write32(w, math.Float32bits(x))
31201         }
31202         {
31203                 x := (*(*(struct {
31204                         Frames [2]int32
31205                         Speed  float32
31206                         Blend  float32
31207                         NoLoop bool
31208                 }))(obj)).Blend
31209                 write32(w, math.Float32bits(x))
31210         }
31211         {
31212                 x := (*(*(struct {
31213                         Frames [2]int32
31214                         Speed  float32
31215                         Blend  float32
31216                         NoLoop bool
31217                 }))(obj)).NoLoop
31218                 if x {
31219                         write8(w, 1)
31220                 } else {
31221                         write8(w, 0)
31222                 }
31223         }
31224 }
31225
31226 func (obj *AOAnim) Deserialize(r io.Reader) {
31227         for local367 := range (*(*(struct {
31228                 Frames [2]int32
31229                 Speed  float32
31230                 Blend  float32
31231                 NoLoop bool
31232         }))(obj)).Frames {
31233                 {
31234                         p := &((*(*(struct {
31235                                 Frames [2]int32
31236                                 Speed  float32
31237                                 Blend  float32
31238                                 NoLoop bool
31239                         }))(obj)).Frames)[local367]
31240                         *p = int32(read32(r))
31241                 }
31242         }
31243         {
31244                 p := &(*(*(struct {
31245                         Frames [2]int32
31246                         Speed  float32
31247                         Blend  float32
31248                         NoLoop bool
31249                 }))(obj)).Speed
31250                 *p = math.Float32frombits(read32(r))
31251         }
31252         {
31253                 p := &(*(*(struct {
31254                         Frames [2]int32
31255                         Speed  float32
31256                         Blend  float32
31257                         NoLoop bool
31258                 }))(obj)).Blend
31259                 *p = math.Float32frombits(read32(r))
31260         }
31261         {
31262                 p := &(*(*(struct {
31263                         Frames [2]int32
31264                         Speed  float32
31265                         Blend  float32
31266                         NoLoop bool
31267                 }))(obj)).NoLoop
31268                 switch n := read8(r); n {
31269                 case 0:
31270                         *p = false
31271                 case 1:
31272                         *p = true
31273                 default:
31274                         chk(fmt.Errorf("invalid bool: %d", n))
31275                 }
31276         }
31277 }
31278
31279 func (obj *AOBonePos) Serialize(w io.Writer) {
31280         if err := pcall(func() {
31281                 ((*(*(struct {
31282                         Pos Vec
31283                         Rot [3]float32
31284                 }))(obj)).Pos).Serialize(w)
31285         }); err != nil {
31286                 if err == io.EOF {
31287                         chk(io.EOF)
31288                 }
31289                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31290         }
31291         for local368 := range (*(*(struct {
31292                 Pos Vec
31293                 Rot [3]float32
31294         }))(obj)).Rot {
31295                 {
31296                         x := ((*(*(struct {
31297                                 Pos Vec
31298                                 Rot [3]float32
31299                         }))(obj)).Rot)[local368]
31300                         write32(w, math.Float32bits(x))
31301                 }
31302         }
31303 }
31304
31305 func (obj *AOBonePos) Deserialize(r io.Reader) {
31306         if err := pcall(func() {
31307                 ((*(*(struct {
31308                         Pos Vec
31309                         Rot [3]float32
31310                 }))(obj)).Pos).Deserialize(r)
31311         }); err != nil {
31312                 if err == io.EOF {
31313                         chk(io.EOF)
31314                 }
31315                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31316         }
31317         for local369 := range (*(*(struct {
31318                 Pos Vec
31319                 Rot [3]float32
31320         }))(obj)).Rot {
31321                 {
31322                         p := &((*(*(struct {
31323                                 Pos Vec
31324                                 Rot [3]float32
31325                         }))(obj)).Rot)[local369]
31326                         *p = math.Float32frombits(read32(r))
31327                 }
31328         }
31329 }
31330
31331 func (obj *AOAttach) Serialize(w io.Writer) {
31332         if err := pcall(func() {
31333                 ((*(*(struct {
31334                         ParentID     AOID
31335                         Bone         string
31336                         Pos          Vec
31337                         Rot          [3]float32
31338                         ForceVisible bool
31339                 }))(obj)).ParentID).Serialize(w)
31340         }); err != nil {
31341                 if err == io.EOF {
31342                         chk(io.EOF)
31343                 }
31344                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
31345         }
31346         if len(([]byte((*(*(struct {
31347                 ParentID     AOID
31348                 Bone         string
31349                 Pos          Vec
31350                 Rot          [3]float32
31351                 ForceVisible bool
31352         }))(obj)).Bone))) > math.MaxUint16 {
31353                 chk(ErrTooLong)
31354         }
31355         {
31356                 x := uint16(len(([]byte((*(*(struct {
31357                         ParentID     AOID
31358                         Bone         string
31359                         Pos          Vec
31360                         Rot          [3]float32
31361                         ForceVisible bool
31362                 }))(obj)).Bone))))
31363                 write16(w, uint16(x))
31364         }
31365         {
31366                 _, err := w.Write(([]byte((*(*(struct {
31367                         ParentID     AOID
31368                         Bone         string
31369                         Pos          Vec
31370                         Rot          [3]float32
31371                         ForceVisible bool
31372                 }))(obj)).Bone))[:])
31373                 chk(err)
31374         }
31375         if err := pcall(func() {
31376                 ((*(*(struct {
31377                         ParentID     AOID
31378                         Bone         string
31379                         Pos          Vec
31380                         Rot          [3]float32
31381                         ForceVisible bool
31382                 }))(obj)).Pos).Serialize(w)
31383         }); err != nil {
31384                 if err == io.EOF {
31385                         chk(io.EOF)
31386                 }
31387                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31388         }
31389         for local370 := range (*(*(struct {
31390                 ParentID     AOID
31391                 Bone         string
31392                 Pos          Vec
31393                 Rot          [3]float32
31394                 ForceVisible bool
31395         }))(obj)).Rot {
31396                 {
31397                         x := ((*(*(struct {
31398                                 ParentID     AOID
31399                                 Bone         string
31400                                 Pos          Vec
31401                                 Rot          [3]float32
31402                                 ForceVisible bool
31403                         }))(obj)).Rot)[local370]
31404                         write32(w, math.Float32bits(x))
31405                 }
31406         }
31407         {
31408                 x := (*(*(struct {
31409                         ParentID     AOID
31410                         Bone         string
31411                         Pos          Vec
31412                         Rot          [3]float32
31413                         ForceVisible bool
31414                 }))(obj)).ForceVisible
31415                 if x {
31416                         write8(w, 1)
31417                 } else {
31418                         write8(w, 0)
31419                 }
31420         }
31421 }
31422
31423 func (obj *AOAttach) Deserialize(r io.Reader) {
31424         if err := pcall(func() {
31425                 ((*(*(struct {
31426                         ParentID     AOID
31427                         Bone         string
31428                         Pos          Vec
31429                         Rot          [3]float32
31430                         ForceVisible bool
31431                 }))(obj)).ParentID).Deserialize(r)
31432         }); err != nil {
31433                 if err == io.EOF {
31434                         chk(io.EOF)
31435                 }
31436                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
31437         }
31438         var local371 []uint8
31439         var local372 uint16
31440         {
31441                 p := &local372
31442                 *p = read16(r)
31443         }
31444         (local371) = make([]uint8, local372)
31445         {
31446                 _, err := io.ReadFull(r, (local371)[:])
31447                 chk(err)
31448         }
31449         ((*(*(struct {
31450                 ParentID     AOID
31451                 Bone         string
31452                 Pos          Vec
31453                 Rot          [3]float32
31454                 ForceVisible bool
31455         }))(obj)).Bone) = string(local371)
31456         if err := pcall(func() {
31457                 ((*(*(struct {
31458                         ParentID     AOID
31459                         Bone         string
31460                         Pos          Vec
31461                         Rot          [3]float32
31462                         ForceVisible bool
31463                 }))(obj)).Pos).Deserialize(r)
31464         }); err != nil {
31465                 if err == io.EOF {
31466                         chk(io.EOF)
31467                 }
31468                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31469         }
31470         for local373 := range (*(*(struct {
31471                 ParentID     AOID
31472                 Bone         string
31473                 Pos          Vec
31474                 Rot          [3]float32
31475                 ForceVisible bool
31476         }))(obj)).Rot {
31477                 {
31478                         p := &((*(*(struct {
31479                                 ParentID     AOID
31480                                 Bone         string
31481                                 Pos          Vec
31482                                 Rot          [3]float32
31483                                 ForceVisible bool
31484                         }))(obj)).Rot)[local373]
31485                         *p = math.Float32frombits(read32(r))
31486                 }
31487         }
31488         {
31489                 p := &(*(*(struct {
31490                         ParentID     AOID
31491                         Bone         string
31492                         Pos          Vec
31493                         Rot          [3]float32
31494                         ForceVisible bool
31495                 }))(obj)).ForceVisible
31496                 switch n := read8(r); n {
31497                 case 0:
31498                         *p = false
31499                 case 1:
31500                         *p = true
31501                 default:
31502                         chk(fmt.Errorf("invalid bool: %d", n))
31503                 }
31504         }
31505 }
31506
31507 func (obj *AOPhysOverride) Serialize(w io.Writer) {
31508         {
31509                 x := (*(*(struct {
31510                         Walk, Jump, Gravity float32
31511
31512                         // Player only.
31513                         NoSneak, NoSneakGlitch, OldSneak bool
31514                 }))(obj)).Walk
31515                 write32(w, math.Float32bits(x))
31516         }
31517         {
31518                 x := (*(*(struct {
31519                         Walk, Jump, Gravity float32
31520
31521                         // Player only.
31522                         NoSneak, NoSneakGlitch, OldSneak bool
31523                 }))(obj)).Jump
31524                 write32(w, math.Float32bits(x))
31525         }
31526         {
31527                 x := (*(*(struct {
31528                         Walk, Jump, Gravity float32
31529
31530                         // Player only.
31531                         NoSneak, NoSneakGlitch, OldSneak bool
31532                 }))(obj)).Gravity
31533                 write32(w, math.Float32bits(x))
31534         }
31535         {
31536                 x := (*(*(struct {
31537                         Walk, Jump, Gravity float32
31538
31539                         // Player only.
31540                         NoSneak, NoSneakGlitch, OldSneak bool
31541                 }))(obj)).NoSneak
31542                 if x {
31543                         write8(w, 1)
31544                 } else {
31545                         write8(w, 0)
31546                 }
31547         }
31548         {
31549                 x := (*(*(struct {
31550                         Walk, Jump, Gravity float32
31551
31552                         // Player only.
31553                         NoSneak, NoSneakGlitch, OldSneak bool
31554                 }))(obj)).NoSneakGlitch
31555                 if x {
31556                         write8(w, 1)
31557                 } else {
31558                         write8(w, 0)
31559                 }
31560         }
31561         {
31562                 x := (*(*(struct {
31563                         Walk, Jump, Gravity float32
31564
31565                         // Player only.
31566                         NoSneak, NoSneakGlitch, OldSneak bool
31567                 }))(obj)).OldSneak
31568                 if x {
31569                         write8(w, 1)
31570                 } else {
31571                         write8(w, 0)
31572                 }
31573         }
31574 }
31575
31576 func (obj *AOPhysOverride) Deserialize(r io.Reader) {
31577         {
31578                 p := &(*(*(struct {
31579                         Walk, Jump, Gravity float32
31580
31581                         // Player only.
31582                         NoSneak, NoSneakGlitch, OldSneak bool
31583                 }))(obj)).Walk
31584                 *p = math.Float32frombits(read32(r))
31585         }
31586         {
31587                 p := &(*(*(struct {
31588                         Walk, Jump, Gravity float32
31589
31590                         // Player only.
31591                         NoSneak, NoSneakGlitch, OldSneak bool
31592                 }))(obj)).Jump
31593                 *p = math.Float32frombits(read32(r))
31594         }
31595         {
31596                 p := &(*(*(struct {
31597                         Walk, Jump, Gravity float32
31598
31599                         // Player only.
31600                         NoSneak, NoSneakGlitch, OldSneak bool
31601                 }))(obj)).Gravity
31602                 *p = math.Float32frombits(read32(r))
31603         }
31604         {
31605                 p := &(*(*(struct {
31606                         Walk, Jump, Gravity float32
31607
31608                         // Player only.
31609                         NoSneak, NoSneakGlitch, OldSneak bool
31610                 }))(obj)).NoSneak
31611                 switch n := read8(r); n {
31612                 case 0:
31613                         *p = false
31614                 case 1:
31615                         *p = true
31616                 default:
31617                         chk(fmt.Errorf("invalid bool: %d", n))
31618                 }
31619         }
31620         {
31621                 p := &(*(*(struct {
31622                         Walk, Jump, Gravity float32
31623
31624                         // Player only.
31625                         NoSneak, NoSneakGlitch, OldSneak bool
31626                 }))(obj)).NoSneakGlitch
31627                 switch n := read8(r); n {
31628                 case 0:
31629                         *p = false
31630                 case 1:
31631                         *p = true
31632                 default:
31633                         chk(fmt.Errorf("invalid bool: %d", n))
31634                 }
31635         }
31636         {
31637                 p := &(*(*(struct {
31638                         Walk, Jump, Gravity float32
31639
31640                         // Player only.
31641                         NoSneak, NoSneakGlitch, OldSneak bool
31642                 }))(obj)).OldSneak
31643                 switch n := read8(r); n {
31644                 case 0:
31645                         *p = false
31646                 case 1:
31647                         *p = true
31648                 default:
31649                         chk(fmt.Errorf("invalid bool: %d", n))
31650                 }
31651         }
31652 }
31653
31654 func (obj *aoType) Serialize(w io.Writer) {
31655         {
31656                 x := *(*(uint8))(obj)
31657                 write8(w, uint8(x))
31658         }
31659 }
31660
31661 func (obj *aoType) Deserialize(r io.Reader) {
31662         {
31663                 p := &*(*(uint8))(obj)
31664                 *p = read8(r)
31665         }
31666 }
31667
31668 func (obj *NodeMetaField) Serialize(w io.Writer) {
31669         if err := pcall(func() {
31670                 ((*(*(struct {
31671                         Field
31672                         Private bool
31673                 }))(obj)).Field).Serialize(w)
31674         }); err != nil {
31675                 if err == io.EOF {
31676                         chk(io.EOF)
31677                 }
31678                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
31679         }
31680         {
31681                 x := (*(*(struct {
31682                         Field
31683                         Private bool
31684                 }))(obj)).Private
31685                 if x {
31686                         write8(w, 1)
31687                 } else {
31688                         write8(w, 0)
31689                 }
31690         }
31691 }
31692
31693 func (obj *NodeMetaField) Deserialize(r io.Reader) {
31694         if err := pcall(func() {
31695                 ((*(*(struct {
31696                         Field
31697                         Private bool
31698                 }))(obj)).Field).Deserialize(r)
31699         }); err != nil {
31700                 if err == io.EOF {
31701                         chk(io.EOF)
31702                 }
31703                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
31704         }
31705         {
31706                 p := &(*(*(struct {
31707                         Field
31708                         Private bool
31709                 }))(obj)).Private
31710                 switch n := read8(r); n {
31711                 case 0:
31712                         *p = false
31713                 case 1:
31714                         *p = true
31715                 default:
31716                         chk(fmt.Errorf("invalid bool: %d", n))
31717                 }
31718         }
31719 }
31720
31721 func (obj *MinimapType) Serialize(w io.Writer) {
31722         {
31723                 x := *(*(uint16))(obj)
31724                 write16(w, uint16(x))
31725         }
31726 }
31727
31728 func (obj *MinimapType) Deserialize(r io.Reader) {
31729         {
31730                 p := &*(*(uint16))(obj)
31731                 *p = read16(r)
31732         }
31733 }
31734
31735 func (obj *Param1Type) Serialize(w io.Writer) {
31736         {
31737                 x := *(*(uint8))(obj)
31738                 write8(w, uint8(x))
31739         }
31740 }
31741
31742 func (obj *Param1Type) Deserialize(r io.Reader) {
31743         {
31744                 p := &*(*(uint8))(obj)
31745                 *p = read8(r)
31746         }
31747 }
31748
31749 func (obj *Param2Type) Serialize(w io.Writer) {
31750         {
31751                 x := *(*(uint8))(obj)
31752                 write8(w, uint8(x))
31753         }
31754 }
31755
31756 func (obj *Param2Type) Deserialize(r io.Reader) {
31757         {
31758                 p := &*(*(uint8))(obj)
31759                 *p = read8(r)
31760         }
31761 }
31762
31763 func (obj *DrawType) Serialize(w io.Writer) {
31764         {
31765                 x := *(*(uint8))(obj)
31766                 write8(w, uint8(x))
31767         }
31768 }
31769
31770 func (obj *DrawType) Deserialize(r io.Reader) {
31771         {
31772                 p := &*(*(uint8))(obj)
31773                 *p = read8(r)
31774         }
31775 }
31776
31777 func (obj *TileDef) Serialize(w io.Writer) {
31778         {
31779                 local374 := uint8(6)
31780                 {
31781                         x := local374
31782                         write8(w, uint8(x))
31783                 }
31784         }
31785         if err := pcall(func() {
31786                 ((*(*(struct {
31787                         Texture
31788                         Anim  TileAnim
31789                         Flags TileFlags
31790
31791                         //mt:if %s.Flags&TileColor != 0
31792                         R, G, B uint8
31793
31794                         //mt:if %s.Flags&TileScale != 0
31795                         Scale uint8
31796
31797                         //mt:if %s.Flags&TileAlign != 0
31798                         Align AlignType
31799                 }))(obj)).Texture).Serialize(w)
31800         }); err != nil {
31801                 if err == io.EOF {
31802                         chk(io.EOF)
31803                 }
31804                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
31805         }
31806         if err := pcall(func() {
31807                 ((*(*(struct {
31808                         Texture
31809                         Anim  TileAnim
31810                         Flags TileFlags
31811
31812                         //mt:if %s.Flags&TileColor != 0
31813                         R, G, B uint8
31814
31815                         //mt:if %s.Flags&TileScale != 0
31816                         Scale uint8
31817
31818                         //mt:if %s.Flags&TileAlign != 0
31819                         Align AlignType
31820                 }))(obj)).Anim).Serialize(w)
31821         }); err != nil {
31822                 if err == io.EOF {
31823                         chk(io.EOF)
31824                 }
31825                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
31826         }
31827         if err := pcall(func() {
31828                 ((*(*(struct {
31829                         Texture
31830                         Anim  TileAnim
31831                         Flags TileFlags
31832
31833                         //mt:if %s.Flags&TileColor != 0
31834                         R, G, B uint8
31835
31836                         //mt:if %s.Flags&TileScale != 0
31837                         Scale uint8
31838
31839                         //mt:if %s.Flags&TileAlign != 0
31840                         Align AlignType
31841                 }))(obj)).Flags).Serialize(w)
31842         }); err != nil {
31843                 if err == io.EOF {
31844                         chk(io.EOF)
31845                 }
31846                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
31847         }
31848         if (*(*(struct {
31849                 Texture
31850                 Anim  TileAnim
31851                 Flags TileFlags
31852
31853                 //mt:if %s.Flags&TileColor != 0
31854                 R, G, B uint8
31855
31856                 //mt:if %s.Flags&TileScale != 0
31857                 Scale uint8
31858
31859                 //mt:if %s.Flags&TileAlign != 0
31860                 Align AlignType
31861         }))(obj)).Flags&TileColor != 0 {
31862                 {
31863                         x := (*(*(struct {
31864                                 Texture
31865                                 Anim  TileAnim
31866                                 Flags TileFlags
31867
31868                                 //mt:if %s.Flags&TileColor != 0
31869                                 R, G, B uint8
31870
31871                                 //mt:if %s.Flags&TileScale != 0
31872                                 Scale uint8
31873
31874                                 //mt:if %s.Flags&TileAlign != 0
31875                                 Align AlignType
31876                         }))(obj)).R
31877                         write8(w, uint8(x))
31878                 }
31879                 {
31880                         x := (*(*(struct {
31881                                 Texture
31882                                 Anim  TileAnim
31883                                 Flags TileFlags
31884
31885                                 //mt:if %s.Flags&TileColor != 0
31886                                 R, G, B uint8
31887
31888                                 //mt:if %s.Flags&TileScale != 0
31889                                 Scale uint8
31890
31891                                 //mt:if %s.Flags&TileAlign != 0
31892                                 Align AlignType
31893                         }))(obj)).G
31894                         write8(w, uint8(x))
31895                 }
31896                 {
31897                         x := (*(*(struct {
31898                                 Texture
31899                                 Anim  TileAnim
31900                                 Flags TileFlags
31901
31902                                 //mt:if %s.Flags&TileColor != 0
31903                                 R, G, B uint8
31904
31905                                 //mt:if %s.Flags&TileScale != 0
31906                                 Scale uint8
31907
31908                                 //mt:if %s.Flags&TileAlign != 0
31909                                 Align AlignType
31910                         }))(obj)).B
31911                         write8(w, uint8(x))
31912                 }
31913         }
31914         if (*(*(struct {
31915                 Texture
31916                 Anim  TileAnim
31917                 Flags TileFlags
31918
31919                 //mt:if %s.Flags&TileColor != 0
31920                 R, G, B uint8
31921
31922                 //mt:if %s.Flags&TileScale != 0
31923                 Scale uint8
31924
31925                 //mt:if %s.Flags&TileAlign != 0
31926                 Align AlignType
31927         }))(obj)).Flags&TileScale != 0 {
31928                 {
31929                         x := (*(*(struct {
31930                                 Texture
31931                                 Anim  TileAnim
31932                                 Flags TileFlags
31933
31934                                 //mt:if %s.Flags&TileColor != 0
31935                                 R, G, B uint8
31936
31937                                 //mt:if %s.Flags&TileScale != 0
31938                                 Scale uint8
31939
31940                                 //mt:if %s.Flags&TileAlign != 0
31941                                 Align AlignType
31942                         }))(obj)).Scale
31943                         write8(w, uint8(x))
31944                 }
31945         }
31946         if (*(*(struct {
31947                 Texture
31948                 Anim  TileAnim
31949                 Flags TileFlags
31950
31951                 //mt:if %s.Flags&TileColor != 0
31952                 R, G, B uint8
31953
31954                 //mt:if %s.Flags&TileScale != 0
31955                 Scale uint8
31956
31957                 //mt:if %s.Flags&TileAlign != 0
31958                 Align AlignType
31959         }))(obj)).Flags&TileAlign != 0 {
31960                 if err := pcall(func() {
31961                         ((*(*(struct {
31962                                 Texture
31963                                 Anim  TileAnim
31964                                 Flags TileFlags
31965
31966                                 //mt:if %s.Flags&TileColor != 0
31967                                 R, G, B uint8
31968
31969                                 //mt:if %s.Flags&TileScale != 0
31970                                 Scale uint8
31971
31972                                 //mt:if %s.Flags&TileAlign != 0
31973                                 Align AlignType
31974                         }))(obj)).Align).Serialize(w)
31975                 }); err != nil {
31976                         if err == io.EOF {
31977                                 chk(io.EOF)
31978                         }
31979                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
31980                 }
31981         }
31982 }
31983
31984 func (obj *TileDef) Deserialize(r io.Reader) {
31985         {
31986                 var local375 uint8
31987                 local376 := uint8(6)
31988                 {
31989                         p := &local375
31990                         *p = read8(r)
31991                 }
31992                 if local375 != local376 {
31993                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local375))
31994                 }
31995         }
31996         if err := pcall(func() {
31997                 ((*(*(struct {
31998                         Texture
31999                         Anim  TileAnim
32000                         Flags TileFlags
32001
32002                         //mt:if %s.Flags&TileColor != 0
32003                         R, G, B uint8
32004
32005                         //mt:if %s.Flags&TileScale != 0
32006                         Scale uint8
32007
32008                         //mt:if %s.Flags&TileAlign != 0
32009                         Align AlignType
32010                 }))(obj)).Texture).Deserialize(r)
32011         }); err != nil {
32012                 if err == io.EOF {
32013                         chk(io.EOF)
32014                 }
32015                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
32016         }
32017         if err := pcall(func() {
32018                 ((*(*(struct {
32019                         Texture
32020                         Anim  TileAnim
32021                         Flags TileFlags
32022
32023                         //mt:if %s.Flags&TileColor != 0
32024                         R, G, B uint8
32025
32026                         //mt:if %s.Flags&TileScale != 0
32027                         Scale uint8
32028
32029                         //mt:if %s.Flags&TileAlign != 0
32030                         Align AlignType
32031                 }))(obj)).Anim).Deserialize(r)
32032         }); err != nil {
32033                 if err == io.EOF {
32034                         chk(io.EOF)
32035                 }
32036                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32037         }
32038         if err := pcall(func() {
32039                 ((*(*(struct {
32040                         Texture
32041                         Anim  TileAnim
32042                         Flags TileFlags
32043
32044                         //mt:if %s.Flags&TileColor != 0
32045                         R, G, B uint8
32046
32047                         //mt:if %s.Flags&TileScale != 0
32048                         Scale uint8
32049
32050                         //mt:if %s.Flags&TileAlign != 0
32051                         Align AlignType
32052                 }))(obj)).Flags).Deserialize(r)
32053         }); err != nil {
32054                 if err == io.EOF {
32055                         chk(io.EOF)
32056                 }
32057                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32058         }
32059         if (*(*(struct {
32060                 Texture
32061                 Anim  TileAnim
32062                 Flags TileFlags
32063
32064                 //mt:if %s.Flags&TileColor != 0
32065                 R, G, B uint8
32066
32067                 //mt:if %s.Flags&TileScale != 0
32068                 Scale uint8
32069
32070                 //mt:if %s.Flags&TileAlign != 0
32071                 Align AlignType
32072         }))(obj)).Flags&TileColor != 0 {
32073                 {
32074                         p := &(*(*(struct {
32075                                 Texture
32076                                 Anim  TileAnim
32077                                 Flags TileFlags
32078
32079                                 //mt:if %s.Flags&TileColor != 0
32080                                 R, G, B uint8
32081
32082                                 //mt:if %s.Flags&TileScale != 0
32083                                 Scale uint8
32084
32085                                 //mt:if %s.Flags&TileAlign != 0
32086                                 Align AlignType
32087                         }))(obj)).R
32088                         *p = read8(r)
32089                 }
32090                 {
32091                         p := &(*(*(struct {
32092                                 Texture
32093                                 Anim  TileAnim
32094                                 Flags TileFlags
32095
32096                                 //mt:if %s.Flags&TileColor != 0
32097                                 R, G, B uint8
32098
32099                                 //mt:if %s.Flags&TileScale != 0
32100                                 Scale uint8
32101
32102                                 //mt:if %s.Flags&TileAlign != 0
32103                                 Align AlignType
32104                         }))(obj)).G
32105                         *p = read8(r)
32106                 }
32107                 {
32108                         p := &(*(*(struct {
32109                                 Texture
32110                                 Anim  TileAnim
32111                                 Flags TileFlags
32112
32113                                 //mt:if %s.Flags&TileColor != 0
32114                                 R, G, B uint8
32115
32116                                 //mt:if %s.Flags&TileScale != 0
32117                                 Scale uint8
32118
32119                                 //mt:if %s.Flags&TileAlign != 0
32120                                 Align AlignType
32121                         }))(obj)).B
32122                         *p = read8(r)
32123                 }
32124         }
32125         if (*(*(struct {
32126                 Texture
32127                 Anim  TileAnim
32128                 Flags TileFlags
32129
32130                 //mt:if %s.Flags&TileColor != 0
32131                 R, G, B uint8
32132
32133                 //mt:if %s.Flags&TileScale != 0
32134                 Scale uint8
32135
32136                 //mt:if %s.Flags&TileAlign != 0
32137                 Align AlignType
32138         }))(obj)).Flags&TileScale != 0 {
32139                 {
32140                         p := &(*(*(struct {
32141                                 Texture
32142                                 Anim  TileAnim
32143                                 Flags TileFlags
32144
32145                                 //mt:if %s.Flags&TileColor != 0
32146                                 R, G, B uint8
32147
32148                                 //mt:if %s.Flags&TileScale != 0
32149                                 Scale uint8
32150
32151                                 //mt:if %s.Flags&TileAlign != 0
32152                                 Align AlignType
32153                         }))(obj)).Scale
32154                         *p = read8(r)
32155                 }
32156         }
32157         if (*(*(struct {
32158                 Texture
32159                 Anim  TileAnim
32160                 Flags TileFlags
32161
32162                 //mt:if %s.Flags&TileColor != 0
32163                 R, G, B uint8
32164
32165                 //mt:if %s.Flags&TileScale != 0
32166                 Scale uint8
32167
32168                 //mt:if %s.Flags&TileAlign != 0
32169                 Align AlignType
32170         }))(obj)).Flags&TileAlign != 0 {
32171                 if err := pcall(func() {
32172                         ((*(*(struct {
32173                                 Texture
32174                                 Anim  TileAnim
32175                                 Flags TileFlags
32176
32177                                 //mt:if %s.Flags&TileColor != 0
32178                                 R, G, B uint8
32179
32180                                 //mt:if %s.Flags&TileScale != 0
32181                                 Scale uint8
32182
32183                                 //mt:if %s.Flags&TileAlign != 0
32184                                 Align AlignType
32185                         }))(obj)).Align).Deserialize(r)
32186                 }); err != nil {
32187                         if err == io.EOF {
32188                                 chk(io.EOF)
32189                         }
32190                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32191                 }
32192         }
32193 }
32194
32195 func (obj *WaveType) Serialize(w io.Writer) {
32196         {
32197                 x := *(*(uint8))(obj)
32198                 write8(w, uint8(x))
32199         }
32200 }
32201
32202 func (obj *WaveType) Deserialize(r io.Reader) {
32203         {
32204                 p := &*(*(uint8))(obj)
32205                 *p = read8(r)
32206         }
32207 }
32208
32209 func (obj *LiquidType) Serialize(w io.Writer) {
32210         {
32211                 x := *(*(uint8))(obj)
32212                 write8(w, uint8(x))
32213         }
32214 }
32215
32216 func (obj *LiquidType) Deserialize(r io.Reader) {
32217         {
32218                 p := &*(*(uint8))(obj)
32219                 *p = read8(r)
32220         }
32221 }
32222
32223 func (obj *NodeBox) Serialize(w io.Writer) {
32224         {
32225                 local377 := uint8(6)
32226                 {
32227                         x := local377
32228                         write8(w, uint8(x))
32229                 }
32230         }
32231         if err := pcall(func() {
32232                 ((*(*(struct {
32233                         Type NodeBoxType
32234
32235                         //mt:if %s.Type == MountedBox
32236                         WallTop, WallBot, WallSides Box
32237
32238                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32239                         Fixed []Box
32240
32241                         //mt:if %s.Type == ConnectedBox
32242                         ConnDirs, DiscoDirs  DirBoxes
32243                         DiscoAll, DiscoSides []Box
32244                 }))(obj)).Type).Serialize(w)
32245         }); err != nil {
32246                 if err == io.EOF {
32247                         chk(io.EOF)
32248                 }
32249                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
32250         }
32251         if !((*(*(struct {
32252                 Type NodeBoxType
32253
32254                 //mt:if %s.Type == MountedBox
32255                 WallTop, WallBot, WallSides Box
32256
32257                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32258                 Fixed []Box
32259
32260                 //mt:if %s.Type == ConnectedBox
32261                 ConnDirs, DiscoDirs  DirBoxes
32262                 DiscoAll, DiscoSides []Box
32263         }))(obj)).Type < maxBox) {
32264                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32265         }
32266         if (*(*(struct {
32267                 Type NodeBoxType
32268
32269                 //mt:if %s.Type == MountedBox
32270                 WallTop, WallBot, WallSides Box
32271
32272                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32273                 Fixed []Box
32274
32275                 //mt:if %s.Type == ConnectedBox
32276                 ConnDirs, DiscoDirs  DirBoxes
32277                 DiscoAll, DiscoSides []Box
32278         }))(obj)).Type == MountedBox {
32279                 if err := pcall(func() {
32280                         ((*(*(struct {
32281                                 Type NodeBoxType
32282
32283                                 //mt:if %s.Type == MountedBox
32284                                 WallTop, WallBot, WallSides Box
32285
32286                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32287                                 Fixed []Box
32288
32289                                 //mt:if %s.Type == ConnectedBox
32290                                 ConnDirs, DiscoDirs  DirBoxes
32291                                 DiscoAll, DiscoSides []Box
32292                         }))(obj)).WallTop).Serialize(w)
32293                 }); err != nil {
32294                         if err == io.EOF {
32295                                 chk(io.EOF)
32296                         }
32297                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32298                 }
32299                 if err := pcall(func() {
32300                         ((*(*(struct {
32301                                 Type NodeBoxType
32302
32303                                 //mt:if %s.Type == MountedBox
32304                                 WallTop, WallBot, WallSides Box
32305
32306                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32307                                 Fixed []Box
32308
32309                                 //mt:if %s.Type == ConnectedBox
32310                                 ConnDirs, DiscoDirs  DirBoxes
32311                                 DiscoAll, DiscoSides []Box
32312                         }))(obj)).WallBot).Serialize(w)
32313                 }); err != nil {
32314                         if err == io.EOF {
32315                                 chk(io.EOF)
32316                         }
32317                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32318                 }
32319                 if err := pcall(func() {
32320                         ((*(*(struct {
32321                                 Type NodeBoxType
32322
32323                                 //mt:if %s.Type == MountedBox
32324                                 WallTop, WallBot, WallSides Box
32325
32326                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32327                                 Fixed []Box
32328
32329                                 //mt:if %s.Type == ConnectedBox
32330                                 ConnDirs, DiscoDirs  DirBoxes
32331                                 DiscoAll, DiscoSides []Box
32332                         }))(obj)).WallSides).Serialize(w)
32333                 }); err != nil {
32334                         if err == io.EOF {
32335                                 chk(io.EOF)
32336                         }
32337                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32338                 }
32339         }
32340         if t := (*(*(struct {
32341                 Type NodeBoxType
32342
32343                 //mt:if %s.Type == MountedBox
32344                 WallTop, WallBot, WallSides Box
32345
32346                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32347                 Fixed []Box
32348
32349                 //mt:if %s.Type == ConnectedBox
32350                 ConnDirs, DiscoDirs  DirBoxes
32351                 DiscoAll, DiscoSides []Box
32352         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32353                 if len(((*(*(struct {
32354                         Type NodeBoxType
32355
32356                         //mt:if %s.Type == MountedBox
32357                         WallTop, WallBot, WallSides Box
32358
32359                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32360                         Fixed []Box
32361
32362                         //mt:if %s.Type == ConnectedBox
32363                         ConnDirs, DiscoDirs  DirBoxes
32364                         DiscoAll, DiscoSides []Box
32365                 }))(obj)).Fixed)) > math.MaxUint16 {
32366                         chk(ErrTooLong)
32367                 }
32368                 {
32369                         x := uint16(len(((*(*(struct {
32370                                 Type NodeBoxType
32371
32372                                 //mt:if %s.Type == MountedBox
32373                                 WallTop, WallBot, WallSides Box
32374
32375                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32376                                 Fixed []Box
32377
32378                                 //mt:if %s.Type == ConnectedBox
32379                                 ConnDirs, DiscoDirs  DirBoxes
32380                                 DiscoAll, DiscoSides []Box
32381                         }))(obj)).Fixed)))
32382                         write16(w, uint16(x))
32383                 }
32384                 for local378 := range (*(*(struct {
32385                         Type NodeBoxType
32386
32387                         //mt:if %s.Type == MountedBox
32388                         WallTop, WallBot, WallSides Box
32389
32390                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32391                         Fixed []Box
32392
32393                         //mt:if %s.Type == ConnectedBox
32394                         ConnDirs, DiscoDirs  DirBoxes
32395                         DiscoAll, DiscoSides []Box
32396                 }))(obj)).Fixed {
32397                         if err := pcall(func() {
32398                                 (((*(*(struct {
32399                                         Type NodeBoxType
32400
32401                                         //mt:if %s.Type == MountedBox
32402                                         WallTop, WallBot, WallSides Box
32403
32404                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32405                                         Fixed []Box
32406
32407                                         //mt:if %s.Type == ConnectedBox
32408                                         ConnDirs, DiscoDirs  DirBoxes
32409                                         DiscoAll, DiscoSides []Box
32410                                 }))(obj)).Fixed)[local378]).Serialize(w)
32411                         }); err != nil {
32412                                 if err == io.EOF {
32413                                         chk(io.EOF)
32414                                 }
32415                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32416                         }
32417                 }
32418         }
32419         if (*(*(struct {
32420                 Type NodeBoxType
32421
32422                 //mt:if %s.Type == MountedBox
32423                 WallTop, WallBot, WallSides Box
32424
32425                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32426                 Fixed []Box
32427
32428                 //mt:if %s.Type == ConnectedBox
32429                 ConnDirs, DiscoDirs  DirBoxes
32430                 DiscoAll, DiscoSides []Box
32431         }))(obj)).Type == ConnectedBox {
32432                 if err := pcall(func() {
32433                         ((*(*(struct {
32434                                 Type NodeBoxType
32435
32436                                 //mt:if %s.Type == MountedBox
32437                                 WallTop, WallBot, WallSides Box
32438
32439                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32440                                 Fixed []Box
32441
32442                                 //mt:if %s.Type == ConnectedBox
32443                                 ConnDirs, DiscoDirs  DirBoxes
32444                                 DiscoAll, DiscoSides []Box
32445                         }))(obj)).ConnDirs).Serialize(w)
32446                 }); err != nil {
32447                         if err == io.EOF {
32448                                 chk(io.EOF)
32449                         }
32450                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32451                 }
32452                 if err := pcall(func() {
32453                         ((*(*(struct {
32454                                 Type NodeBoxType
32455
32456                                 //mt:if %s.Type == MountedBox
32457                                 WallTop, WallBot, WallSides Box
32458
32459                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32460                                 Fixed []Box
32461
32462                                 //mt:if %s.Type == ConnectedBox
32463                                 ConnDirs, DiscoDirs  DirBoxes
32464                                 DiscoAll, DiscoSides []Box
32465                         }))(obj)).DiscoDirs).Serialize(w)
32466                 }); err != nil {
32467                         if err == io.EOF {
32468                                 chk(io.EOF)
32469                         }
32470                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32471                 }
32472                 if len(((*(*(struct {
32473                         Type NodeBoxType
32474
32475                         //mt:if %s.Type == MountedBox
32476                         WallTop, WallBot, WallSides Box
32477
32478                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32479                         Fixed []Box
32480
32481                         //mt:if %s.Type == ConnectedBox
32482                         ConnDirs, DiscoDirs  DirBoxes
32483                         DiscoAll, DiscoSides []Box
32484                 }))(obj)).DiscoAll)) > math.MaxUint16 {
32485                         chk(ErrTooLong)
32486                 }
32487                 {
32488                         x := uint16(len(((*(*(struct {
32489                                 Type NodeBoxType
32490
32491                                 //mt:if %s.Type == MountedBox
32492                                 WallTop, WallBot, WallSides Box
32493
32494                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32495                                 Fixed []Box
32496
32497                                 //mt:if %s.Type == ConnectedBox
32498                                 ConnDirs, DiscoDirs  DirBoxes
32499                                 DiscoAll, DiscoSides []Box
32500                         }))(obj)).DiscoAll)))
32501                         write16(w, uint16(x))
32502                 }
32503                 for local379 := range (*(*(struct {
32504                         Type NodeBoxType
32505
32506                         //mt:if %s.Type == MountedBox
32507                         WallTop, WallBot, WallSides Box
32508
32509                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32510                         Fixed []Box
32511
32512                         //mt:if %s.Type == ConnectedBox
32513                         ConnDirs, DiscoDirs  DirBoxes
32514                         DiscoAll, DiscoSides []Box
32515                 }))(obj)).DiscoAll {
32516                         if err := pcall(func() {
32517                                 (((*(*(struct {
32518                                         Type NodeBoxType
32519
32520                                         //mt:if %s.Type == MountedBox
32521                                         WallTop, WallBot, WallSides Box
32522
32523                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32524                                         Fixed []Box
32525
32526                                         //mt:if %s.Type == ConnectedBox
32527                                         ConnDirs, DiscoDirs  DirBoxes
32528                                         DiscoAll, DiscoSides []Box
32529                                 }))(obj)).DiscoAll)[local379]).Serialize(w)
32530                         }); err != nil {
32531                                 if err == io.EOF {
32532                                         chk(io.EOF)
32533                                 }
32534                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32535                         }
32536                 }
32537                 if len(((*(*(struct {
32538                         Type NodeBoxType
32539
32540                         //mt:if %s.Type == MountedBox
32541                         WallTop, WallBot, WallSides Box
32542
32543                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32544                         Fixed []Box
32545
32546                         //mt:if %s.Type == ConnectedBox
32547                         ConnDirs, DiscoDirs  DirBoxes
32548                         DiscoAll, DiscoSides []Box
32549                 }))(obj)).DiscoSides)) > math.MaxUint16 {
32550                         chk(ErrTooLong)
32551                 }
32552                 {
32553                         x := uint16(len(((*(*(struct {
32554                                 Type NodeBoxType
32555
32556                                 //mt:if %s.Type == MountedBox
32557                                 WallTop, WallBot, WallSides Box
32558
32559                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32560                                 Fixed []Box
32561
32562                                 //mt:if %s.Type == ConnectedBox
32563                                 ConnDirs, DiscoDirs  DirBoxes
32564                                 DiscoAll, DiscoSides []Box
32565                         }))(obj)).DiscoSides)))
32566                         write16(w, uint16(x))
32567                 }
32568                 for local380 := range (*(*(struct {
32569                         Type NodeBoxType
32570
32571                         //mt:if %s.Type == MountedBox
32572                         WallTop, WallBot, WallSides Box
32573
32574                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32575                         Fixed []Box
32576
32577                         //mt:if %s.Type == ConnectedBox
32578                         ConnDirs, DiscoDirs  DirBoxes
32579                         DiscoAll, DiscoSides []Box
32580                 }))(obj)).DiscoSides {
32581                         if err := pcall(func() {
32582                                 (((*(*(struct {
32583                                         Type NodeBoxType
32584
32585                                         //mt:if %s.Type == MountedBox
32586                                         WallTop, WallBot, WallSides Box
32587
32588                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32589                                         Fixed []Box
32590
32591                                         //mt:if %s.Type == ConnectedBox
32592                                         ConnDirs, DiscoDirs  DirBoxes
32593                                         DiscoAll, DiscoSides []Box
32594                                 }))(obj)).DiscoSides)[local380]).Serialize(w)
32595                         }); err != nil {
32596                                 if err == io.EOF {
32597                                         chk(io.EOF)
32598                                 }
32599                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32600                         }
32601                 }
32602         }
32603 }
32604
32605 func (obj *NodeBox) Deserialize(r io.Reader) {
32606         {
32607                 var local381 uint8
32608                 local382 := uint8(6)
32609                 {
32610                         p := &local381
32611                         *p = read8(r)
32612                 }
32613                 if local381 != local382 {
32614                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local381))
32615                 }
32616         }
32617         if err := pcall(func() {
32618                 ((*(*(struct {
32619                         Type NodeBoxType
32620
32621                         //mt:if %s.Type == MountedBox
32622                         WallTop, WallBot, WallSides Box
32623
32624                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32625                         Fixed []Box
32626
32627                         //mt:if %s.Type == ConnectedBox
32628                         ConnDirs, DiscoDirs  DirBoxes
32629                         DiscoAll, DiscoSides []Box
32630                 }))(obj)).Type).Deserialize(r)
32631         }); err != nil {
32632                 if err == io.EOF {
32633                         chk(io.EOF)
32634                 }
32635                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
32636         }
32637         if !((*(*(struct {
32638                 Type NodeBoxType
32639
32640                 //mt:if %s.Type == MountedBox
32641                 WallTop, WallBot, WallSides Box
32642
32643                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32644                 Fixed []Box
32645
32646                 //mt:if %s.Type == ConnectedBox
32647                 ConnDirs, DiscoDirs  DirBoxes
32648                 DiscoAll, DiscoSides []Box
32649         }))(obj)).Type < maxBox) {
32650                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32651         }
32652         if (*(*(struct {
32653                 Type NodeBoxType
32654
32655                 //mt:if %s.Type == MountedBox
32656                 WallTop, WallBot, WallSides Box
32657
32658                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32659                 Fixed []Box
32660
32661                 //mt:if %s.Type == ConnectedBox
32662                 ConnDirs, DiscoDirs  DirBoxes
32663                 DiscoAll, DiscoSides []Box
32664         }))(obj)).Type == MountedBox {
32665                 if err := pcall(func() {
32666                         ((*(*(struct {
32667                                 Type NodeBoxType
32668
32669                                 //mt:if %s.Type == MountedBox
32670                                 WallTop, WallBot, WallSides Box
32671
32672                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32673                                 Fixed []Box
32674
32675                                 //mt:if %s.Type == ConnectedBox
32676                                 ConnDirs, DiscoDirs  DirBoxes
32677                                 DiscoAll, DiscoSides []Box
32678                         }))(obj)).WallTop).Deserialize(r)
32679                 }); err != nil {
32680                         if err == io.EOF {
32681                                 chk(io.EOF)
32682                         }
32683                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32684                 }
32685                 if err := pcall(func() {
32686                         ((*(*(struct {
32687                                 Type NodeBoxType
32688
32689                                 //mt:if %s.Type == MountedBox
32690                                 WallTop, WallBot, WallSides Box
32691
32692                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32693                                 Fixed []Box
32694
32695                                 //mt:if %s.Type == ConnectedBox
32696                                 ConnDirs, DiscoDirs  DirBoxes
32697                                 DiscoAll, DiscoSides []Box
32698                         }))(obj)).WallBot).Deserialize(r)
32699                 }); err != nil {
32700                         if err == io.EOF {
32701                                 chk(io.EOF)
32702                         }
32703                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32704                 }
32705                 if err := pcall(func() {
32706                         ((*(*(struct {
32707                                 Type NodeBoxType
32708
32709                                 //mt:if %s.Type == MountedBox
32710                                 WallTop, WallBot, WallSides Box
32711
32712                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32713                                 Fixed []Box
32714
32715                                 //mt:if %s.Type == ConnectedBox
32716                                 ConnDirs, DiscoDirs  DirBoxes
32717                                 DiscoAll, DiscoSides []Box
32718                         }))(obj)).WallSides).Deserialize(r)
32719                 }); err != nil {
32720                         if err == io.EOF {
32721                                 chk(io.EOF)
32722                         }
32723                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32724                 }
32725         }
32726         if t := (*(*(struct {
32727                 Type NodeBoxType
32728
32729                 //mt:if %s.Type == MountedBox
32730                 WallTop, WallBot, WallSides Box
32731
32732                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32733                 Fixed []Box
32734
32735                 //mt:if %s.Type == ConnectedBox
32736                 ConnDirs, DiscoDirs  DirBoxes
32737                 DiscoAll, DiscoSides []Box
32738         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32739                 var local383 uint16
32740                 {
32741                         p := &local383
32742                         *p = read16(r)
32743                 }
32744                 ((*(*(struct {
32745                         Type NodeBoxType
32746
32747                         //mt:if %s.Type == MountedBox
32748                         WallTop, WallBot, WallSides Box
32749
32750                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32751                         Fixed []Box
32752
32753                         //mt:if %s.Type == ConnectedBox
32754                         ConnDirs, DiscoDirs  DirBoxes
32755                         DiscoAll, DiscoSides []Box
32756                 }))(obj)).Fixed) = make([]Box, local383)
32757                 for local384 := range (*(*(struct {
32758                         Type NodeBoxType
32759
32760                         //mt:if %s.Type == MountedBox
32761                         WallTop, WallBot, WallSides Box
32762
32763                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32764                         Fixed []Box
32765
32766                         //mt:if %s.Type == ConnectedBox
32767                         ConnDirs, DiscoDirs  DirBoxes
32768                         DiscoAll, DiscoSides []Box
32769                 }))(obj)).Fixed {
32770                         if err := pcall(func() {
32771                                 (((*(*(struct {
32772                                         Type NodeBoxType
32773
32774                                         //mt:if %s.Type == MountedBox
32775                                         WallTop, WallBot, WallSides Box
32776
32777                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32778                                         Fixed []Box
32779
32780                                         //mt:if %s.Type == ConnectedBox
32781                                         ConnDirs, DiscoDirs  DirBoxes
32782                                         DiscoAll, DiscoSides []Box
32783                                 }))(obj)).Fixed)[local384]).Deserialize(r)
32784                         }); err != nil {
32785                                 if err == io.EOF {
32786                                         chk(io.EOF)
32787                                 }
32788                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32789                         }
32790                 }
32791         }
32792         if (*(*(struct {
32793                 Type NodeBoxType
32794
32795                 //mt:if %s.Type == MountedBox
32796                 WallTop, WallBot, WallSides Box
32797
32798                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32799                 Fixed []Box
32800
32801                 //mt:if %s.Type == ConnectedBox
32802                 ConnDirs, DiscoDirs  DirBoxes
32803                 DiscoAll, DiscoSides []Box
32804         }))(obj)).Type == ConnectedBox {
32805                 if err := pcall(func() {
32806                         ((*(*(struct {
32807                                 Type NodeBoxType
32808
32809                                 //mt:if %s.Type == MountedBox
32810                                 WallTop, WallBot, WallSides Box
32811
32812                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32813                                 Fixed []Box
32814
32815                                 //mt:if %s.Type == ConnectedBox
32816                                 ConnDirs, DiscoDirs  DirBoxes
32817                                 DiscoAll, DiscoSides []Box
32818                         }))(obj)).ConnDirs).Deserialize(r)
32819                 }); err != nil {
32820                         if err == io.EOF {
32821                                 chk(io.EOF)
32822                         }
32823                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32824                 }
32825                 if err := pcall(func() {
32826                         ((*(*(struct {
32827                                 Type NodeBoxType
32828
32829                                 //mt:if %s.Type == MountedBox
32830                                 WallTop, WallBot, WallSides Box
32831
32832                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32833                                 Fixed []Box
32834
32835                                 //mt:if %s.Type == ConnectedBox
32836                                 ConnDirs, DiscoDirs  DirBoxes
32837                                 DiscoAll, DiscoSides []Box
32838                         }))(obj)).DiscoDirs).Deserialize(r)
32839                 }); err != nil {
32840                         if err == io.EOF {
32841                                 chk(io.EOF)
32842                         }
32843                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32844                 }
32845                 var local385 uint16
32846                 {
32847                         p := &local385
32848                         *p = read16(r)
32849                 }
32850                 ((*(*(struct {
32851                         Type NodeBoxType
32852
32853                         //mt:if %s.Type == MountedBox
32854                         WallTop, WallBot, WallSides Box
32855
32856                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32857                         Fixed []Box
32858
32859                         //mt:if %s.Type == ConnectedBox
32860                         ConnDirs, DiscoDirs  DirBoxes
32861                         DiscoAll, DiscoSides []Box
32862                 }))(obj)).DiscoAll) = make([]Box, local385)
32863                 for local386 := range (*(*(struct {
32864                         Type NodeBoxType
32865
32866                         //mt:if %s.Type == MountedBox
32867                         WallTop, WallBot, WallSides Box
32868
32869                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32870                         Fixed []Box
32871
32872                         //mt:if %s.Type == ConnectedBox
32873                         ConnDirs, DiscoDirs  DirBoxes
32874                         DiscoAll, DiscoSides []Box
32875                 }))(obj)).DiscoAll {
32876                         if err := pcall(func() {
32877                                 (((*(*(struct {
32878                                         Type NodeBoxType
32879
32880                                         //mt:if %s.Type == MountedBox
32881                                         WallTop, WallBot, WallSides Box
32882
32883                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32884                                         Fixed []Box
32885
32886                                         //mt:if %s.Type == ConnectedBox
32887                                         ConnDirs, DiscoDirs  DirBoxes
32888                                         DiscoAll, DiscoSides []Box
32889                                 }))(obj)).DiscoAll)[local386]).Deserialize(r)
32890                         }); err != nil {
32891                                 if err == io.EOF {
32892                                         chk(io.EOF)
32893                                 }
32894                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32895                         }
32896                 }
32897                 var local387 uint16
32898                 {
32899                         p := &local387
32900                         *p = read16(r)
32901                 }
32902                 ((*(*(struct {
32903                         Type NodeBoxType
32904
32905                         //mt:if %s.Type == MountedBox
32906                         WallTop, WallBot, WallSides Box
32907
32908                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32909                         Fixed []Box
32910
32911                         //mt:if %s.Type == ConnectedBox
32912                         ConnDirs, DiscoDirs  DirBoxes
32913                         DiscoAll, DiscoSides []Box
32914                 }))(obj)).DiscoSides) = make([]Box, local387)
32915                 for local388 := range (*(*(struct {
32916                         Type NodeBoxType
32917
32918                         //mt:if %s.Type == MountedBox
32919                         WallTop, WallBot, WallSides Box
32920
32921                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32922                         Fixed []Box
32923
32924                         //mt:if %s.Type == ConnectedBox
32925                         ConnDirs, DiscoDirs  DirBoxes
32926                         DiscoAll, DiscoSides []Box
32927                 }))(obj)).DiscoSides {
32928                         if err := pcall(func() {
32929                                 (((*(*(struct {
32930                                         Type NodeBoxType
32931
32932                                         //mt:if %s.Type == MountedBox
32933                                         WallTop, WallBot, WallSides Box
32934
32935                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32936                                         Fixed []Box
32937
32938                                         //mt:if %s.Type == ConnectedBox
32939                                         ConnDirs, DiscoDirs  DirBoxes
32940                                         DiscoAll, DiscoSides []Box
32941                                 }))(obj)).DiscoSides)[local388]).Deserialize(r)
32942                         }); err != nil {
32943                                 if err == io.EOF {
32944                                         chk(io.EOF)
32945                                 }
32946                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32947                         }
32948                 }
32949         }
32950 }
32951
32952 func (obj *SoundDef) Serialize(w io.Writer) {
32953         if len(([]byte((*(*(struct {
32954                 Name              string
32955                 Gain, Pitch, Fade float32
32956         }))(obj)).Name))) > math.MaxUint16 {
32957                 chk(ErrTooLong)
32958         }
32959         {
32960                 x := uint16(len(([]byte((*(*(struct {
32961                         Name              string
32962                         Gain, Pitch, Fade float32
32963                 }))(obj)).Name))))
32964                 write16(w, uint16(x))
32965         }
32966         {
32967                 _, err := w.Write(([]byte((*(*(struct {
32968                         Name              string
32969                         Gain, Pitch, Fade float32
32970                 }))(obj)).Name))[:])
32971                 chk(err)
32972         }
32973         {
32974                 x := (*(*(struct {
32975                         Name              string
32976                         Gain, Pitch, Fade float32
32977                 }))(obj)).Gain
32978                 write32(w, math.Float32bits(x))
32979         }
32980         {
32981                 x := (*(*(struct {
32982                         Name              string
32983                         Gain, Pitch, Fade float32
32984                 }))(obj)).Pitch
32985                 write32(w, math.Float32bits(x))
32986         }
32987         {
32988                 x := (*(*(struct {
32989                         Name              string
32990                         Gain, Pitch, Fade float32
32991                 }))(obj)).Fade
32992                 write32(w, math.Float32bits(x))
32993         }
32994 }
32995
32996 func (obj *SoundDef) Deserialize(r io.Reader) {
32997         var local389 []uint8
32998         var local390 uint16
32999         {
33000                 p := &local390
33001                 *p = read16(r)
33002         }
33003         (local389) = make([]uint8, local390)
33004         {
33005                 _, err := io.ReadFull(r, (local389)[:])
33006                 chk(err)
33007         }
33008         ((*(*(struct {
33009                 Name              string
33010                 Gain, Pitch, Fade float32
33011         }))(obj)).Name) = string(local389)
33012         {
33013                 p := &(*(*(struct {
33014                         Name              string
33015                         Gain, Pitch, Fade float32
33016                 }))(obj)).Gain
33017                 *p = math.Float32frombits(read32(r))
33018         }
33019         {
33020                 p := &(*(*(struct {
33021                         Name              string
33022                         Gain, Pitch, Fade float32
33023                 }))(obj)).Pitch
33024                 *p = math.Float32frombits(read32(r))
33025         }
33026         {
33027                 p := &(*(*(struct {
33028                         Name              string
33029                         Gain, Pitch, Fade float32
33030                 }))(obj)).Fade
33031                 *p = math.Float32frombits(read32(r))
33032         }
33033 }
33034
33035 func (obj *AlphaUse) Serialize(w io.Writer) {
33036         {
33037                 x := *(*(uint8))(obj)
33038                 write8(w, uint8(x))
33039         }
33040 }
33041
33042 func (obj *AlphaUse) Deserialize(r io.Reader) {
33043         {
33044                 p := &*(*(uint8))(obj)
33045                 *p = read8(r)
33046         }
33047 }
33048
33049 func (obj *Keys) Serialize(w io.Writer) {
33050         {
33051                 x := *(*(uint32))(obj)
33052                 write32(w, uint32(x))
33053         }
33054 }
33055
33056 func (obj *Keys) Deserialize(r io.Reader) {
33057         {
33058                 p := &*(*(uint32))(obj)
33059                 *p = read32(r)
33060         }
33061 }
33062
33063 func (obj *MapBlkFlags) Serialize(w io.Writer) {
33064         {
33065                 x := *(*(uint8))(obj)
33066                 write8(w, uint8(x))
33067         }
33068 }
33069
33070 func (obj *MapBlkFlags) Deserialize(r io.Reader) {
33071         {
33072                 p := &*(*(uint8))(obj)
33073                 *p = read8(r)
33074         }
33075 }
33076
33077 func (obj *LitFromBlks) Serialize(w io.Writer) {
33078         {
33079                 x := *(*(uint16))(obj)
33080                 write16(w, uint16(x))
33081         }
33082 }
33083
33084 func (obj *LitFromBlks) Deserialize(r io.Reader) {
33085         {
33086                 p := &*(*(uint16))(obj)
33087                 *p = read16(r)
33088         }
33089 }
33090
33091 func (obj *AOInitData) Serialize(w io.Writer) {
33092         {
33093                 local391 := uint8(1)
33094                 {
33095                         x := local391
33096                         write8(w, uint8(x))
33097                 }
33098         }
33099         if len(([]byte((*(*(struct {
33100
33101                 // For players.
33102                 Name     string
33103                 IsPlayer bool
33104
33105                 ID AOID
33106
33107                 Pos
33108                 Rot [3]float32
33109
33110                 HP uint16
33111
33112                 // See (de)serialize.fmt.
33113                 Msgs []AOMsg
33114         }))(obj)).Name))) > math.MaxUint16 {
33115                 chk(ErrTooLong)
33116         }
33117         {
33118                 x := uint16(len(([]byte((*(*(struct {
33119
33120                         // For players.
33121                         Name     string
33122                         IsPlayer bool
33123
33124                         ID AOID
33125
33126                         Pos
33127                         Rot [3]float32
33128
33129                         HP uint16
33130
33131                         // See (de)serialize.fmt.
33132                         Msgs []AOMsg
33133                 }))(obj)).Name))))
33134                 write16(w, uint16(x))
33135         }
33136         {
33137                 _, err := w.Write(([]byte((*(*(struct {
33138
33139                         // For players.
33140                         Name     string
33141                         IsPlayer bool
33142
33143                         ID AOID
33144
33145                         Pos
33146                         Rot [3]float32
33147
33148                         HP uint16
33149
33150                         // See (de)serialize.fmt.
33151                         Msgs []AOMsg
33152                 }))(obj)).Name))[:])
33153                 chk(err)
33154         }
33155         {
33156                 x := (*(*(struct {
33157
33158                         // For players.
33159                         Name     string
33160                         IsPlayer bool
33161
33162                         ID AOID
33163
33164                         Pos
33165                         Rot [3]float32
33166
33167                         HP uint16
33168
33169                         // See (de)serialize.fmt.
33170                         Msgs []AOMsg
33171                 }))(obj)).IsPlayer
33172                 if x {
33173                         write8(w, 1)
33174                 } else {
33175                         write8(w, 0)
33176                 }
33177         }
33178         if err := pcall(func() {
33179                 ((*(*(struct {
33180
33181                         // For players.
33182                         Name     string
33183                         IsPlayer bool
33184
33185                         ID AOID
33186
33187                         Pos
33188                         Rot [3]float32
33189
33190                         HP uint16
33191
33192                         // See (de)serialize.fmt.
33193                         Msgs []AOMsg
33194                 }))(obj)).ID).Serialize(w)
33195         }); err != nil {
33196                 if err == io.EOF {
33197                         chk(io.EOF)
33198                 }
33199                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
33200         }
33201         if err := pcall(func() {
33202                 ((*(*(struct {
33203
33204                         // For players.
33205                         Name     string
33206                         IsPlayer bool
33207
33208                         ID AOID
33209
33210                         Pos
33211                         Rot [3]float32
33212
33213                         HP uint16
33214
33215                         // See (de)serialize.fmt.
33216                         Msgs []AOMsg
33217                 }))(obj)).Pos).Serialize(w)
33218         }); err != nil {
33219                 if err == io.EOF {
33220                         chk(io.EOF)
33221                 }
33222                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
33223         }
33224         for local392 := range (*(*(struct {
33225
33226                 // For players.
33227                 Name     string
33228                 IsPlayer bool
33229
33230                 ID AOID
33231
33232                 Pos
33233                 Rot [3]float32
33234
33235                 HP uint16
33236
33237                 // See (de)serialize.fmt.
33238                 Msgs []AOMsg
33239         }))(obj)).Rot {
33240                 {
33241                         x := ((*(*(struct {
33242
33243                                 // For players.
33244                                 Name     string
33245                                 IsPlayer bool
33246
33247                                 ID AOID
33248
33249                                 Pos
33250                                 Rot [3]float32
33251
33252                                 HP uint16
33253
33254                                 // See (de)serialize.fmt.
33255                                 Msgs []AOMsg
33256                         }))(obj)).Rot)[local392]
33257                         write32(w, math.Float32bits(x))
33258                 }
33259         }
33260         {
33261                 x := (*(*(struct {
33262
33263                         // For players.
33264                         Name     string
33265                         IsPlayer bool
33266
33267                         ID AOID
33268
33269                         Pos
33270                         Rot [3]float32
33271
33272                         HP uint16
33273
33274                         // See (de)serialize.fmt.
33275                         Msgs []AOMsg
33276                 }))(obj)).HP
33277                 write16(w, uint16(x))
33278         }
33279         {
33280                 x := (*(*(struct {
33281
33282                         // For players.
33283                         Name     string
33284                         IsPlayer bool
33285
33286                         ID AOID
33287
33288                         Pos
33289                         Rot [3]float32
33290
33291                         HP uint16
33292
33293                         // See (de)serialize.fmt.
33294                         Msgs []AOMsg
33295                 }))(obj)).Msgs
33296                 { // For AOInitData.Msgs.
33297                         if len(x) > math.MaxUint8 {
33298                                 chk(ErrTooLong)
33299                         }
33300                         write8(w, uint8(len(x)))
33301                         for _, msg := range x {
33302                                 var b bytes.Buffer
33303                                 chk(writeAOMsg(&b, msg))
33304                                 if b.Len() > math.MaxUint32 {
33305                                         chk(ErrTooLong)
33306                                 }
33307                                 write32(w, uint32(b.Len()))
33308                                 _, err := b.WriteTo(w)
33309                                 chk(err)
33310                         }
33311                 }
33312         }
33313 }
33314
33315 func (obj *AOInitData) Deserialize(r io.Reader) {
33316         {
33317                 var local393 uint8
33318                 local394 := uint8(1)
33319                 {
33320                         p := &local393
33321                         *p = read8(r)
33322                 }
33323                 if local393 != local394 {
33324                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local393))
33325                 }
33326         }
33327         var local395 []uint8
33328         var local396 uint16
33329         {
33330                 p := &local396
33331                 *p = read16(r)
33332         }
33333         (local395) = make([]uint8, local396)
33334         {
33335                 _, err := io.ReadFull(r, (local395)[:])
33336                 chk(err)
33337         }
33338         ((*(*(struct {
33339
33340                 // For players.
33341                 Name     string
33342                 IsPlayer bool
33343
33344                 ID AOID
33345
33346                 Pos
33347                 Rot [3]float32
33348
33349                 HP uint16
33350
33351                 // See (de)serialize.fmt.
33352                 Msgs []AOMsg
33353         }))(obj)).Name) = string(local395)
33354         {
33355                 p := &(*(*(struct {
33356
33357                         // For players.
33358                         Name     string
33359                         IsPlayer bool
33360
33361                         ID AOID
33362
33363                         Pos
33364                         Rot [3]float32
33365
33366                         HP uint16
33367
33368                         // See (de)serialize.fmt.
33369                         Msgs []AOMsg
33370                 }))(obj)).IsPlayer
33371                 switch n := read8(r); n {
33372                 case 0:
33373                         *p = false
33374                 case 1:
33375                         *p = true
33376                 default:
33377                         chk(fmt.Errorf("invalid bool: %d", n))
33378                 }
33379         }
33380         if err := pcall(func() {
33381                 ((*(*(struct {
33382
33383                         // For players.
33384                         Name     string
33385                         IsPlayer bool
33386
33387                         ID AOID
33388
33389                         Pos
33390                         Rot [3]float32
33391
33392                         HP uint16
33393
33394                         // See (de)serialize.fmt.
33395                         Msgs []AOMsg
33396                 }))(obj)).ID).Deserialize(r)
33397         }); err != nil {
33398                 if err == io.EOF {
33399                         chk(io.EOF)
33400                 }
33401                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
33402         }
33403         if err := pcall(func() {
33404                 ((*(*(struct {
33405
33406                         // For players.
33407                         Name     string
33408                         IsPlayer bool
33409
33410                         ID AOID
33411
33412                         Pos
33413                         Rot [3]float32
33414
33415                         HP uint16
33416
33417                         // See (de)serialize.fmt.
33418                         Msgs []AOMsg
33419                 }))(obj)).Pos).Deserialize(r)
33420         }); err != nil {
33421                 if err == io.EOF {
33422                         chk(io.EOF)
33423                 }
33424                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
33425         }
33426         for local397 := range (*(*(struct {
33427
33428                 // For players.
33429                 Name     string
33430                 IsPlayer bool
33431
33432                 ID AOID
33433
33434                 Pos
33435                 Rot [3]float32
33436
33437                 HP uint16
33438
33439                 // See (de)serialize.fmt.
33440                 Msgs []AOMsg
33441         }))(obj)).Rot {
33442                 {
33443                         p := &((*(*(struct {
33444
33445                                 // For players.
33446                                 Name     string
33447                                 IsPlayer bool
33448
33449                                 ID AOID
33450
33451                                 Pos
33452                                 Rot [3]float32
33453
33454                                 HP uint16
33455
33456                                 // See (de)serialize.fmt.
33457                                 Msgs []AOMsg
33458                         }))(obj)).Rot)[local397]
33459                         *p = math.Float32frombits(read32(r))
33460                 }
33461         }
33462         {
33463                 p := &(*(*(struct {
33464
33465                         // For players.
33466                         Name     string
33467                         IsPlayer bool
33468
33469                         ID AOID
33470
33471                         Pos
33472                         Rot [3]float32
33473
33474                         HP uint16
33475
33476                         // See (de)serialize.fmt.
33477                         Msgs []AOMsg
33478                 }))(obj)).HP
33479                 *p = read16(r)
33480         }
33481         {
33482                 p := &(*(*(struct {
33483
33484                         // For players.
33485                         Name     string
33486                         IsPlayer bool
33487
33488                         ID AOID
33489
33490                         Pos
33491                         Rot [3]float32
33492
33493                         HP uint16
33494
33495                         // See (de)serialize.fmt.
33496                         Msgs []AOMsg
33497                 }))(obj)).Msgs
33498                 { // For AOInitData.Msgs.
33499                         *p = make([]AOMsg, read8(r))
33500                         for i := range *p {
33501                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
33502                                 msg, err := readAOMsg(r)
33503                                 chk(err)
33504                                 (*p)[i] = msg
33505                                 if r.N > 0 {
33506                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
33507                                 }
33508                         }
33509                 }
33510         }
33511 }
33512
33513 func (obj *ItemType) Serialize(w io.Writer) {
33514         {
33515                 x := *(*(uint8))(obj)
33516                 write8(w, uint8(x))
33517         }
33518 }
33519
33520 func (obj *ItemType) Deserialize(r io.Reader) {
33521         {
33522                 p := &*(*(uint8))(obj)
33523                 *p = read8(r)
33524         }
33525 }
33526
33527 func (obj *ToolCaps) Serialize(w io.Writer) {
33528         if _ = (*(*(struct {
33529                 //mt:if _ = %s; false
33530                 NonNil bool
33531
33532                 AttackCooldown float32
33533                 MaxDropLvl     int16
33534
33535                 //mt:len32
33536                 GroupCaps []ToolGroupCap
33537
33538                 //mt:len32
33539                 DmgGroups []Group
33540
33541                 //mt:32tou16
33542                 PunchUses int32
33543         }))(obj)); false {
33544                 {
33545                         x := (*(*(struct {
33546                                 //mt:if _ = %s; false
33547                                 NonNil bool
33548
33549                                 AttackCooldown float32
33550                                 MaxDropLvl     int16
33551
33552                                 //mt:len32
33553                                 GroupCaps []ToolGroupCap
33554
33555                                 //mt:len32
33556                                 DmgGroups []Group
33557
33558                                 //mt:32tou16
33559                                 PunchUses int32
33560                         }))(obj)).NonNil
33561                         if x {
33562                                 write8(w, 1)
33563                         } else {
33564                                 write8(w, 0)
33565                         }
33566                 }
33567         }
33568         {
33569                 ow := w
33570                 w := new(bytes.Buffer)
33571                 /*
33572                    if r.N > 0 { (*(*(struct {
33573                         //mt:if _ = %s; false
33574                         NonNil  bool
33575
33576                         AttackCooldown  float32
33577                         MaxDropLvl      int16
33578
33579                         //mt:len32
33580                         GroupCaps       []ToolGroupCap
33581
33582                         //mt:len32
33583                         DmgGroups       []Group
33584
33585                         //mt:32tou16
33586                         PunchUses       int32
33587                    }))(obj)).NonNil = true}; /**/{
33588                         if (*(*(struct {
33589                                 //mt:if _ = %s; false
33590                                 NonNil bool
33591
33592                                 AttackCooldown float32
33593                                 MaxDropLvl     int16
33594
33595                                 //mt:len32
33596                                 GroupCaps []ToolGroupCap
33597
33598                                 //mt:len32
33599                                 DmgGroups []Group
33600
33601                                 //mt:32tou16
33602                                 PunchUses int32
33603                         }))(obj)).NonNil {
33604                                 {
33605                                         local398 := uint8(5)
33606                                         {
33607                                                 x := local398
33608                                                 write8(w, uint8(x))
33609                                         }
33610                                 }
33611                                 {
33612                                         x := (*(*(struct {
33613                                                 //mt:if _ = %s; false
33614                                                 NonNil bool
33615
33616                                                 AttackCooldown float32
33617                                                 MaxDropLvl     int16
33618
33619                                                 //mt:len32
33620                                                 GroupCaps []ToolGroupCap
33621
33622                                                 //mt:len32
33623                                                 DmgGroups []Group
33624
33625                                                 //mt:32tou16
33626                                                 PunchUses int32
33627                                         }))(obj)).AttackCooldown
33628                                         write32(w, math.Float32bits(x))
33629                                 }
33630                                 {
33631                                         x := (*(*(struct {
33632                                                 //mt:if _ = %s; false
33633                                                 NonNil bool
33634
33635                                                 AttackCooldown float32
33636                                                 MaxDropLvl     int16
33637
33638                                                 //mt:len32
33639                                                 GroupCaps []ToolGroupCap
33640
33641                                                 //mt:len32
33642                                                 DmgGroups []Group
33643
33644                                                 //mt:32tou16
33645                                                 PunchUses int32
33646                                         }))(obj)).MaxDropLvl
33647                                         write16(w, uint16(x))
33648                                 }
33649                                 if len(((*(*(struct {
33650                                         //mt:if _ = %s; false
33651                                         NonNil bool
33652
33653                                         AttackCooldown float32
33654                                         MaxDropLvl     int16
33655
33656                                         //mt:len32
33657                                         GroupCaps []ToolGroupCap
33658
33659                                         //mt:len32
33660                                         DmgGroups []Group
33661
33662                                         //mt:32tou16
33663                                         PunchUses int32
33664                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
33665                                         chk(ErrTooLong)
33666                                 }
33667                                 {
33668                                         x := uint32(len(((*(*(struct {
33669                                                 //mt:if _ = %s; false
33670                                                 NonNil bool
33671
33672                                                 AttackCooldown float32
33673                                                 MaxDropLvl     int16
33674
33675                                                 //mt:len32
33676                                                 GroupCaps []ToolGroupCap
33677
33678                                                 //mt:len32
33679                                                 DmgGroups []Group
33680
33681                                                 //mt:32tou16
33682                                                 PunchUses int32
33683                                         }))(obj)).GroupCaps)))
33684                                         write32(w, uint32(x))
33685                                 }
33686                                 for local399 := range (*(*(struct {
33687                                         //mt:if _ = %s; false
33688                                         NonNil bool
33689
33690                                         AttackCooldown float32
33691                                         MaxDropLvl     int16
33692
33693                                         //mt:len32
33694                                         GroupCaps []ToolGroupCap
33695
33696                                         //mt:len32
33697                                         DmgGroups []Group
33698
33699                                         //mt:32tou16
33700                                         PunchUses int32
33701                                 }))(obj)).GroupCaps {
33702                                         if err := pcall(func() {
33703                                                 (((*(*(struct {
33704                                                         //mt:if _ = %s; false
33705                                                         NonNil bool
33706
33707                                                         AttackCooldown float32
33708                                                         MaxDropLvl     int16
33709
33710                                                         //mt:len32
33711                                                         GroupCaps []ToolGroupCap
33712
33713                                                         //mt:len32
33714                                                         DmgGroups []Group
33715
33716                                                         //mt:32tou16
33717                                                         PunchUses int32
33718                                                 }))(obj)).GroupCaps)[local399]).Serialize(w)
33719                                         }); err != nil {
33720                                                 if err == io.EOF {
33721                                                         chk(io.EOF)
33722                                                 }
33723                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
33724                                         }
33725                                 }
33726                                 if len(((*(*(struct {
33727                                         //mt:if _ = %s; false
33728                                         NonNil bool
33729
33730                                         AttackCooldown float32
33731                                         MaxDropLvl     int16
33732
33733                                         //mt:len32
33734                                         GroupCaps []ToolGroupCap
33735
33736                                         //mt:len32
33737                                         DmgGroups []Group
33738
33739                                         //mt:32tou16
33740                                         PunchUses int32
33741                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
33742                                         chk(ErrTooLong)
33743                                 }
33744                                 {
33745                                         x := uint32(len(((*(*(struct {
33746                                                 //mt:if _ = %s; false
33747                                                 NonNil bool
33748
33749                                                 AttackCooldown float32
33750                                                 MaxDropLvl     int16
33751
33752                                                 //mt:len32
33753                                                 GroupCaps []ToolGroupCap
33754
33755                                                 //mt:len32
33756                                                 DmgGroups []Group
33757
33758                                                 //mt:32tou16
33759                                                 PunchUses int32
33760                                         }))(obj)).DmgGroups)))
33761                                         write32(w, uint32(x))
33762                                 }
33763                                 for local400 := range (*(*(struct {
33764                                         //mt:if _ = %s; false
33765                                         NonNil bool
33766
33767                                         AttackCooldown float32
33768                                         MaxDropLvl     int16
33769
33770                                         //mt:len32
33771                                         GroupCaps []ToolGroupCap
33772
33773                                         //mt:len32
33774                                         DmgGroups []Group
33775
33776                                         //mt:32tou16
33777                                         PunchUses int32
33778                                 }))(obj)).DmgGroups {
33779                                         if err := pcall(func() {
33780                                                 (((*(*(struct {
33781                                                         //mt:if _ = %s; false
33782                                                         NonNil bool
33783
33784                                                         AttackCooldown float32
33785                                                         MaxDropLvl     int16
33786
33787                                                         //mt:len32
33788                                                         GroupCaps []ToolGroupCap
33789
33790                                                         //mt:len32
33791                                                         DmgGroups []Group
33792
33793                                                         //mt:32tou16
33794                                                         PunchUses int32
33795                                                 }))(obj)).DmgGroups)[local400]).Serialize(w)
33796                                         }); err != nil {
33797                                                 if err == io.EOF {
33798                                                         chk(io.EOF)
33799                                                 }
33800                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
33801                                         }
33802                                 }
33803                                 {
33804                                         x := uint16((*(*(struct {
33805                                                 //mt:if _ = %s; false
33806                                                 NonNil bool
33807
33808                                                 AttackCooldown float32
33809                                                 MaxDropLvl     int16
33810
33811                                                 //mt:len32
33812                                                 GroupCaps []ToolGroupCap
33813
33814                                                 //mt:len32
33815                                                 DmgGroups []Group
33816
33817                                                 //mt:32tou16
33818                                                 PunchUses int32
33819                                         }))(obj)).PunchUses)
33820                                         write16(w, uint16(x))
33821                                 }
33822                         }
33823                 }
33824                 {
33825                         buf := w
33826                         w := ow
33827                         if len((buf.Bytes())) > math.MaxUint16 {
33828                                 chk(ErrTooLong)
33829                         }
33830                         {
33831                                 x := uint16(len((buf.Bytes())))
33832                                 write16(w, uint16(x))
33833                         }
33834                         {
33835                                 _, err := w.Write((buf.Bytes())[:])
33836                                 chk(err)
33837                         }
33838                 }
33839         }
33840 }
33841
33842 func (obj *ToolCaps) Deserialize(r io.Reader) {
33843         if _ = (*(*(struct {
33844                 //mt:if _ = %s; false
33845                 NonNil bool
33846
33847                 AttackCooldown float32
33848                 MaxDropLvl     int16
33849
33850                 //mt:len32
33851                 GroupCaps []ToolGroupCap
33852
33853                 //mt:len32
33854                 DmgGroups []Group
33855
33856                 //mt:32tou16
33857                 PunchUses int32
33858         }))(obj)); false {
33859                 {
33860                         p := &(*(*(struct {
33861                                 //mt:if _ = %s; false
33862                                 NonNil bool
33863
33864                                 AttackCooldown float32
33865                                 MaxDropLvl     int16
33866
33867                                 //mt:len32
33868                                 GroupCaps []ToolGroupCap
33869
33870                                 //mt:len32
33871                                 DmgGroups []Group
33872
33873                                 //mt:32tou16
33874                                 PunchUses int32
33875                         }))(obj)).NonNil
33876                         switch n := read8(r); n {
33877                         case 0:
33878                                 *p = false
33879                         case 1:
33880                                 *p = true
33881                         default:
33882                                 chk(fmt.Errorf("invalid bool: %d", n))
33883                         }
33884                 }
33885         }
33886         {
33887                 var n uint16
33888                 {
33889                         p := &n
33890                         *p = read16(r)
33891                 }
33892                 r := &io.LimitedReader{R: r, N: int64(n)}
33893                 if r.N > 0 {
33894                         (*(*(struct {
33895                                 //mt:if _ = %s; false
33896                                 NonNil bool
33897
33898                                 AttackCooldown float32
33899                                 MaxDropLvl     int16
33900
33901                                 //mt:len32
33902                                 GroupCaps []ToolGroupCap
33903
33904                                 //mt:len32
33905                                 DmgGroups []Group
33906
33907                                 //mt:32tou16
33908                                 PunchUses int32
33909                         }))(obj)).NonNil = true
33910                 } /**/
33911                 {
33912                         if (*(*(struct {
33913                                 //mt:if _ = %s; false
33914                                 NonNil bool
33915
33916                                 AttackCooldown float32
33917                                 MaxDropLvl     int16
33918
33919                                 //mt:len32
33920                                 GroupCaps []ToolGroupCap
33921
33922                                 //mt:len32
33923                                 DmgGroups []Group
33924
33925                                 //mt:32tou16
33926                                 PunchUses int32
33927                         }))(obj)).NonNil {
33928                                 {
33929                                         var local401 uint8
33930                                         local402 := uint8(5)
33931                                         {
33932                                                 p := &local401
33933                                                 *p = read8(r)
33934                                         }
33935                                         if local401 != local402 {
33936                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local401))
33937                                         }
33938                                 }
33939                                 {
33940                                         p := &(*(*(struct {
33941                                                 //mt:if _ = %s; false
33942                                                 NonNil bool
33943
33944                                                 AttackCooldown float32
33945                                                 MaxDropLvl     int16
33946
33947                                                 //mt:len32
33948                                                 GroupCaps []ToolGroupCap
33949
33950                                                 //mt:len32
33951                                                 DmgGroups []Group
33952
33953                                                 //mt:32tou16
33954                                                 PunchUses int32
33955                                         }))(obj)).AttackCooldown
33956                                         *p = math.Float32frombits(read32(r))
33957                                 }
33958                                 {
33959                                         p := &(*(*(struct {
33960                                                 //mt:if _ = %s; false
33961                                                 NonNil bool
33962
33963                                                 AttackCooldown float32
33964                                                 MaxDropLvl     int16
33965
33966                                                 //mt:len32
33967                                                 GroupCaps []ToolGroupCap
33968
33969                                                 //mt:len32
33970                                                 DmgGroups []Group
33971
33972                                                 //mt:32tou16
33973                                                 PunchUses int32
33974                                         }))(obj)).MaxDropLvl
33975                                         *p = int16(read16(r))
33976                                 }
33977                                 var local403 uint32
33978                                 {
33979                                         p := &local403
33980                                         *p = read32(r)
33981                                 }
33982                                 ((*(*(struct {
33983                                         //mt:if _ = %s; false
33984                                         NonNil bool
33985
33986                                         AttackCooldown float32
33987                                         MaxDropLvl     int16
33988
33989                                         //mt:len32
33990                                         GroupCaps []ToolGroupCap
33991
33992                                         //mt:len32
33993                                         DmgGroups []Group
33994
33995                                         //mt:32tou16
33996                                         PunchUses int32
33997                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local403)
33998                                 for local404 := range (*(*(struct {
33999                                         //mt:if _ = %s; false
34000                                         NonNil bool
34001
34002                                         AttackCooldown float32
34003                                         MaxDropLvl     int16
34004
34005                                         //mt:len32
34006                                         GroupCaps []ToolGroupCap
34007
34008                                         //mt:len32
34009                                         DmgGroups []Group
34010
34011                                         //mt:32tou16
34012                                         PunchUses int32
34013                                 }))(obj)).GroupCaps {
34014                                         if err := pcall(func() {
34015                                                 (((*(*(struct {
34016                                                         //mt:if _ = %s; false
34017                                                         NonNil bool
34018
34019                                                         AttackCooldown float32
34020                                                         MaxDropLvl     int16
34021
34022                                                         //mt:len32
34023                                                         GroupCaps []ToolGroupCap
34024
34025                                                         //mt:len32
34026                                                         DmgGroups []Group
34027
34028                                                         //mt:32tou16
34029                                                         PunchUses int32
34030                                                 }))(obj)).GroupCaps)[local404]).Deserialize(r)
34031                                         }); err != nil {
34032                                                 if err == io.EOF {
34033                                                         chk(io.EOF)
34034                                                 }
34035                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
34036                                         }
34037                                 }
34038                                 var local405 uint32
34039                                 {
34040                                         p := &local405
34041                                         *p = read32(r)
34042                                 }
34043                                 ((*(*(struct {
34044                                         //mt:if _ = %s; false
34045                                         NonNil bool
34046
34047                                         AttackCooldown float32
34048                                         MaxDropLvl     int16
34049
34050                                         //mt:len32
34051                                         GroupCaps []ToolGroupCap
34052
34053                                         //mt:len32
34054                                         DmgGroups []Group
34055
34056                                         //mt:32tou16
34057                                         PunchUses int32
34058                                 }))(obj)).DmgGroups) = make([]Group, local405)
34059                                 for local406 := range (*(*(struct {
34060                                         //mt:if _ = %s; false
34061                                         NonNil bool
34062
34063                                         AttackCooldown float32
34064                                         MaxDropLvl     int16
34065
34066                                         //mt:len32
34067                                         GroupCaps []ToolGroupCap
34068
34069                                         //mt:len32
34070                                         DmgGroups []Group
34071
34072                                         //mt:32tou16
34073                                         PunchUses int32
34074                                 }))(obj)).DmgGroups {
34075                                         if err := pcall(func() {
34076                                                 (((*(*(struct {
34077                                                         //mt:if _ = %s; false
34078                                                         NonNil bool
34079
34080                                                         AttackCooldown float32
34081                                                         MaxDropLvl     int16
34082
34083                                                         //mt:len32
34084                                                         GroupCaps []ToolGroupCap
34085
34086                                                         //mt:len32
34087                                                         DmgGroups []Group
34088
34089                                                         //mt:32tou16
34090                                                         PunchUses int32
34091                                                 }))(obj)).DmgGroups)[local406]).Deserialize(r)
34092                                         }); err != nil {
34093                                                 if err == io.EOF {
34094                                                         chk(io.EOF)
34095                                                 }
34096                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
34097                                         }
34098                                 }
34099                                 var local407 uint16
34100                                 {
34101                                         p := &local407
34102                                         *p = read16(r)
34103                                 }
34104                                 (*(*(struct {
34105                                         //mt:if _ = %s; false
34106                                         NonNil bool
34107
34108                                         AttackCooldown float32
34109                                         MaxDropLvl     int16
34110
34111                                         //mt:len32
34112                                         GroupCaps []ToolGroupCap
34113
34114                                         //mt:len32
34115                                         DmgGroups []Group
34116
34117                                         //mt:32tou16
34118                                         PunchUses int32
34119                                 }))(obj)).PunchUses = int32(local407)
34120                         }
34121                 }
34122                 if r.N > 0 {
34123                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34124                 }
34125         }
34126 }
34127
34128 func (obj *AnimType) Serialize(w io.Writer) {
34129         {
34130                 x := *(*(uint8))(obj)
34131                 write8(w, uint8(x))
34132         }
34133 }
34134
34135 func (obj *AnimType) Deserialize(r io.Reader) {
34136         {
34137                 p := &*(*(uint8))(obj)
34138                 *p = read8(r)
34139         }
34140 }
34141
34142 func (obj *HUDType) Serialize(w io.Writer) {
34143         {
34144                 x := *(*(uint8))(obj)
34145                 write8(w, uint8(x))
34146         }
34147 }
34148
34149 func (obj *HUDType) Deserialize(r io.Reader) {
34150         {
34151                 p := &*(*(uint8))(obj)
34152                 *p = read8(r)
34153         }
34154 }
34155
34156 func (obj *Box) Serialize(w io.Writer) {
34157         for local408 := range *(*([2]Vec))(obj) {
34158                 if err := pcall(func() {
34159                         ((*(*([2]Vec))(obj))[local408]).Serialize(w)
34160                 }); err != nil {
34161                         if err == io.EOF {
34162                                 chk(io.EOF)
34163                         }
34164                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34165                 }
34166         }
34167 }
34168
34169 func (obj *Box) Deserialize(r io.Reader) {
34170         for local409 := range *(*([2]Vec))(obj) {
34171                 if err := pcall(func() {
34172                         ((*(*([2]Vec))(obj))[local409]).Deserialize(r)
34173                 }); err != nil {
34174                         if err == io.EOF {
34175                                 chk(io.EOF)
34176                         }
34177                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34178                 }
34179         }
34180 }
34181
34182 func (obj *TileFlags) Serialize(w io.Writer) {
34183         {
34184                 x := *(*(uint16))(obj)
34185                 write16(w, uint16(x))
34186         }
34187 }
34188
34189 func (obj *TileFlags) Deserialize(r io.Reader) {
34190         {
34191                 p := &*(*(uint16))(obj)
34192                 *p = read16(r)
34193         }
34194 }
34195
34196 func (obj *AlignType) Serialize(w io.Writer) {
34197         {
34198                 x := *(*(uint8))(obj)
34199                 write8(w, uint8(x))
34200         }
34201 }
34202
34203 func (obj *AlignType) Deserialize(r io.Reader) {
34204         {
34205                 p := &*(*(uint8))(obj)
34206                 *p = read8(r)
34207         }
34208 }
34209
34210 func (obj *NodeBoxType) Serialize(w io.Writer) {
34211         {
34212                 x := *(*(uint8))(obj)
34213                 write8(w, uint8(x))
34214         }
34215 }
34216
34217 func (obj *NodeBoxType) Deserialize(r io.Reader) {
34218         {
34219                 p := &*(*(uint8))(obj)
34220                 *p = read8(r)
34221         }
34222 }
34223
34224 func (obj *DirBoxes) Serialize(w io.Writer) {
34225         if len(((*(*(struct {
34226                 Top, Bot                 []Box
34227                 Front, Left, Back, Right []Box
34228         }))(obj)).Top)) > math.MaxUint16 {
34229                 chk(ErrTooLong)
34230         }
34231         {
34232                 x := uint16(len(((*(*(struct {
34233                         Top, Bot                 []Box
34234                         Front, Left, Back, Right []Box
34235                 }))(obj)).Top)))
34236                 write16(w, uint16(x))
34237         }
34238         for local410 := range (*(*(struct {
34239                 Top, Bot                 []Box
34240                 Front, Left, Back, Right []Box
34241         }))(obj)).Top {
34242                 if err := pcall(func() {
34243                         (((*(*(struct {
34244                                 Top, Bot                 []Box
34245                                 Front, Left, Back, Right []Box
34246                         }))(obj)).Top)[local410]).Serialize(w)
34247                 }); err != nil {
34248                         if err == io.EOF {
34249                                 chk(io.EOF)
34250                         }
34251                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34252                 }
34253         }
34254         if len(((*(*(struct {
34255                 Top, Bot                 []Box
34256                 Front, Left, Back, Right []Box
34257         }))(obj)).Bot)) > math.MaxUint16 {
34258                 chk(ErrTooLong)
34259         }
34260         {
34261                 x := uint16(len(((*(*(struct {
34262                         Top, Bot                 []Box
34263                         Front, Left, Back, Right []Box
34264                 }))(obj)).Bot)))
34265                 write16(w, uint16(x))
34266         }
34267         for local411 := range (*(*(struct {
34268                 Top, Bot                 []Box
34269                 Front, Left, Back, Right []Box
34270         }))(obj)).Bot {
34271                 if err := pcall(func() {
34272                         (((*(*(struct {
34273                                 Top, Bot                 []Box
34274                                 Front, Left, Back, Right []Box
34275                         }))(obj)).Bot)[local411]).Serialize(w)
34276                 }); err != nil {
34277                         if err == io.EOF {
34278                                 chk(io.EOF)
34279                         }
34280                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34281                 }
34282         }
34283         if len(((*(*(struct {
34284                 Top, Bot                 []Box
34285                 Front, Left, Back, Right []Box
34286         }))(obj)).Front)) > math.MaxUint16 {
34287                 chk(ErrTooLong)
34288         }
34289         {
34290                 x := uint16(len(((*(*(struct {
34291                         Top, Bot                 []Box
34292                         Front, Left, Back, Right []Box
34293                 }))(obj)).Front)))
34294                 write16(w, uint16(x))
34295         }
34296         for local412 := range (*(*(struct {
34297                 Top, Bot                 []Box
34298                 Front, Left, Back, Right []Box
34299         }))(obj)).Front {
34300                 if err := pcall(func() {
34301                         (((*(*(struct {
34302                                 Top, Bot                 []Box
34303                                 Front, Left, Back, Right []Box
34304                         }))(obj)).Front)[local412]).Serialize(w)
34305                 }); err != nil {
34306                         if err == io.EOF {
34307                                 chk(io.EOF)
34308                         }
34309                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34310                 }
34311         }
34312         if len(((*(*(struct {
34313                 Top, Bot                 []Box
34314                 Front, Left, Back, Right []Box
34315         }))(obj)).Left)) > math.MaxUint16 {
34316                 chk(ErrTooLong)
34317         }
34318         {
34319                 x := uint16(len(((*(*(struct {
34320                         Top, Bot                 []Box
34321                         Front, Left, Back, Right []Box
34322                 }))(obj)).Left)))
34323                 write16(w, uint16(x))
34324         }
34325         for local413 := range (*(*(struct {
34326                 Top, Bot                 []Box
34327                 Front, Left, Back, Right []Box
34328         }))(obj)).Left {
34329                 if err := pcall(func() {
34330                         (((*(*(struct {
34331                                 Top, Bot                 []Box
34332                                 Front, Left, Back, Right []Box
34333                         }))(obj)).Left)[local413]).Serialize(w)
34334                 }); err != nil {
34335                         if err == io.EOF {
34336                                 chk(io.EOF)
34337                         }
34338                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34339                 }
34340         }
34341         if len(((*(*(struct {
34342                 Top, Bot                 []Box
34343                 Front, Left, Back, Right []Box
34344         }))(obj)).Back)) > math.MaxUint16 {
34345                 chk(ErrTooLong)
34346         }
34347         {
34348                 x := uint16(len(((*(*(struct {
34349                         Top, Bot                 []Box
34350                         Front, Left, Back, Right []Box
34351                 }))(obj)).Back)))
34352                 write16(w, uint16(x))
34353         }
34354         for local414 := range (*(*(struct {
34355                 Top, Bot                 []Box
34356                 Front, Left, Back, Right []Box
34357         }))(obj)).Back {
34358                 if err := pcall(func() {
34359                         (((*(*(struct {
34360                                 Top, Bot                 []Box
34361                                 Front, Left, Back, Right []Box
34362                         }))(obj)).Back)[local414]).Serialize(w)
34363                 }); err != nil {
34364                         if err == io.EOF {
34365                                 chk(io.EOF)
34366                         }
34367                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34368                 }
34369         }
34370         if len(((*(*(struct {
34371                 Top, Bot                 []Box
34372                 Front, Left, Back, Right []Box
34373         }))(obj)).Right)) > math.MaxUint16 {
34374                 chk(ErrTooLong)
34375         }
34376         {
34377                 x := uint16(len(((*(*(struct {
34378                         Top, Bot                 []Box
34379                         Front, Left, Back, Right []Box
34380                 }))(obj)).Right)))
34381                 write16(w, uint16(x))
34382         }
34383         for local415 := range (*(*(struct {
34384                 Top, Bot                 []Box
34385                 Front, Left, Back, Right []Box
34386         }))(obj)).Right {
34387                 if err := pcall(func() {
34388                         (((*(*(struct {
34389                                 Top, Bot                 []Box
34390                                 Front, Left, Back, Right []Box
34391                         }))(obj)).Right)[local415]).Serialize(w)
34392                 }); err != nil {
34393                         if err == io.EOF {
34394                                 chk(io.EOF)
34395                         }
34396                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34397                 }
34398         }
34399 }
34400
34401 func (obj *DirBoxes) Deserialize(r io.Reader) {
34402         var local416 uint16
34403         {
34404                 p := &local416
34405                 *p = read16(r)
34406         }
34407         ((*(*(struct {
34408                 Top, Bot                 []Box
34409                 Front, Left, Back, Right []Box
34410         }))(obj)).Top) = make([]Box, local416)
34411         for local417 := range (*(*(struct {
34412                 Top, Bot                 []Box
34413                 Front, Left, Back, Right []Box
34414         }))(obj)).Top {
34415                 if err := pcall(func() {
34416                         (((*(*(struct {
34417                                 Top, Bot                 []Box
34418                                 Front, Left, Back, Right []Box
34419                         }))(obj)).Top)[local417]).Deserialize(r)
34420                 }); err != nil {
34421                         if err == io.EOF {
34422                                 chk(io.EOF)
34423                         }
34424                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34425                 }
34426         }
34427         var local418 uint16
34428         {
34429                 p := &local418
34430                 *p = read16(r)
34431         }
34432         ((*(*(struct {
34433                 Top, Bot                 []Box
34434                 Front, Left, Back, Right []Box
34435         }))(obj)).Bot) = make([]Box, local418)
34436         for local419 := range (*(*(struct {
34437                 Top, Bot                 []Box
34438                 Front, Left, Back, Right []Box
34439         }))(obj)).Bot {
34440                 if err := pcall(func() {
34441                         (((*(*(struct {
34442                                 Top, Bot                 []Box
34443                                 Front, Left, Back, Right []Box
34444                         }))(obj)).Bot)[local419]).Deserialize(r)
34445                 }); err != nil {
34446                         if err == io.EOF {
34447                                 chk(io.EOF)
34448                         }
34449                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34450                 }
34451         }
34452         var local420 uint16
34453         {
34454                 p := &local420
34455                 *p = read16(r)
34456         }
34457         ((*(*(struct {
34458                 Top, Bot                 []Box
34459                 Front, Left, Back, Right []Box
34460         }))(obj)).Front) = make([]Box, local420)
34461         for local421 := range (*(*(struct {
34462                 Top, Bot                 []Box
34463                 Front, Left, Back, Right []Box
34464         }))(obj)).Front {
34465                 if err := pcall(func() {
34466                         (((*(*(struct {
34467                                 Top, Bot                 []Box
34468                                 Front, Left, Back, Right []Box
34469                         }))(obj)).Front)[local421]).Deserialize(r)
34470                 }); err != nil {
34471                         if err == io.EOF {
34472                                 chk(io.EOF)
34473                         }
34474                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34475                 }
34476         }
34477         var local422 uint16
34478         {
34479                 p := &local422
34480                 *p = read16(r)
34481         }
34482         ((*(*(struct {
34483                 Top, Bot                 []Box
34484                 Front, Left, Back, Right []Box
34485         }))(obj)).Left) = make([]Box, local422)
34486         for local423 := range (*(*(struct {
34487                 Top, Bot                 []Box
34488                 Front, Left, Back, Right []Box
34489         }))(obj)).Left {
34490                 if err := pcall(func() {
34491                         (((*(*(struct {
34492                                 Top, Bot                 []Box
34493                                 Front, Left, Back, Right []Box
34494                         }))(obj)).Left)[local423]).Deserialize(r)
34495                 }); err != nil {
34496                         if err == io.EOF {
34497                                 chk(io.EOF)
34498                         }
34499                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34500                 }
34501         }
34502         var local424 uint16
34503         {
34504                 p := &local424
34505                 *p = read16(r)
34506         }
34507         ((*(*(struct {
34508                 Top, Bot                 []Box
34509                 Front, Left, Back, Right []Box
34510         }))(obj)).Back) = make([]Box, local424)
34511         for local425 := range (*(*(struct {
34512                 Top, Bot                 []Box
34513                 Front, Left, Back, Right []Box
34514         }))(obj)).Back {
34515                 if err := pcall(func() {
34516                         (((*(*(struct {
34517                                 Top, Bot                 []Box
34518                                 Front, Left, Back, Right []Box
34519                         }))(obj)).Back)[local425]).Deserialize(r)
34520                 }); err != nil {
34521                         if err == io.EOF {
34522                                 chk(io.EOF)
34523                         }
34524                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34525                 }
34526         }
34527         var local426 uint16
34528         {
34529                 p := &local426
34530                 *p = read16(r)
34531         }
34532         ((*(*(struct {
34533                 Top, Bot                 []Box
34534                 Front, Left, Back, Right []Box
34535         }))(obj)).Right) = make([]Box, local426)
34536         for local427 := range (*(*(struct {
34537                 Top, Bot                 []Box
34538                 Front, Left, Back, Right []Box
34539         }))(obj)).Right {
34540                 if err := pcall(func() {
34541                         (((*(*(struct {
34542                                 Top, Bot                 []Box
34543                                 Front, Left, Back, Right []Box
34544                         }))(obj)).Right)[local427]).Deserialize(r)
34545                 }); err != nil {
34546                         if err == io.EOF {
34547                                 chk(io.EOF)
34548                         }
34549                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34550                 }
34551         }
34552 }
34553
34554 func (obj *ToolGroupCap) Serialize(w io.Writer) {
34555         if len(([]byte((*(*(struct {
34556                 Name string
34557
34558                 //mt:32to16
34559                 Uses int32
34560
34561                 MaxLvl int16
34562
34563                 //mt:len32
34564                 Times []DigTime
34565         }))(obj)).Name))) > math.MaxUint16 {
34566                 chk(ErrTooLong)
34567         }
34568         {
34569                 x := uint16(len(([]byte((*(*(struct {
34570                         Name string
34571
34572                         //mt:32to16
34573                         Uses int32
34574
34575                         MaxLvl int16
34576
34577                         //mt:len32
34578                         Times []DigTime
34579                 }))(obj)).Name))))
34580                 write16(w, uint16(x))
34581         }
34582         {
34583                 _, err := w.Write(([]byte((*(*(struct {
34584                         Name string
34585
34586                         //mt:32to16
34587                         Uses int32
34588
34589                         MaxLvl int16
34590
34591                         //mt:len32
34592                         Times []DigTime
34593                 }))(obj)).Name))[:])
34594                 chk(err)
34595         }
34596         {
34597                 x := int16((*(*(struct {
34598                         Name string
34599
34600                         //mt:32to16
34601                         Uses int32
34602
34603                         MaxLvl int16
34604
34605                         //mt:len32
34606                         Times []DigTime
34607                 }))(obj)).Uses)
34608                 write16(w, uint16(x))
34609         }
34610         {
34611                 x := (*(*(struct {
34612                         Name string
34613
34614                         //mt:32to16
34615                         Uses int32
34616
34617                         MaxLvl int16
34618
34619                         //mt:len32
34620                         Times []DigTime
34621                 }))(obj)).MaxLvl
34622                 write16(w, uint16(x))
34623         }
34624         if len(((*(*(struct {
34625                 Name string
34626
34627                 //mt:32to16
34628                 Uses int32
34629
34630                 MaxLvl int16
34631
34632                 //mt:len32
34633                 Times []DigTime
34634         }))(obj)).Times)) > math.MaxUint32 {
34635                 chk(ErrTooLong)
34636         }
34637         {
34638                 x := uint32(len(((*(*(struct {
34639                         Name string
34640
34641                         //mt:32to16
34642                         Uses int32
34643
34644                         MaxLvl int16
34645
34646                         //mt:len32
34647                         Times []DigTime
34648                 }))(obj)).Times)))
34649                 write32(w, uint32(x))
34650         }
34651         for local428 := range (*(*(struct {
34652                 Name string
34653
34654                 //mt:32to16
34655                 Uses int32
34656
34657                 MaxLvl int16
34658
34659                 //mt:len32
34660                 Times []DigTime
34661         }))(obj)).Times {
34662                 if err := pcall(func() {
34663                         (((*(*(struct {
34664                                 Name string
34665
34666                                 //mt:32to16
34667                                 Uses int32
34668
34669                                 MaxLvl int16
34670
34671                                 //mt:len32
34672                                 Times []DigTime
34673                         }))(obj)).Times)[local428]).Serialize(w)
34674                 }); err != nil {
34675                         if err == io.EOF {
34676                                 chk(io.EOF)
34677                         }
34678                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34679                 }
34680         }
34681 }
34682
34683 func (obj *ToolGroupCap) Deserialize(r io.Reader) {
34684         var local429 []uint8
34685         var local430 uint16
34686         {
34687                 p := &local430
34688                 *p = read16(r)
34689         }
34690         (local429) = make([]uint8, local430)
34691         {
34692                 _, err := io.ReadFull(r, (local429)[:])
34693                 chk(err)
34694         }
34695         ((*(*(struct {
34696                 Name string
34697
34698                 //mt:32to16
34699                 Uses int32
34700
34701                 MaxLvl int16
34702
34703                 //mt:len32
34704                 Times []DigTime
34705         }))(obj)).Name) = string(local429)
34706         var local431 int16
34707         {
34708                 p := &local431
34709                 *p = int16(read16(r))
34710         }
34711         (*(*(struct {
34712                 Name string
34713
34714                 //mt:32to16
34715                 Uses int32
34716
34717                 MaxLvl int16
34718
34719                 //mt:len32
34720                 Times []DigTime
34721         }))(obj)).Uses = int32(local431)
34722         {
34723                 p := &(*(*(struct {
34724                         Name string
34725
34726                         //mt:32to16
34727                         Uses int32
34728
34729                         MaxLvl int16
34730
34731                         //mt:len32
34732                         Times []DigTime
34733                 }))(obj)).MaxLvl
34734                 *p = int16(read16(r))
34735         }
34736         var local432 uint32
34737         {
34738                 p := &local432
34739                 *p = read32(r)
34740         }
34741         ((*(*(struct {
34742                 Name string
34743
34744                 //mt:32to16
34745                 Uses int32
34746
34747                 MaxLvl int16
34748
34749                 //mt:len32
34750                 Times []DigTime
34751         }))(obj)).Times) = make([]DigTime, local432)
34752         for local433 := range (*(*(struct {
34753                 Name string
34754
34755                 //mt:32to16
34756                 Uses int32
34757
34758                 MaxLvl int16
34759
34760                 //mt:len32
34761                 Times []DigTime
34762         }))(obj)).Times {
34763                 if err := pcall(func() {
34764                         (((*(*(struct {
34765                                 Name string
34766
34767                                 //mt:32to16
34768                                 Uses int32
34769
34770                                 MaxLvl int16
34771
34772                                 //mt:len32
34773                                 Times []DigTime
34774                         }))(obj)).Times)[local433]).Deserialize(r)
34775                 }); err != nil {
34776                         if err == io.EOF {
34777                                 chk(io.EOF)
34778                         }
34779                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34780                 }
34781         }
34782 }
34783
34784 func (obj *DigTime) Serialize(w io.Writer) {
34785         {
34786                 x := (*(*(struct {
34787                         Rating int16
34788                         Time   float32
34789                 }))(obj)).Rating
34790                 write16(w, uint16(x))
34791         }
34792         {
34793                 x := (*(*(struct {
34794                         Rating int16
34795                         Time   float32
34796                 }))(obj)).Time
34797                 write32(w, math.Float32bits(x))
34798         }
34799 }
34800
34801 func (obj *DigTime) Deserialize(r io.Reader) {
34802         {
34803                 p := &(*(*(struct {
34804                         Rating int16
34805                         Time   float32
34806                 }))(obj)).Rating
34807                 *p = int16(read16(r))
34808         }
34809         {
34810                 p := &(*(*(struct {
34811                         Rating int16
34812                         Time   float32
34813                 }))(obj)).Time
34814                 *p = math.Float32frombits(read32(r))
34815         }
34816 }