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
  23 func write16(w io.Writer, x uint16) {
  24         buf := make([]byte, 2)
  25         be.PutUint16(buf, x)
  26         _, err := w.Write(buf)
  27         chk(err)
  28 }
  29
  30 func write32(w io.Writer, x uint32) {
  31         buf := make([]byte, 4)
  32         be.PutUint32(buf, x)
  33         _, err := w.Write(buf)
  34         chk(err)
  35 }
  36
  37 func write64(w io.Writer, x uint64) {
  38         buf := make([]byte, 8)
  39         be.PutUint64(buf, x)
  40         _, err := w.Write(buf)
  41         chk(err)
  42 }
  43 func readBuf(r io.Reader, n int) []byte {
  44         buf := make([]byte, n)
  45         _, err := io.ReadFull(r, buf)
  46         chk(err)
  47         return buf
  48 }
  49
  50 func read8(r io.Reader) uint8   { return readBuf(r, 1)[0] }
  51 func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  52 func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  53 func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  54
  55 func (obj *ToSrvNil) serialize(w io.Writer) {
  56 }
  57
  58 func (obj *ToSrvNil) deserialize(r io.Reader) {
  59 }
  60
  61 func (obj *ToSrvInit) serialize(w io.Writer) {
  62         {
  63                 x := (*(*(struct {
  64                         SerializeVer             uint8
  65                         SupportedCompression     CompressionModes
  66                         MinProtoVer, MaxProtoVer uint16
  67                         PlayerName               string
  68
  69                         //mt:opt
  70                         SendFullItemMeta bool
  71                 }))(obj)).SerializeVer
  72                 write8(w, uint8(x))
  73         }
  74         if err := pcall(func() {
  75                 ((*(*(struct {
  76                         SerializeVer             uint8
  77                         SupportedCompression     CompressionModes
  78                         MinProtoVer, MaxProtoVer uint16
  79                         PlayerName               string
  80
  81                         //mt:opt
  82                         SendFullItemMeta bool
  83                 }))(obj)).SupportedCompression).serialize(w)
  84         }); err != nil {
  85                 if err == io.EOF {
  86                         chk(io.EOF)
  87                 }
  88                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
  89         }
  90         {
  91                 x := (*(*(struct {
  92                         SerializeVer             uint8
  93                         SupportedCompression     CompressionModes
  94                         MinProtoVer, MaxProtoVer uint16
  95                         PlayerName               string
  96
  97                         //mt:opt
  98                         SendFullItemMeta bool
  99                 }))(obj)).MinProtoVer
 100                 write16(w, uint16(x))
 101         }
 102         {
 103                 x := (*(*(struct {
 104                         SerializeVer             uint8
 105                         SupportedCompression     CompressionModes
 106                         MinProtoVer, MaxProtoVer uint16
 107                         PlayerName               string
 108
 109                         //mt:opt
 110                         SendFullItemMeta bool
 111                 }))(obj)).MaxProtoVer
 112                 write16(w, uint16(x))
 113         }
 114         if len(([]byte((*(*(struct {
 115                 SerializeVer             uint8
 116                 SupportedCompression     CompressionModes
 117                 MinProtoVer, MaxProtoVer uint16
 118                 PlayerName               string
 119
 120                 //mt:opt
 121                 SendFullItemMeta bool
 122         }))(obj)).PlayerName))) > math.MaxUint16 {
 123                 chk(ErrTooLong)
 124         }
 125         {
 126                 x := uint16(len(([]byte((*(*(struct {
 127                         SerializeVer             uint8
 128                         SupportedCompression     CompressionModes
 129                         MinProtoVer, MaxProtoVer uint16
 130                         PlayerName               string
 131
 132                         //mt:opt
 133                         SendFullItemMeta bool
 134                 }))(obj)).PlayerName))))
 135                 write16(w, uint16(x))
 136         }
 137         {
 138                 _, err := w.Write(([]byte((*(*(struct {
 139                         SerializeVer             uint8
 140                         SupportedCompression     CompressionModes
 141                         MinProtoVer, MaxProtoVer uint16
 142                         PlayerName               string
 143
 144                         //mt:opt
 145                         SendFullItemMeta bool
 146                 }))(obj)).PlayerName))[:])
 147                 chk(err)
 148         }
 149         if err := pcall(func() {
 150                 {
 151                         x := (*(*(struct {
 152                                 SerializeVer             uint8
 153                                 SupportedCompression     CompressionModes
 154                                 MinProtoVer, MaxProtoVer uint16
 155                                 PlayerName               string
 156
 157                                 //mt:opt
 158                                 SendFullItemMeta bool
 159                         }))(obj)).SendFullItemMeta
 160                         if x {
 161                                 write8(w, 1)
 162                         } else {
 163                                 write8(w, 0)
 164                         }
 165                 }
 166         }); err != nil && err != io.EOF {
 167                 chk(err)
 168         }
 169 }
 170
 171 func (obj *ToSrvInit) deserialize(r io.Reader) {
 172         {
 173                 p := &(*(*(struct {
 174                         SerializeVer             uint8
 175                         SupportedCompression     CompressionModes
 176                         MinProtoVer, MaxProtoVer uint16
 177                         PlayerName               string
 178
 179                         //mt:opt
 180                         SendFullItemMeta bool
 181                 }))(obj)).SerializeVer
 182                 *p = read8(r)
 183         }
 184         if err := pcall(func() {
 185                 ((*(*(struct {
 186                         SerializeVer             uint8
 187                         SupportedCompression     CompressionModes
 188                         MinProtoVer, MaxProtoVer uint16
 189                         PlayerName               string
 190
 191                         //mt:opt
 192                         SendFullItemMeta bool
 193                 }))(obj)).SupportedCompression).deserialize(r)
 194         }); err != nil {
 195                 if err == io.EOF {
 196                         chk(io.EOF)
 197                 }
 198                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
 199         }
 200         {
 201                 p := &(*(*(struct {
 202                         SerializeVer             uint8
 203                         SupportedCompression     CompressionModes
 204                         MinProtoVer, MaxProtoVer uint16
 205                         PlayerName               string
 206
 207                         //mt:opt
 208                         SendFullItemMeta bool
 209                 }))(obj)).MinProtoVer
 210                 *p = read16(r)
 211         }
 212         {
 213                 p := &(*(*(struct {
 214                         SerializeVer             uint8
 215                         SupportedCompression     CompressionModes
 216                         MinProtoVer, MaxProtoVer uint16
 217                         PlayerName               string
 218
 219                         //mt:opt
 220                         SendFullItemMeta bool
 221                 }))(obj)).MaxProtoVer
 222                 *p = read16(r)
 223         }
 224         var local1 []uint8
 225         var local2 uint16
 226         {
 227                 p := &local2
 228                 *p = read16(r)
 229         }
 230         (local1) = make([]uint8, local2)
 231         {
 232                 _, err := io.ReadFull(r, (local1)[:])
 233                 chk(err)
 234         }
 235         ((*(*(struct {
 236                 SerializeVer             uint8
 237                 SupportedCompression     CompressionModes
 238                 MinProtoVer, MaxProtoVer uint16
 239                 PlayerName               string
 240
 241                 //mt:opt
 242                 SendFullItemMeta bool
 243         }))(obj)).PlayerName) = string(local1)
 244         if err := pcall(func() {
 245                 {
 246                         p := &(*(*(struct {
 247                                 SerializeVer             uint8
 248                                 SupportedCompression     CompressionModes
 249                                 MinProtoVer, MaxProtoVer uint16
 250                                 PlayerName               string
 251
 252                                 //mt:opt
 253                                 SendFullItemMeta bool
 254                         }))(obj)).SendFullItemMeta
 255                         switch n := read8(r); n {
 256                         case 0:
 257                                 *p = false
 258                         case 1:
 259                                 *p = true
 260                         default:
 261                                 chk(fmt.Errorf("invalid bool: %d", n))
 262                         }
 263                 }
 264         }); err != nil && err != io.EOF {
 265                 chk(err)
 266         }
 267 }
 268
 269 func (obj *ToSrvInit2) serialize(w io.Writer) {
 270         if len(([]byte((*(*(struct {
 271                 Lang string
 272         }))(obj)).Lang))) > math.MaxUint16 {
 273                 chk(ErrTooLong)
 274         }
 275         {
 276                 x := uint16(len(([]byte((*(*(struct {
 277                         Lang string
 278                 }))(obj)).Lang))))
 279                 write16(w, uint16(x))
 280         }
 281         {
 282                 _, err := w.Write(([]byte((*(*(struct {
 283                         Lang string
 284                 }))(obj)).Lang))[:])
 285                 chk(err)
 286         }
 287 }
 288
 289 func (obj *ToSrvInit2) deserialize(r io.Reader) {
 290         var local3 []uint8
 291         var local4 uint16
 292         {
 293                 p := &local4
 294                 *p = read16(r)
 295         }
 296         (local3) = make([]uint8, local4)
 297         {
 298                 _, err := io.ReadFull(r, (local3)[:])
 299                 chk(err)
 300         }
 301         ((*(*(struct {
 302                 Lang string
 303         }))(obj)).Lang) = string(local3)
 304 }
 305
 306 func (obj *ToSrvJoinModChan) serialize(w io.Writer) {
 307         if len(([]byte((*(*(struct {
 308                 Channel string
 309         }))(obj)).Channel))) > math.MaxUint16 {
 310                 chk(ErrTooLong)
 311         }
 312         {
 313                 x := uint16(len(([]byte((*(*(struct {
 314                         Channel string
 315                 }))(obj)).Channel))))
 316                 write16(w, uint16(x))
 317         }
 318         {
 319                 _, err := w.Write(([]byte((*(*(struct {
 320                         Channel string
 321                 }))(obj)).Channel))[:])
 322                 chk(err)
 323         }
 324 }
 325
 326 func (obj *ToSrvJoinModChan) deserialize(r io.Reader) {
 327         var local5 []uint8
 328         var local6 uint16
 329         {
 330                 p := &local6
 331                 *p = read16(r)
 332         }
 333         (local5) = make([]uint8, local6)
 334         {
 335                 _, err := io.ReadFull(r, (local5)[:])
 336                 chk(err)
 337         }
 338         ((*(*(struct {
 339                 Channel string
 340         }))(obj)).Channel) = string(local5)
 341 }
 342
 343 func (obj *ToSrvLeaveModChan) serialize(w io.Writer) {
 344         if len(([]byte((*(*(struct {
 345                 Channel string
 346         }))(obj)).Channel))) > math.MaxUint16 {
 347                 chk(ErrTooLong)
 348         }
 349         {
 350                 x := uint16(len(([]byte((*(*(struct {
 351                         Channel string
 352                 }))(obj)).Channel))))
 353                 write16(w, uint16(x))
 354         }
 355         {
 356                 _, err := w.Write(([]byte((*(*(struct {
 357                         Channel string
 358                 }))(obj)).Channel))[:])
 359                 chk(err)
 360         }
 361 }
 362
 363 func (obj *ToSrvLeaveModChan) deserialize(r io.Reader) {
 364         var local7 []uint8
 365         var local8 uint16
 366         {
 367                 p := &local8
 368                 *p = read16(r)
 369         }
 370         (local7) = make([]uint8, local8)
 371         {
 372                 _, err := io.ReadFull(r, (local7)[:])
 373                 chk(err)
 374         }
 375         ((*(*(struct {
 376                 Channel string
 377         }))(obj)).Channel) = string(local7)
 378 }
 379
 380 func (obj *ToSrvMsgModChan) serialize(w io.Writer) {
 381         if len(([]byte((*(*(struct {
 382                 Channel string
 383                 Msg     string
 384         }))(obj)).Channel))) > math.MaxUint16 {
 385                 chk(ErrTooLong)
 386         }
 387         {
 388                 x := uint16(len(([]byte((*(*(struct {
 389                         Channel string
 390                         Msg     string
 391                 }))(obj)).Channel))))
 392                 write16(w, uint16(x))
 393         }
 394         {
 395                 _, err := w.Write(([]byte((*(*(struct {
 396                         Channel string
 397                         Msg     string
 398                 }))(obj)).Channel))[:])
 399                 chk(err)
 400         }
 401         if len(([]byte((*(*(struct {
 402                 Channel string
 403                 Msg     string
 404         }))(obj)).Msg))) > math.MaxUint16 {
 405                 chk(ErrTooLong)
 406         }
 407         {
 408                 x := uint16(len(([]byte((*(*(struct {
 409                         Channel string
 410                         Msg     string
 411                 }))(obj)).Msg))))
 412                 write16(w, uint16(x))
 413         }
 414         {
 415                 _, err := w.Write(([]byte((*(*(struct {
 416                         Channel string
 417                         Msg     string
 418                 }))(obj)).Msg))[:])
 419                 chk(err)
 420         }
 421 }
 422
 423 func (obj *ToSrvMsgModChan) deserialize(r io.Reader) {
 424         var local9 []uint8
 425         var local10 uint16
 426         {
 427                 p := &local10
 428                 *p = read16(r)
 429         }
 430         (local9) = make([]uint8, local10)
 431         {
 432                 _, err := io.ReadFull(r, (local9)[:])
 433                 chk(err)
 434         }
 435         ((*(*(struct {
 436                 Channel string
 437                 Msg     string
 438         }))(obj)).Channel) = string(local9)
 439         var local11 []uint8
 440         var local12 uint16
 441         {
 442                 p := &local12
 443                 *p = read16(r)
 444         }
 445         (local11) = make([]uint8, local12)
 446         {
 447                 _, err := io.ReadFull(r, (local11)[:])
 448                 chk(err)
 449         }
 450         ((*(*(struct {
 451                 Channel string
 452                 Msg     string
 453         }))(obj)).Msg) = string(local11)
 454 }
 455
 456 func (obj *ToSrvPlayerPos) serialize(w io.Writer) {
 457         if err := pcall(func() {
 458                 ((*(*(struct {
 459                         Pos PlayerPos
 460                 }))(obj)).Pos).serialize(w)
 461         }); err != nil {
 462                 if err == io.EOF {
 463                         chk(io.EOF)
 464                 }
 465                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 466         }
 467 }
 468
 469 func (obj *ToSrvPlayerPos) deserialize(r io.Reader) {
 470         if err := pcall(func() {
 471                 ((*(*(struct {
 472                         Pos PlayerPos
 473                 }))(obj)).Pos).deserialize(r)
 474         }); err != nil {
 475                 if err == io.EOF {
 476                         chk(io.EOF)
 477                 }
 478                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 479         }
 480 }
 481
 482 func (obj *ToSrvGotBlks) serialize(w io.Writer) {
 483         if len(((*(*(struct {
 484                 //mt:len8
 485                 Blks [][3]int16
 486         }))(obj)).Blks)) > math.MaxUint8 {
 487                 chk(ErrTooLong)
 488         }
 489         {
 490                 x := uint8(len(((*(*(struct {
 491                         //mt:len8
 492                         Blks [][3]int16
 493                 }))(obj)).Blks)))
 494                 write8(w, uint8(x))
 495         }
 496         for local13 := range (*(*(struct {
 497                 //mt:len8
 498                 Blks [][3]int16
 499         }))(obj)).Blks {
 500                 for local14 := range ((*(*(struct {
 501                         //mt:len8
 502                         Blks [][3]int16
 503                 }))(obj)).Blks)[local13] {
 504                         {
 505                                 x := (((*(*(struct {
 506                                         //mt:len8
 507                                         Blks [][3]int16
 508                                 }))(obj)).Blks)[local13])[local14]
 509                                 write16(w, uint16(x))
 510                         }
 511                 }
 512         }
 513 }
 514
 515 func (obj *ToSrvGotBlks) deserialize(r io.Reader) {
 516         var local15 uint8
 517         {
 518                 p := &local15
 519                 *p = read8(r)
 520         }
 521         ((*(*(struct {
 522                 //mt:len8
 523                 Blks [][3]int16
 524         }))(obj)).Blks) = make([][3]int16, local15)
 525         for local16 := range (*(*(struct {
 526                 //mt:len8
 527                 Blks [][3]int16
 528         }))(obj)).Blks {
 529                 for local17 := range ((*(*(struct {
 530                         //mt:len8
 531                         Blks [][3]int16
 532                 }))(obj)).Blks)[local16] {
 533                         {
 534                                 p := &(((*(*(struct {
 535                                         //mt:len8
 536                                         Blks [][3]int16
 537                                 }))(obj)).Blks)[local16])[local17]
 538                                 *p = int16(read16(r))
 539                         }
 540                 }
 541         }
 542 }
 543
 544 func (obj *ToSrvDeletedBlks) serialize(w io.Writer) {
 545         if len(((*(*(struct {
 546                 //mt:len8
 547                 Blks [][3]int16
 548         }))(obj)).Blks)) > math.MaxUint8 {
 549                 chk(ErrTooLong)
 550         }
 551         {
 552                 x := uint8(len(((*(*(struct {
 553                         //mt:len8
 554                         Blks [][3]int16
 555                 }))(obj)).Blks)))
 556                 write8(w, uint8(x))
 557         }
 558         for local18 := range (*(*(struct {
 559                 //mt:len8
 560                 Blks [][3]int16
 561         }))(obj)).Blks {
 562                 for local19 := range ((*(*(struct {
 563                         //mt:len8
 564                         Blks [][3]int16
 565                 }))(obj)).Blks)[local18] {
 566                         {
 567                                 x := (((*(*(struct {
 568                                         //mt:len8
 569                                         Blks [][3]int16
 570                                 }))(obj)).Blks)[local18])[local19]
 571                                 write16(w, uint16(x))
 572                         }
 573                 }
 574         }
 575 }
 576
 577 func (obj *ToSrvDeletedBlks) deserialize(r io.Reader) {
 578         var local20 uint8
 579         {
 580                 p := &local20
 581                 *p = read8(r)
 582         }
 583         ((*(*(struct {
 584                 //mt:len8
 585                 Blks [][3]int16
 586         }))(obj)).Blks) = make([][3]int16, local20)
 587         for local21 := range (*(*(struct {
 588                 //mt:len8
 589                 Blks [][3]int16
 590         }))(obj)).Blks {
 591                 for local22 := range ((*(*(struct {
 592                         //mt:len8
 593                         Blks [][3]int16
 594                 }))(obj)).Blks)[local21] {
 595                         {
 596                                 p := &(((*(*(struct {
 597                                         //mt:len8
 598                                         Blks [][3]int16
 599                                 }))(obj)).Blks)[local21])[local22]
 600                                 *p = int16(read16(r))
 601                         }
 602                 }
 603         }
 604 }
 605
 606 func (obj *ToSrvInvAction) serialize(w io.Writer) {
 607         {
 608                 _, err := w.Write(([]byte((*(*(struct {
 609                         //mt:raw
 610                         Action string
 611                 }))(obj)).Action))[:])
 612                 chk(err)
 613         }
 614 }
 615
 616 func (obj *ToSrvInvAction) deserialize(r io.Reader) {
 617         var local23 []uint8
 618         for {
 619                 var local24 uint8
 620                 err := pcall(func() {
 621                         {
 622                                 p := &local24
 623                                 *p = read8(r)
 624                         }
 625                 })
 626                 if err == io.EOF {
 627                         break
 628                 }
 629                 (local23) = append((local23), local24)
 630                 chk(err)
 631         }
 632         ((*(*(struct {
 633                 //mt:raw
 634                 Action string
 635         }))(obj)).Action) = string(local23)
 636 }
 637
 638 func (obj *ToSrvChatMsg) serialize(w io.Writer) {
 639         if len((utf16.Encode([]rune((*(*(struct {
 640                 //mt:utf16
 641                 Msg string
 642         }))(obj)).Msg)))) > math.MaxUint16 {
 643                 chk(ErrTooLong)
 644         }
 645         {
 646                 x := uint16(len((utf16.Encode([]rune((*(*(struct {
 647                         //mt:utf16
 648                         Msg string
 649                 }))(obj)).Msg)))))
 650                 write16(w, uint16(x))
 651         }
 652         for local25 := range utf16.Encode([]rune((*(*(struct {
 653                 //mt:utf16
 654                 Msg string
 655         }))(obj)).Msg)) {
 656                 {
 657                         x := (utf16.Encode([]rune((*(*(struct {
 658                                 //mt:utf16
 659                                 Msg string
 660                         }))(obj)).Msg)))[local25]
 661                         write16(w, uint16(x))
 662                 }
 663         }
 664 }
 665
 666 func (obj *ToSrvChatMsg) deserialize(r io.Reader) {
 667         var local26 []uint16
 668         var local27 uint16
 669         {
 670                 p := &local27
 671                 *p = read16(r)
 672         }
 673         (local26) = make([]uint16, local27)
 674         for local28 := range local26 {
 675                 {
 676                         p := &(local26)[local28]
 677                         *p = read16(r)
 678                 }
 679         }
 680         (*(*(struct {
 681                 //mt:utf16
 682                 Msg string
 683         }))(obj)).Msg = string(utf16.Decode(local26))
 684 }
 685
 686 func (obj *ToSrvFallDmg) serialize(w io.Writer) {
 687         {
 688                 x := (*(*(struct {
 689                         Amount uint16
 690                 }))(obj)).Amount
 691                 write16(w, uint16(x))
 692         }
 693 }
 694
 695 func (obj *ToSrvFallDmg) deserialize(r io.Reader) {
 696         {
 697                 p := &(*(*(struct {
 698                         Amount uint16
 699                 }))(obj)).Amount
 700                 *p = read16(r)
 701         }
 702 }
 703
 704 func (obj *ToSrvSelectItem) serialize(w io.Writer) {
 705         {
 706                 x := (*(*(struct {
 707                         Slot uint16
 708                 }))(obj)).Slot
 709                 write16(w, uint16(x))
 710         }
 711 }
 712
 713 func (obj *ToSrvSelectItem) deserialize(r io.Reader) {
 714         {
 715                 p := &(*(*(struct {
 716                         Slot uint16
 717                 }))(obj)).Slot
 718                 *p = read16(r)
 719         }
 720 }
 721
 722 func (obj *ToSrvRespawn) serialize(w io.Writer) {
 723 }
 724
 725 func (obj *ToSrvRespawn) deserialize(r io.Reader) {
 726 }
 727
 728 func (obj *ToSrvInteract) serialize(w io.Writer) {
 729         if err := pcall(func() {
 730                 ((*(*(struct {
 731                         Action   Interaction
 732                         ItemSlot uint16
 733                         //mt:lenhdr 32
 734                         Pointed PointedThing
 735                         //mt:end
 736                         Pos PlayerPos
 737                 }))(obj)).Action).serialize(w)
 738         }); err != nil {
 739                 if err == io.EOF {
 740                         chk(io.EOF)
 741                 }
 742                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Interaction", err))
 743         }
 744         {
 745                 x := (*(*(struct {
 746                         Action   Interaction
 747                         ItemSlot uint16
 748                         //mt:lenhdr 32
 749                         Pointed PointedThing
 750                         //mt:end
 751                         Pos PlayerPos
 752                 }))(obj)).ItemSlot
 753                 write16(w, uint16(x))
 754         }
 755         {
 756                 ow := w
 757                 w := new(bytes.Buffer)
 758                 {
 759                         x := (*(*(struct {
 760                                 Action   Interaction
 761                                 ItemSlot uint16
 762                                 //mt:lenhdr 32
 763                                 Pointed PointedThing
 764                                 //mt:end
 765                                 Pos PlayerPos
 766                         }))(obj)).Pointed
 767                         chk(writePointedThing(w, x))
 768                 }
 769                 {
 770                         buf := w
 771                         w := ow
 772                         if len((buf.Bytes())) > math.MaxUint32 {
 773                                 chk(ErrTooLong)
 774                         }
 775                         {
 776                                 x := uint32(len((buf.Bytes())))
 777                                 write32(w, uint32(x))
 778                         }
 779                         {
 780                                 _, err := w.Write((buf.Bytes())[:])
 781                                 chk(err)
 782                         }
 783                 }
 784         }
 785         if err := pcall(func() {
 786                 ((*(*(struct {
 787                         Action   Interaction
 788                         ItemSlot uint16
 789                         //mt:lenhdr 32
 790                         Pointed PointedThing
 791                         //mt:end
 792                         Pos PlayerPos
 793                 }))(obj)).Pos).serialize(w)
 794         }); err != nil {
 795                 if err == io.EOF {
 796                         chk(io.EOF)
 797                 }
 798                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 799         }
 800 }
 801
 802 func (obj *ToSrvInteract) deserialize(r io.Reader) {
 803         if err := pcall(func() {
 804                 ((*(*(struct {
 805                         Action   Interaction
 806                         ItemSlot uint16
 807                         //mt:lenhdr 32
 808                         Pointed PointedThing
 809                         //mt:end
 810                         Pos PlayerPos
 811                 }))(obj)).Action).deserialize(r)
 812         }); err != nil {
 813                 if err == io.EOF {
 814                         chk(io.EOF)
 815                 }
 816                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Interaction", err))
 817         }
 818         {
 819                 p := &(*(*(struct {
 820                         Action   Interaction
 821                         ItemSlot uint16
 822                         //mt:lenhdr 32
 823                         Pointed PointedThing
 824                         //mt:end
 825                         Pos PlayerPos
 826                 }))(obj)).ItemSlot
 827                 *p = read16(r)
 828         }
 829         {
 830                 var n uint32
 831                 {
 832                         p := &n
 833                         *p = read32(r)
 834                 }
 835                 r := &io.LimitedReader{r, int64(n)}
 836                 {
 837                         p := &(*(*(struct {
 838                                 Action   Interaction
 839                                 ItemSlot uint16
 840                                 //mt:lenhdr 32
 841                                 Pointed PointedThing
 842                                 //mt:end
 843                                 Pos PlayerPos
 844                         }))(obj)).Pointed
 845                         {
 846                                 var err error
 847                                 *p, err = readPointedThing(r)
 848                                 chk(err)
 849                         }
 850                 }
 851                 if r.N > 0 {
 852                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 853                 }
 854         }
 855         if err := pcall(func() {
 856                 ((*(*(struct {
 857                         Action   Interaction
 858                         ItemSlot uint16
 859                         //mt:lenhdr 32
 860                         Pointed PointedThing
 861                         //mt:end
 862                         Pos PlayerPos
 863                 }))(obj)).Pos).deserialize(r)
 864         }); err != nil {
 865                 if err == io.EOF {
 866                         chk(io.EOF)
 867                 }
 868                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 869         }
 870 }
 871
 872 func (obj *ToSrvRemovedSounds) serialize(w io.Writer) {
 873         if len(((*(*(struct {
 874                 IDs []SoundID
 875         }))(obj)).IDs)) > math.MaxUint16 {
 876                 chk(ErrTooLong)
 877         }
 878         {
 879                 x := uint16(len(((*(*(struct {
 880                         IDs []SoundID
 881                 }))(obj)).IDs)))
 882                 write16(w, uint16(x))
 883         }
 884         for local29 := range (*(*(struct {
 885                 IDs []SoundID
 886         }))(obj)).IDs {
 887                 if err := pcall(func() {
 888                         (((*(*(struct {
 889                                 IDs []SoundID
 890                         }))(obj)).IDs)[local29]).serialize(w)
 891                 }); err != nil {
 892                         if err == io.EOF {
 893                                 chk(io.EOF)
 894                         }
 895                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
 896                 }
 897         }
 898 }
 899
 900 func (obj *ToSrvRemovedSounds) deserialize(r io.Reader) {
 901         var local30 uint16
 902         {
 903                 p := &local30
 904                 *p = read16(r)
 905         }
 906         ((*(*(struct {
 907                 IDs []SoundID
 908         }))(obj)).IDs) = make([]SoundID, local30)
 909         for local31 := range (*(*(struct {
 910                 IDs []SoundID
 911         }))(obj)).IDs {
 912                 if err := pcall(func() {
 913                         (((*(*(struct {
 914                                 IDs []SoundID
 915                         }))(obj)).IDs)[local31]).deserialize(r)
 916                 }); err != nil {
 917                         if err == io.EOF {
 918                                 chk(io.EOF)
 919                         }
 920                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
 921                 }
 922         }
 923 }
 924
 925 func (obj *ToSrvNodeMetaFields) serialize(w io.Writer) {
 926         for local32 := range (*(*(struct {
 927                 Pos      [3]int16
 928                 Formname string
 929                 Fields   []Field
 930         }))(obj)).Pos {
 931                 {
 932                         x := ((*(*(struct {
 933                                 Pos      [3]int16
 934                                 Formname string
 935                                 Fields   []Field
 936                         }))(obj)).Pos)[local32]
 937                         write16(w, uint16(x))
 938                 }
 939         }
 940         if len(([]byte((*(*(struct {
 941                 Pos      [3]int16
 942                 Formname string
 943                 Fields   []Field
 944         }))(obj)).Formname))) > math.MaxUint16 {
 945                 chk(ErrTooLong)
 946         }
 947         {
 948                 x := uint16(len(([]byte((*(*(struct {
 949                         Pos      [3]int16
 950                         Formname string
 951                         Fields   []Field
 952                 }))(obj)).Formname))))
 953                 write16(w, uint16(x))
 954         }
 955         {
 956                 _, err := w.Write(([]byte((*(*(struct {
 957                         Pos      [3]int16
 958                         Formname string
 959                         Fields   []Field
 960                 }))(obj)).Formname))[:])
 961                 chk(err)
 962         }
 963         if len(((*(*(struct {
 964                 Pos      [3]int16
 965                 Formname string
 966                 Fields   []Field
 967         }))(obj)).Fields)) > math.MaxUint16 {
 968                 chk(ErrTooLong)
 969         }
 970         {
 971                 x := uint16(len(((*(*(struct {
 972                         Pos      [3]int16
 973                         Formname string
 974                         Fields   []Field
 975                 }))(obj)).Fields)))
 976                 write16(w, uint16(x))
 977         }
 978         for local33 := range (*(*(struct {
 979                 Pos      [3]int16
 980                 Formname string
 981                 Fields   []Field
 982         }))(obj)).Fields {
 983                 if err := pcall(func() {
 984                         (((*(*(struct {
 985                                 Pos      [3]int16
 986                                 Formname string
 987                                 Fields   []Field
 988                         }))(obj)).Fields)[local33]).serialize(w)
 989                 }); err != nil {
 990                         if err == io.EOF {
 991                                 chk(io.EOF)
 992                         }
 993                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
 994                 }
 995         }
 996 }
 997
 998 func (obj *ToSrvNodeMetaFields) deserialize(r io.Reader) {
 999         for local34 := range (*(*(struct {
1000                 Pos      [3]int16
1001                 Formname string
1002                 Fields   []Field
1003         }))(obj)).Pos {
1004                 {
1005                         p := &((*(*(struct {
1006                                 Pos      [3]int16
1007                                 Formname string
1008                                 Fields   []Field
1009                         }))(obj)).Pos)[local34]
1010                         *p = int16(read16(r))
1011                 }
1012         }
1013         var local35 []uint8
1014         var local36 uint16
1015         {
1016                 p := &local36
1017                 *p = read16(r)
1018         }
1019         (local35) = make([]uint8, local36)
1020         {
1021                 _, err := io.ReadFull(r, (local35)[:])
1022                 chk(err)
1023         }
1024         ((*(*(struct {
1025                 Pos      [3]int16
1026                 Formname string
1027                 Fields   []Field
1028         }))(obj)).Formname) = string(local35)
1029         var local37 uint16
1030         {
1031                 p := &local37
1032                 *p = read16(r)
1033         }
1034         ((*(*(struct {
1035                 Pos      [3]int16
1036                 Formname string
1037                 Fields   []Field
1038         }))(obj)).Fields) = make([]Field, local37)
1039         for local38 := range (*(*(struct {
1040                 Pos      [3]int16
1041                 Formname string
1042                 Fields   []Field
1043         }))(obj)).Fields {
1044                 if err := pcall(func() {
1045                         (((*(*(struct {
1046                                 Pos      [3]int16
1047                                 Formname string
1048                                 Fields   []Field
1049                         }))(obj)).Fields)[local38]).deserialize(r)
1050                 }); err != nil {
1051                         if err == io.EOF {
1052                                 chk(io.EOF)
1053                         }
1054                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1055                 }
1056         }
1057 }
1058
1059 func (obj *ToSrvInvFields) serialize(w io.Writer) {
1060         if len(([]byte((*(*(struct {
1061                 Formname string
1062                 Fields   []Field
1063         }))(obj)).Formname))) > math.MaxUint16 {
1064                 chk(ErrTooLong)
1065         }
1066         {
1067                 x := uint16(len(([]byte((*(*(struct {
1068                         Formname string
1069                         Fields   []Field
1070                 }))(obj)).Formname))))
1071                 write16(w, uint16(x))
1072         }
1073         {
1074                 _, err := w.Write(([]byte((*(*(struct {
1075                         Formname string
1076                         Fields   []Field
1077                 }))(obj)).Formname))[:])
1078                 chk(err)
1079         }
1080         if len(((*(*(struct {
1081                 Formname string
1082                 Fields   []Field
1083         }))(obj)).Fields)) > math.MaxUint16 {
1084                 chk(ErrTooLong)
1085         }
1086         {
1087                 x := uint16(len(((*(*(struct {
1088                         Formname string
1089                         Fields   []Field
1090                 }))(obj)).Fields)))
1091                 write16(w, uint16(x))
1092         }
1093         for local39 := range (*(*(struct {
1094                 Formname string
1095                 Fields   []Field
1096         }))(obj)).Fields {
1097                 if err := pcall(func() {
1098                         (((*(*(struct {
1099                                 Formname string
1100                                 Fields   []Field
1101                         }))(obj)).Fields)[local39]).serialize(w)
1102                 }); err != nil {
1103                         if err == io.EOF {
1104                                 chk(io.EOF)
1105                         }
1106                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1107                 }
1108         }
1109 }
1110
1111 func (obj *ToSrvInvFields) deserialize(r io.Reader) {
1112         var local40 []uint8
1113         var local41 uint16
1114         {
1115                 p := &local41
1116                 *p = read16(r)
1117         }
1118         (local40) = make([]uint8, local41)
1119         {
1120                 _, err := io.ReadFull(r, (local40)[:])
1121                 chk(err)
1122         }
1123         ((*(*(struct {
1124                 Formname string
1125                 Fields   []Field
1126         }))(obj)).Formname) = string(local40)
1127         var local42 uint16
1128         {
1129                 p := &local42
1130                 *p = read16(r)
1131         }
1132         ((*(*(struct {
1133                 Formname string
1134                 Fields   []Field
1135         }))(obj)).Fields) = make([]Field, local42)
1136         for local43 := range (*(*(struct {
1137                 Formname string
1138                 Fields   []Field
1139         }))(obj)).Fields {
1140                 if err := pcall(func() {
1141                         (((*(*(struct {
1142                                 Formname string
1143                                 Fields   []Field
1144                         }))(obj)).Fields)[local43]).deserialize(r)
1145                 }); err != nil {
1146                         if err == io.EOF {
1147                                 chk(io.EOF)
1148                         }
1149                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1150                 }
1151         }
1152 }
1153
1154 func (obj *ToSrvReqMedia) serialize(w io.Writer) {
1155         if len(((*(*(struct {
1156                 Filenames []string
1157         }))(obj)).Filenames)) > math.MaxUint16 {
1158                 chk(ErrTooLong)
1159         }
1160         {
1161                 x := uint16(len(((*(*(struct {
1162                         Filenames []string
1163                 }))(obj)).Filenames)))
1164                 write16(w, uint16(x))
1165         }
1166         for local44 := range (*(*(struct {
1167                 Filenames []string
1168         }))(obj)).Filenames {
1169                 if len(([]byte(((*(*(struct {
1170                         Filenames []string
1171                 }))(obj)).Filenames)[local44]))) > math.MaxUint16 {
1172                         chk(ErrTooLong)
1173                 }
1174                 {
1175                         x := uint16(len(([]byte(((*(*(struct {
1176                                 Filenames []string
1177                         }))(obj)).Filenames)[local44]))))
1178                         write16(w, uint16(x))
1179                 }
1180                 {
1181                         _, err := w.Write(([]byte(((*(*(struct {
1182                                 Filenames []string
1183                         }))(obj)).Filenames)[local44]))[:])
1184                         chk(err)
1185                 }
1186         }
1187 }
1188
1189 func (obj *ToSrvReqMedia) deserialize(r io.Reader) {
1190         var local45 uint16
1191         {
1192                 p := &local45
1193                 *p = read16(r)
1194         }
1195         ((*(*(struct {
1196                 Filenames []string
1197         }))(obj)).Filenames) = make([]string, local45)
1198         for local46 := range (*(*(struct {
1199                 Filenames []string
1200         }))(obj)).Filenames {
1201                 var local47 []uint8
1202                 var local48 uint16
1203                 {
1204                         p := &local48
1205                         *p = read16(r)
1206                 }
1207                 (local47) = make([]uint8, local48)
1208                 {
1209                         _, err := io.ReadFull(r, (local47)[:])
1210                         chk(err)
1211                 }
1212                 (((*(*(struct {
1213                         Filenames []string
1214                 }))(obj)).Filenames)[local46]) = string(local47)
1215         }
1216 }
1217
1218 func (obj *ToSrvCltReady) serialize(w io.Writer) {
1219         {
1220                 x := (*(*(struct {
1221                         // Version information.
1222                         Major, Minor, Patch uint8
1223                         Reserved            uint8
1224                         Version             string
1225                         Formspec            uint16
1226                 }))(obj)).Major
1227                 write8(w, uint8(x))
1228         }
1229         {
1230                 x := (*(*(struct {
1231                         // Version information.
1232                         Major, Minor, Patch uint8
1233                         Reserved            uint8
1234                         Version             string
1235                         Formspec            uint16
1236                 }))(obj)).Minor
1237                 write8(w, uint8(x))
1238         }
1239         {
1240                 x := (*(*(struct {
1241                         // Version information.
1242                         Major, Minor, Patch uint8
1243                         Reserved            uint8
1244                         Version             string
1245                         Formspec            uint16
1246                 }))(obj)).Patch
1247                 write8(w, uint8(x))
1248         }
1249         {
1250                 x := (*(*(struct {
1251                         // Version information.
1252                         Major, Minor, Patch uint8
1253                         Reserved            uint8
1254                         Version             string
1255                         Formspec            uint16
1256                 }))(obj)).Reserved
1257                 write8(w, uint8(x))
1258         }
1259         if len(([]byte((*(*(struct {
1260                 // Version information.
1261                 Major, Minor, Patch uint8
1262                 Reserved            uint8
1263                 Version             string
1264                 Formspec            uint16
1265         }))(obj)).Version))) > math.MaxUint16 {
1266                 chk(ErrTooLong)
1267         }
1268         {
1269                 x := uint16(len(([]byte((*(*(struct {
1270                         // Version information.
1271                         Major, Minor, Patch uint8
1272                         Reserved            uint8
1273                         Version             string
1274                         Formspec            uint16
1275                 }))(obj)).Version))))
1276                 write16(w, uint16(x))
1277         }
1278         {
1279                 _, err := w.Write(([]byte((*(*(struct {
1280                         // Version information.
1281                         Major, Minor, Patch uint8
1282                         Reserved            uint8
1283                         Version             string
1284                         Formspec            uint16
1285                 }))(obj)).Version))[:])
1286                 chk(err)
1287         }
1288         {
1289                 x := (*(*(struct {
1290                         // Version information.
1291                         Major, Minor, Patch uint8
1292                         Reserved            uint8
1293                         Version             string
1294                         Formspec            uint16
1295                 }))(obj)).Formspec
1296                 write16(w, uint16(x))
1297         }
1298 }
1299
1300 func (obj *ToSrvCltReady) deserialize(r io.Reader) {
1301         {
1302                 p := &(*(*(struct {
1303                         // Version information.
1304                         Major, Minor, Patch uint8
1305                         Reserved            uint8
1306                         Version             string
1307                         Formspec            uint16
1308                 }))(obj)).Major
1309                 *p = read8(r)
1310         }
1311         {
1312                 p := &(*(*(struct {
1313                         // Version information.
1314                         Major, Minor, Patch uint8
1315                         Reserved            uint8
1316                         Version             string
1317                         Formspec            uint16
1318                 }))(obj)).Minor
1319                 *p = read8(r)
1320         }
1321         {
1322                 p := &(*(*(struct {
1323                         // Version information.
1324                         Major, Minor, Patch uint8
1325                         Reserved            uint8
1326                         Version             string
1327                         Formspec            uint16
1328                 }))(obj)).Patch
1329                 *p = read8(r)
1330         }
1331         {
1332                 p := &(*(*(struct {
1333                         // Version information.
1334                         Major, Minor, Patch uint8
1335                         Reserved            uint8
1336                         Version             string
1337                         Formspec            uint16
1338                 }))(obj)).Reserved
1339                 *p = read8(r)
1340         }
1341         var local49 []uint8
1342         var local50 uint16
1343         {
1344                 p := &local50
1345                 *p = read16(r)
1346         }
1347         (local49) = make([]uint8, local50)
1348         {
1349                 _, err := io.ReadFull(r, (local49)[:])
1350                 chk(err)
1351         }
1352         ((*(*(struct {
1353                 // Version information.
1354                 Major, Minor, Patch uint8
1355                 Reserved            uint8
1356                 Version             string
1357                 Formspec            uint16
1358         }))(obj)).Version) = string(local49)
1359         {
1360                 p := &(*(*(struct {
1361                         // Version information.
1362                         Major, Minor, Patch uint8
1363                         Reserved            uint8
1364                         Version             string
1365                         Formspec            uint16
1366                 }))(obj)).Formspec
1367                 *p = read16(r)
1368         }
1369 }
1370
1371 func (obj *ToSrvFirstSRP) serialize(w io.Writer) {
1372         if len(((*(*(struct {
1373                 Salt        []byte
1374                 Verifier    []byte
1375                 EmptyPasswd bool
1376         }))(obj)).Salt)) > math.MaxUint16 {
1377                 chk(ErrTooLong)
1378         }
1379         {
1380                 x := uint16(len(((*(*(struct {
1381                         Salt        []byte
1382                         Verifier    []byte
1383                         EmptyPasswd bool
1384                 }))(obj)).Salt)))
1385                 write16(w, uint16(x))
1386         }
1387         {
1388                 _, err := w.Write(((*(*(struct {
1389                         Salt        []byte
1390                         Verifier    []byte
1391                         EmptyPasswd bool
1392                 }))(obj)).Salt)[:])
1393                 chk(err)
1394         }
1395         if len(((*(*(struct {
1396                 Salt        []byte
1397                 Verifier    []byte
1398                 EmptyPasswd bool
1399         }))(obj)).Verifier)) > math.MaxUint16 {
1400                 chk(ErrTooLong)
1401         }
1402         {
1403                 x := uint16(len(((*(*(struct {
1404                         Salt        []byte
1405                         Verifier    []byte
1406                         EmptyPasswd bool
1407                 }))(obj)).Verifier)))
1408                 write16(w, uint16(x))
1409         }
1410         {
1411                 _, err := w.Write(((*(*(struct {
1412                         Salt        []byte
1413                         Verifier    []byte
1414                         EmptyPasswd bool
1415                 }))(obj)).Verifier)[:])
1416                 chk(err)
1417         }
1418         {
1419                 x := (*(*(struct {
1420                         Salt        []byte
1421                         Verifier    []byte
1422                         EmptyPasswd bool
1423                 }))(obj)).EmptyPasswd
1424                 if x {
1425                         write8(w, 1)
1426                 } else {
1427                         write8(w, 0)
1428                 }
1429         }
1430 }
1431
1432 func (obj *ToSrvFirstSRP) deserialize(r io.Reader) {
1433         var local51 uint16
1434         {
1435                 p := &local51
1436                 *p = read16(r)
1437         }
1438         ((*(*(struct {
1439                 Salt        []byte
1440                 Verifier    []byte
1441                 EmptyPasswd bool
1442         }))(obj)).Salt) = make([]byte, local51)
1443         {
1444                 _, err := io.ReadFull(r, ((*(*(struct {
1445                         Salt        []byte
1446                         Verifier    []byte
1447                         EmptyPasswd bool
1448                 }))(obj)).Salt)[:])
1449                 chk(err)
1450         }
1451         var local52 uint16
1452         {
1453                 p := &local52
1454                 *p = read16(r)
1455         }
1456         ((*(*(struct {
1457                 Salt        []byte
1458                 Verifier    []byte
1459                 EmptyPasswd bool
1460         }))(obj)).Verifier) = make([]byte, local52)
1461         {
1462                 _, err := io.ReadFull(r, ((*(*(struct {
1463                         Salt        []byte
1464                         Verifier    []byte
1465                         EmptyPasswd bool
1466                 }))(obj)).Verifier)[:])
1467                 chk(err)
1468         }
1469         {
1470                 p := &(*(*(struct {
1471                         Salt        []byte
1472                         Verifier    []byte
1473                         EmptyPasswd bool
1474                 }))(obj)).EmptyPasswd
1475                 switch n := read8(r); n {
1476                 case 0:
1477                         *p = false
1478                 case 1:
1479                         *p = true
1480                 default:
1481                         chk(fmt.Errorf("invalid bool: %d", n))
1482                 }
1483         }
1484 }
1485
1486 func (obj *ToSrvSRPBytesA) serialize(w io.Writer) {
1487         if len(((*(*(struct {
1488                 A      []byte
1489                 NoSHA1 bool
1490         }))(obj)).A)) > math.MaxUint16 {
1491                 chk(ErrTooLong)
1492         }
1493         {
1494                 x := uint16(len(((*(*(struct {
1495                         A      []byte
1496                         NoSHA1 bool
1497                 }))(obj)).A)))
1498                 write16(w, uint16(x))
1499         }
1500         {
1501                 _, err := w.Write(((*(*(struct {
1502                         A      []byte
1503                         NoSHA1 bool
1504                 }))(obj)).A)[:])
1505                 chk(err)
1506         }
1507         {
1508                 x := (*(*(struct {
1509                         A      []byte
1510                         NoSHA1 bool
1511                 }))(obj)).NoSHA1
1512                 if x {
1513                         write8(w, 1)
1514                 } else {
1515                         write8(w, 0)
1516                 }
1517         }
1518 }
1519
1520 func (obj *ToSrvSRPBytesA) deserialize(r io.Reader) {
1521         var local53 uint16
1522         {
1523                 p := &local53
1524                 *p = read16(r)
1525         }
1526         ((*(*(struct {
1527                 A      []byte
1528                 NoSHA1 bool
1529         }))(obj)).A) = make([]byte, local53)
1530         {
1531                 _, err := io.ReadFull(r, ((*(*(struct {
1532                         A      []byte
1533                         NoSHA1 bool
1534                 }))(obj)).A)[:])
1535                 chk(err)
1536         }
1537         {
1538                 p := &(*(*(struct {
1539                         A      []byte
1540                         NoSHA1 bool
1541                 }))(obj)).NoSHA1
1542                 switch n := read8(r); n {
1543                 case 0:
1544                         *p = false
1545                 case 1:
1546                         *p = true
1547                 default:
1548                         chk(fmt.Errorf("invalid bool: %d", n))
1549                 }
1550         }
1551 }
1552
1553 func (obj *ToSrvSRPBytesM) serialize(w io.Writer) {
1554         if len(((*(*(struct {
1555                 M []byte
1556         }))(obj)).M)) > math.MaxUint16 {
1557                 chk(ErrTooLong)
1558         }
1559         {
1560                 x := uint16(len(((*(*(struct {
1561                         M []byte
1562                 }))(obj)).M)))
1563                 write16(w, uint16(x))
1564         }
1565         {
1566                 _, err := w.Write(((*(*(struct {
1567                         M []byte
1568                 }))(obj)).M)[:])
1569                 chk(err)
1570         }
1571 }
1572
1573 func (obj *ToSrvSRPBytesM) deserialize(r io.Reader) {
1574         var local54 uint16
1575         {
1576                 p := &local54
1577                 *p = read16(r)
1578         }
1579         ((*(*(struct {
1580                 M []byte
1581         }))(obj)).M) = make([]byte, local54)
1582         {
1583                 _, err := io.ReadFull(r, ((*(*(struct {
1584                         M []byte
1585                 }))(obj)).M)[:])
1586                 chk(err)
1587         }
1588 }
1589
1590 func (obj *ToCltHello) serialize(w io.Writer) {
1591         {
1592                 x := (*(*(struct {
1593                         SerializeVer uint8
1594                         Compression  CompressionModes
1595                         ProtoVer     uint16
1596                         AuthMethods
1597                         Username string
1598                 }))(obj)).SerializeVer
1599                 write8(w, uint8(x))
1600         }
1601         if err := pcall(func() {
1602                 ((*(*(struct {
1603                         SerializeVer uint8
1604                         Compression  CompressionModes
1605                         ProtoVer     uint16
1606                         AuthMethods
1607                         Username string
1608                 }))(obj)).Compression).serialize(w)
1609         }); err != nil {
1610                 if err == io.EOF {
1611                         chk(io.EOF)
1612                 }
1613                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
1614         }
1615         {
1616                 x := (*(*(struct {
1617                         SerializeVer uint8
1618                         Compression  CompressionModes
1619                         ProtoVer     uint16
1620                         AuthMethods
1621                         Username string
1622                 }))(obj)).ProtoVer
1623                 write16(w, uint16(x))
1624         }
1625         if err := pcall(func() {
1626                 ((*(*(struct {
1627                         SerializeVer uint8
1628                         Compression  CompressionModes
1629                         ProtoVer     uint16
1630                         AuthMethods
1631                         Username string
1632                 }))(obj)).AuthMethods).serialize(w)
1633         }); err != nil {
1634                 if err == io.EOF {
1635                         chk(io.EOF)
1636                 }
1637                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1638         }
1639         if len(([]byte((*(*(struct {
1640                 SerializeVer uint8
1641                 Compression  CompressionModes
1642                 ProtoVer     uint16
1643                 AuthMethods
1644                 Username string
1645         }))(obj)).Username))) > math.MaxUint16 {
1646                 chk(ErrTooLong)
1647         }
1648         {
1649                 x := uint16(len(([]byte((*(*(struct {
1650                         SerializeVer uint8
1651                         Compression  CompressionModes
1652                         ProtoVer     uint16
1653                         AuthMethods
1654                         Username string
1655                 }))(obj)).Username))))
1656                 write16(w, uint16(x))
1657         }
1658         {
1659                 _, err := w.Write(([]byte((*(*(struct {
1660                         SerializeVer uint8
1661                         Compression  CompressionModes
1662                         ProtoVer     uint16
1663                         AuthMethods
1664                         Username string
1665                 }))(obj)).Username))[:])
1666                 chk(err)
1667         }
1668 }
1669
1670 func (obj *ToCltHello) deserialize(r io.Reader) {
1671         {
1672                 p := &(*(*(struct {
1673                         SerializeVer uint8
1674                         Compression  CompressionModes
1675                         ProtoVer     uint16
1676                         AuthMethods
1677                         Username string
1678                 }))(obj)).SerializeVer
1679                 *p = read8(r)
1680         }
1681         if err := pcall(func() {
1682                 ((*(*(struct {
1683                         SerializeVer uint8
1684                         Compression  CompressionModes
1685                         ProtoVer     uint16
1686                         AuthMethods
1687                         Username string
1688                 }))(obj)).Compression).deserialize(r)
1689         }); err != nil {
1690                 if err == io.EOF {
1691                         chk(io.EOF)
1692                 }
1693                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
1694         }
1695         {
1696                 p := &(*(*(struct {
1697                         SerializeVer uint8
1698                         Compression  CompressionModes
1699                         ProtoVer     uint16
1700                         AuthMethods
1701                         Username string
1702                 }))(obj)).ProtoVer
1703                 *p = read16(r)
1704         }
1705         if err := pcall(func() {
1706                 ((*(*(struct {
1707                         SerializeVer uint8
1708                         Compression  CompressionModes
1709                         ProtoVer     uint16
1710                         AuthMethods
1711                         Username string
1712                 }))(obj)).AuthMethods).deserialize(r)
1713         }); err != nil {
1714                 if err == io.EOF {
1715                         chk(io.EOF)
1716                 }
1717                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1718         }
1719         var local55 []uint8
1720         var local56 uint16
1721         {
1722                 p := &local56
1723                 *p = read16(r)
1724         }
1725         (local55) = make([]uint8, local56)
1726         {
1727                 _, err := io.ReadFull(r, (local55)[:])
1728                 chk(err)
1729         }
1730         ((*(*(struct {
1731                 SerializeVer uint8
1732                 Compression  CompressionModes
1733                 ProtoVer     uint16
1734                 AuthMethods
1735                 Username string
1736         }))(obj)).Username) = string(local55)
1737 }
1738
1739 func (obj *ToCltAcceptAuth) serialize(w io.Writer) {
1740         if err := pcall(func() {
1741                 ((*(*(struct {
1742                         // The client does the equivalent of
1743                         //      PlayerPos[1] -= 5
1744                         // before using PlayerPos.
1745                         PlayerPos Pos
1746
1747                         MapSeed         uint64
1748                         SendInterval    float32
1749                         SudoAuthMethods AuthMethods
1750                 }))(obj)).PlayerPos).serialize(w)
1751         }); err != nil {
1752                 if err == io.EOF {
1753                         chk(io.EOF)
1754                 }
1755                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
1756         }
1757         {
1758                 x := (*(*(struct {
1759                         // The client does the equivalent of
1760                         //      PlayerPos[1] -= 5
1761                         // before using PlayerPos.
1762                         PlayerPos Pos
1763
1764                         MapSeed         uint64
1765                         SendInterval    float32
1766                         SudoAuthMethods AuthMethods
1767                 }))(obj)).MapSeed
1768                 write64(w, uint64(x))
1769         }
1770         {
1771                 x := (*(*(struct {
1772                         // The client does the equivalent of
1773                         //      PlayerPos[1] -= 5
1774                         // before using PlayerPos.
1775                         PlayerPos Pos
1776
1777                         MapSeed         uint64
1778                         SendInterval    float32
1779                         SudoAuthMethods AuthMethods
1780                 }))(obj)).SendInterval
1781                 write32(w, math.Float32bits(x))
1782         }
1783         if err := pcall(func() {
1784                 ((*(*(struct {
1785                         // The client does the equivalent of
1786                         //      PlayerPos[1] -= 5
1787                         // before using PlayerPos.
1788                         PlayerPos Pos
1789
1790                         MapSeed         uint64
1791                         SendInterval    float32
1792                         SudoAuthMethods AuthMethods
1793                 }))(obj)).SudoAuthMethods).serialize(w)
1794         }); err != nil {
1795                 if err == io.EOF {
1796                         chk(io.EOF)
1797                 }
1798                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1799         }
1800 }
1801
1802 func (obj *ToCltAcceptAuth) deserialize(r io.Reader) {
1803         if err := pcall(func() {
1804                 ((*(*(struct {
1805                         // The client does the equivalent of
1806                         //      PlayerPos[1] -= 5
1807                         // before using PlayerPos.
1808                         PlayerPos Pos
1809
1810                         MapSeed         uint64
1811                         SendInterval    float32
1812                         SudoAuthMethods AuthMethods
1813                 }))(obj)).PlayerPos).deserialize(r)
1814         }); err != nil {
1815                 if err == io.EOF {
1816                         chk(io.EOF)
1817                 }
1818                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
1819         }
1820         {
1821                 p := &(*(*(struct {
1822                         // The client does the equivalent of
1823                         //      PlayerPos[1] -= 5
1824                         // before using PlayerPos.
1825                         PlayerPos Pos
1826
1827                         MapSeed         uint64
1828                         SendInterval    float32
1829                         SudoAuthMethods AuthMethods
1830                 }))(obj)).MapSeed
1831                 *p = read64(r)
1832         }
1833         {
1834                 p := &(*(*(struct {
1835                         // The client does the equivalent of
1836                         //      PlayerPos[1] -= 5
1837                         // before using PlayerPos.
1838                         PlayerPos Pos
1839
1840                         MapSeed         uint64
1841                         SendInterval    float32
1842                         SudoAuthMethods AuthMethods
1843                 }))(obj)).SendInterval
1844                 *p = math.Float32frombits(read32(r))
1845         }
1846         if err := pcall(func() {
1847                 ((*(*(struct {
1848                         // The client does the equivalent of
1849                         //      PlayerPos[1] -= 5
1850                         // before using PlayerPos.
1851                         PlayerPos Pos
1852
1853                         MapSeed         uint64
1854                         SendInterval    float32
1855                         SudoAuthMethods AuthMethods
1856                 }))(obj)).SudoAuthMethods).deserialize(r)
1857         }); err != nil {
1858                 if err == io.EOF {
1859                         chk(io.EOF)
1860                 }
1861                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1862         }
1863 }
1864
1865 func (obj *ToCltAcceptSudoMode) serialize(w io.Writer) {
1866 }
1867
1868 func (obj *ToCltAcceptSudoMode) deserialize(r io.Reader) {
1869 }
1870
1871 func (obj *ToCltDenySudoMode) serialize(w io.Writer) {
1872 }
1873
1874 func (obj *ToCltDenySudoMode) deserialize(r io.Reader) {
1875 }
1876
1877 func (obj *ToCltDisco) serialize(w io.Writer) {
1878         if err := pcall(func() {
1879                 ((*(*(struct {
1880                         Reason DiscoReason
1881
1882                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1883                         Custom string
1884
1885                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1886                         Reconnect bool
1887                 }))(obj)).Reason).serialize(w)
1888         }); err != nil {
1889                 if err == io.EOF {
1890                         chk(io.EOF)
1891                 }
1892                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DiscoReason", err))
1893         }
1894         if !((*(*(struct {
1895                 Reason DiscoReason
1896
1897                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1898                 Custom string
1899
1900                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1901                 Reconnect bool
1902         }))(obj)).Reason < maxDiscoReason) {
1903                 chk(errors.New("assertion failed: %s.Reason < maxDiscoReason"))
1904         }
1905         if dr := (*(*(struct {
1906                 Reason DiscoReason
1907
1908                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1909                 Custom string
1910
1911                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1912                 Reconnect bool
1913         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
1914                 if len(([]byte((*(*(struct {
1915                         Reason DiscoReason
1916
1917                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1918                         Custom string
1919
1920                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1921                         Reconnect bool
1922                 }))(obj)).Custom))) > math.MaxUint16 {
1923                         chk(ErrTooLong)
1924                 }
1925                 {
1926                         x := uint16(len(([]byte((*(*(struct {
1927                                 Reason DiscoReason
1928
1929                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1930                                 Custom string
1931
1932                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1933                                 Reconnect bool
1934                         }))(obj)).Custom))))
1935                         write16(w, uint16(x))
1936                 }
1937                 {
1938                         _, err := w.Write(([]byte((*(*(struct {
1939                                 Reason DiscoReason
1940
1941                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1942                                 Custom string
1943
1944                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1945                                 Reconnect bool
1946                         }))(obj)).Custom))[:])
1947                         chk(err)
1948                 }
1949         }
1950         if dr := (*(*(struct {
1951                 Reason DiscoReason
1952
1953                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1954                 Custom string
1955
1956                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1957                 Reconnect bool
1958         }))(obj)).Reason; dr == Shutdown || dr == Crash {
1959                 {
1960                         x := (*(*(struct {
1961                                 Reason DiscoReason
1962
1963                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1964                                 Custom string
1965
1966                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1967                                 Reconnect bool
1968                         }))(obj)).Reconnect
1969                         if x {
1970                                 write8(w, 1)
1971                         } else {
1972                                 write8(w, 0)
1973                         }
1974                 }
1975         }
1976 }
1977
1978 func (obj *ToCltDisco) deserialize(r io.Reader) {
1979         if err := pcall(func() {
1980                 ((*(*(struct {
1981                         Reason DiscoReason
1982
1983                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1984                         Custom string
1985
1986                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1987                         Reconnect bool
1988                 }))(obj)).Reason).deserialize(r)
1989         }); err != nil {
1990                 if err == io.EOF {
1991                         chk(io.EOF)
1992                 }
1993                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DiscoReason", err))
1994         }
1995         if !((*(*(struct {
1996                 Reason DiscoReason
1997
1998                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1999                 Custom string
2000
2001                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2002                 Reconnect bool
2003         }))(obj)).Reason < maxDiscoReason) {
2004                 chk(errors.New("assertion failed: %s.Reason < maxDiscoReason"))
2005         }
2006         if dr := (*(*(struct {
2007                 Reason DiscoReason
2008
2009                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2010                 Custom string
2011
2012                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2013                 Reconnect bool
2014         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
2015                 var local57 []uint8
2016                 var local58 uint16
2017                 {
2018                         p := &local58
2019                         *p = read16(r)
2020                 }
2021                 (local57) = make([]uint8, local58)
2022                 {
2023                         _, err := io.ReadFull(r, (local57)[:])
2024                         chk(err)
2025                 }
2026                 ((*(*(struct {
2027                         Reason DiscoReason
2028
2029                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2030                         Custom string
2031
2032                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2033                         Reconnect bool
2034                 }))(obj)).Custom) = string(local57)
2035         }
2036         if dr := (*(*(struct {
2037                 Reason DiscoReason
2038
2039                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2040                 Custom string
2041
2042                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2043                 Reconnect bool
2044         }))(obj)).Reason; dr == Shutdown || dr == Crash {
2045                 {
2046                         p := &(*(*(struct {
2047                                 Reason DiscoReason
2048
2049                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2050                                 Custom string
2051
2052                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2053                                 Reconnect bool
2054                         }))(obj)).Reconnect
2055                         switch n := read8(r); n {
2056                         case 0:
2057                                 *p = false
2058                         case 1:
2059                                 *p = true
2060                         default:
2061                                 chk(fmt.Errorf("invalid bool: %d", n))
2062                         }
2063                 }
2064         }
2065 }
2066
2067 func (obj *ToCltBlkData) serialize(w io.Writer) {
2068         for local59 := range (*(*(struct {
2069                 Blkpos [3]int16
2070                 Blk    MapBlk
2071         }))(obj)).Blkpos {
2072                 {
2073                         x := ((*(*(struct {
2074                                 Blkpos [3]int16
2075                                 Blk    MapBlk
2076                         }))(obj)).Blkpos)[local59]
2077                         write16(w, uint16(x))
2078                 }
2079         }
2080         if err := pcall(func() {
2081                 ((*(*(struct {
2082                         Blkpos [3]int16
2083                         Blk    MapBlk
2084                 }))(obj)).Blk).serialize(w)
2085         }); err != nil {
2086                 if err == io.EOF {
2087                         chk(io.EOF)
2088                 }
2089                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlk", err))
2090         }
2091 }
2092
2093 func (obj *ToCltBlkData) deserialize(r io.Reader) {
2094         for local60 := range (*(*(struct {
2095                 Blkpos [3]int16
2096                 Blk    MapBlk
2097         }))(obj)).Blkpos {
2098                 {
2099                         p := &((*(*(struct {
2100                                 Blkpos [3]int16
2101                                 Blk    MapBlk
2102                         }))(obj)).Blkpos)[local60]
2103                         *p = int16(read16(r))
2104                 }
2105         }
2106         if err := pcall(func() {
2107                 ((*(*(struct {
2108                         Blkpos [3]int16
2109                         Blk    MapBlk
2110                 }))(obj)).Blk).deserialize(r)
2111         }); err != nil {
2112                 if err == io.EOF {
2113                         chk(io.EOF)
2114                 }
2115                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlk", err))
2116         }
2117 }
2118
2119 func (obj *ToCltAddNode) serialize(w io.Writer) {
2120         for local61 := range (*(*(struct {
2121                 Pos [3]int16
2122                 Node
2123                 KeepMeta bool
2124         }))(obj)).Pos {
2125                 {
2126                         x := ((*(*(struct {
2127                                 Pos [3]int16
2128                                 Node
2129                                 KeepMeta bool
2130                         }))(obj)).Pos)[local61]
2131                         write16(w, uint16(x))
2132                 }
2133         }
2134         if err := pcall(func() {
2135                 ((*(*(struct {
2136                         Pos [3]int16
2137                         Node
2138                         KeepMeta bool
2139                 }))(obj)).Node).serialize(w)
2140         }); err != nil {
2141                 if err == io.EOF {
2142                         chk(io.EOF)
2143                 }
2144                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Node", err))
2145         }
2146         {
2147                 x := (*(*(struct {
2148                         Pos [3]int16
2149                         Node
2150                         KeepMeta bool
2151                 }))(obj)).KeepMeta
2152                 if x {
2153                         write8(w, 1)
2154                 } else {
2155                         write8(w, 0)
2156                 }
2157         }
2158 }
2159
2160 func (obj *ToCltAddNode) deserialize(r io.Reader) {
2161         for local62 := range (*(*(struct {
2162                 Pos [3]int16
2163                 Node
2164                 KeepMeta bool
2165         }))(obj)).Pos {
2166                 {
2167                         p := &((*(*(struct {
2168                                 Pos [3]int16
2169                                 Node
2170                                 KeepMeta bool
2171                         }))(obj)).Pos)[local62]
2172                         *p = int16(read16(r))
2173                 }
2174         }
2175         if err := pcall(func() {
2176                 ((*(*(struct {
2177                         Pos [3]int16
2178                         Node
2179                         KeepMeta bool
2180                 }))(obj)).Node).deserialize(r)
2181         }); err != nil {
2182                 if err == io.EOF {
2183                         chk(io.EOF)
2184                 }
2185                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Node", err))
2186         }
2187         {
2188                 p := &(*(*(struct {
2189                         Pos [3]int16
2190                         Node
2191                         KeepMeta bool
2192                 }))(obj)).KeepMeta
2193                 switch n := read8(r); n {
2194                 case 0:
2195                         *p = false
2196                 case 1:
2197                         *p = true
2198                 default:
2199                         chk(fmt.Errorf("invalid bool: %d", n))
2200                 }
2201         }
2202 }
2203
2204 func (obj *ToCltRemoveNode) serialize(w io.Writer) {
2205         for local63 := range (*(*(struct {
2206                 Pos [3]int16
2207         }))(obj)).Pos {
2208                 {
2209                         x := ((*(*(struct {
2210                                 Pos [3]int16
2211                         }))(obj)).Pos)[local63]
2212                         write16(w, uint16(x))
2213                 }
2214         }
2215 }
2216
2217 func (obj *ToCltRemoveNode) deserialize(r io.Reader) {
2218         for local64 := range (*(*(struct {
2219                 Pos [3]int16
2220         }))(obj)).Pos {
2221                 {
2222                         p := &((*(*(struct {
2223                                 Pos [3]int16
2224                         }))(obj)).Pos)[local64]
2225                         *p = int16(read16(r))
2226                 }
2227         }
2228 }
2229
2230 func (obj *ToCltInv) serialize(w io.Writer) {
2231         {
2232                 _, err := w.Write(([]byte((*(*(struct {
2233                         //mt:raw
2234                         Inv string
2235                 }))(obj)).Inv))[:])
2236                 chk(err)
2237         }
2238 }
2239
2240 func (obj *ToCltInv) deserialize(r io.Reader) {
2241         var local65 []uint8
2242         for {
2243                 var local66 uint8
2244                 err := pcall(func() {
2245                         {
2246                                 p := &local66
2247                                 *p = read8(r)
2248                         }
2249                 })
2250                 if err == io.EOF {
2251                         break
2252                 }
2253                 (local65) = append((local65), local66)
2254                 chk(err)
2255         }
2256         ((*(*(struct {
2257                 //mt:raw
2258                 Inv string
2259         }))(obj)).Inv) = string(local65)
2260 }
2261
2262 func (obj *ToCltTimeOfDay) serialize(w io.Writer) {
2263         {
2264                 x := (*(*(struct {
2265                         Time  uint16  // %24000
2266                         Speed float32 // Speed times faster than real time
2267                 }))(obj)).Time
2268                 write16(w, uint16(x))
2269         }
2270         {
2271                 x := (*(*(struct {
2272                         Time  uint16  // %24000
2273                         Speed float32 // Speed times faster than real time
2274                 }))(obj)).Speed
2275                 write32(w, math.Float32bits(x))
2276         }
2277 }
2278
2279 func (obj *ToCltTimeOfDay) deserialize(r io.Reader) {
2280         {
2281                 p := &(*(*(struct {
2282                         Time  uint16  // %24000
2283                         Speed float32 // Speed times faster than real time
2284                 }))(obj)).Time
2285                 *p = read16(r)
2286         }
2287         {
2288                 p := &(*(*(struct {
2289                         Time  uint16  // %24000
2290                         Speed float32 // Speed times faster than real time
2291                 }))(obj)).Speed
2292                 *p = math.Float32frombits(read32(r))
2293         }
2294 }
2295
2296 func (obj *ToCltCSMRestrictionFlags) serialize(w io.Writer) {
2297         if err := pcall(func() {
2298                 ((*(*(struct {
2299                         Flags CSMRestrictionFlags
2300
2301                         // MapRange is the maximum distance from the player CSMs can read the map
2302                         // if Flags&LimitMapRange != 0.
2303                         MapRange uint32
2304                 }))(obj)).Flags).serialize(w)
2305         }); err != nil {
2306                 if err == io.EOF {
2307                         chk(io.EOF)
2308                 }
2309                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CSMRestrictionFlags", err))
2310         }
2311         {
2312                 x := (*(*(struct {
2313                         Flags CSMRestrictionFlags
2314
2315                         // MapRange is the maximum distance from the player CSMs can read the map
2316                         // if Flags&LimitMapRange != 0.
2317                         MapRange uint32
2318                 }))(obj)).MapRange
2319                 write32(w, uint32(x))
2320         }
2321 }
2322
2323 func (obj *ToCltCSMRestrictionFlags) deserialize(r io.Reader) {
2324         if err := pcall(func() {
2325                 ((*(*(struct {
2326                         Flags CSMRestrictionFlags
2327
2328                         // MapRange is the maximum distance from the player CSMs can read the map
2329                         // if Flags&LimitMapRange != 0.
2330                         MapRange uint32
2331                 }))(obj)).Flags).deserialize(r)
2332         }); err != nil {
2333                 if err == io.EOF {
2334                         chk(io.EOF)
2335                 }
2336                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CSMRestrictionFlags", err))
2337         }
2338         {
2339                 p := &(*(*(struct {
2340                         Flags CSMRestrictionFlags
2341
2342                         // MapRange is the maximum distance from the player CSMs can read the map
2343                         // if Flags&LimitMapRange != 0.
2344                         MapRange uint32
2345                 }))(obj)).MapRange
2346                 *p = read32(r)
2347         }
2348 }
2349
2350 func (obj *ToCltAddPlayerVel) serialize(w io.Writer) {
2351         if err := pcall(func() {
2352                 ((*(*(struct {
2353                         Vel Vec
2354                 }))(obj)).Vel).serialize(w)
2355         }); err != nil {
2356                 if err == io.EOF {
2357                         chk(io.EOF)
2358                 }
2359                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
2360         }
2361 }
2362
2363 func (obj *ToCltAddPlayerVel) deserialize(r io.Reader) {
2364         if err := pcall(func() {
2365                 ((*(*(struct {
2366                         Vel Vec
2367                 }))(obj)).Vel).deserialize(r)
2368         }); err != nil {
2369                 if err == io.EOF {
2370                         chk(io.EOF)
2371                 }
2372                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
2373         }
2374 }
2375
2376 func (obj *ToCltMediaPush) serialize(w io.Writer) {
2377         {
2378                 local67 := uint16(sha1.Size)
2379                 {
2380                         x := local67
2381                         write16(w, uint16(x))
2382                 }
2383         }
2384         {
2385                 _, err := w.Write(((*(*(struct {
2386                         //mt:const uint16(sha1.Size)
2387                         SHA1        [sha1.Size]byte
2388                         Filename    string
2389                         ShouldCache bool
2390
2391                         //mt:len32
2392                         Data []byte
2393                 }))(obj)).SHA1)[:])
2394                 chk(err)
2395         }
2396         if len(([]byte((*(*(struct {
2397                 //mt:const uint16(sha1.Size)
2398                 SHA1        [sha1.Size]byte
2399                 Filename    string
2400                 ShouldCache bool
2401
2402                 //mt:len32
2403                 Data []byte
2404         }))(obj)).Filename))) > math.MaxUint16 {
2405                 chk(ErrTooLong)
2406         }
2407         {
2408                 x := uint16(len(([]byte((*(*(struct {
2409                         //mt:const uint16(sha1.Size)
2410                         SHA1        [sha1.Size]byte
2411                         Filename    string
2412                         ShouldCache bool
2413
2414                         //mt:len32
2415                         Data []byte
2416                 }))(obj)).Filename))))
2417                 write16(w, uint16(x))
2418         }
2419         {
2420                 _, err := w.Write(([]byte((*(*(struct {
2421                         //mt:const uint16(sha1.Size)
2422                         SHA1        [sha1.Size]byte
2423                         Filename    string
2424                         ShouldCache bool
2425
2426                         //mt:len32
2427                         Data []byte
2428                 }))(obj)).Filename))[:])
2429                 chk(err)
2430         }
2431         {
2432                 x := (*(*(struct {
2433                         //mt:const uint16(sha1.Size)
2434                         SHA1        [sha1.Size]byte
2435                         Filename    string
2436                         ShouldCache bool
2437
2438                         //mt:len32
2439                         Data []byte
2440                 }))(obj)).ShouldCache
2441                 if x {
2442                         write8(w, 1)
2443                 } else {
2444                         write8(w, 0)
2445                 }
2446         }
2447         if len(((*(*(struct {
2448                 //mt:const uint16(sha1.Size)
2449                 SHA1        [sha1.Size]byte
2450                 Filename    string
2451                 ShouldCache bool
2452
2453                 //mt:len32
2454                 Data []byte
2455         }))(obj)).Data)) > math.MaxUint32 {
2456                 chk(ErrTooLong)
2457         }
2458         {
2459                 x := uint32(len(((*(*(struct {
2460                         //mt:const uint16(sha1.Size)
2461                         SHA1        [sha1.Size]byte
2462                         Filename    string
2463                         ShouldCache bool
2464
2465                         //mt:len32
2466                         Data []byte
2467                 }))(obj)).Data)))
2468                 write32(w, uint32(x))
2469         }
2470         {
2471                 _, err := w.Write(((*(*(struct {
2472                         //mt:const uint16(sha1.Size)
2473                         SHA1        [sha1.Size]byte
2474                         Filename    string
2475                         ShouldCache bool
2476
2477                         //mt:len32
2478                         Data []byte
2479                 }))(obj)).Data)[:])
2480                 chk(err)
2481         }
2482 }
2483
2484 func (obj *ToCltMediaPush) deserialize(r io.Reader) {
2485         {
2486                 var local68 uint16
2487                 {
2488                         p := &local68
2489                         *p = read16(r)
2490                 }
2491                 if local68 != (20) {
2492                         chk(fmt.Errorf("const %v: %v", 20, local68))
2493                 }
2494         }
2495         {
2496                 _, err := io.ReadFull(r, ((*(*(struct {
2497                         //mt:const uint16(sha1.Size)
2498                         SHA1        [sha1.Size]byte
2499                         Filename    string
2500                         ShouldCache bool
2501
2502                         //mt:len32
2503                         Data []byte
2504                 }))(obj)).SHA1)[:])
2505                 chk(err)
2506         }
2507         var local69 []uint8
2508         var local70 uint16
2509         {
2510                 p := &local70
2511                 *p = read16(r)
2512         }
2513         (local69) = make([]uint8, local70)
2514         {
2515                 _, err := io.ReadFull(r, (local69)[:])
2516                 chk(err)
2517         }
2518         ((*(*(struct {
2519                 //mt:const uint16(sha1.Size)
2520                 SHA1        [sha1.Size]byte
2521                 Filename    string
2522                 ShouldCache bool
2523
2524                 //mt:len32
2525                 Data []byte
2526         }))(obj)).Filename) = string(local69)
2527         {
2528                 p := &(*(*(struct {
2529                         //mt:const uint16(sha1.Size)
2530                         SHA1        [sha1.Size]byte
2531                         Filename    string
2532                         ShouldCache bool
2533
2534                         //mt:len32
2535                         Data []byte
2536                 }))(obj)).ShouldCache
2537                 switch n := read8(r); n {
2538                 case 0:
2539                         *p = false
2540                 case 1:
2541                         *p = true
2542                 default:
2543                         chk(fmt.Errorf("invalid bool: %d", n))
2544                 }
2545         }
2546         var local71 uint32
2547         {
2548                 p := &local71
2549                 *p = read32(r)
2550         }
2551         ((*(*(struct {
2552                 //mt:const uint16(sha1.Size)
2553                 SHA1        [sha1.Size]byte
2554                 Filename    string
2555                 ShouldCache bool
2556
2557                 //mt:len32
2558                 Data []byte
2559         }))(obj)).Data) = make([]byte, local71)
2560         {
2561                 _, err := io.ReadFull(r, ((*(*(struct {
2562                         //mt:const uint16(sha1.Size)
2563                         SHA1        [sha1.Size]byte
2564                         Filename    string
2565                         ShouldCache bool
2566
2567                         //mt:len32
2568                         Data []byte
2569                 }))(obj)).Data)[:])
2570                 chk(err)
2571         }
2572 }
2573
2574 func (obj *ToCltChatMsg) serialize(w io.Writer) {
2575         {
2576                 local72 := uint8(1)
2577                 {
2578                         x := local72
2579                         write8(w, uint8(x))
2580                 }
2581         }
2582         if err := pcall(func() {
2583                 ((*(*(struct {
2584                         Type ChatMsgType
2585
2586                         //mt:utf16
2587                         Sender, Text string
2588
2589                         Timestamp int64 // Unix time.
2590                 }))(obj)).Type).serialize(w)
2591         }); err != nil {
2592                 if err == io.EOF {
2593                         chk(io.EOF)
2594                 }
2595                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
2596         }
2597         if len((utf16.Encode([]rune((*(*(struct {
2598                 Type ChatMsgType
2599
2600                 //mt:utf16
2601                 Sender, Text string
2602
2603                 Timestamp int64 // Unix time.
2604         }))(obj)).Sender)))) > math.MaxUint16 {
2605                 chk(ErrTooLong)
2606         }
2607         {
2608                 x := uint16(len((utf16.Encode([]rune((*(*(struct {
2609                         Type ChatMsgType
2610
2611                         //mt:utf16
2612                         Sender, Text string
2613
2614                         Timestamp int64 // Unix time.
2615                 }))(obj)).Sender)))))
2616                 write16(w, uint16(x))
2617         }
2618         for local73 := range utf16.Encode([]rune((*(*(struct {
2619                 Type ChatMsgType
2620
2621                 //mt:utf16
2622                 Sender, Text string
2623
2624                 Timestamp int64 // Unix time.
2625         }))(obj)).Sender)) {
2626                 {
2627                         x := (utf16.Encode([]rune((*(*(struct {
2628                                 Type ChatMsgType
2629
2630                                 //mt:utf16
2631                                 Sender, Text string
2632
2633                                 Timestamp int64 // Unix time.
2634                         }))(obj)).Sender)))[local73]
2635                         write16(w, uint16(x))
2636                 }
2637         }
2638         if len((utf16.Encode([]rune((*(*(struct {
2639                 Type ChatMsgType
2640
2641                 //mt:utf16
2642                 Sender, Text string
2643
2644                 Timestamp int64 // Unix time.
2645         }))(obj)).Text)))) > math.MaxUint16 {
2646                 chk(ErrTooLong)
2647         }
2648         {
2649                 x := uint16(len((utf16.Encode([]rune((*(*(struct {
2650                         Type ChatMsgType
2651
2652                         //mt:utf16
2653                         Sender, Text string
2654
2655                         Timestamp int64 // Unix time.
2656                 }))(obj)).Text)))))
2657                 write16(w, uint16(x))
2658         }
2659         for local74 := range utf16.Encode([]rune((*(*(struct {
2660                 Type ChatMsgType
2661
2662                 //mt:utf16
2663                 Sender, Text string
2664
2665                 Timestamp int64 // Unix time.
2666         }))(obj)).Text)) {
2667                 {
2668                         x := (utf16.Encode([]rune((*(*(struct {
2669                                 Type ChatMsgType
2670
2671                                 //mt:utf16
2672                                 Sender, Text string
2673
2674                                 Timestamp int64 // Unix time.
2675                         }))(obj)).Text)))[local74]
2676                         write16(w, uint16(x))
2677                 }
2678         }
2679         {
2680                 x := (*(*(struct {
2681                         Type ChatMsgType
2682
2683                         //mt:utf16
2684                         Sender, Text string
2685
2686                         Timestamp int64 // Unix time.
2687                 }))(obj)).Timestamp
2688                 write64(w, uint64(x))
2689         }
2690 }
2691
2692 func (obj *ToCltChatMsg) deserialize(r io.Reader) {
2693         {
2694                 var local75 uint8
2695                 {
2696                         p := &local75
2697                         *p = read8(r)
2698                 }
2699                 if local75 != (1) {
2700                         chk(fmt.Errorf("const %v: %v", 1, local75))
2701                 }
2702         }
2703         if err := pcall(func() {
2704                 ((*(*(struct {
2705                         Type ChatMsgType
2706
2707                         //mt:utf16
2708                         Sender, Text string
2709
2710                         Timestamp int64 // Unix time.
2711                 }))(obj)).Type).deserialize(r)
2712         }); err != nil {
2713                 if err == io.EOF {
2714                         chk(io.EOF)
2715                 }
2716                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
2717         }
2718         var local76 []uint16
2719         var local77 uint16
2720         {
2721                 p := &local77
2722                 *p = read16(r)
2723         }
2724         (local76) = make([]uint16, local77)
2725         for local78 := range local76 {
2726                 {
2727                         p := &(local76)[local78]
2728                         *p = read16(r)
2729                 }
2730         }
2731         (*(*(struct {
2732                 Type ChatMsgType
2733
2734                 //mt:utf16
2735                 Sender, Text string
2736
2737                 Timestamp int64 // Unix time.
2738         }))(obj)).Sender = string(utf16.Decode(local76))
2739         var local79 []uint16
2740         var local80 uint16
2741         {
2742                 p := &local80
2743                 *p = read16(r)
2744         }
2745         (local79) = make([]uint16, local80)
2746         for local81 := range local79 {
2747                 {
2748                         p := &(local79)[local81]
2749                         *p = read16(r)
2750                 }
2751         }
2752         (*(*(struct {
2753                 Type ChatMsgType
2754
2755                 //mt:utf16
2756                 Sender, Text string
2757
2758                 Timestamp int64 // Unix time.
2759         }))(obj)).Text = string(utf16.Decode(local79))
2760         {
2761                 p := &(*(*(struct {
2762                         Type ChatMsgType
2763
2764                         //mt:utf16
2765                         Sender, Text string
2766
2767                         Timestamp int64 // Unix time.
2768                 }))(obj)).Timestamp
2769                 *p = int64(read64(r))
2770         }
2771 }
2772
2773 func (obj *ToCltAORmAdd) serialize(w io.Writer) {
2774         if len(((*(*(struct {
2775                 Remove []AOID
2776                 Add    []struct {
2777                         ID AOID
2778                         //mt:const genericCAO
2779                         //mt:lenhdr 32
2780                         InitData AOInitData
2781                 }
2782         }))(obj)).Remove)) > math.MaxUint16 {
2783                 chk(ErrTooLong)
2784         }
2785         {
2786                 x := uint16(len(((*(*(struct {
2787                         Remove []AOID
2788                         Add    []struct {
2789                                 ID AOID
2790                                 //mt:const genericCAO
2791                                 //mt:lenhdr 32
2792                                 InitData AOInitData
2793                         }
2794                 }))(obj)).Remove)))
2795                 write16(w, uint16(x))
2796         }
2797         for local82 := range (*(*(struct {
2798                 Remove []AOID
2799                 Add    []struct {
2800                         ID AOID
2801                         //mt:const genericCAO
2802                         //mt:lenhdr 32
2803                         InitData AOInitData
2804                 }
2805         }))(obj)).Remove {
2806                 if err := pcall(func() {
2807                         (((*(*(struct {
2808                                 Remove []AOID
2809                                 Add    []struct {
2810                                         ID AOID
2811                                         //mt:const genericCAO
2812                                         //mt:lenhdr 32
2813                                         InitData AOInitData
2814                                 }
2815                         }))(obj)).Remove)[local82]).serialize(w)
2816                 }); err != nil {
2817                         if err == io.EOF {
2818                                 chk(io.EOF)
2819                         }
2820                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2821                 }
2822         }
2823         if len(((*(*(struct {
2824                 Remove []AOID
2825                 Add    []struct {
2826                         ID AOID
2827                         //mt:const genericCAO
2828                         //mt:lenhdr 32
2829                         InitData AOInitData
2830                 }
2831         }))(obj)).Add)) > math.MaxUint16 {
2832                 chk(ErrTooLong)
2833         }
2834         {
2835                 x := uint16(len(((*(*(struct {
2836                         Remove []AOID
2837                         Add    []struct {
2838                                 ID AOID
2839                                 //mt:const genericCAO
2840                                 //mt:lenhdr 32
2841                                 InitData AOInitData
2842                         }
2843                 }))(obj)).Add)))
2844                 write16(w, uint16(x))
2845         }
2846         for local83 := range (*(*(struct {
2847                 Remove []AOID
2848                 Add    []struct {
2849                         ID AOID
2850                         //mt:const genericCAO
2851                         //mt:lenhdr 32
2852                         InitData AOInitData
2853                 }
2854         }))(obj)).Add {
2855                 if err := pcall(func() {
2856                         ((((*(*(struct {
2857                                 Remove []AOID
2858                                 Add    []struct {
2859                                         ID AOID
2860                                         //mt:const genericCAO
2861                                         //mt:lenhdr 32
2862                                         InitData AOInitData
2863                                 }
2864                         }))(obj)).Add)[local83]).ID).serialize(w)
2865                 }); err != nil {
2866                         if err == io.EOF {
2867                                 chk(io.EOF)
2868                         }
2869                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2870                 }
2871                 {
2872                         local84 := genericCAO
2873                         if err := pcall(func() {
2874                                 (local84).serialize(w)
2875                         }); err != nil {
2876                                 if err == io.EOF {
2877                                         chk(io.EOF)
2878                                 }
2879                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
2880                         }
2881                 }
2882                 {
2883                         ow := w
2884                         w := new(bytes.Buffer)
2885                         if err := pcall(func() {
2886                                 ((((*(*(struct {
2887                                         Remove []AOID
2888                                         Add    []struct {
2889                                                 ID AOID
2890                                                 //mt:const genericCAO
2891                                                 //mt:lenhdr 32
2892                                                 InitData AOInitData
2893                                         }
2894                                 }))(obj)).Add)[local83]).InitData).serialize(w)
2895                         }); err != nil {
2896                                 if err == io.EOF {
2897                                         chk(io.EOF)
2898                                 }
2899                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
2900                         }
2901                         {
2902                                 buf := w
2903                                 w := ow
2904                                 if len((buf.Bytes())) > math.MaxUint32 {
2905                                         chk(ErrTooLong)
2906                                 }
2907                                 {
2908                                         x := uint32(len((buf.Bytes())))
2909                                         write32(w, uint32(x))
2910                                 }
2911                                 {
2912                                         _, err := w.Write((buf.Bytes())[:])
2913                                         chk(err)
2914                                 }
2915                         }
2916                 }
2917         }
2918 }
2919
2920 func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
2921         var local85 uint16
2922         {
2923                 p := &local85
2924                 *p = read16(r)
2925         }
2926         ((*(*(struct {
2927                 Remove []AOID
2928                 Add    []struct {
2929                         ID AOID
2930                         //mt:const genericCAO
2931                         //mt:lenhdr 32
2932                         InitData AOInitData
2933                 }
2934         }))(obj)).Remove) = make([]AOID, local85)
2935         for local86 := range (*(*(struct {
2936                 Remove []AOID
2937                 Add    []struct {
2938                         ID AOID
2939                         //mt:const genericCAO
2940                         //mt:lenhdr 32
2941                         InitData AOInitData
2942                 }
2943         }))(obj)).Remove {
2944                 if err := pcall(func() {
2945                         (((*(*(struct {
2946                                 Remove []AOID
2947                                 Add    []struct {
2948                                         ID AOID
2949                                         //mt:const genericCAO
2950                                         //mt:lenhdr 32
2951                                         InitData AOInitData
2952                                 }
2953                         }))(obj)).Remove)[local86]).deserialize(r)
2954                 }); err != nil {
2955                         if err == io.EOF {
2956                                 chk(io.EOF)
2957                         }
2958                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2959                 }
2960         }
2961         var local87 uint16
2962         {
2963                 p := &local87
2964                 *p = read16(r)
2965         }
2966         ((*(*(struct {
2967                 Remove []AOID
2968                 Add    []struct {
2969                         ID AOID
2970                         //mt:const genericCAO
2971                         //mt:lenhdr 32
2972                         InitData AOInitData
2973                 }
2974         }))(obj)).Add) = make([]struct {
2975                 ID       AOID
2976                 InitData AOInitData
2977         }, local87)
2978         for local88 := range (*(*(struct {
2979                 Remove []AOID
2980                 Add    []struct {
2981                         ID AOID
2982                         //mt:const genericCAO
2983                         //mt:lenhdr 32
2984                         InitData AOInitData
2985                 }
2986         }))(obj)).Add {
2987                 if err := pcall(func() {
2988                         ((((*(*(struct {
2989                                 Remove []AOID
2990                                 Add    []struct {
2991                                         ID AOID
2992                                         //mt:const genericCAO
2993                                         //mt:lenhdr 32
2994                                         InitData AOInitData
2995                                 }
2996                         }))(obj)).Add)[local88]).ID).deserialize(r)
2997                 }); err != nil {
2998                         if err == io.EOF {
2999                                 chk(io.EOF)
3000                         }
3001                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
3002                 }
3003                 {
3004                         var local89 aoType
3005                         if err := pcall(func() {
3006                                 (local89).deserialize(r)
3007                         }); err != nil {
3008                                 if err == io.EOF {
3009                                         chk(io.EOF)
3010                                 }
3011                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
3012                         }
3013                         if local89 != (101) {
3014                                 chk(fmt.Errorf("const %v: %v", 101, local89))
3015                         }
3016                 }
3017                 {
3018                         var n uint32
3019                         {
3020                                 p := &n
3021                                 *p = read32(r)
3022                         }
3023                         r := &io.LimitedReader{r, int64(n)}
3024                         if err := pcall(func() {
3025                                 ((((*(*(struct {
3026                                         Remove []AOID
3027                                         Add    []struct {
3028                                                 ID AOID
3029                                                 //mt:const genericCAO
3030                                                 //mt:lenhdr 32
3031                                                 InitData AOInitData
3032                                         }
3033                                 }))(obj)).Add)[local88]).InitData).deserialize(r)
3034                         }); err != nil {
3035                                 if err == io.EOF {
3036                                         chk(io.EOF)
3037                                 }
3038                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
3039                         }
3040                         if r.N > 0 {
3041                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3042                         }
3043                 }
3044         }
3045 }
3046
3047 func (obj *ToCltAOMsgs) serialize(w io.Writer) {
3048         for local90 := range (*(*(struct {
3049                 //mt:raw
3050                 Msgs []IDAOMsg
3051         }))(obj)).Msgs {
3052                 if err := pcall(func() {
3053                         (((*(*(struct {
3054                                 //mt:raw
3055                                 Msgs []IDAOMsg
3056                         }))(obj)).Msgs)[local90]).serialize(w)
3057                 }); err != nil {
3058                         if err == io.EOF {
3059                                 chk(io.EOF)
3060                         }
3061                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.IDAOMsg", err))
3062                 }
3063         }
3064 }
3065
3066 func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
3067         for {
3068                 var local91 IDAOMsg
3069                 err := pcall(func() {
3070                         if err := pcall(func() {
3071                                 (local91).deserialize(r)
3072                         }); err != nil {
3073                                 if err == io.EOF {
3074                                         chk(io.EOF)
3075                                 }
3076                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.IDAOMsg", err))
3077                         }
3078                 })
3079                 if err == io.EOF {
3080                         break
3081                 }
3082                 ((*(*(struct {
3083                         //mt:raw
3084                         Msgs []IDAOMsg
3085                 }))(obj)).Msgs) = append(((*(*(struct {
3086                         //mt:raw
3087                         Msgs []IDAOMsg
3088                 }))(obj)).Msgs), local91)
3089                 chk(err)
3090         }
3091 }
3092
3093 func (obj *ToCltHP) serialize(w io.Writer) {
3094         {
3095                 x := (*(*(struct {
3096                         HP uint16
3097                 }))(obj)).HP
3098                 write16(w, uint16(x))
3099         }
3100 }
3101
3102 func (obj *ToCltHP) deserialize(r io.Reader) {
3103         {
3104                 p := &(*(*(struct {
3105                         HP uint16
3106                 }))(obj)).HP
3107                 *p = read16(r)
3108         }
3109 }
3110
3111 func (obj *ToCltMovePlayer) serialize(w io.Writer) {
3112         if err := pcall(func() {
3113                 ((*(*(struct {
3114                         Pos
3115                         Pitch, Yaw float32
3116                 }))(obj)).Pos).serialize(w)
3117         }); err != nil {
3118                 if err == io.EOF {
3119                         chk(io.EOF)
3120                 }
3121                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3122         }
3123         {
3124                 x := (*(*(struct {
3125                         Pos
3126                         Pitch, Yaw float32
3127                 }))(obj)).Pitch
3128                 write32(w, math.Float32bits(x))
3129         }
3130         {
3131                 x := (*(*(struct {
3132                         Pos
3133                         Pitch, Yaw float32
3134                 }))(obj)).Yaw
3135                 write32(w, math.Float32bits(x))
3136         }
3137 }
3138
3139 func (obj *ToCltMovePlayer) deserialize(r io.Reader) {
3140         if err := pcall(func() {
3141                 ((*(*(struct {
3142                         Pos
3143                         Pitch, Yaw float32
3144                 }))(obj)).Pos).deserialize(r)
3145         }); err != nil {
3146                 if err == io.EOF {
3147                         chk(io.EOF)
3148                 }
3149                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3150         }
3151         {
3152                 p := &(*(*(struct {
3153                         Pos
3154                         Pitch, Yaw float32
3155                 }))(obj)).Pitch
3156                 *p = math.Float32frombits(read32(r))
3157         }
3158         {
3159                 p := &(*(*(struct {
3160                         Pos
3161                         Pitch, Yaw float32
3162                 }))(obj)).Yaw
3163                 *p = math.Float32frombits(read32(r))
3164         }
3165 }
3166
3167 func (obj *ToCltDiscoLegacy) serialize(w io.Writer) {
3168         if len((utf16.Encode([]rune((*(*(struct {
3169                 //mt:utf16
3170                 Reason string
3171         }))(obj)).Reason)))) > math.MaxUint16 {
3172                 chk(ErrTooLong)
3173         }
3174         {
3175                 x := uint16(len((utf16.Encode([]rune((*(*(struct {
3176                         //mt:utf16
3177                         Reason string
3178                 }))(obj)).Reason)))))
3179                 write16(w, uint16(x))
3180         }
3181         for local92 := range utf16.Encode([]rune((*(*(struct {
3182                 //mt:utf16
3183                 Reason string
3184         }))(obj)).Reason)) {
3185                 {
3186                         x := (utf16.Encode([]rune((*(*(struct {
3187                                 //mt:utf16
3188                                 Reason string
3189                         }))(obj)).Reason)))[local92]
3190                         write16(w, uint16(x))
3191                 }
3192         }
3193 }
3194
3195 func (obj *ToCltDiscoLegacy) deserialize(r io.Reader) {
3196         var local93 []uint16
3197         var local94 uint16
3198         {
3199                 p := &local94
3200                 *p = read16(r)
3201         }
3202         (local93) = make([]uint16, local94)
3203         for local95 := range local93 {
3204                 {
3205                         p := &(local93)[local95]
3206                         *p = read16(r)
3207                 }
3208         }
3209         (*(*(struct {
3210                 //mt:utf16
3211                 Reason string
3212         }))(obj)).Reason = string(utf16.Decode(local93))
3213 }
3214
3215 func (obj *ToCltFOV) serialize(w io.Writer) {
3216         {
3217                 x := (*(*(struct {
3218                         FOV            float32
3219                         Multiplier     bool
3220                         TransitionTime float32
3221                 }))(obj)).FOV
3222                 write32(w, math.Float32bits(x))
3223         }
3224         {
3225                 x := (*(*(struct {
3226                         FOV            float32
3227                         Multiplier     bool
3228                         TransitionTime float32
3229                 }))(obj)).Multiplier
3230                 if x {
3231                         write8(w, 1)
3232                 } else {
3233                         write8(w, 0)
3234                 }
3235         }
3236         {
3237                 x := (*(*(struct {
3238                         FOV            float32
3239                         Multiplier     bool
3240                         TransitionTime float32
3241                 }))(obj)).TransitionTime
3242                 write32(w, math.Float32bits(x))
3243         }
3244 }
3245
3246 func (obj *ToCltFOV) deserialize(r io.Reader) {
3247         {
3248                 p := &(*(*(struct {
3249                         FOV            float32
3250                         Multiplier     bool
3251                         TransitionTime float32
3252                 }))(obj)).FOV
3253                 *p = math.Float32frombits(read32(r))
3254         }
3255         {
3256                 p := &(*(*(struct {
3257                         FOV            float32
3258                         Multiplier     bool
3259                         TransitionTime float32
3260                 }))(obj)).Multiplier
3261                 switch n := read8(r); n {
3262                 case 0:
3263                         *p = false
3264                 case 1:
3265                         *p = true
3266                 default:
3267                         chk(fmt.Errorf("invalid bool: %d", n))
3268                 }
3269         }
3270         {
3271                 p := &(*(*(struct {
3272                         FOV            float32
3273                         Multiplier     bool
3274                         TransitionTime float32
3275                 }))(obj)).TransitionTime
3276                 *p = math.Float32frombits(read32(r))
3277         }
3278 }
3279
3280 func (obj *ToCltDeathScreen) serialize(w io.Writer) {
3281         {
3282                 x := (*(*(struct {
3283                         PointCam bool
3284                         PointAt  Pos
3285                 }))(obj)).PointCam
3286                 if x {
3287                         write8(w, 1)
3288                 } else {
3289                         write8(w, 0)
3290                 }
3291         }
3292         if err := pcall(func() {
3293                 ((*(*(struct {
3294                         PointCam bool
3295                         PointAt  Pos
3296                 }))(obj)).PointAt).serialize(w)
3297         }); err != nil {
3298                 if err == io.EOF {
3299                         chk(io.EOF)
3300                 }
3301                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3302         }
3303 }
3304
3305 func (obj *ToCltDeathScreen) deserialize(r io.Reader) {
3306         {
3307                 p := &(*(*(struct {
3308                         PointCam bool
3309                         PointAt  Pos
3310                 }))(obj)).PointCam
3311                 switch n := read8(r); n {
3312                 case 0:
3313                         *p = false
3314                 case 1:
3315                         *p = true
3316                 default:
3317                         chk(fmt.Errorf("invalid bool: %d", n))
3318                 }
3319         }
3320         if err := pcall(func() {
3321                 ((*(*(struct {
3322                         PointCam bool
3323                         PointAt  Pos
3324                 }))(obj)).PointAt).deserialize(r)
3325         }); err != nil {
3326                 if err == io.EOF {
3327                         chk(io.EOF)
3328                 }
3329                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3330         }
3331 }
3332
3333 func (obj *ToCltMedia) serialize(w io.Writer) {
3334         {
3335                 x := (*(*(struct {
3336                         // N is the total number of ToCltMedia packets.
3337                         // I is the index of this packet.
3338                         N, I uint16
3339
3340                         //mt:len32
3341                         Files []struct {
3342                                 Name string
3343
3344                                 //mt:len32
3345                                 Data []byte
3346                         }
3347                 }))(obj)).N
3348                 write16(w, uint16(x))
3349         }
3350         {
3351                 x := (*(*(struct {
3352                         // N is the total number of ToCltMedia packets.
3353                         // I is the index of this packet.
3354                         N, I uint16
3355
3356                         //mt:len32
3357                         Files []struct {
3358                                 Name string
3359
3360                                 //mt:len32
3361                                 Data []byte
3362                         }
3363                 }))(obj)).I
3364                 write16(w, uint16(x))
3365         }
3366         if len(((*(*(struct {
3367                 // N is the total number of ToCltMedia packets.
3368                 // I is the index of this packet.
3369                 N, I uint16
3370
3371                 //mt:len32
3372                 Files []struct {
3373                         Name string
3374
3375                         //mt:len32
3376                         Data []byte
3377                 }
3378         }))(obj)).Files)) > math.MaxUint32 {
3379                 chk(ErrTooLong)
3380         }
3381         {
3382                 x := uint32(len(((*(*(struct {
3383                         // N is the total number of ToCltMedia packets.
3384                         // I is the index of this packet.
3385                         N, I uint16
3386
3387                         //mt:len32
3388                         Files []struct {
3389                                 Name string
3390
3391                                 //mt:len32
3392                                 Data []byte
3393                         }
3394                 }))(obj)).Files)))
3395                 write32(w, uint32(x))
3396         }
3397         for local96 := range (*(*(struct {
3398                 // N is the total number of ToCltMedia packets.
3399                 // I is the index of this packet.
3400                 N, I uint16
3401
3402                 //mt:len32
3403                 Files []struct {
3404                         Name string
3405
3406                         //mt:len32
3407                         Data []byte
3408                 }
3409         }))(obj)).Files {
3410                 if len(([]byte((((*(*(struct {
3411                         // N is the total number of ToCltMedia packets.
3412                         // I is the index of this packet.
3413                         N, I uint16
3414
3415                         //mt:len32
3416                         Files []struct {
3417                                 Name string
3418
3419                                 //mt:len32
3420                                 Data []byte
3421                         }
3422                 }))(obj)).Files)[local96]).Name))) > math.MaxUint16 {
3423                         chk(ErrTooLong)
3424                 }
3425                 {
3426                         x := uint16(len(([]byte((((*(*(struct {
3427                                 // N is the total number of ToCltMedia packets.
3428                                 // I is the index of this packet.
3429                                 N, I uint16
3430
3431                                 //mt:len32
3432                                 Files []struct {
3433                                         Name string
3434
3435                                         //mt:len32
3436                                         Data []byte
3437                                 }
3438                         }))(obj)).Files)[local96]).Name))))
3439                         write16(w, uint16(x))
3440                 }
3441                 {
3442                         _, err := w.Write(([]byte((((*(*(struct {
3443                                 // N is the total number of ToCltMedia packets.
3444                                 // I is the index of this packet.
3445                                 N, I uint16
3446
3447                                 //mt:len32
3448                                 Files []struct {
3449                                         Name string
3450
3451                                         //mt:len32
3452                                         Data []byte
3453                                 }
3454                         }))(obj)).Files)[local96]).Name))[:])
3455                         chk(err)
3456                 }
3457                 if len(((((*(*(struct {
3458                         // N is the total number of ToCltMedia packets.
3459                         // I is the index of this packet.
3460                         N, I uint16
3461
3462                         //mt:len32
3463                         Files []struct {
3464                                 Name string
3465
3466                                 //mt:len32
3467                                 Data []byte
3468                         }
3469                 }))(obj)).Files)[local96]).Data)) > math.MaxUint32 {
3470                         chk(ErrTooLong)
3471                 }
3472                 {
3473                         x := uint32(len(((((*(*(struct {
3474                                 // N is the total number of ToCltMedia packets.
3475                                 // I is the index of this packet.
3476                                 N, I uint16
3477
3478                                 //mt:len32
3479                                 Files []struct {
3480                                         Name string
3481
3482                                         //mt:len32
3483                                         Data []byte
3484                                 }
3485                         }))(obj)).Files)[local96]).Data)))
3486                         write32(w, uint32(x))
3487                 }
3488                 {
3489                         _, err := w.Write(((((*(*(struct {
3490                                 // N is the total number of ToCltMedia packets.
3491                                 // I is the index of this packet.
3492                                 N, I uint16
3493
3494                                 //mt:len32
3495                                 Files []struct {
3496                                         Name string
3497
3498                                         //mt:len32
3499                                         Data []byte
3500                                 }
3501                         }))(obj)).Files)[local96]).Data)[:])
3502                         chk(err)
3503                 }
3504         }
3505 }
3506
3507 func (obj *ToCltMedia) deserialize(r io.Reader) {
3508         {
3509                 p := &(*(*(struct {
3510                         // N is the total number of ToCltMedia packets.
3511                         // I is the index of this packet.
3512                         N, I uint16
3513
3514                         //mt:len32
3515                         Files []struct {
3516                                 Name string
3517
3518                                 //mt:len32
3519                                 Data []byte
3520                         }
3521                 }))(obj)).N
3522                 *p = read16(r)
3523         }
3524         {
3525                 p := &(*(*(struct {
3526                         // N is the total number of ToCltMedia packets.
3527                         // I is the index of this packet.
3528                         N, I uint16
3529
3530                         //mt:len32
3531                         Files []struct {
3532                                 Name string
3533
3534                                 //mt:len32
3535                                 Data []byte
3536                         }
3537                 }))(obj)).I
3538                 *p = read16(r)
3539         }
3540         var local97 uint32
3541         {
3542                 p := &local97
3543                 *p = read32(r)
3544         }
3545         ((*(*(struct {
3546                 // N is the total number of ToCltMedia packets.
3547                 // I is the index of this packet.
3548                 N, I uint16
3549
3550                 //mt:len32
3551                 Files []struct {
3552                         Name string
3553
3554                         //mt:len32
3555                         Data []byte
3556                 }
3557         }))(obj)).Files) = make([]struct {
3558                 Name string
3559                 Data []byte
3560         }, local97)
3561         for local98 := range (*(*(struct {
3562                 // N is the total number of ToCltMedia packets.
3563                 // I is the index of this packet.
3564                 N, I uint16
3565
3566                 //mt:len32
3567                 Files []struct {
3568                         Name string
3569
3570                         //mt:len32
3571                         Data []byte
3572                 }
3573         }))(obj)).Files {
3574                 var local99 []uint8
3575                 var local100 uint16
3576                 {
3577                         p := &local100
3578                         *p = read16(r)
3579                 }
3580                 (local99) = make([]uint8, local100)
3581                 {
3582                         _, err := io.ReadFull(r, (local99)[:])
3583                         chk(err)
3584                 }
3585                 ((((*(*(struct {
3586                         // N is the total number of ToCltMedia packets.
3587                         // I is the index of this packet.
3588                         N, I uint16
3589
3590                         //mt:len32
3591                         Files []struct {
3592                                 Name string
3593
3594                                 //mt:len32
3595                                 Data []byte
3596                         }
3597                 }))(obj)).Files)[local98]).Name) = string(local99)
3598                 var local101 uint32
3599                 {
3600                         p := &local101
3601                         *p = read32(r)
3602                 }
3603                 ((((*(*(struct {
3604                         // N is the total number of ToCltMedia packets.
3605                         // I is the index of this packet.
3606                         N, I uint16
3607
3608                         //mt:len32
3609                         Files []struct {
3610                                 Name string
3611
3612                                 //mt:len32
3613                                 Data []byte
3614                         }
3615                 }))(obj)).Files)[local98]).Data) = make([]byte, local101)
3616                 {
3617                         _, err := io.ReadFull(r, ((((*(*(struct {
3618                                 // N is the total number of ToCltMedia packets.
3619                                 // I is the index of this packet.
3620                                 N, I uint16
3621
3622                                 //mt:len32
3623                                 Files []struct {
3624                                         Name string
3625
3626                                         //mt:len32
3627                                         Data []byte
3628                                 }
3629                         }))(obj)).Files)[local98]).Data)[:])
3630                         chk(err)
3631                 }
3632         }
3633 }
3634
3635 func (obj *ToCltNodeDefs) serialize(w io.Writer) {
3636         {
3637                 ow := w
3638                 w := new(bytes.Buffer)
3639                 {
3640                         w := zlib.NewWriter(w)
3641                         {
3642                                 local102 := uint8(1)
3643                                 {
3644                                         x := local102
3645                                         write8(w, uint8(x))
3646                                 }
3647                         }
3648                         {
3649                                 x := (*(*(struct {
3650
3651                                         // See (de)serialize.fmt.
3652                                         Defs []NodeDef
3653                                 }))(obj)).Defs
3654                                 { // For ToCltNodeDefs.Defs.
3655                                         if len(x) > math.MaxUint16 {
3656                                                 chk(ErrTooLong)
3657                                         }
3658                                         write16(w, uint16(len(x)))
3659                                         var b bytes.Buffer
3660                                         for i := range x {
3661                                                 x[i].serialize(&b)
3662                                         }
3663                                         if b.Len() > math.MaxUint32 {
3664                                                 chk(ErrTooLong)
3665                                         }
3666                                         write32(w, uint32(b.Len()))
3667                                         _, err := b.WriteTo(w)
3668                                         chk(err)
3669                                 }
3670                         }
3671                         chk(w.Close())
3672                 }
3673                 {
3674                         buf := w
3675                         w := ow
3676                         if len((buf.Bytes())) > math.MaxUint32 {
3677                                 chk(ErrTooLong)
3678                         }
3679                         {
3680                                 x := uint32(len((buf.Bytes())))
3681                                 write32(w, uint32(x))
3682                         }
3683                         {
3684                                 _, err := w.Write((buf.Bytes())[:])
3685                                 chk(err)
3686                         }
3687                 }
3688         }
3689 }
3690
3691 func (obj *ToCltNodeDefs) deserialize(r io.Reader) {
3692         {
3693                 var n uint32
3694                 {
3695                         p := &n
3696                         *p = read32(r)
3697                 }
3698                 r := &io.LimitedReader{r, int64(n)}
3699                 {
3700                         r, err := zlib.NewReader(byteReader{r})
3701                         chk(err)
3702                         {
3703                                 var local103 uint8
3704                                 {
3705                                         p := &local103
3706                                         *p = read8(r)
3707                                 }
3708                                 if local103 != (1) {
3709                                         chk(fmt.Errorf("const %v: %v", 1, local103))
3710                                 }
3711                         }
3712                         {
3713                                 p := &(*(*(struct {
3714
3715                                         // See (de)serialize.fmt.
3716                                         Defs []NodeDef
3717                                 }))(obj)).Defs
3718                                 { // For ToCltNodeDefs.Defs.
3719                                         *p = make([]NodeDef, read16(r))
3720                                         r := &io.LimitedReader{r, int64(read32(r))}
3721                                         for i := range *p {
3722                                                 (*p)[i].deserialize(r)
3723                                         }
3724                                         if r.N > 0 {
3725                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3726                                         }
3727                                 }
3728                         }
3729                         chk(r.Close())
3730                 }
3731                 if r.N > 0 {
3732                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3733                 }
3734         }
3735 }
3736
3737 func (obj *ToCltAnnounceMedia) serialize(w io.Writer) {
3738         if len(((*(*(struct {
3739                 Files []struct {
3740                         Name       string
3741                         Base64SHA1 string
3742                 }
3743                 URL string
3744         }))(obj)).Files)) > math.MaxUint16 {
3745                 chk(ErrTooLong)
3746         }
3747         {
3748                 x := uint16(len(((*(*(struct {
3749                         Files []struct {
3750                                 Name       string
3751                                 Base64SHA1 string
3752                         }
3753                         URL string
3754                 }))(obj)).Files)))
3755                 write16(w, uint16(x))
3756         }
3757         for local104 := range (*(*(struct {
3758                 Files []struct {
3759                         Name       string
3760                         Base64SHA1 string
3761                 }
3762                 URL string
3763         }))(obj)).Files {
3764                 if len(([]byte((((*(*(struct {
3765                         Files []struct {
3766                                 Name       string
3767                                 Base64SHA1 string
3768                         }
3769                         URL string
3770                 }))(obj)).Files)[local104]).Name))) > math.MaxUint16 {
3771                         chk(ErrTooLong)
3772                 }
3773                 {
3774                         x := uint16(len(([]byte((((*(*(struct {
3775                                 Files []struct {
3776                                         Name       string
3777                                         Base64SHA1 string
3778                                 }
3779                                 URL string
3780                         }))(obj)).Files)[local104]).Name))))
3781                         write16(w, uint16(x))
3782                 }
3783                 {
3784                         _, err := w.Write(([]byte((((*(*(struct {
3785                                 Files []struct {
3786                                         Name       string
3787                                         Base64SHA1 string
3788                                 }
3789                                 URL string
3790                         }))(obj)).Files)[local104]).Name))[:])
3791                         chk(err)
3792                 }
3793                 if len(([]byte((((*(*(struct {
3794                         Files []struct {
3795                                 Name       string
3796                                 Base64SHA1 string
3797                         }
3798                         URL string
3799                 }))(obj)).Files)[local104]).Base64SHA1))) > math.MaxUint16 {
3800                         chk(ErrTooLong)
3801                 }
3802                 {
3803                         x := uint16(len(([]byte((((*(*(struct {
3804                                 Files []struct {
3805                                         Name       string
3806                                         Base64SHA1 string
3807                                 }
3808                                 URL string
3809                         }))(obj)).Files)[local104]).Base64SHA1))))
3810                         write16(w, uint16(x))
3811                 }
3812                 {
3813                         _, err := w.Write(([]byte((((*(*(struct {
3814                                 Files []struct {
3815                                         Name       string
3816                                         Base64SHA1 string
3817                                 }
3818                                 URL string
3819                         }))(obj)).Files)[local104]).Base64SHA1))[:])
3820                         chk(err)
3821                 }
3822         }
3823         if len(([]byte((*(*(struct {
3824                 Files []struct {
3825                         Name       string
3826                         Base64SHA1 string
3827                 }
3828                 URL string
3829         }))(obj)).URL))) > math.MaxUint16 {
3830                 chk(ErrTooLong)
3831         }
3832         {
3833                 x := uint16(len(([]byte((*(*(struct {
3834                         Files []struct {
3835                                 Name       string
3836                                 Base64SHA1 string
3837                         }
3838                         URL string
3839                 }))(obj)).URL))))
3840                 write16(w, uint16(x))
3841         }
3842         {
3843                 _, err := w.Write(([]byte((*(*(struct {
3844                         Files []struct {
3845                                 Name       string
3846                                 Base64SHA1 string
3847                         }
3848                         URL string
3849                 }))(obj)).URL))[:])
3850                 chk(err)
3851         }
3852 }
3853
3854 func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
3855         var local105 uint16
3856         {
3857                 p := &local105
3858                 *p = read16(r)
3859         }
3860         ((*(*(struct {
3861                 Files []struct {
3862                         Name       string
3863                         Base64SHA1 string
3864                 }
3865                 URL string
3866         }))(obj)).Files) = make([]struct {
3867                 Name       string
3868                 Base64SHA1 string
3869         }, local105)
3870         for local106 := range (*(*(struct {
3871                 Files []struct {
3872                         Name       string
3873                         Base64SHA1 string
3874                 }
3875                 URL string
3876         }))(obj)).Files {
3877                 var local107 []uint8
3878                 var local108 uint16
3879                 {
3880                         p := &local108
3881                         *p = read16(r)
3882                 }
3883                 (local107) = make([]uint8, local108)
3884                 {
3885                         _, err := io.ReadFull(r, (local107)[:])
3886                         chk(err)
3887                 }
3888                 ((((*(*(struct {
3889                         Files []struct {
3890                                 Name       string
3891                                 Base64SHA1 string
3892                         }
3893                         URL string
3894                 }))(obj)).Files)[local106]).Name) = string(local107)
3895                 var local109 []uint8
3896                 var local110 uint16
3897                 {
3898                         p := &local110
3899                         *p = read16(r)
3900                 }
3901                 (local109) = make([]uint8, local110)
3902                 {
3903                         _, err := io.ReadFull(r, (local109)[:])
3904                         chk(err)
3905                 }
3906                 ((((*(*(struct {
3907                         Files []struct {
3908                                 Name       string
3909                                 Base64SHA1 string
3910                         }
3911                         URL string
3912                 }))(obj)).Files)[local106]).Base64SHA1) = string(local109)
3913         }
3914         var local111 []uint8
3915         var local112 uint16
3916         {
3917                 p := &local112
3918                 *p = read16(r)
3919         }
3920         (local111) = make([]uint8, local112)
3921         {
3922                 _, err := io.ReadFull(r, (local111)[:])
3923                 chk(err)
3924         }
3925         ((*(*(struct {
3926                 Files []struct {
3927                         Name       string
3928                         Base64SHA1 string
3929                 }
3930                 URL string
3931         }))(obj)).URL) = string(local111)
3932 }
3933
3934 func (obj *ToCltItemDefs) serialize(w io.Writer) {
3935         {
3936                 ow := w
3937                 w := new(bytes.Buffer)
3938                 {
3939                         w := zlib.NewWriter(w)
3940                         {
3941                                 local113 := uint8(0)
3942                                 {
3943                                         x := local113
3944                                         write8(w, uint8(x))
3945                                 }
3946                         }
3947                         if len(((*(*(struct {
3948                                 Defs    []ItemDef
3949                                 Aliases []struct{ Alias, Orig string }
3950                         }))(obj)).Defs)) > math.MaxUint16 {
3951                                 chk(ErrTooLong)
3952                         }
3953                         {
3954                                 x := uint16(len(((*(*(struct {
3955                                         Defs    []ItemDef
3956                                         Aliases []struct{ Alias, Orig string }
3957                                 }))(obj)).Defs)))
3958                                 write16(w, uint16(x))
3959                         }
3960                         for local114 := range (*(*(struct {
3961                                 Defs    []ItemDef
3962                                 Aliases []struct{ Alias, Orig string }
3963                         }))(obj)).Defs {
3964                                 if err := pcall(func() {
3965                                         (((*(*(struct {
3966                                                 Defs    []ItemDef
3967                                                 Aliases []struct{ Alias, Orig string }
3968                                         }))(obj)).Defs)[local114]).serialize(w)
3969                                 }); err != nil {
3970                                         if err == io.EOF {
3971                                                 chk(io.EOF)
3972                                         }
3973                                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
3974                                 }
3975                         }
3976                         if len(((*(*(struct {
3977                                 Defs    []ItemDef
3978                                 Aliases []struct{ Alias, Orig string }
3979                         }))(obj)).Aliases)) > math.MaxUint16 {
3980                                 chk(ErrTooLong)
3981                         }
3982                         {
3983                                 x := uint16(len(((*(*(struct {
3984                                         Defs    []ItemDef
3985                                         Aliases []struct{ Alias, Orig string }
3986                                 }))(obj)).Aliases)))
3987                                 write16(w, uint16(x))
3988                         }
3989                         for local115 := range (*(*(struct {
3990                                 Defs    []ItemDef
3991                                 Aliases []struct{ Alias, Orig string }
3992                         }))(obj)).Aliases {
3993                                 if len(([]byte((((*(*(struct {
3994                                         Defs    []ItemDef
3995                                         Aliases []struct{ Alias, Orig string }
3996                                 }))(obj)).Aliases)[local115]).Alias))) > math.MaxUint16 {
3997                                         chk(ErrTooLong)
3998                                 }
3999                                 {
4000                                         x := uint16(len(([]byte((((*(*(struct {
4001                                                 Defs    []ItemDef
4002                                                 Aliases []struct{ Alias, Orig string }
4003                                         }))(obj)).Aliases)[local115]).Alias))))
4004                                         write16(w, uint16(x))
4005                                 }
4006                                 {
4007                                         _, err := w.Write(([]byte((((*(*(struct {
4008                                                 Defs    []ItemDef
4009                                                 Aliases []struct{ Alias, Orig string }
4010                                         }))(obj)).Aliases)[local115]).Alias))[:])
4011                                         chk(err)
4012                                 }
4013                                 if len(([]byte((((*(*(struct {
4014                                         Defs    []ItemDef
4015                                         Aliases []struct{ Alias, Orig string }
4016                                 }))(obj)).Aliases)[local115]).Orig))) > math.MaxUint16 {
4017                                         chk(ErrTooLong)
4018                                 }
4019                                 {
4020                                         x := uint16(len(([]byte((((*(*(struct {
4021                                                 Defs    []ItemDef
4022                                                 Aliases []struct{ Alias, Orig string }
4023                                         }))(obj)).Aliases)[local115]).Orig))))
4024                                         write16(w, uint16(x))
4025                                 }
4026                                 {
4027                                         _, err := w.Write(([]byte((((*(*(struct {
4028                                                 Defs    []ItemDef
4029                                                 Aliases []struct{ Alias, Orig string }
4030                                         }))(obj)).Aliases)[local115]).Orig))[:])
4031                                         chk(err)
4032                                 }
4033                         }
4034                         chk(w.Close())
4035                 }
4036                 {
4037                         buf := w
4038                         w := ow
4039                         if len((buf.Bytes())) > math.MaxUint32 {
4040                                 chk(ErrTooLong)
4041                         }
4042                         {
4043                                 x := uint32(len((buf.Bytes())))
4044                                 write32(w, uint32(x))
4045                         }
4046                         {
4047                                 _, err := w.Write((buf.Bytes())[:])
4048                                 chk(err)
4049                         }
4050                 }
4051         }
4052 }
4053
4054 func (obj *ToCltItemDefs) deserialize(r io.Reader) {
4055         {
4056                 var n uint32
4057                 {
4058                         p := &n
4059                         *p = read32(r)
4060                 }
4061                 r := &io.LimitedReader{r, int64(n)}
4062                 {
4063                         r, err := zlib.NewReader(byteReader{r})
4064                         chk(err)
4065                         {
4066                                 var local116 uint8
4067                                 {
4068                                         p := &local116
4069                                         *p = read8(r)
4070                                 }
4071                                 if local116 != (0) {
4072                                         chk(fmt.Errorf("const %v: %v", 0, local116))
4073                                 }
4074                         }
4075                         var local117 uint16
4076                         {
4077                                 p := &local117
4078                                 *p = read16(r)
4079                         }
4080                         ((*(*(struct {
4081                                 Defs    []ItemDef
4082                                 Aliases []struct{ Alias, Orig string }
4083                         }))(obj)).Defs) = make([]ItemDef, local117)
4084                         for local118 := range (*(*(struct {
4085                                 Defs    []ItemDef
4086                                 Aliases []struct{ Alias, Orig string }
4087                         }))(obj)).Defs {
4088                                 if err := pcall(func() {
4089                                         (((*(*(struct {
4090                                                 Defs    []ItemDef
4091                                                 Aliases []struct{ Alias, Orig string }
4092                                         }))(obj)).Defs)[local118]).deserialize(r)
4093                                 }); err != nil {
4094                                         if err == io.EOF {
4095                                                 chk(io.EOF)
4096                                         }
4097                                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
4098                                 }
4099                         }
4100                         var local119 uint16
4101                         {
4102                                 p := &local119
4103                                 *p = read16(r)
4104                         }
4105                         ((*(*(struct {
4106                                 Defs    []ItemDef
4107                                 Aliases []struct{ Alias, Orig string }
4108                         }))(obj)).Aliases) = make([]struct {
4109                                 Alias string
4110                                 Orig  string
4111                         }, local119)
4112                         for local120 := range (*(*(struct {
4113                                 Defs    []ItemDef
4114                                 Aliases []struct{ Alias, Orig string }
4115                         }))(obj)).Aliases {
4116                                 var local121 []uint8
4117                                 var local122 uint16
4118                                 {
4119                                         p := &local122
4120                                         *p = read16(r)
4121                                 }
4122                                 (local121) = make([]uint8, local122)
4123                                 {
4124                                         _, err := io.ReadFull(r, (local121)[:])
4125                                         chk(err)
4126                                 }
4127                                 ((((*(*(struct {
4128                                         Defs    []ItemDef
4129                                         Aliases []struct{ Alias, Orig string }
4130                                 }))(obj)).Aliases)[local120]).Alias) = string(local121)
4131                                 var local123 []uint8
4132                                 var local124 uint16
4133                                 {
4134                                         p := &local124
4135                                         *p = read16(r)
4136                                 }
4137                                 (local123) = make([]uint8, local124)
4138                                 {
4139                                         _, err := io.ReadFull(r, (local123)[:])
4140                                         chk(err)
4141                                 }
4142                                 ((((*(*(struct {
4143                                         Defs    []ItemDef
4144                                         Aliases []struct{ Alias, Orig string }
4145                                 }))(obj)).Aliases)[local120]).Orig) = string(local123)
4146                         }
4147                         chk(r.Close())
4148                 }
4149                 if r.N > 0 {
4150                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
4151                 }
4152         }
4153 }
4154
4155 func (obj *ToCltPlaySound) serialize(w io.Writer) {
4156         if err := pcall(func() {
4157                 ((*(*(struct {
4158                         ID      SoundID
4159                         Name    string
4160                         Gain    float32
4161                         SrcType SoundSrcType
4162                         Pos
4163                         SrcAOID   AOID
4164                         Loop      bool
4165                         Fade      float32
4166                         Pitch     float32
4167                         Ephemeral bool
4168                 }))(obj)).ID).serialize(w)
4169         }); err != nil {
4170                 if err == io.EOF {
4171                         chk(io.EOF)
4172                 }
4173                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4174         }
4175         if len(([]byte((*(*(struct {
4176                 ID      SoundID
4177                 Name    string
4178                 Gain    float32
4179                 SrcType SoundSrcType
4180                 Pos
4181                 SrcAOID   AOID
4182                 Loop      bool
4183                 Fade      float32
4184                 Pitch     float32
4185                 Ephemeral bool
4186         }))(obj)).Name))) > math.MaxUint16 {
4187                 chk(ErrTooLong)
4188         }
4189         {
4190                 x := uint16(len(([]byte((*(*(struct {
4191                         ID      SoundID
4192                         Name    string
4193                         Gain    float32
4194                         SrcType SoundSrcType
4195                         Pos
4196                         SrcAOID   AOID
4197                         Loop      bool
4198                         Fade      float32
4199                         Pitch     float32
4200                         Ephemeral bool
4201                 }))(obj)).Name))))
4202                 write16(w, uint16(x))
4203         }
4204         {
4205                 _, err := w.Write(([]byte((*(*(struct {
4206                         ID      SoundID
4207                         Name    string
4208                         Gain    float32
4209                         SrcType SoundSrcType
4210                         Pos
4211                         SrcAOID   AOID
4212                         Loop      bool
4213                         Fade      float32
4214                         Pitch     float32
4215                         Ephemeral bool
4216                 }))(obj)).Name))[:])
4217                 chk(err)
4218         }
4219         {
4220                 x := (*(*(struct {
4221                         ID      SoundID
4222                         Name    string
4223                         Gain    float32
4224                         SrcType SoundSrcType
4225                         Pos
4226                         SrcAOID   AOID
4227                         Loop      bool
4228                         Fade      float32
4229                         Pitch     float32
4230                         Ephemeral bool
4231                 }))(obj)).Gain
4232                 write32(w, math.Float32bits(x))
4233         }
4234         if err := pcall(func() {
4235                 ((*(*(struct {
4236                         ID      SoundID
4237                         Name    string
4238                         Gain    float32
4239                         SrcType SoundSrcType
4240                         Pos
4241                         SrcAOID   AOID
4242                         Loop      bool
4243                         Fade      float32
4244                         Pitch     float32
4245                         Ephemeral bool
4246                 }))(obj)).SrcType).serialize(w)
4247         }); err != nil {
4248                 if err == io.EOF {
4249                         chk(io.EOF)
4250                 }
4251                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundSrcType", err))
4252         }
4253         if err := pcall(func() {
4254                 ((*(*(struct {
4255                         ID      SoundID
4256                         Name    string
4257                         Gain    float32
4258                         SrcType SoundSrcType
4259                         Pos
4260                         SrcAOID   AOID
4261                         Loop      bool
4262                         Fade      float32
4263                         Pitch     float32
4264                         Ephemeral bool
4265                 }))(obj)).Pos).serialize(w)
4266         }); err != nil {
4267                 if err == io.EOF {
4268                         chk(io.EOF)
4269                 }
4270                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
4271         }
4272         if err := pcall(func() {
4273                 ((*(*(struct {
4274                         ID      SoundID
4275                         Name    string
4276                         Gain    float32
4277                         SrcType SoundSrcType
4278                         Pos
4279                         SrcAOID   AOID
4280                         Loop      bool
4281                         Fade      float32
4282                         Pitch     float32
4283                         Ephemeral bool
4284                 }))(obj)).SrcAOID).serialize(w)
4285         }); err != nil {
4286                 if err == io.EOF {
4287                         chk(io.EOF)
4288                 }
4289                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
4290         }
4291         {
4292                 x := (*(*(struct {
4293                         ID      SoundID
4294                         Name    string
4295                         Gain    float32
4296                         SrcType SoundSrcType
4297                         Pos
4298                         SrcAOID   AOID
4299                         Loop      bool
4300                         Fade      float32
4301                         Pitch     float32
4302                         Ephemeral bool
4303                 }))(obj)).Loop
4304                 if x {
4305                         write8(w, 1)
4306                 } else {
4307                         write8(w, 0)
4308                 }
4309         }
4310         {
4311                 x := (*(*(struct {
4312                         ID      SoundID
4313                         Name    string
4314                         Gain    float32
4315                         SrcType SoundSrcType
4316                         Pos
4317                         SrcAOID   AOID
4318                         Loop      bool
4319                         Fade      float32
4320                         Pitch     float32
4321                         Ephemeral bool
4322                 }))(obj)).Fade
4323                 write32(w, math.Float32bits(x))
4324         }
4325         {
4326                 x := (*(*(struct {
4327                         ID      SoundID
4328                         Name    string
4329                         Gain    float32
4330                         SrcType SoundSrcType
4331                         Pos
4332                         SrcAOID   AOID
4333                         Loop      bool
4334                         Fade      float32
4335                         Pitch     float32
4336                         Ephemeral bool
4337                 }))(obj)).Pitch
4338                 write32(w, math.Float32bits(x))
4339         }
4340         {
4341                 x := (*(*(struct {
4342                         ID      SoundID
4343                         Name    string
4344                         Gain    float32
4345                         SrcType SoundSrcType
4346                         Pos
4347                         SrcAOID   AOID
4348                         Loop      bool
4349                         Fade      float32
4350                         Pitch     float32
4351                         Ephemeral bool
4352                 }))(obj)).Ephemeral
4353                 if x {
4354                         write8(w, 1)
4355                 } else {
4356                         write8(w, 0)
4357                 }
4358         }
4359 }
4360
4361 func (obj *ToCltPlaySound) deserialize(r io.Reader) {
4362         if err := pcall(func() {
4363                 ((*(*(struct {
4364                         ID      SoundID
4365                         Name    string
4366                         Gain    float32
4367                         SrcType SoundSrcType
4368                         Pos
4369                         SrcAOID   AOID
4370                         Loop      bool
4371                         Fade      float32
4372                         Pitch     float32
4373                         Ephemeral bool
4374                 }))(obj)).ID).deserialize(r)
4375         }); err != nil {
4376                 if err == io.EOF {
4377                         chk(io.EOF)
4378                 }
4379                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4380         }
4381         var local125 []uint8
4382         var local126 uint16
4383         {
4384                 p := &local126
4385                 *p = read16(r)
4386         }
4387         (local125) = make([]uint8, local126)
4388         {
4389                 _, err := io.ReadFull(r, (local125)[:])
4390                 chk(err)
4391         }
4392         ((*(*(struct {
4393                 ID      SoundID
4394                 Name    string
4395                 Gain    float32
4396                 SrcType SoundSrcType
4397                 Pos
4398                 SrcAOID   AOID
4399                 Loop      bool
4400                 Fade      float32
4401                 Pitch     float32
4402                 Ephemeral bool
4403         }))(obj)).Name) = string(local125)
4404         {
4405                 p := &(*(*(struct {
4406                         ID      SoundID
4407                         Name    string
4408                         Gain    float32
4409                         SrcType SoundSrcType
4410                         Pos
4411                         SrcAOID   AOID
4412                         Loop      bool
4413                         Fade      float32
4414                         Pitch     float32
4415                         Ephemeral bool
4416                 }))(obj)).Gain
4417                 *p = math.Float32frombits(read32(r))
4418         }
4419         if err := pcall(func() {
4420                 ((*(*(struct {
4421                         ID      SoundID
4422                         Name    string
4423                         Gain    float32
4424                         SrcType SoundSrcType
4425                         Pos
4426                         SrcAOID   AOID
4427                         Loop      bool
4428                         Fade      float32
4429                         Pitch     float32
4430                         Ephemeral bool
4431                 }))(obj)).SrcType).deserialize(r)
4432         }); err != nil {
4433                 if err == io.EOF {
4434                         chk(io.EOF)
4435                 }
4436                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundSrcType", err))
4437         }
4438         if err := pcall(func() {
4439                 ((*(*(struct {
4440                         ID      SoundID
4441                         Name    string
4442                         Gain    float32
4443                         SrcType SoundSrcType
4444                         Pos
4445                         SrcAOID   AOID
4446                         Loop      bool
4447                         Fade      float32
4448                         Pitch     float32
4449                         Ephemeral bool
4450                 }))(obj)).Pos).deserialize(r)
4451         }); err != nil {
4452                 if err == io.EOF {
4453                         chk(io.EOF)
4454                 }
4455                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
4456         }
4457         if err := pcall(func() {
4458                 ((*(*(struct {
4459                         ID      SoundID
4460                         Name    string
4461                         Gain    float32
4462                         SrcType SoundSrcType
4463                         Pos
4464                         SrcAOID   AOID
4465                         Loop      bool
4466                         Fade      float32
4467                         Pitch     float32
4468                         Ephemeral bool
4469                 }))(obj)).SrcAOID).deserialize(r)
4470         }); err != nil {
4471                 if err == io.EOF {
4472                         chk(io.EOF)
4473                 }
4474                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
4475         }
4476         {
4477                 p := &(*(*(struct {
4478                         ID      SoundID
4479                         Name    string
4480                         Gain    float32
4481                         SrcType SoundSrcType
4482                         Pos
4483                         SrcAOID   AOID
4484                         Loop      bool
4485                         Fade      float32
4486                         Pitch     float32
4487                         Ephemeral bool
4488                 }))(obj)).Loop
4489                 switch n := read8(r); n {
4490                 case 0:
4491                         *p = false
4492                 case 1:
4493                         *p = true
4494                 default:
4495                         chk(fmt.Errorf("invalid bool: %d", n))
4496                 }
4497         }
4498         {
4499                 p := &(*(*(struct {
4500                         ID      SoundID
4501                         Name    string
4502                         Gain    float32
4503                         SrcType SoundSrcType
4504                         Pos
4505                         SrcAOID   AOID
4506                         Loop      bool
4507                         Fade      float32
4508                         Pitch     float32
4509                         Ephemeral bool
4510                 }))(obj)).Fade
4511                 *p = math.Float32frombits(read32(r))
4512         }
4513         {
4514                 p := &(*(*(struct {
4515                         ID      SoundID
4516                         Name    string
4517                         Gain    float32
4518                         SrcType SoundSrcType
4519                         Pos
4520                         SrcAOID   AOID
4521                         Loop      bool
4522                         Fade      float32
4523                         Pitch     float32
4524                         Ephemeral bool
4525                 }))(obj)).Pitch
4526                 *p = math.Float32frombits(read32(r))
4527         }
4528         {
4529                 p := &(*(*(struct {
4530                         ID      SoundID
4531                         Name    string
4532                         Gain    float32
4533                         SrcType SoundSrcType
4534                         Pos
4535                         SrcAOID   AOID
4536                         Loop      bool
4537                         Fade      float32
4538                         Pitch     float32
4539                         Ephemeral bool
4540                 }))(obj)).Ephemeral
4541                 switch n := read8(r); n {
4542                 case 0:
4543                         *p = false
4544                 case 1:
4545                         *p = true
4546                 default:
4547                         chk(fmt.Errorf("invalid bool: %d", n))
4548                 }
4549         }
4550 }
4551
4552 func (obj *ToCltStopSound) serialize(w io.Writer) {
4553         if err := pcall(func() {
4554                 ((*(*(struct {
4555                         ID SoundID
4556                 }))(obj)).ID).serialize(w)
4557         }); err != nil {
4558                 if err == io.EOF {
4559                         chk(io.EOF)
4560                 }
4561                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4562         }
4563 }
4564
4565 func (obj *ToCltStopSound) deserialize(r io.Reader) {
4566         if err := pcall(func() {
4567                 ((*(*(struct {
4568                         ID SoundID
4569                 }))(obj)).ID).deserialize(r)
4570         }); err != nil {
4571                 if err == io.EOF {
4572                         chk(io.EOF)
4573                 }
4574                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4575         }
4576 }
4577
4578 func (obj *ToCltPrivs) serialize(w io.Writer) {
4579         if len(((*(*(struct {
4580                 Privs []string
4581         }))(obj)).Privs)) > math.MaxUint16 {
4582                 chk(ErrTooLong)
4583         }
4584         {
4585                 x := uint16(len(((*(*(struct {
4586                         Privs []string
4587                 }))(obj)).Privs)))
4588                 write16(w, uint16(x))
4589         }
4590         for local127 := range (*(*(struct {
4591                 Privs []string
4592         }))(obj)).Privs {
4593                 if len(([]byte(((*(*(struct {
4594                         Privs []string
4595                 }))(obj)).Privs)[local127]))) > math.MaxUint16 {
4596                         chk(ErrTooLong)
4597                 }
4598                 {
4599                         x := uint16(len(([]byte(((*(*(struct {
4600                                 Privs []string
4601                         }))(obj)).Privs)[local127]))))
4602                         write16(w, uint16(x))
4603                 }
4604                 {
4605                         _, err := w.Write(([]byte(((*(*(struct {
4606                                 Privs []string
4607                         }))(obj)).Privs)[local127]))[:])
4608                         chk(err)
4609                 }
4610         }
4611 }
4612
4613 func (obj *ToCltPrivs) deserialize(r io.Reader) {
4614         var local128 uint16
4615         {
4616                 p := &local128
4617                 *p = read16(r)
4618         }
4619         ((*(*(struct {
4620                 Privs []string
4621         }))(obj)).Privs) = make([]string, local128)
4622         for local129 := range (*(*(struct {
4623                 Privs []string
4624         }))(obj)).Privs {
4625                 var local130 []uint8
4626                 var local131 uint16
4627                 {
4628                         p := &local131
4629                         *p = read16(r)
4630                 }
4631                 (local130) = make([]uint8, local131)
4632                 {
4633                         _, err := io.ReadFull(r, (local130)[:])
4634                         chk(err)
4635                 }
4636                 (((*(*(struct {
4637                         Privs []string
4638                 }))(obj)).Privs)[local129]) = string(local130)
4639         }
4640 }
4641
4642 func (obj *ToCltInvFormspec) serialize(w io.Writer) {
4643         if len(([]byte((*(*(struct {
4644                 //mt:len32
4645                 Formspec string
4646         }))(obj)).Formspec))) > math.MaxUint32 {
4647                 chk(ErrTooLong)
4648         }
4649         {
4650                 x := uint32(len(([]byte((*(*(struct {
4651                         //mt:len32
4652                         Formspec string
4653                 }))(obj)).Formspec))))
4654                 write32(w, uint32(x))
4655         }
4656         {
4657                 _, err := w.Write(([]byte((*(*(struct {
4658                         //mt:len32
4659                         Formspec string
4660                 }))(obj)).Formspec))[:])
4661                 chk(err)
4662         }
4663 }
4664
4665 func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
4666         var local132 []uint8
4667         var local133 uint32
4668         {
4669                 p := &local133
4670                 *p = read32(r)
4671         }
4672         (local132) = make([]uint8, local133)
4673         {
4674                 _, err := io.ReadFull(r, (local132)[:])
4675                 chk(err)
4676         }
4677         ((*(*(struct {
4678                 //mt:len32
4679                 Formspec string
4680         }))(obj)).Formspec) = string(local132)
4681 }
4682
4683 func (obj *ToCltDetachedInv) serialize(w io.Writer) {
4684         if len(([]byte((*(*(struct {
4685                 Name string
4686                 Keep bool
4687                 Len  uint16 // deprecated
4688
4689                 //mt:raw
4690                 Inv string
4691         }))(obj)).Name))) > math.MaxUint16 {
4692                 chk(ErrTooLong)
4693         }
4694         {
4695                 x := uint16(len(([]byte((*(*(struct {
4696                         Name string
4697                         Keep bool
4698                         Len  uint16 // deprecated
4699
4700                         //mt:raw
4701                         Inv string
4702                 }))(obj)).Name))))
4703                 write16(w, uint16(x))
4704         }
4705         {
4706                 _, err := w.Write(([]byte((*(*(struct {
4707                         Name string
4708                         Keep bool
4709                         Len  uint16 // deprecated
4710
4711                         //mt:raw
4712                         Inv string
4713                 }))(obj)).Name))[:])
4714                 chk(err)
4715         }
4716         {
4717                 x := (*(*(struct {
4718                         Name string
4719                         Keep bool
4720                         Len  uint16 // deprecated
4721
4722                         //mt:raw
4723                         Inv string
4724                 }))(obj)).Keep
4725                 if x {
4726                         write8(w, 1)
4727                 } else {
4728                         write8(w, 0)
4729                 }
4730         }
4731         {
4732                 x := (*(*(struct {
4733                         Name string
4734                         Keep bool
4735                         Len  uint16 // deprecated
4736
4737                         //mt:raw
4738                         Inv string
4739                 }))(obj)).Len
4740                 write16(w, uint16(x))
4741         }
4742         {
4743                 _, err := w.Write(([]byte((*(*(struct {
4744                         Name string
4745                         Keep bool
4746                         Len  uint16 // deprecated
4747
4748                         //mt:raw
4749                         Inv string
4750                 }))(obj)).Inv))[:])
4751                 chk(err)
4752         }
4753 }
4754
4755 func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
4756         var local134 []uint8
4757         var local135 uint16
4758         {
4759                 p := &local135
4760                 *p = read16(r)
4761         }
4762         (local134) = make([]uint8, local135)
4763         {
4764                 _, err := io.ReadFull(r, (local134)[:])
4765                 chk(err)
4766         }
4767         ((*(*(struct {
4768                 Name string
4769                 Keep bool
4770                 Len  uint16 // deprecated
4771
4772                 //mt:raw
4773                 Inv string
4774         }))(obj)).Name) = string(local134)
4775         {
4776                 p := &(*(*(struct {
4777                         Name string
4778                         Keep bool
4779                         Len  uint16 // deprecated
4780
4781                         //mt:raw
4782                         Inv string
4783                 }))(obj)).Keep
4784                 switch n := read8(r); n {
4785                 case 0:
4786                         *p = false
4787                 case 1:
4788                         *p = true
4789                 default:
4790                         chk(fmt.Errorf("invalid bool: %d", n))
4791                 }
4792         }
4793         {
4794                 p := &(*(*(struct {
4795                         Name string
4796                         Keep bool
4797                         Len  uint16 // deprecated
4798
4799                         //mt:raw
4800                         Inv string
4801                 }))(obj)).Len
4802                 *p = read16(r)
4803         }
4804         var local136 []uint8
4805         for {
4806                 var local137 uint8
4807                 err := pcall(func() {
4808                         {
4809                                 p := &local137
4810                                 *p = read8(r)
4811                         }
4812                 })
4813                 if err == io.EOF {
4814                         break
4815                 }
4816                 (local136) = append((local136), local137)
4817                 chk(err)
4818         }
4819         ((*(*(struct {
4820                 Name string
4821                 Keep bool
4822                 Len  uint16 // deprecated
4823
4824                 //mt:raw
4825                 Inv string
4826         }))(obj)).Inv) = string(local136)
4827 }
4828
4829 func (obj *ToCltShowFormspec) serialize(w io.Writer) {
4830         if len(([]byte((*(*(struct {
4831                 //mt:len32
4832                 Formspec string
4833
4834                 Formname string
4835         }))(obj)).Formspec))) > math.MaxUint32 {
4836                 chk(ErrTooLong)
4837         }
4838         {
4839                 x := uint32(len(([]byte((*(*(struct {
4840                         //mt:len32
4841                         Formspec string
4842
4843                         Formname string
4844                 }))(obj)).Formspec))))
4845                 write32(w, uint32(x))
4846         }
4847         {
4848                 _, err := w.Write(([]byte((*(*(struct {
4849                         //mt:len32
4850                         Formspec string
4851
4852                         Formname string
4853                 }))(obj)).Formspec))[:])
4854                 chk(err)
4855         }
4856         if len(([]byte((*(*(struct {
4857                 //mt:len32
4858                 Formspec string
4859
4860                 Formname string
4861         }))(obj)).Formname))) > math.MaxUint16 {
4862                 chk(ErrTooLong)
4863         }
4864         {
4865                 x := uint16(len(([]byte((*(*(struct {
4866                         //mt:len32
4867                         Formspec string
4868
4869                         Formname string
4870                 }))(obj)).Formname))))
4871                 write16(w, uint16(x))
4872         }
4873         {
4874                 _, err := w.Write(([]byte((*(*(struct {
4875                         //mt:len32
4876                         Formspec string
4877
4878                         Formname string
4879                 }))(obj)).Formname))[:])
4880                 chk(err)
4881         }
4882 }
4883
4884 func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
4885         var local138 []uint8
4886         var local139 uint32
4887         {
4888                 p := &local139
4889                 *p = read32(r)
4890         }
4891         (local138) = make([]uint8, local139)
4892         {
4893                 _, err := io.ReadFull(r, (local138)[:])
4894                 chk(err)
4895         }
4896         ((*(*(struct {
4897                 //mt:len32
4898                 Formspec string
4899
4900                 Formname string
4901         }))(obj)).Formspec) = string(local138)
4902         var local140 []uint8
4903         var local141 uint16
4904         {
4905                 p := &local141
4906                 *p = read16(r)
4907         }
4908         (local140) = make([]uint8, local141)
4909         {
4910                 _, err := io.ReadFull(r, (local140)[:])
4911                 chk(err)
4912         }
4913         ((*(*(struct {
4914                 //mt:len32
4915                 Formspec string
4916
4917                 Formname string
4918         }))(obj)).Formname) = string(local140)
4919 }
4920
4921 func (obj *ToCltMovement) serialize(w io.Writer) {
4922         {
4923                 x := (*(*(struct {
4924                         DefaultAccel, AirAccel, FastAccel,
4925                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4926                         Fluidity, Smoothing, Sink,
4927                         Gravity float32
4928                 }))(obj)).DefaultAccel
4929                 write32(w, math.Float32bits(x))
4930         }
4931         {
4932                 x := (*(*(struct {
4933                         DefaultAccel, AirAccel, FastAccel,
4934                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4935                         Fluidity, Smoothing, Sink,
4936                         Gravity float32
4937                 }))(obj)).AirAccel
4938                 write32(w, math.Float32bits(x))
4939         }
4940         {
4941                 x := (*(*(struct {
4942                         DefaultAccel, AirAccel, FastAccel,
4943                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4944                         Fluidity, Smoothing, Sink,
4945                         Gravity float32
4946                 }))(obj)).FastAccel
4947                 write32(w, math.Float32bits(x))
4948         }
4949         {
4950                 x := (*(*(struct {
4951                         DefaultAccel, AirAccel, FastAccel,
4952                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4953                         Fluidity, Smoothing, Sink,
4954                         Gravity float32
4955                 }))(obj)).WalkSpeed
4956                 write32(w, math.Float32bits(x))
4957         }
4958         {
4959                 x := (*(*(struct {
4960                         DefaultAccel, AirAccel, FastAccel,
4961                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4962                         Fluidity, Smoothing, Sink,
4963                         Gravity float32
4964                 }))(obj)).CrouchSpeed
4965                 write32(w, math.Float32bits(x))
4966         }
4967         {
4968                 x := (*(*(struct {
4969                         DefaultAccel, AirAccel, FastAccel,
4970                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4971                         Fluidity, Smoothing, Sink,
4972                         Gravity float32
4973                 }))(obj)).FastSpeed
4974                 write32(w, math.Float32bits(x))
4975         }
4976         {
4977                 x := (*(*(struct {
4978                         DefaultAccel, AirAccel, FastAccel,
4979                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4980                         Fluidity, Smoothing, Sink,
4981                         Gravity float32
4982                 }))(obj)).ClimbSpeed
4983                 write32(w, math.Float32bits(x))
4984         }
4985         {
4986                 x := (*(*(struct {
4987                         DefaultAccel, AirAccel, FastAccel,
4988                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4989                         Fluidity, Smoothing, Sink,
4990                         Gravity float32
4991                 }))(obj)).JumpSpeed
4992                 write32(w, math.Float32bits(x))
4993         }
4994         {
4995                 x := (*(*(struct {
4996                         DefaultAccel, AirAccel, FastAccel,
4997                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4998                         Fluidity, Smoothing, Sink,
4999                         Gravity float32
5000                 }))(obj)).Fluidity
5001                 write32(w, math.Float32bits(x))
5002         }
5003         {
5004                 x := (*(*(struct {
5005                         DefaultAccel, AirAccel, FastAccel,
5006                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5007                         Fluidity, Smoothing, Sink,
5008                         Gravity float32
5009                 }))(obj)).Smoothing
5010                 write32(w, math.Float32bits(x))
5011         }
5012         {
5013                 x := (*(*(struct {
5014                         DefaultAccel, AirAccel, FastAccel,
5015                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5016                         Fluidity, Smoothing, Sink,
5017                         Gravity float32
5018                 }))(obj)).Sink
5019                 write32(w, math.Float32bits(x))
5020         }
5021         {
5022                 x := (*(*(struct {
5023                         DefaultAccel, AirAccel, FastAccel,
5024                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5025                         Fluidity, Smoothing, Sink,
5026                         Gravity float32
5027                 }))(obj)).Gravity
5028                 write32(w, math.Float32bits(x))
5029         }
5030 }
5031
5032 func (obj *ToCltMovement) deserialize(r io.Reader) {
5033         {
5034                 p := &(*(*(struct {
5035                         DefaultAccel, AirAccel, FastAccel,
5036                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5037                         Fluidity, Smoothing, Sink,
5038                         Gravity float32
5039                 }))(obj)).DefaultAccel
5040                 *p = math.Float32frombits(read32(r))
5041         }
5042         {
5043                 p := &(*(*(struct {
5044                         DefaultAccel, AirAccel, FastAccel,
5045                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5046                         Fluidity, Smoothing, Sink,
5047                         Gravity float32
5048                 }))(obj)).AirAccel
5049                 *p = math.Float32frombits(read32(r))
5050         }
5051         {
5052                 p := &(*(*(struct {
5053                         DefaultAccel, AirAccel, FastAccel,
5054                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5055                         Fluidity, Smoothing, Sink,
5056                         Gravity float32
5057                 }))(obj)).FastAccel
5058                 *p = math.Float32frombits(read32(r))
5059         }
5060         {
5061                 p := &(*(*(struct {
5062                         DefaultAccel, AirAccel, FastAccel,
5063                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5064                         Fluidity, Smoothing, Sink,
5065                         Gravity float32
5066                 }))(obj)).WalkSpeed
5067                 *p = math.Float32frombits(read32(r))
5068         }
5069         {
5070                 p := &(*(*(struct {
5071                         DefaultAccel, AirAccel, FastAccel,
5072                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5073                         Fluidity, Smoothing, Sink,
5074                         Gravity float32
5075                 }))(obj)).CrouchSpeed
5076                 *p = math.Float32frombits(read32(r))
5077         }
5078         {
5079                 p := &(*(*(struct {
5080                         DefaultAccel, AirAccel, FastAccel,
5081                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5082                         Fluidity, Smoothing, Sink,
5083                         Gravity float32
5084                 }))(obj)).FastSpeed
5085                 *p = math.Float32frombits(read32(r))
5086         }
5087         {
5088                 p := &(*(*(struct {
5089                         DefaultAccel, AirAccel, FastAccel,
5090                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5091                         Fluidity, Smoothing, Sink,
5092                         Gravity float32
5093                 }))(obj)).ClimbSpeed
5094                 *p = math.Float32frombits(read32(r))
5095         }
5096         {
5097                 p := &(*(*(struct {
5098                         DefaultAccel, AirAccel, FastAccel,
5099                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5100                         Fluidity, Smoothing, Sink,
5101                         Gravity float32
5102                 }))(obj)).JumpSpeed
5103                 *p = math.Float32frombits(read32(r))
5104         }
5105         {
5106                 p := &(*(*(struct {
5107                         DefaultAccel, AirAccel, FastAccel,
5108                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5109                         Fluidity, Smoothing, Sink,
5110                         Gravity float32
5111                 }))(obj)).Fluidity
5112                 *p = math.Float32frombits(read32(r))
5113         }
5114         {
5115                 p := &(*(*(struct {
5116                         DefaultAccel, AirAccel, FastAccel,
5117                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5118                         Fluidity, Smoothing, Sink,
5119                         Gravity float32
5120                 }))(obj)).Smoothing
5121                 *p = math.Float32frombits(read32(r))
5122         }
5123         {
5124                 p := &(*(*(struct {
5125                         DefaultAccel, AirAccel, FastAccel,
5126                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5127                         Fluidity, Smoothing, Sink,
5128                         Gravity float32
5129                 }))(obj)).Sink
5130                 *p = math.Float32frombits(read32(r))
5131         }
5132         {
5133                 p := &(*(*(struct {
5134                         DefaultAccel, AirAccel, FastAccel,
5135                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
5136                         Fluidity, Smoothing, Sink,
5137                         Gravity float32
5138                 }))(obj)).Gravity
5139                 *p = math.Float32frombits(read32(r))
5140         }
5141 }
5142
5143 func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
5144         for local142 := range (*(*(struct {
5145                 Pos, Vel, Acc  [3]float32
5146                 ExpirationTime float32 // in seconds.
5147                 Size           float32
5148                 Collide        bool
5149
5150                 //mt:len32
5151                 Texture
5152
5153                 Vertical    bool
5154                 CollisionRm bool
5155                 AnimParams  TileAnim
5156                 Glow        uint8
5157                 AOCollision bool
5158                 NodeParam0  Content
5159                 NodeParam2  uint8
5160                 NodeTile    uint8
5161         }))(obj)).Pos {
5162                 {
5163                         x := ((*(*(struct {
5164                                 Pos, Vel, Acc  [3]float32
5165                                 ExpirationTime float32 // in seconds.
5166                                 Size           float32
5167                                 Collide        bool
5168
5169                                 //mt:len32
5170                                 Texture
5171
5172                                 Vertical    bool
5173                                 CollisionRm bool
5174                                 AnimParams  TileAnim
5175                                 Glow        uint8
5176                                 AOCollision bool
5177                                 NodeParam0  Content
5178                                 NodeParam2  uint8
5179                                 NodeTile    uint8
5180                         }))(obj)).Pos)[local142]
5181                         write32(w, math.Float32bits(x))
5182                 }
5183         }
5184         for local143 := range (*(*(struct {
5185                 Pos, Vel, Acc  [3]float32
5186                 ExpirationTime float32 // in seconds.
5187                 Size           float32
5188                 Collide        bool
5189
5190                 //mt:len32
5191                 Texture
5192
5193                 Vertical    bool
5194                 CollisionRm bool
5195                 AnimParams  TileAnim
5196                 Glow        uint8
5197                 AOCollision bool
5198                 NodeParam0  Content
5199                 NodeParam2  uint8
5200                 NodeTile    uint8
5201         }))(obj)).Vel {
5202                 {
5203                         x := ((*(*(struct {
5204                                 Pos, Vel, Acc  [3]float32
5205                                 ExpirationTime float32 // in seconds.
5206                                 Size           float32
5207                                 Collide        bool
5208
5209                                 //mt:len32
5210                                 Texture
5211
5212                                 Vertical    bool
5213                                 CollisionRm bool
5214                                 AnimParams  TileAnim
5215                                 Glow        uint8
5216                                 AOCollision bool
5217                                 NodeParam0  Content
5218                                 NodeParam2  uint8
5219                                 NodeTile    uint8
5220                         }))(obj)).Vel)[local143]
5221                         write32(w, math.Float32bits(x))
5222                 }
5223         }
5224         for local144 := range (*(*(struct {
5225                 Pos, Vel, Acc  [3]float32
5226                 ExpirationTime float32 // in seconds.
5227                 Size           float32
5228                 Collide        bool
5229
5230                 //mt:len32
5231                 Texture
5232
5233                 Vertical    bool
5234                 CollisionRm bool
5235                 AnimParams  TileAnim
5236                 Glow        uint8
5237                 AOCollision bool
5238                 NodeParam0  Content
5239                 NodeParam2  uint8
5240                 NodeTile    uint8
5241         }))(obj)).Acc {
5242                 {
5243                         x := ((*(*(struct {
5244                                 Pos, Vel, Acc  [3]float32
5245                                 ExpirationTime float32 // in seconds.
5246                                 Size           float32
5247                                 Collide        bool
5248
5249                                 //mt:len32
5250                                 Texture
5251
5252                                 Vertical    bool
5253                                 CollisionRm bool
5254                                 AnimParams  TileAnim
5255                                 Glow        uint8
5256                                 AOCollision bool
5257                                 NodeParam0  Content
5258                                 NodeParam2  uint8
5259                                 NodeTile    uint8
5260                         }))(obj)).Acc)[local144]
5261                         write32(w, math.Float32bits(x))
5262                 }
5263         }
5264         {
5265                 x := (*(*(struct {
5266                         Pos, Vel, Acc  [3]float32
5267                         ExpirationTime float32 // in seconds.
5268                         Size           float32
5269                         Collide        bool
5270
5271                         //mt:len32
5272                         Texture
5273
5274                         Vertical    bool
5275                         CollisionRm bool
5276                         AnimParams  TileAnim
5277                         Glow        uint8
5278                         AOCollision bool
5279                         NodeParam0  Content
5280                         NodeParam2  uint8
5281                         NodeTile    uint8
5282                 }))(obj)).ExpirationTime
5283                 write32(w, math.Float32bits(x))
5284         }
5285         {
5286                 x := (*(*(struct {
5287                         Pos, Vel, Acc  [3]float32
5288                         ExpirationTime float32 // in seconds.
5289                         Size           float32
5290                         Collide        bool
5291
5292                         //mt:len32
5293                         Texture
5294
5295                         Vertical    bool
5296                         CollisionRm bool
5297                         AnimParams  TileAnim
5298                         Glow        uint8
5299                         AOCollision bool
5300                         NodeParam0  Content
5301                         NodeParam2  uint8
5302                         NodeTile    uint8
5303                 }))(obj)).Size
5304                 write32(w, math.Float32bits(x))
5305         }
5306         {
5307                 x := (*(*(struct {
5308                         Pos, Vel, Acc  [3]float32
5309                         ExpirationTime float32 // in seconds.
5310                         Size           float32
5311                         Collide        bool
5312
5313                         //mt:len32
5314                         Texture
5315
5316                         Vertical    bool
5317                         CollisionRm bool
5318                         AnimParams  TileAnim
5319                         Glow        uint8
5320                         AOCollision bool
5321                         NodeParam0  Content
5322                         NodeParam2  uint8
5323                         NodeTile    uint8
5324                 }))(obj)).Collide
5325                 if x {
5326                         write8(w, 1)
5327                 } else {
5328                         write8(w, 0)
5329                 }
5330         }
5331         if len(([]byte(*(*string)(&((*(*(struct {
5332                 Pos, Vel, Acc  [3]float32
5333                 ExpirationTime float32 // in seconds.
5334                 Size           float32
5335                 Collide        bool
5336
5337                 //mt:len32
5338                 Texture
5339
5340                 Vertical    bool
5341                 CollisionRm bool
5342                 AnimParams  TileAnim
5343                 Glow        uint8
5344                 AOCollision bool
5345                 NodeParam0  Content
5346                 NodeParam2  uint8
5347                 NodeTile    uint8
5348         }))(obj)).Texture))))) > math.MaxUint32 {
5349                 chk(ErrTooLong)
5350         }
5351         {
5352                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5353                         Pos, Vel, Acc  [3]float32
5354                         ExpirationTime float32 // in seconds.
5355                         Size           float32
5356                         Collide        bool
5357
5358                         //mt:len32
5359                         Texture
5360
5361                         Vertical    bool
5362                         CollisionRm bool
5363                         AnimParams  TileAnim
5364                         Glow        uint8
5365                         AOCollision bool
5366                         NodeParam0  Content
5367                         NodeParam2  uint8
5368                         NodeTile    uint8
5369                 }))(obj)).Texture))))))
5370                 write32(w, uint32(x))
5371         }
5372         {
5373                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5374                         Pos, Vel, Acc  [3]float32
5375                         ExpirationTime float32 // in seconds.
5376                         Size           float32
5377                         Collide        bool
5378
5379                         //mt:len32
5380                         Texture
5381
5382                         Vertical    bool
5383                         CollisionRm bool
5384                         AnimParams  TileAnim
5385                         Glow        uint8
5386                         AOCollision bool
5387                         NodeParam0  Content
5388                         NodeParam2  uint8
5389                         NodeTile    uint8
5390                 }))(obj)).Texture))))[:])
5391                 chk(err)
5392         }
5393         {
5394                 x := (*(*(struct {
5395                         Pos, Vel, Acc  [3]float32
5396                         ExpirationTime float32 // in seconds.
5397                         Size           float32
5398                         Collide        bool
5399
5400                         //mt:len32
5401                         Texture
5402
5403                         Vertical    bool
5404                         CollisionRm bool
5405                         AnimParams  TileAnim
5406                         Glow        uint8
5407                         AOCollision bool
5408                         NodeParam0  Content
5409                         NodeParam2  uint8
5410                         NodeTile    uint8
5411                 }))(obj)).Vertical
5412                 if x {
5413                         write8(w, 1)
5414                 } else {
5415                         write8(w, 0)
5416                 }
5417         }
5418         {
5419                 x := (*(*(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)).CollisionRm
5437                 if x {
5438                         write8(w, 1)
5439                 } else {
5440                         write8(w, 0)
5441                 }
5442         }
5443         if err := pcall(func() {
5444                 ((*(*(struct {
5445                         Pos, Vel, Acc  [3]float32
5446                         ExpirationTime float32 // in seconds.
5447                         Size           float32
5448                         Collide        bool
5449
5450                         //mt:len32
5451                         Texture
5452
5453                         Vertical    bool
5454                         CollisionRm bool
5455                         AnimParams  TileAnim
5456                         Glow        uint8
5457                         AOCollision bool
5458                         NodeParam0  Content
5459                         NodeParam2  uint8
5460                         NodeTile    uint8
5461                 }))(obj)).AnimParams).serialize(w)
5462         }); err != nil {
5463                 if err == io.EOF {
5464                         chk(io.EOF)
5465                 }
5466                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
5467         }
5468         {
5469                 x := (*(*(struct {
5470                         Pos, Vel, Acc  [3]float32
5471                         ExpirationTime float32 // in seconds.
5472                         Size           float32
5473                         Collide        bool
5474
5475                         //mt:len32
5476                         Texture
5477
5478                         Vertical    bool
5479                         CollisionRm bool
5480                         AnimParams  TileAnim
5481                         Glow        uint8
5482                         AOCollision bool
5483                         NodeParam0  Content
5484                         NodeParam2  uint8
5485                         NodeTile    uint8
5486                 }))(obj)).Glow
5487                 write8(w, uint8(x))
5488         }
5489         {
5490                 x := (*(*(struct {
5491                         Pos, Vel, Acc  [3]float32
5492                         ExpirationTime float32 // in seconds.
5493                         Size           float32
5494                         Collide        bool
5495
5496                         //mt:len32
5497                         Texture
5498
5499                         Vertical    bool
5500                         CollisionRm bool
5501                         AnimParams  TileAnim
5502                         Glow        uint8
5503                         AOCollision bool
5504                         NodeParam0  Content
5505                         NodeParam2  uint8
5506                         NodeTile    uint8
5507                 }))(obj)).AOCollision
5508                 if x {
5509                         write8(w, 1)
5510                 } else {
5511                         write8(w, 0)
5512                 }
5513         }
5514         if err := pcall(func() {
5515                 ((*(*(struct {
5516                         Pos, Vel, Acc  [3]float32
5517                         ExpirationTime float32 // in seconds.
5518                         Size           float32
5519                         Collide        bool
5520
5521                         //mt:len32
5522                         Texture
5523
5524                         Vertical    bool
5525                         CollisionRm bool
5526                         AnimParams  TileAnim
5527                         Glow        uint8
5528                         AOCollision bool
5529                         NodeParam0  Content
5530                         NodeParam2  uint8
5531                         NodeTile    uint8
5532                 }))(obj)).NodeParam0).serialize(w)
5533         }); err != nil {
5534                 if err == io.EOF {
5535                         chk(io.EOF)
5536                 }
5537                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
5538         }
5539         {
5540                 x := (*(*(struct {
5541                         Pos, Vel, Acc  [3]float32
5542                         ExpirationTime float32 // in seconds.
5543                         Size           float32
5544                         Collide        bool
5545
5546                         //mt:len32
5547                         Texture
5548
5549                         Vertical    bool
5550                         CollisionRm bool
5551                         AnimParams  TileAnim
5552                         Glow        uint8
5553                         AOCollision bool
5554                         NodeParam0  Content
5555                         NodeParam2  uint8
5556                         NodeTile    uint8
5557                 }))(obj)).NodeParam2
5558                 write8(w, uint8(x))
5559         }
5560         {
5561                 x := (*(*(struct {
5562                         Pos, Vel, Acc  [3]float32
5563                         ExpirationTime float32 // in seconds.
5564                         Size           float32
5565                         Collide        bool
5566
5567                         //mt:len32
5568                         Texture
5569
5570                         Vertical    bool
5571                         CollisionRm bool
5572                         AnimParams  TileAnim
5573                         Glow        uint8
5574                         AOCollision bool
5575                         NodeParam0  Content
5576                         NodeParam2  uint8
5577                         NodeTile    uint8
5578                 }))(obj)).NodeTile
5579                 write8(w, uint8(x))
5580         }
5581 }
5582
5583 func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
5584         for local145 := range (*(*(struct {
5585                 Pos, Vel, Acc  [3]float32
5586                 ExpirationTime float32 // in seconds.
5587                 Size           float32
5588                 Collide        bool
5589
5590                 //mt:len32
5591                 Texture
5592
5593                 Vertical    bool
5594                 CollisionRm bool
5595                 AnimParams  TileAnim
5596                 Glow        uint8
5597                 AOCollision bool
5598                 NodeParam0  Content
5599                 NodeParam2  uint8
5600                 NodeTile    uint8
5601         }))(obj)).Pos {
5602                 {
5603                         p := &((*(*(struct {
5604                                 Pos, Vel, Acc  [3]float32
5605                                 ExpirationTime float32 // in seconds.
5606                                 Size           float32
5607                                 Collide        bool
5608
5609                                 //mt:len32
5610                                 Texture
5611
5612                                 Vertical    bool
5613                                 CollisionRm bool
5614                                 AnimParams  TileAnim
5615                                 Glow        uint8
5616                                 AOCollision bool
5617                                 NodeParam0  Content
5618                                 NodeParam2  uint8
5619                                 NodeTile    uint8
5620                         }))(obj)).Pos)[local145]
5621                         *p = math.Float32frombits(read32(r))
5622                 }
5623         }
5624         for local146 := range (*(*(struct {
5625                 Pos, Vel, Acc  [3]float32
5626                 ExpirationTime float32 // in seconds.
5627                 Size           float32
5628                 Collide        bool
5629
5630                 //mt:len32
5631                 Texture
5632
5633                 Vertical    bool
5634                 CollisionRm bool
5635                 AnimParams  TileAnim
5636                 Glow        uint8
5637                 AOCollision bool
5638                 NodeParam0  Content
5639                 NodeParam2  uint8
5640                 NodeTile    uint8
5641         }))(obj)).Vel {
5642                 {
5643                         p := &((*(*(struct {
5644                                 Pos, Vel, Acc  [3]float32
5645                                 ExpirationTime float32 // in seconds.
5646                                 Size           float32
5647                                 Collide        bool
5648
5649                                 //mt:len32
5650                                 Texture
5651
5652                                 Vertical    bool
5653                                 CollisionRm bool
5654                                 AnimParams  TileAnim
5655                                 Glow        uint8
5656                                 AOCollision bool
5657                                 NodeParam0  Content
5658                                 NodeParam2  uint8
5659                                 NodeTile    uint8
5660                         }))(obj)).Vel)[local146]
5661                         *p = math.Float32frombits(read32(r))
5662                 }
5663         }
5664         for local147 := range (*(*(struct {
5665                 Pos, Vel, Acc  [3]float32
5666                 ExpirationTime float32 // in seconds.
5667                 Size           float32
5668                 Collide        bool
5669
5670                 //mt:len32
5671                 Texture
5672
5673                 Vertical    bool
5674                 CollisionRm bool
5675                 AnimParams  TileAnim
5676                 Glow        uint8
5677                 AOCollision bool
5678                 NodeParam0  Content
5679                 NodeParam2  uint8
5680                 NodeTile    uint8
5681         }))(obj)).Acc {
5682                 {
5683                         p := &((*(*(struct {
5684                                 Pos, Vel, Acc  [3]float32
5685                                 ExpirationTime float32 // in seconds.
5686                                 Size           float32
5687                                 Collide        bool
5688
5689                                 //mt:len32
5690                                 Texture
5691
5692                                 Vertical    bool
5693                                 CollisionRm bool
5694                                 AnimParams  TileAnim
5695                                 Glow        uint8
5696                                 AOCollision bool
5697                                 NodeParam0  Content
5698                                 NodeParam2  uint8
5699                                 NodeTile    uint8
5700                         }))(obj)).Acc)[local147]
5701                         *p = math.Float32frombits(read32(r))
5702                 }
5703         }
5704         {
5705                 p := &(*(*(struct {
5706                         Pos, Vel, Acc  [3]float32
5707                         ExpirationTime float32 // in seconds.
5708                         Size           float32
5709                         Collide        bool
5710
5711                         //mt:len32
5712                         Texture
5713
5714                         Vertical    bool
5715                         CollisionRm bool
5716                         AnimParams  TileAnim
5717                         Glow        uint8
5718                         AOCollision bool
5719                         NodeParam0  Content
5720                         NodeParam2  uint8
5721                         NodeTile    uint8
5722                 }))(obj)).ExpirationTime
5723                 *p = math.Float32frombits(read32(r))
5724         }
5725         {
5726                 p := &(*(*(struct {
5727                         Pos, Vel, Acc  [3]float32
5728                         ExpirationTime float32 // in seconds.
5729                         Size           float32
5730                         Collide        bool
5731
5732                         //mt:len32
5733                         Texture
5734
5735                         Vertical    bool
5736                         CollisionRm bool
5737                         AnimParams  TileAnim
5738                         Glow        uint8
5739                         AOCollision bool
5740                         NodeParam0  Content
5741                         NodeParam2  uint8
5742                         NodeTile    uint8
5743                 }))(obj)).Size
5744                 *p = math.Float32frombits(read32(r))
5745         }
5746         {
5747                 p := &(*(*(struct {
5748                         Pos, Vel, Acc  [3]float32
5749                         ExpirationTime float32 // in seconds.
5750                         Size           float32
5751                         Collide        bool
5752
5753                         //mt:len32
5754                         Texture
5755
5756                         Vertical    bool
5757                         CollisionRm bool
5758                         AnimParams  TileAnim
5759                         Glow        uint8
5760                         AOCollision bool
5761                         NodeParam0  Content
5762                         NodeParam2  uint8
5763                         NodeTile    uint8
5764                 }))(obj)).Collide
5765                 switch n := read8(r); n {
5766                 case 0:
5767                         *p = false
5768                 case 1:
5769                         *p = true
5770                 default:
5771                         chk(fmt.Errorf("invalid bool: %d", n))
5772                 }
5773         }
5774         var local148 []uint8
5775         var local149 uint32
5776         {
5777                 p := &local149
5778                 *p = read32(r)
5779         }
5780         (local148) = make([]uint8, local149)
5781         {
5782                 _, err := io.ReadFull(r, (local148)[:])
5783                 chk(err)
5784         }
5785         (*(*string)(&((*(*(struct {
5786                 Pos, Vel, Acc  [3]float32
5787                 ExpirationTime float32 // in seconds.
5788                 Size           float32
5789                 Collide        bool
5790
5791                 //mt:len32
5792                 Texture
5793
5794                 Vertical    bool
5795                 CollisionRm bool
5796                 AnimParams  TileAnim
5797                 Glow        uint8
5798                 AOCollision bool
5799                 NodeParam0  Content
5800                 NodeParam2  uint8
5801                 NodeTile    uint8
5802         }))(obj)).Texture))) = string(local148)
5803         {
5804                 p := &(*(*(struct {
5805                         Pos, Vel, Acc  [3]float32
5806                         ExpirationTime float32 // in seconds.
5807                         Size           float32
5808                         Collide        bool
5809
5810                         //mt:len32
5811                         Texture
5812
5813                         Vertical    bool
5814                         CollisionRm bool
5815                         AnimParams  TileAnim
5816                         Glow        uint8
5817                         AOCollision bool
5818                         NodeParam0  Content
5819                         NodeParam2  uint8
5820                         NodeTile    uint8
5821                 }))(obj)).Vertical
5822                 switch n := read8(r); n {
5823                 case 0:
5824                         *p = false
5825                 case 1:
5826                         *p = true
5827                 default:
5828                         chk(fmt.Errorf("invalid bool: %d", n))
5829                 }
5830         }
5831         {
5832                 p := &(*(*(struct {
5833                         Pos, Vel, Acc  [3]float32
5834                         ExpirationTime float32 // in seconds.
5835                         Size           float32
5836                         Collide        bool
5837
5838                         //mt:len32
5839                         Texture
5840
5841                         Vertical    bool
5842                         CollisionRm bool
5843                         AnimParams  TileAnim
5844                         Glow        uint8
5845                         AOCollision bool
5846                         NodeParam0  Content
5847                         NodeParam2  uint8
5848                         NodeTile    uint8
5849                 }))(obj)).CollisionRm
5850                 switch n := read8(r); n {
5851                 case 0:
5852                         *p = false
5853                 case 1:
5854                         *p = true
5855                 default:
5856                         chk(fmt.Errorf("invalid bool: %d", n))
5857                 }
5858         }
5859         if err := pcall(func() {
5860                 ((*(*(struct {
5861                         Pos, Vel, Acc  [3]float32
5862                         ExpirationTime float32 // in seconds.
5863                         Size           float32
5864                         Collide        bool
5865
5866                         //mt:len32
5867                         Texture
5868
5869                         Vertical    bool
5870                         CollisionRm bool
5871                         AnimParams  TileAnim
5872                         Glow        uint8
5873                         AOCollision bool
5874                         NodeParam0  Content
5875                         NodeParam2  uint8
5876                         NodeTile    uint8
5877                 }))(obj)).AnimParams).deserialize(r)
5878         }); err != nil {
5879                 if err == io.EOF {
5880                         chk(io.EOF)
5881                 }
5882                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
5883         }
5884         {
5885                 p := &(*(*(struct {
5886                         Pos, Vel, Acc  [3]float32
5887                         ExpirationTime float32 // in seconds.
5888                         Size           float32
5889                         Collide        bool
5890
5891                         //mt:len32
5892                         Texture
5893
5894                         Vertical    bool
5895                         CollisionRm bool
5896                         AnimParams  TileAnim
5897                         Glow        uint8
5898                         AOCollision bool
5899                         NodeParam0  Content
5900                         NodeParam2  uint8
5901                         NodeTile    uint8
5902                 }))(obj)).Glow
5903                 *p = read8(r)
5904         }
5905         {
5906                 p := &(*(*(struct {
5907                         Pos, Vel, Acc  [3]float32
5908                         ExpirationTime float32 // in seconds.
5909                         Size           float32
5910                         Collide        bool
5911
5912                         //mt:len32
5913                         Texture
5914
5915                         Vertical    bool
5916                         CollisionRm bool
5917                         AnimParams  TileAnim
5918                         Glow        uint8
5919                         AOCollision bool
5920                         NodeParam0  Content
5921                         NodeParam2  uint8
5922                         NodeTile    uint8
5923                 }))(obj)).AOCollision
5924                 switch n := read8(r); n {
5925                 case 0:
5926                         *p = false
5927                 case 1:
5928                         *p = true
5929                 default:
5930                         chk(fmt.Errorf("invalid bool: %d", n))
5931                 }
5932         }
5933         if err := pcall(func() {
5934                 ((*(*(struct {
5935                         Pos, Vel, Acc  [3]float32
5936                         ExpirationTime float32 // in seconds.
5937                         Size           float32
5938                         Collide        bool
5939
5940                         //mt:len32
5941                         Texture
5942
5943                         Vertical    bool
5944                         CollisionRm bool
5945                         AnimParams  TileAnim
5946                         Glow        uint8
5947                         AOCollision bool
5948                         NodeParam0  Content
5949                         NodeParam2  uint8
5950                         NodeTile    uint8
5951                 }))(obj)).NodeParam0).deserialize(r)
5952         }); err != nil {
5953                 if err == io.EOF {
5954                         chk(io.EOF)
5955                 }
5956                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
5957         }
5958         {
5959                 p := &(*(*(struct {
5960                         Pos, Vel, Acc  [3]float32
5961                         ExpirationTime float32 // in seconds.
5962                         Size           float32
5963                         Collide        bool
5964
5965                         //mt:len32
5966                         Texture
5967
5968                         Vertical    bool
5969                         CollisionRm bool
5970                         AnimParams  TileAnim
5971                         Glow        uint8
5972                         AOCollision bool
5973                         NodeParam0  Content
5974                         NodeParam2  uint8
5975                         NodeTile    uint8
5976                 }))(obj)).NodeParam2
5977                 *p = read8(r)
5978         }
5979         {
5980                 p := &(*(*(struct {
5981                         Pos, Vel, Acc  [3]float32
5982                         ExpirationTime float32 // in seconds.
5983                         Size           float32
5984                         Collide        bool
5985
5986                         //mt:len32
5987                         Texture
5988
5989                         Vertical    bool
5990                         CollisionRm bool
5991                         AnimParams  TileAnim
5992                         Glow        uint8
5993                         AOCollision bool
5994                         NodeParam0  Content
5995                         NodeParam2  uint8
5996                         NodeTile    uint8
5997                 }))(obj)).NodeTile
5998                 *p = read8(r)
5999         }
6000 }
6001
6002 func (obj *ToCltAddParticleSpawner) serialize(w io.Writer) {
6003         {
6004                 x := (*(*(struct {
6005                         Amount         uint16
6006                         Duration       float32
6007                         Pos, Vel, Acc  [2][3]float32
6008                         ExpirationTime [2]float32 // in seconds.
6009                         Size           [2]float32
6010                         Collide        bool
6011
6012                         //mt:len32
6013                         Texture
6014
6015                         ID           ParticleSpawnerID
6016                         Vertical     bool
6017                         CollisionRm  bool
6018                         AttachedAOID AOID
6019                         AnimParams   TileAnim
6020                         Glow         uint8
6021                         AOCollision  bool
6022                         NodeParam0   Content
6023                         NodeParam2   uint8
6024                         NodeTile     uint8
6025                 }))(obj)).Amount
6026                 write16(w, uint16(x))
6027         }
6028         {
6029                 x := (*(*(struct {
6030                         Amount         uint16
6031                         Duration       float32
6032                         Pos, Vel, Acc  [2][3]float32
6033                         ExpirationTime [2]float32 // in seconds.
6034                         Size           [2]float32
6035                         Collide        bool
6036
6037                         //mt:len32
6038                         Texture
6039
6040                         ID           ParticleSpawnerID
6041                         Vertical     bool
6042                         CollisionRm  bool
6043                         AttachedAOID AOID
6044                         AnimParams   TileAnim
6045                         Glow         uint8
6046                         AOCollision  bool
6047                         NodeParam0   Content
6048                         NodeParam2   uint8
6049                         NodeTile     uint8
6050                 }))(obj)).Duration
6051                 write32(w, math.Float32bits(x))
6052         }
6053         for local150 := range (*(*(struct {
6054                 Amount         uint16
6055                 Duration       float32
6056                 Pos, Vel, Acc  [2][3]float32
6057                 ExpirationTime [2]float32 // in seconds.
6058                 Size           [2]float32
6059                 Collide        bool
6060
6061                 //mt:len32
6062                 Texture
6063
6064                 ID           ParticleSpawnerID
6065                 Vertical     bool
6066                 CollisionRm  bool
6067                 AttachedAOID AOID
6068                 AnimParams   TileAnim
6069                 Glow         uint8
6070                 AOCollision  bool
6071                 NodeParam0   Content
6072                 NodeParam2   uint8
6073                 NodeTile     uint8
6074         }))(obj)).Pos {
6075                 for local151 := range ((*(*(struct {
6076                         Amount         uint16
6077                         Duration       float32
6078                         Pos, Vel, Acc  [2][3]float32
6079                         ExpirationTime [2]float32 // in seconds.
6080                         Size           [2]float32
6081                         Collide        bool
6082
6083                         //mt:len32
6084                         Texture
6085
6086                         ID           ParticleSpawnerID
6087                         Vertical     bool
6088                         CollisionRm  bool
6089                         AttachedAOID AOID
6090                         AnimParams   TileAnim
6091                         Glow         uint8
6092                         AOCollision  bool
6093                         NodeParam0   Content
6094                         NodeParam2   uint8
6095                         NodeTile     uint8
6096                 }))(obj)).Pos)[local150] {
6097                         {
6098                                 x := (((*(*(struct {
6099                                         Amount         uint16
6100                                         Duration       float32
6101                                         Pos, Vel, Acc  [2][3]float32
6102                                         ExpirationTime [2]float32 // in seconds.
6103                                         Size           [2]float32
6104                                         Collide        bool
6105
6106                                         //mt:len32
6107                                         Texture
6108
6109                                         ID           ParticleSpawnerID
6110                                         Vertical     bool
6111                                         CollisionRm  bool
6112                                         AttachedAOID AOID
6113                                         AnimParams   TileAnim
6114                                         Glow         uint8
6115                                         AOCollision  bool
6116                                         NodeParam0   Content
6117                                         NodeParam2   uint8
6118                                         NodeTile     uint8
6119                                 }))(obj)).Pos)[local150])[local151]
6120                                 write32(w, math.Float32bits(x))
6121                         }
6122                 }
6123         }
6124         for local152 := range (*(*(struct {
6125                 Amount         uint16
6126                 Duration       float32
6127                 Pos, Vel, Acc  [2][3]float32
6128                 ExpirationTime [2]float32 // in seconds.
6129                 Size           [2]float32
6130                 Collide        bool
6131
6132                 //mt:len32
6133                 Texture
6134
6135                 ID           ParticleSpawnerID
6136                 Vertical     bool
6137                 CollisionRm  bool
6138                 AttachedAOID AOID
6139                 AnimParams   TileAnim
6140                 Glow         uint8
6141                 AOCollision  bool
6142                 NodeParam0   Content
6143                 NodeParam2   uint8
6144                 NodeTile     uint8
6145         }))(obj)).Vel {
6146                 for local153 := range ((*(*(struct {
6147                         Amount         uint16
6148                         Duration       float32
6149                         Pos, Vel, Acc  [2][3]float32
6150                         ExpirationTime [2]float32 // in seconds.
6151                         Size           [2]float32
6152                         Collide        bool
6153
6154                         //mt:len32
6155                         Texture
6156
6157                         ID           ParticleSpawnerID
6158                         Vertical     bool
6159                         CollisionRm  bool
6160                         AttachedAOID AOID
6161                         AnimParams   TileAnim
6162                         Glow         uint8
6163                         AOCollision  bool
6164                         NodeParam0   Content
6165                         NodeParam2   uint8
6166                         NodeTile     uint8
6167                 }))(obj)).Vel)[local152] {
6168                         {
6169                                 x := (((*(*(struct {
6170                                         Amount         uint16
6171                                         Duration       float32
6172                                         Pos, Vel, Acc  [2][3]float32
6173                                         ExpirationTime [2]float32 // in seconds.
6174                                         Size           [2]float32
6175                                         Collide        bool
6176
6177                                         //mt:len32
6178                                         Texture
6179
6180                                         ID           ParticleSpawnerID
6181                                         Vertical     bool
6182                                         CollisionRm  bool
6183                                         AttachedAOID AOID
6184                                         AnimParams   TileAnim
6185                                         Glow         uint8
6186                                         AOCollision  bool
6187                                         NodeParam0   Content
6188                                         NodeParam2   uint8
6189                                         NodeTile     uint8
6190                                 }))(obj)).Vel)[local152])[local153]
6191                                 write32(w, math.Float32bits(x))
6192                         }
6193                 }
6194         }
6195         for local154 := range (*(*(struct {
6196                 Amount         uint16
6197                 Duration       float32
6198                 Pos, Vel, Acc  [2][3]float32
6199                 ExpirationTime [2]float32 // in seconds.
6200                 Size           [2]float32
6201                 Collide        bool
6202
6203                 //mt:len32
6204                 Texture
6205
6206                 ID           ParticleSpawnerID
6207                 Vertical     bool
6208                 CollisionRm  bool
6209                 AttachedAOID AOID
6210                 AnimParams   TileAnim
6211                 Glow         uint8
6212                 AOCollision  bool
6213                 NodeParam0   Content
6214                 NodeParam2   uint8
6215                 NodeTile     uint8
6216         }))(obj)).Acc {
6217                 for local155 := range ((*(*(struct {
6218                         Amount         uint16
6219                         Duration       float32
6220                         Pos, Vel, Acc  [2][3]float32
6221                         ExpirationTime [2]float32 // in seconds.
6222                         Size           [2]float32
6223                         Collide        bool
6224
6225                         //mt:len32
6226                         Texture
6227
6228                         ID           ParticleSpawnerID
6229                         Vertical     bool
6230                         CollisionRm  bool
6231                         AttachedAOID AOID
6232                         AnimParams   TileAnim
6233                         Glow         uint8
6234                         AOCollision  bool
6235                         NodeParam0   Content
6236                         NodeParam2   uint8
6237                         NodeTile     uint8
6238                 }))(obj)).Acc)[local154] {
6239                         {
6240                                 x := (((*(*(struct {
6241                                         Amount         uint16
6242                                         Duration       float32
6243                                         Pos, Vel, Acc  [2][3]float32
6244                                         ExpirationTime [2]float32 // in seconds.
6245                                         Size           [2]float32
6246                                         Collide        bool
6247
6248                                         //mt:len32
6249                                         Texture
6250
6251                                         ID           ParticleSpawnerID
6252                                         Vertical     bool
6253                                         CollisionRm  bool
6254                                         AttachedAOID AOID
6255                                         AnimParams   TileAnim
6256                                         Glow         uint8
6257                                         AOCollision  bool
6258                                         NodeParam0   Content
6259                                         NodeParam2   uint8
6260                                         NodeTile     uint8
6261                                 }))(obj)).Acc)[local154])[local155]
6262                                 write32(w, math.Float32bits(x))
6263                         }
6264                 }
6265         }
6266         for local156 := range (*(*(struct {
6267                 Amount         uint16
6268                 Duration       float32
6269                 Pos, Vel, Acc  [2][3]float32
6270                 ExpirationTime [2]float32 // in seconds.
6271                 Size           [2]float32
6272                 Collide        bool
6273
6274                 //mt:len32
6275                 Texture
6276
6277                 ID           ParticleSpawnerID
6278                 Vertical     bool
6279                 CollisionRm  bool
6280                 AttachedAOID AOID
6281                 AnimParams   TileAnim
6282                 Glow         uint8
6283                 AOCollision  bool
6284                 NodeParam0   Content
6285                 NodeParam2   uint8
6286                 NodeTile     uint8
6287         }))(obj)).ExpirationTime {
6288                 {
6289                         x := ((*(*(struct {
6290                                 Amount         uint16
6291                                 Duration       float32
6292                                 Pos, Vel, Acc  [2][3]float32
6293                                 ExpirationTime [2]float32 // in seconds.
6294                                 Size           [2]float32
6295                                 Collide        bool
6296
6297                                 //mt:len32
6298                                 Texture
6299
6300                                 ID           ParticleSpawnerID
6301                                 Vertical     bool
6302                                 CollisionRm  bool
6303                                 AttachedAOID AOID
6304                                 AnimParams   TileAnim
6305                                 Glow         uint8
6306                                 AOCollision  bool
6307                                 NodeParam0   Content
6308                                 NodeParam2   uint8
6309                                 NodeTile     uint8
6310                         }))(obj)).ExpirationTime)[local156]
6311                         write32(w, math.Float32bits(x))
6312                 }
6313         }
6314         for local157 := range (*(*(struct {
6315                 Amount         uint16
6316                 Duration       float32
6317                 Pos, Vel, Acc  [2][3]float32
6318                 ExpirationTime [2]float32 // in seconds.
6319                 Size           [2]float32
6320                 Collide        bool
6321
6322                 //mt:len32
6323                 Texture
6324
6325                 ID           ParticleSpawnerID
6326                 Vertical     bool
6327                 CollisionRm  bool
6328                 AttachedAOID AOID
6329                 AnimParams   TileAnim
6330                 Glow         uint8
6331                 AOCollision  bool
6332                 NodeParam0   Content
6333                 NodeParam2   uint8
6334                 NodeTile     uint8
6335         }))(obj)).Size {
6336                 {
6337                         x := ((*(*(struct {
6338                                 Amount         uint16
6339                                 Duration       float32
6340                                 Pos, Vel, Acc  [2][3]float32
6341                                 ExpirationTime [2]float32 // in seconds.
6342                                 Size           [2]float32
6343                                 Collide        bool
6344
6345                                 //mt:len32
6346                                 Texture
6347
6348                                 ID           ParticleSpawnerID
6349                                 Vertical     bool
6350                                 CollisionRm  bool
6351                                 AttachedAOID AOID
6352                                 AnimParams   TileAnim
6353                                 Glow         uint8
6354                                 AOCollision  bool
6355                                 NodeParam0   Content
6356                                 NodeParam2   uint8
6357                                 NodeTile     uint8
6358                         }))(obj)).Size)[local157]
6359                         write32(w, math.Float32bits(x))
6360                 }
6361         }
6362         {
6363                 x := (*(*(struct {
6364                         Amount         uint16
6365                         Duration       float32
6366                         Pos, Vel, Acc  [2][3]float32
6367                         ExpirationTime [2]float32 // in seconds.
6368                         Size           [2]float32
6369                         Collide        bool
6370
6371                         //mt:len32
6372                         Texture
6373
6374                         ID           ParticleSpawnerID
6375                         Vertical     bool
6376                         CollisionRm  bool
6377                         AttachedAOID AOID
6378                         AnimParams   TileAnim
6379                         Glow         uint8
6380                         AOCollision  bool
6381                         NodeParam0   Content
6382                         NodeParam2   uint8
6383                         NodeTile     uint8
6384                 }))(obj)).Collide
6385                 if x {
6386                         write8(w, 1)
6387                 } else {
6388                         write8(w, 0)
6389                 }
6390         }
6391         if len(([]byte(*(*string)(&((*(*(struct {
6392                 Amount         uint16
6393                 Duration       float32
6394                 Pos, Vel, Acc  [2][3]float32
6395                 ExpirationTime [2]float32 // in seconds.
6396                 Size           [2]float32
6397                 Collide        bool
6398
6399                 //mt:len32
6400                 Texture
6401
6402                 ID           ParticleSpawnerID
6403                 Vertical     bool
6404                 CollisionRm  bool
6405                 AttachedAOID AOID
6406                 AnimParams   TileAnim
6407                 Glow         uint8
6408                 AOCollision  bool
6409                 NodeParam0   Content
6410                 NodeParam2   uint8
6411                 NodeTile     uint8
6412         }))(obj)).Texture))))) > math.MaxUint32 {
6413                 chk(ErrTooLong)
6414         }
6415         {
6416                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6417                         Amount         uint16
6418                         Duration       float32
6419                         Pos, Vel, Acc  [2][3]float32
6420                         ExpirationTime [2]float32 // in seconds.
6421                         Size           [2]float32
6422                         Collide        bool
6423
6424                         //mt:len32
6425                         Texture
6426
6427                         ID           ParticleSpawnerID
6428                         Vertical     bool
6429                         CollisionRm  bool
6430                         AttachedAOID AOID
6431                         AnimParams   TileAnim
6432                         Glow         uint8
6433                         AOCollision  bool
6434                         NodeParam0   Content
6435                         NodeParam2   uint8
6436                         NodeTile     uint8
6437                 }))(obj)).Texture))))))
6438                 write32(w, uint32(x))
6439         }
6440         {
6441                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6442                         Amount         uint16
6443                         Duration       float32
6444                         Pos, Vel, Acc  [2][3]float32
6445                         ExpirationTime [2]float32 // in seconds.
6446                         Size           [2]float32
6447                         Collide        bool
6448
6449                         //mt:len32
6450                         Texture
6451
6452                         ID           ParticleSpawnerID
6453                         Vertical     bool
6454                         CollisionRm  bool
6455                         AttachedAOID AOID
6456                         AnimParams   TileAnim
6457                         Glow         uint8
6458                         AOCollision  bool
6459                         NodeParam0   Content
6460                         NodeParam2   uint8
6461                         NodeTile     uint8
6462                 }))(obj)).Texture))))[:])
6463                 chk(err)
6464         }
6465         if err := pcall(func() {
6466                 ((*(*(struct {
6467                         Amount         uint16
6468                         Duration       float32
6469                         Pos, Vel, Acc  [2][3]float32
6470                         ExpirationTime [2]float32 // in seconds.
6471                         Size           [2]float32
6472                         Collide        bool
6473
6474                         //mt:len32
6475                         Texture
6476
6477                         ID           ParticleSpawnerID
6478                         Vertical     bool
6479                         CollisionRm  bool
6480                         AttachedAOID AOID
6481                         AnimParams   TileAnim
6482                         Glow         uint8
6483                         AOCollision  bool
6484                         NodeParam0   Content
6485                         NodeParam2   uint8
6486                         NodeTile     uint8
6487                 }))(obj)).ID).serialize(w)
6488         }); err != nil {
6489                 if err == io.EOF {
6490                         chk(io.EOF)
6491                 }
6492                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
6493         }
6494         {
6495                 x := (*(*(struct {
6496                         Amount         uint16
6497                         Duration       float32
6498                         Pos, Vel, Acc  [2][3]float32
6499                         ExpirationTime [2]float32 // in seconds.
6500                         Size           [2]float32
6501                         Collide        bool
6502
6503                         //mt:len32
6504                         Texture
6505
6506                         ID           ParticleSpawnerID
6507                         Vertical     bool
6508                         CollisionRm  bool
6509                         AttachedAOID AOID
6510                         AnimParams   TileAnim
6511                         Glow         uint8
6512                         AOCollision  bool
6513                         NodeParam0   Content
6514                         NodeParam2   uint8
6515                         NodeTile     uint8
6516                 }))(obj)).Vertical
6517                 if x {
6518                         write8(w, 1)
6519                 } else {
6520                         write8(w, 0)
6521                 }
6522         }
6523         {
6524                 x := (*(*(struct {
6525                         Amount         uint16
6526                         Duration       float32
6527                         Pos, Vel, Acc  [2][3]float32
6528                         ExpirationTime [2]float32 // in seconds.
6529                         Size           [2]float32
6530                         Collide        bool
6531
6532                         //mt:len32
6533                         Texture
6534
6535                         ID           ParticleSpawnerID
6536                         Vertical     bool
6537                         CollisionRm  bool
6538                         AttachedAOID AOID
6539                         AnimParams   TileAnim
6540                         Glow         uint8
6541                         AOCollision  bool
6542                         NodeParam0   Content
6543                         NodeParam2   uint8
6544                         NodeTile     uint8
6545                 }))(obj)).CollisionRm
6546                 if x {
6547                         write8(w, 1)
6548                 } else {
6549                         write8(w, 0)
6550                 }
6551         }
6552         if err := pcall(func() {
6553                 ((*(*(struct {
6554                         Amount         uint16
6555                         Duration       float32
6556                         Pos, Vel, Acc  [2][3]float32
6557                         ExpirationTime [2]float32 // in seconds.
6558                         Size           [2]float32
6559                         Collide        bool
6560
6561                         //mt:len32
6562                         Texture
6563
6564                         ID           ParticleSpawnerID
6565                         Vertical     bool
6566                         CollisionRm  bool
6567                         AttachedAOID AOID
6568                         AnimParams   TileAnim
6569                         Glow         uint8
6570                         AOCollision  bool
6571                         NodeParam0   Content
6572                         NodeParam2   uint8
6573                         NodeTile     uint8
6574                 }))(obj)).AttachedAOID).serialize(w)
6575         }); err != nil {
6576                 if err == io.EOF {
6577                         chk(io.EOF)
6578                 }
6579                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
6580         }
6581         if err := pcall(func() {
6582                 ((*(*(struct {
6583                         Amount         uint16
6584                         Duration       float32
6585                         Pos, Vel, Acc  [2][3]float32
6586                         ExpirationTime [2]float32 // in seconds.
6587                         Size           [2]float32
6588                         Collide        bool
6589
6590                         //mt:len32
6591                         Texture
6592
6593                         ID           ParticleSpawnerID
6594                         Vertical     bool
6595                         CollisionRm  bool
6596                         AttachedAOID AOID
6597                         AnimParams   TileAnim
6598                         Glow         uint8
6599                         AOCollision  bool
6600                         NodeParam0   Content
6601                         NodeParam2   uint8
6602                         NodeTile     uint8
6603                 }))(obj)).AnimParams).serialize(w)
6604         }); err != nil {
6605                 if err == io.EOF {
6606                         chk(io.EOF)
6607                 }
6608                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
6609         }
6610         {
6611                 x := (*(*(struct {
6612                         Amount         uint16
6613                         Duration       float32
6614                         Pos, Vel, Acc  [2][3]float32
6615                         ExpirationTime [2]float32 // in seconds.
6616                         Size           [2]float32
6617                         Collide        bool
6618
6619                         //mt:len32
6620                         Texture
6621
6622                         ID           ParticleSpawnerID
6623                         Vertical     bool
6624                         CollisionRm  bool
6625                         AttachedAOID AOID
6626                         AnimParams   TileAnim
6627                         Glow         uint8
6628                         AOCollision  bool
6629                         NodeParam0   Content
6630                         NodeParam2   uint8
6631                         NodeTile     uint8
6632                 }))(obj)).Glow
6633                 write8(w, uint8(x))
6634         }
6635         {
6636                 x := (*(*(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)).AOCollision
6658                 if x {
6659                         write8(w, 1)
6660                 } else {
6661                         write8(w, 0)
6662                 }
6663         }
6664         if err := pcall(func() {
6665                 ((*(*(struct {
6666                         Amount         uint16
6667                         Duration       float32
6668                         Pos, Vel, Acc  [2][3]float32
6669                         ExpirationTime [2]float32 // in seconds.
6670                         Size           [2]float32
6671                         Collide        bool
6672
6673                         //mt:len32
6674                         Texture
6675
6676                         ID           ParticleSpawnerID
6677                         Vertical     bool
6678                         CollisionRm  bool
6679                         AttachedAOID AOID
6680                         AnimParams   TileAnim
6681                         Glow         uint8
6682                         AOCollision  bool
6683                         NodeParam0   Content
6684                         NodeParam2   uint8
6685                         NodeTile     uint8
6686                 }))(obj)).NodeParam0).serialize(w)
6687         }); err != nil {
6688                 if err == io.EOF {
6689                         chk(io.EOF)
6690                 }
6691                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
6692         }
6693         {
6694                 x := (*(*(struct {
6695                         Amount         uint16
6696                         Duration       float32
6697                         Pos, Vel, Acc  [2][3]float32
6698                         ExpirationTime [2]float32 // in seconds.
6699                         Size           [2]float32
6700                         Collide        bool
6701
6702                         //mt:len32
6703                         Texture
6704
6705                         ID           ParticleSpawnerID
6706                         Vertical     bool
6707                         CollisionRm  bool
6708                         AttachedAOID AOID
6709                         AnimParams   TileAnim
6710                         Glow         uint8
6711                         AOCollision  bool
6712                         NodeParam0   Content
6713                         NodeParam2   uint8
6714                         NodeTile     uint8
6715                 }))(obj)).NodeParam2
6716                 write8(w, uint8(x))
6717         }
6718         {
6719                 x := (*(*(struct {
6720                         Amount         uint16
6721                         Duration       float32
6722                         Pos, Vel, Acc  [2][3]float32
6723                         ExpirationTime [2]float32 // in seconds.
6724                         Size           [2]float32
6725                         Collide        bool
6726
6727                         //mt:len32
6728                         Texture
6729
6730                         ID           ParticleSpawnerID
6731                         Vertical     bool
6732                         CollisionRm  bool
6733                         AttachedAOID AOID
6734                         AnimParams   TileAnim
6735                         Glow         uint8
6736                         AOCollision  bool
6737                         NodeParam0   Content
6738                         NodeParam2   uint8
6739                         NodeTile     uint8
6740                 }))(obj)).NodeTile
6741                 write8(w, uint8(x))
6742         }
6743 }
6744
6745 func (obj *ToCltAddParticleSpawner) deserialize(r io.Reader) {
6746         {
6747                 p := &(*(*(struct {
6748                         Amount         uint16
6749                         Duration       float32
6750                         Pos, Vel, Acc  [2][3]float32
6751                         ExpirationTime [2]float32 // in seconds.
6752                         Size           [2]float32
6753                         Collide        bool
6754
6755                         //mt:len32
6756                         Texture
6757
6758                         ID           ParticleSpawnerID
6759                         Vertical     bool
6760                         CollisionRm  bool
6761                         AttachedAOID AOID
6762                         AnimParams   TileAnim
6763                         Glow         uint8
6764                         AOCollision  bool
6765                         NodeParam0   Content
6766                         NodeParam2   uint8
6767                         NodeTile     uint8
6768                 }))(obj)).Amount
6769                 *p = read16(r)
6770         }
6771         {
6772                 p := &(*(*(struct {
6773                         Amount         uint16
6774                         Duration       float32
6775                         Pos, Vel, Acc  [2][3]float32
6776                         ExpirationTime [2]float32 // in seconds.
6777                         Size           [2]float32
6778                         Collide        bool
6779
6780                         //mt:len32
6781                         Texture
6782
6783                         ID           ParticleSpawnerID
6784                         Vertical     bool
6785                         CollisionRm  bool
6786                         AttachedAOID AOID
6787                         AnimParams   TileAnim
6788                         Glow         uint8
6789                         AOCollision  bool
6790                         NodeParam0   Content
6791                         NodeParam2   uint8
6792                         NodeTile     uint8
6793                 }))(obj)).Duration
6794                 *p = math.Float32frombits(read32(r))
6795         }
6796         for local158 := range (*(*(struct {
6797                 Amount         uint16
6798                 Duration       float32
6799                 Pos, Vel, Acc  [2][3]float32
6800                 ExpirationTime [2]float32 // in seconds.
6801                 Size           [2]float32
6802                 Collide        bool
6803
6804                 //mt:len32
6805                 Texture
6806
6807                 ID           ParticleSpawnerID
6808                 Vertical     bool
6809                 CollisionRm  bool
6810                 AttachedAOID AOID
6811                 AnimParams   TileAnim
6812                 Glow         uint8
6813                 AOCollision  bool
6814                 NodeParam0   Content
6815                 NodeParam2   uint8
6816                 NodeTile     uint8
6817         }))(obj)).Pos {
6818                 for local159 := range ((*(*(struct {
6819                         Amount         uint16
6820                         Duration       float32
6821                         Pos, Vel, Acc  [2][3]float32
6822                         ExpirationTime [2]float32 // in seconds.
6823                         Size           [2]float32
6824                         Collide        bool
6825
6826                         //mt:len32
6827                         Texture
6828
6829                         ID           ParticleSpawnerID
6830                         Vertical     bool
6831                         CollisionRm  bool
6832                         AttachedAOID AOID
6833                         AnimParams   TileAnim
6834                         Glow         uint8
6835                         AOCollision  bool
6836                         NodeParam0   Content
6837                         NodeParam2   uint8
6838                         NodeTile     uint8
6839                 }))(obj)).Pos)[local158] {
6840                         {
6841                                 p := &(((*(*(struct {
6842                                         Amount         uint16
6843                                         Duration       float32
6844                                         Pos, Vel, Acc  [2][3]float32
6845                                         ExpirationTime [2]float32 // in seconds.
6846                                         Size           [2]float32
6847                                         Collide        bool
6848
6849                                         //mt:len32
6850                                         Texture
6851
6852                                         ID           ParticleSpawnerID
6853                                         Vertical     bool
6854                                         CollisionRm  bool
6855                                         AttachedAOID AOID
6856                                         AnimParams   TileAnim
6857                                         Glow         uint8
6858                                         AOCollision  bool
6859                                         NodeParam0   Content
6860                                         NodeParam2   uint8
6861                                         NodeTile     uint8
6862                                 }))(obj)).Pos)[local158])[local159]
6863                                 *p = math.Float32frombits(read32(r))
6864                         }
6865                 }
6866         }
6867         for local160 := range (*(*(struct {
6868                 Amount         uint16
6869                 Duration       float32
6870                 Pos, Vel, Acc  [2][3]float32
6871                 ExpirationTime [2]float32 // in seconds.
6872                 Size           [2]float32
6873                 Collide        bool
6874
6875                 //mt:len32
6876                 Texture
6877
6878                 ID           ParticleSpawnerID
6879                 Vertical     bool
6880                 CollisionRm  bool
6881                 AttachedAOID AOID
6882                 AnimParams   TileAnim
6883                 Glow         uint8
6884                 AOCollision  bool
6885                 NodeParam0   Content
6886                 NodeParam2   uint8
6887                 NodeTile     uint8
6888         }))(obj)).Vel {
6889                 for local161 := range ((*(*(struct {
6890                         Amount         uint16
6891                         Duration       float32
6892                         Pos, Vel, Acc  [2][3]float32
6893                         ExpirationTime [2]float32 // in seconds.
6894                         Size           [2]float32
6895                         Collide        bool
6896
6897                         //mt:len32
6898                         Texture
6899
6900                         ID           ParticleSpawnerID
6901                         Vertical     bool
6902                         CollisionRm  bool
6903                         AttachedAOID AOID
6904                         AnimParams   TileAnim
6905                         Glow         uint8
6906                         AOCollision  bool
6907                         NodeParam0   Content
6908                         NodeParam2   uint8
6909                         NodeTile     uint8
6910                 }))(obj)).Vel)[local160] {
6911                         {
6912                                 p := &(((*(*(struct {
6913                                         Amount         uint16
6914                                         Duration       float32
6915                                         Pos, Vel, Acc  [2][3]float32
6916                                         ExpirationTime [2]float32 // in seconds.
6917                                         Size           [2]float32
6918                                         Collide        bool
6919
6920                                         //mt:len32
6921                                         Texture
6922
6923                                         ID           ParticleSpawnerID
6924                                         Vertical     bool
6925                                         CollisionRm  bool
6926                                         AttachedAOID AOID
6927                                         AnimParams   TileAnim
6928                                         Glow         uint8
6929                                         AOCollision  bool
6930                                         NodeParam0   Content
6931                                         NodeParam2   uint8
6932                                         NodeTile     uint8
6933                                 }))(obj)).Vel)[local160])[local161]
6934                                 *p = math.Float32frombits(read32(r))
6935                         }
6936                 }
6937         }
6938         for local162 := range (*(*(struct {
6939                 Amount         uint16
6940                 Duration       float32
6941                 Pos, Vel, Acc  [2][3]float32
6942                 ExpirationTime [2]float32 // in seconds.
6943                 Size           [2]float32
6944                 Collide        bool
6945
6946                 //mt:len32
6947                 Texture
6948
6949                 ID           ParticleSpawnerID
6950                 Vertical     bool
6951                 CollisionRm  bool
6952                 AttachedAOID AOID
6953                 AnimParams   TileAnim
6954                 Glow         uint8
6955                 AOCollision  bool
6956                 NodeParam0   Content
6957                 NodeParam2   uint8
6958                 NodeTile     uint8
6959         }))(obj)).Acc {
6960                 for local163 := range ((*(*(struct {
6961                         Amount         uint16
6962                         Duration       float32
6963                         Pos, Vel, Acc  [2][3]float32
6964                         ExpirationTime [2]float32 // in seconds.
6965                         Size           [2]float32
6966                         Collide        bool
6967
6968                         //mt:len32
6969                         Texture
6970
6971                         ID           ParticleSpawnerID
6972                         Vertical     bool
6973                         CollisionRm  bool
6974                         AttachedAOID AOID
6975                         AnimParams   TileAnim
6976                         Glow         uint8
6977                         AOCollision  bool
6978                         NodeParam0   Content
6979                         NodeParam2   uint8
6980                         NodeTile     uint8
6981                 }))(obj)).Acc)[local162] {
6982                         {
6983                                 p := &(((*(*(struct {
6984                                         Amount         uint16
6985                                         Duration       float32
6986                                         Pos, Vel, Acc  [2][3]float32
6987                                         ExpirationTime [2]float32 // in seconds.
6988                                         Size           [2]float32
6989                                         Collide        bool
6990
6991                                         //mt:len32
6992                                         Texture
6993
6994                                         ID           ParticleSpawnerID
6995                                         Vertical     bool
6996                                         CollisionRm  bool
6997                                         AttachedAOID AOID
6998                                         AnimParams   TileAnim
6999                                         Glow         uint8
7000                                         AOCollision  bool
7001                                         NodeParam0   Content
7002                                         NodeParam2   uint8
7003                                         NodeTile     uint8
7004                                 }))(obj)).Acc)[local162])[local163]
7005                                 *p = math.Float32frombits(read32(r))
7006                         }
7007                 }
7008         }
7009         for local164 := range (*(*(struct {
7010                 Amount         uint16
7011                 Duration       float32
7012                 Pos, Vel, Acc  [2][3]float32
7013                 ExpirationTime [2]float32 // in seconds.
7014                 Size           [2]float32
7015                 Collide        bool
7016
7017                 //mt:len32
7018                 Texture
7019
7020                 ID           ParticleSpawnerID
7021                 Vertical     bool
7022                 CollisionRm  bool
7023                 AttachedAOID AOID
7024                 AnimParams   TileAnim
7025                 Glow         uint8
7026                 AOCollision  bool
7027                 NodeParam0   Content
7028                 NodeParam2   uint8
7029                 NodeTile     uint8
7030         }))(obj)).ExpirationTime {
7031                 {
7032                         p := &((*(*(struct {
7033                                 Amount         uint16
7034                                 Duration       float32
7035                                 Pos, Vel, Acc  [2][3]float32
7036                                 ExpirationTime [2]float32 // in seconds.
7037                                 Size           [2]float32
7038                                 Collide        bool
7039
7040                                 //mt:len32
7041                                 Texture
7042
7043                                 ID           ParticleSpawnerID
7044                                 Vertical     bool
7045                                 CollisionRm  bool
7046                                 AttachedAOID AOID
7047                                 AnimParams   TileAnim
7048                                 Glow         uint8
7049                                 AOCollision  bool
7050                                 NodeParam0   Content
7051                                 NodeParam2   uint8
7052                                 NodeTile     uint8
7053                         }))(obj)).ExpirationTime)[local164]
7054                         *p = math.Float32frombits(read32(r))
7055                 }
7056         }
7057         for local165 := range (*(*(struct {
7058                 Amount         uint16
7059                 Duration       float32
7060                 Pos, Vel, Acc  [2][3]float32
7061                 ExpirationTime [2]float32 // in seconds.
7062                 Size           [2]float32
7063                 Collide        bool
7064
7065                 //mt:len32
7066                 Texture
7067
7068                 ID           ParticleSpawnerID
7069                 Vertical     bool
7070                 CollisionRm  bool
7071                 AttachedAOID AOID
7072                 AnimParams   TileAnim
7073                 Glow         uint8
7074                 AOCollision  bool
7075                 NodeParam0   Content
7076                 NodeParam2   uint8
7077                 NodeTile     uint8
7078         }))(obj)).Size {
7079                 {
7080                         p := &((*(*(struct {
7081                                 Amount         uint16
7082                                 Duration       float32
7083                                 Pos, Vel, Acc  [2][3]float32
7084                                 ExpirationTime [2]float32 // in seconds.
7085                                 Size           [2]float32
7086                                 Collide        bool
7087
7088                                 //mt:len32
7089                                 Texture
7090
7091                                 ID           ParticleSpawnerID
7092                                 Vertical     bool
7093                                 CollisionRm  bool
7094                                 AttachedAOID AOID
7095                                 AnimParams   TileAnim
7096                                 Glow         uint8
7097                                 AOCollision  bool
7098                                 NodeParam0   Content
7099                                 NodeParam2   uint8
7100                                 NodeTile     uint8
7101                         }))(obj)).Size)[local165]
7102                         *p = math.Float32frombits(read32(r))
7103                 }
7104         }
7105         {
7106                 p := &(*(*(struct {
7107                         Amount         uint16
7108                         Duration       float32
7109                         Pos, Vel, Acc  [2][3]float32
7110                         ExpirationTime [2]float32 // in seconds.
7111                         Size           [2]float32
7112                         Collide        bool
7113
7114                         //mt:len32
7115                         Texture
7116
7117                         ID           ParticleSpawnerID
7118                         Vertical     bool
7119                         CollisionRm  bool
7120                         AttachedAOID AOID
7121                         AnimParams   TileAnim
7122                         Glow         uint8
7123                         AOCollision  bool
7124                         NodeParam0   Content
7125                         NodeParam2   uint8
7126                         NodeTile     uint8
7127                 }))(obj)).Collide
7128                 switch n := read8(r); n {
7129                 case 0:
7130                         *p = false
7131                 case 1:
7132                         *p = true
7133                 default:
7134                         chk(fmt.Errorf("invalid bool: %d", n))
7135                 }
7136         }
7137         var local166 []uint8
7138         var local167 uint32
7139         {
7140                 p := &local167
7141                 *p = read32(r)
7142         }
7143         (local166) = make([]uint8, local167)
7144         {
7145                 _, err := io.ReadFull(r, (local166)[:])
7146                 chk(err)
7147         }
7148         (*(*string)(&((*(*(struct {
7149                 Amount         uint16
7150                 Duration       float32
7151                 Pos, Vel, Acc  [2][3]float32
7152                 ExpirationTime [2]float32 // in seconds.
7153                 Size           [2]float32
7154                 Collide        bool
7155
7156                 //mt:len32
7157                 Texture
7158
7159                 ID           ParticleSpawnerID
7160                 Vertical     bool
7161                 CollisionRm  bool
7162                 AttachedAOID AOID
7163                 AnimParams   TileAnim
7164                 Glow         uint8
7165                 AOCollision  bool
7166                 NodeParam0   Content
7167                 NodeParam2   uint8
7168                 NodeTile     uint8
7169         }))(obj)).Texture))) = string(local166)
7170         if err := pcall(func() {
7171                 ((*(*(struct {
7172                         Amount         uint16
7173                         Duration       float32
7174                         Pos, Vel, Acc  [2][3]float32
7175                         ExpirationTime [2]float32 // in seconds.
7176                         Size           [2]float32
7177                         Collide        bool
7178
7179                         //mt:len32
7180                         Texture
7181
7182                         ID           ParticleSpawnerID
7183                         Vertical     bool
7184                         CollisionRm  bool
7185                         AttachedAOID AOID
7186                         AnimParams   TileAnim
7187                         Glow         uint8
7188                         AOCollision  bool
7189                         NodeParam0   Content
7190                         NodeParam2   uint8
7191                         NodeTile     uint8
7192                 }))(obj)).ID).deserialize(r)
7193         }); err != nil {
7194                 if err == io.EOF {
7195                         chk(io.EOF)
7196                 }
7197                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
7198         }
7199         {
7200                 p := &(*(*(struct {
7201                         Amount         uint16
7202                         Duration       float32
7203                         Pos, Vel, Acc  [2][3]float32
7204                         ExpirationTime [2]float32 // in seconds.
7205                         Size           [2]float32
7206                         Collide        bool
7207
7208                         //mt:len32
7209                         Texture
7210
7211                         ID           ParticleSpawnerID
7212                         Vertical     bool
7213                         CollisionRm  bool
7214                         AttachedAOID AOID
7215                         AnimParams   TileAnim
7216                         Glow         uint8
7217                         AOCollision  bool
7218                         NodeParam0   Content
7219                         NodeParam2   uint8
7220                         NodeTile     uint8
7221                 }))(obj)).Vertical
7222                 switch n := read8(r); n {
7223                 case 0:
7224                         *p = false
7225                 case 1:
7226                         *p = true
7227                 default:
7228                         chk(fmt.Errorf("invalid bool: %d", n))
7229                 }
7230         }
7231         {
7232                 p := &(*(*(struct {
7233                         Amount         uint16
7234                         Duration       float32
7235                         Pos, Vel, Acc  [2][3]float32
7236                         ExpirationTime [2]float32 // in seconds.
7237                         Size           [2]float32
7238                         Collide        bool
7239
7240                         //mt:len32
7241                         Texture
7242
7243                         ID           ParticleSpawnerID
7244                         Vertical     bool
7245                         CollisionRm  bool
7246                         AttachedAOID AOID
7247                         AnimParams   TileAnim
7248                         Glow         uint8
7249                         AOCollision  bool
7250                         NodeParam0   Content
7251                         NodeParam2   uint8
7252                         NodeTile     uint8
7253                 }))(obj)).CollisionRm
7254                 switch n := read8(r); n {
7255                 case 0:
7256                         *p = false
7257                 case 1:
7258                         *p = true
7259                 default:
7260                         chk(fmt.Errorf("invalid bool: %d", n))
7261                 }
7262         }
7263         if err := pcall(func() {
7264                 ((*(*(struct {
7265                         Amount         uint16
7266                         Duration       float32
7267                         Pos, Vel, Acc  [2][3]float32
7268                         ExpirationTime [2]float32 // in seconds.
7269                         Size           [2]float32
7270                         Collide        bool
7271
7272                         //mt:len32
7273                         Texture
7274
7275                         ID           ParticleSpawnerID
7276                         Vertical     bool
7277                         CollisionRm  bool
7278                         AttachedAOID AOID
7279                         AnimParams   TileAnim
7280                         Glow         uint8
7281                         AOCollision  bool
7282                         NodeParam0   Content
7283                         NodeParam2   uint8
7284                         NodeTile     uint8
7285                 }))(obj)).AttachedAOID).deserialize(r)
7286         }); err != nil {
7287                 if err == io.EOF {
7288                         chk(io.EOF)
7289                 }
7290                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
7291         }
7292         if err := pcall(func() {
7293                 ((*(*(struct {
7294                         Amount         uint16
7295                         Duration       float32
7296                         Pos, Vel, Acc  [2][3]float32
7297                         ExpirationTime [2]float32 // in seconds.
7298                         Size           [2]float32
7299                         Collide        bool
7300
7301                         //mt:len32
7302                         Texture
7303
7304                         ID           ParticleSpawnerID
7305                         Vertical     bool
7306                         CollisionRm  bool
7307                         AttachedAOID AOID
7308                         AnimParams   TileAnim
7309                         Glow         uint8
7310                         AOCollision  bool
7311                         NodeParam0   Content
7312                         NodeParam2   uint8
7313                         NodeTile     uint8
7314                 }))(obj)).AnimParams).deserialize(r)
7315         }); err != nil {
7316                 if err == io.EOF {
7317                         chk(io.EOF)
7318                 }
7319                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
7320         }
7321         {
7322                 p := &(*(*(struct {
7323                         Amount         uint16
7324                         Duration       float32
7325                         Pos, Vel, Acc  [2][3]float32
7326                         ExpirationTime [2]float32 // in seconds.
7327                         Size           [2]float32
7328                         Collide        bool
7329
7330                         //mt:len32
7331                         Texture
7332
7333                         ID           ParticleSpawnerID
7334                         Vertical     bool
7335                         CollisionRm  bool
7336                         AttachedAOID AOID
7337                         AnimParams   TileAnim
7338                         Glow         uint8
7339                         AOCollision  bool
7340                         NodeParam0   Content
7341                         NodeParam2   uint8
7342                         NodeTile     uint8
7343                 }))(obj)).Glow
7344                 *p = read8(r)
7345         }
7346         {
7347                 p := &(*(*(struct {
7348                         Amount         uint16
7349                         Duration       float32
7350                         Pos, Vel, Acc  [2][3]float32
7351                         ExpirationTime [2]float32 // in seconds.
7352                         Size           [2]float32
7353                         Collide        bool
7354
7355                         //mt:len32
7356                         Texture
7357
7358                         ID           ParticleSpawnerID
7359                         Vertical     bool
7360                         CollisionRm  bool
7361                         AttachedAOID AOID
7362                         AnimParams   TileAnim
7363                         Glow         uint8
7364                         AOCollision  bool
7365                         NodeParam0   Content
7366                         NodeParam2   uint8
7367                         NodeTile     uint8
7368                 }))(obj)).AOCollision
7369                 switch n := read8(r); n {
7370                 case 0:
7371                         *p = false
7372                 case 1:
7373                         *p = true
7374                 default:
7375                         chk(fmt.Errorf("invalid bool: %d", n))
7376                 }
7377         }
7378         if err := pcall(func() {
7379                 ((*(*(struct {
7380                         Amount         uint16
7381                         Duration       float32
7382                         Pos, Vel, Acc  [2][3]float32
7383                         ExpirationTime [2]float32 // in seconds.
7384                         Size           [2]float32
7385                         Collide        bool
7386
7387                         //mt:len32
7388                         Texture
7389
7390                         ID           ParticleSpawnerID
7391                         Vertical     bool
7392                         CollisionRm  bool
7393                         AttachedAOID AOID
7394                         AnimParams   TileAnim
7395                         Glow         uint8
7396                         AOCollision  bool
7397                         NodeParam0   Content
7398                         NodeParam2   uint8
7399                         NodeTile     uint8
7400                 }))(obj)).NodeParam0).deserialize(r)
7401         }); err != nil {
7402                 if err == io.EOF {
7403                         chk(io.EOF)
7404                 }
7405                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
7406         }
7407         {
7408                 p := &(*(*(struct {
7409                         Amount         uint16
7410                         Duration       float32
7411                         Pos, Vel, Acc  [2][3]float32
7412                         ExpirationTime [2]float32 // in seconds.
7413                         Size           [2]float32
7414                         Collide        bool
7415
7416                         //mt:len32
7417                         Texture
7418
7419                         ID           ParticleSpawnerID
7420                         Vertical     bool
7421                         CollisionRm  bool
7422                         AttachedAOID AOID
7423                         AnimParams   TileAnim
7424                         Glow         uint8
7425                         AOCollision  bool
7426                         NodeParam0   Content
7427                         NodeParam2   uint8
7428                         NodeTile     uint8
7429                 }))(obj)).NodeParam2
7430                 *p = read8(r)
7431         }
7432         {
7433                 p := &(*(*(struct {
7434                         Amount         uint16
7435                         Duration       float32
7436                         Pos, Vel, Acc  [2][3]float32
7437                         ExpirationTime [2]float32 // in seconds.
7438                         Size           [2]float32
7439                         Collide        bool
7440
7441                         //mt:len32
7442                         Texture
7443
7444                         ID           ParticleSpawnerID
7445                         Vertical     bool
7446                         CollisionRm  bool
7447                         AttachedAOID AOID
7448                         AnimParams   TileAnim
7449                         Glow         uint8
7450                         AOCollision  bool
7451                         NodeParam0   Content
7452                         NodeParam2   uint8
7453                         NodeTile     uint8
7454                 }))(obj)).NodeTile
7455                 *p = read8(r)
7456         }
7457 }
7458
7459 func (obj *ToCltAddHUD) serialize(w io.Writer) {
7460         if err := pcall(func() {
7461                 ((*(*(struct {
7462                         ID HUDID
7463
7464                         Type HUDType
7465
7466                         Pos      [2]float32
7467                         Name     string
7468                         Scale    [2]float32
7469                         Text     string
7470                         Number   uint32
7471                         Item     uint32
7472                         Dir      uint32
7473                         Align    [2]float32
7474                         Offset   [2]float32
7475                         WorldPos Pos
7476                         Size     [2]int32
7477                         ZIndex   int16
7478                         Text2    string
7479                 }))(obj)).ID).serialize(w)
7480         }); err != nil {
7481                 if err == io.EOF {
7482                         chk(io.EOF)
7483                 }
7484                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7485         }
7486         if err := pcall(func() {
7487                 ((*(*(struct {
7488                         ID HUDID
7489
7490                         Type HUDType
7491
7492                         Pos      [2]float32
7493                         Name     string
7494                         Scale    [2]float32
7495                         Text     string
7496                         Number   uint32
7497                         Item     uint32
7498                         Dir      uint32
7499                         Align    [2]float32
7500                         Offset   [2]float32
7501                         WorldPos Pos
7502                         Size     [2]int32
7503                         ZIndex   int16
7504                         Text2    string
7505                 }))(obj)).Type).serialize(w)
7506         }); err != nil {
7507                 if err == io.EOF {
7508                         chk(io.EOF)
7509                 }
7510                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
7511         }
7512         for local168 := range (*(*(struct {
7513                 ID HUDID
7514
7515                 Type HUDType
7516
7517                 Pos      [2]float32
7518                 Name     string
7519                 Scale    [2]float32
7520                 Text     string
7521                 Number   uint32
7522                 Item     uint32
7523                 Dir      uint32
7524                 Align    [2]float32
7525                 Offset   [2]float32
7526                 WorldPos Pos
7527                 Size     [2]int32
7528                 ZIndex   int16
7529                 Text2    string
7530         }))(obj)).Pos {
7531                 {
7532                         x := ((*(*(struct {
7533                                 ID HUDID
7534
7535                                 Type HUDType
7536
7537                                 Pos      [2]float32
7538                                 Name     string
7539                                 Scale    [2]float32
7540                                 Text     string
7541                                 Number   uint32
7542                                 Item     uint32
7543                                 Dir      uint32
7544                                 Align    [2]float32
7545                                 Offset   [2]float32
7546                                 WorldPos Pos
7547                                 Size     [2]int32
7548                                 ZIndex   int16
7549                                 Text2    string
7550                         }))(obj)).Pos)[local168]
7551                         write32(w, math.Float32bits(x))
7552                 }
7553         }
7554         if len(([]byte((*(*(struct {
7555                 ID HUDID
7556
7557                 Type HUDType
7558
7559                 Pos      [2]float32
7560                 Name     string
7561                 Scale    [2]float32
7562                 Text     string
7563                 Number   uint32
7564                 Item     uint32
7565                 Dir      uint32
7566                 Align    [2]float32
7567                 Offset   [2]float32
7568                 WorldPos Pos
7569                 Size     [2]int32
7570                 ZIndex   int16
7571                 Text2    string
7572         }))(obj)).Name))) > math.MaxUint16 {
7573                 chk(ErrTooLong)
7574         }
7575         {
7576                 x := uint16(len(([]byte((*(*(struct {
7577                         ID HUDID
7578
7579                         Type HUDType
7580
7581                         Pos      [2]float32
7582                         Name     string
7583                         Scale    [2]float32
7584                         Text     string
7585                         Number   uint32
7586                         Item     uint32
7587                         Dir      uint32
7588                         Align    [2]float32
7589                         Offset   [2]float32
7590                         WorldPos Pos
7591                         Size     [2]int32
7592                         ZIndex   int16
7593                         Text2    string
7594                 }))(obj)).Name))))
7595                 write16(w, uint16(x))
7596         }
7597         {
7598                 _, err := w.Write(([]byte((*(*(struct {
7599                         ID HUDID
7600
7601                         Type HUDType
7602
7603                         Pos      [2]float32
7604                         Name     string
7605                         Scale    [2]float32
7606                         Text     string
7607                         Number   uint32
7608                         Item     uint32
7609                         Dir      uint32
7610                         Align    [2]float32
7611                         Offset   [2]float32
7612                         WorldPos Pos
7613                         Size     [2]int32
7614                         ZIndex   int16
7615                         Text2    string
7616                 }))(obj)).Name))[:])
7617                 chk(err)
7618         }
7619         for local169 := range (*(*(struct {
7620                 ID HUDID
7621
7622                 Type HUDType
7623
7624                 Pos      [2]float32
7625                 Name     string
7626                 Scale    [2]float32
7627                 Text     string
7628                 Number   uint32
7629                 Item     uint32
7630                 Dir      uint32
7631                 Align    [2]float32
7632                 Offset   [2]float32
7633                 WorldPos Pos
7634                 Size     [2]int32
7635                 ZIndex   int16
7636                 Text2    string
7637         }))(obj)).Scale {
7638                 {
7639                         x := ((*(*(struct {
7640                                 ID HUDID
7641
7642                                 Type HUDType
7643
7644                                 Pos      [2]float32
7645                                 Name     string
7646                                 Scale    [2]float32
7647                                 Text     string
7648                                 Number   uint32
7649                                 Item     uint32
7650                                 Dir      uint32
7651                                 Align    [2]float32
7652                                 Offset   [2]float32
7653                                 WorldPos Pos
7654                                 Size     [2]int32
7655                                 ZIndex   int16
7656                                 Text2    string
7657                         }))(obj)).Scale)[local169]
7658                         write32(w, math.Float32bits(x))
7659                 }
7660         }
7661         if len(([]byte((*(*(struct {
7662                 ID HUDID
7663
7664                 Type HUDType
7665
7666                 Pos      [2]float32
7667                 Name     string
7668                 Scale    [2]float32
7669                 Text     string
7670                 Number   uint32
7671                 Item     uint32
7672                 Dir      uint32
7673                 Align    [2]float32
7674                 Offset   [2]float32
7675                 WorldPos Pos
7676                 Size     [2]int32
7677                 ZIndex   int16
7678                 Text2    string
7679         }))(obj)).Text))) > math.MaxUint16 {
7680                 chk(ErrTooLong)
7681         }
7682         {
7683                 x := uint16(len(([]byte((*(*(struct {
7684                         ID HUDID
7685
7686                         Type HUDType
7687
7688                         Pos      [2]float32
7689                         Name     string
7690                         Scale    [2]float32
7691                         Text     string
7692                         Number   uint32
7693                         Item     uint32
7694                         Dir      uint32
7695                         Align    [2]float32
7696                         Offset   [2]float32
7697                         WorldPos Pos
7698                         Size     [2]int32
7699                         ZIndex   int16
7700                         Text2    string
7701                 }))(obj)).Text))))
7702                 write16(w, uint16(x))
7703         }
7704         {
7705                 _, err := w.Write(([]byte((*(*(struct {
7706                         ID HUDID
7707
7708                         Type HUDType
7709
7710                         Pos      [2]float32
7711                         Name     string
7712                         Scale    [2]float32
7713                         Text     string
7714                         Number   uint32
7715                         Item     uint32
7716                         Dir      uint32
7717                         Align    [2]float32
7718                         Offset   [2]float32
7719                         WorldPos Pos
7720                         Size     [2]int32
7721                         ZIndex   int16
7722                         Text2    string
7723                 }))(obj)).Text))[:])
7724                 chk(err)
7725         }
7726         {
7727                 x := (*(*(struct {
7728                         ID HUDID
7729
7730                         Type HUDType
7731
7732                         Pos      [2]float32
7733                         Name     string
7734                         Scale    [2]float32
7735                         Text     string
7736                         Number   uint32
7737                         Item     uint32
7738                         Dir      uint32
7739                         Align    [2]float32
7740                         Offset   [2]float32
7741                         WorldPos Pos
7742                         Size     [2]int32
7743                         ZIndex   int16
7744                         Text2    string
7745                 }))(obj)).Number
7746                 write32(w, uint32(x))
7747         }
7748         {
7749                 x := (*(*(struct {
7750                         ID HUDID
7751
7752                         Type HUDType
7753
7754                         Pos      [2]float32
7755                         Name     string
7756                         Scale    [2]float32
7757                         Text     string
7758                         Number   uint32
7759                         Item     uint32
7760                         Dir      uint32
7761                         Align    [2]float32
7762                         Offset   [2]float32
7763                         WorldPos Pos
7764                         Size     [2]int32
7765                         ZIndex   int16
7766                         Text2    string
7767                 }))(obj)).Item
7768                 write32(w, uint32(x))
7769         }
7770         {
7771                 x := (*(*(struct {
7772                         ID HUDID
7773
7774                         Type HUDType
7775
7776                         Pos      [2]float32
7777                         Name     string
7778                         Scale    [2]float32
7779                         Text     string
7780                         Number   uint32
7781                         Item     uint32
7782                         Dir      uint32
7783                         Align    [2]float32
7784                         Offset   [2]float32
7785                         WorldPos Pos
7786                         Size     [2]int32
7787                         ZIndex   int16
7788                         Text2    string
7789                 }))(obj)).Dir
7790                 write32(w, uint32(x))
7791         }
7792         for local170 := range (*(*(struct {
7793                 ID HUDID
7794
7795                 Type HUDType
7796
7797                 Pos      [2]float32
7798                 Name     string
7799                 Scale    [2]float32
7800                 Text     string
7801                 Number   uint32
7802                 Item     uint32
7803                 Dir      uint32
7804                 Align    [2]float32
7805                 Offset   [2]float32
7806                 WorldPos Pos
7807                 Size     [2]int32
7808                 ZIndex   int16
7809                 Text2    string
7810         }))(obj)).Align {
7811                 {
7812                         x := ((*(*(struct {
7813                                 ID HUDID
7814
7815                                 Type HUDType
7816
7817                                 Pos      [2]float32
7818                                 Name     string
7819                                 Scale    [2]float32
7820                                 Text     string
7821                                 Number   uint32
7822                                 Item     uint32
7823                                 Dir      uint32
7824                                 Align    [2]float32
7825                                 Offset   [2]float32
7826                                 WorldPos Pos
7827                                 Size     [2]int32
7828                                 ZIndex   int16
7829                                 Text2    string
7830                         }))(obj)).Align)[local170]
7831                         write32(w, math.Float32bits(x))
7832                 }
7833         }
7834         for local171 := range (*(*(struct {
7835                 ID HUDID
7836
7837                 Type HUDType
7838
7839                 Pos      [2]float32
7840                 Name     string
7841                 Scale    [2]float32
7842                 Text     string
7843                 Number   uint32
7844                 Item     uint32
7845                 Dir      uint32
7846                 Align    [2]float32
7847                 Offset   [2]float32
7848                 WorldPos Pos
7849                 Size     [2]int32
7850                 ZIndex   int16
7851                 Text2    string
7852         }))(obj)).Offset {
7853                 {
7854                         x := ((*(*(struct {
7855                                 ID HUDID
7856
7857                                 Type HUDType
7858
7859                                 Pos      [2]float32
7860                                 Name     string
7861                                 Scale    [2]float32
7862                                 Text     string
7863                                 Number   uint32
7864                                 Item     uint32
7865                                 Dir      uint32
7866                                 Align    [2]float32
7867                                 Offset   [2]float32
7868                                 WorldPos Pos
7869                                 Size     [2]int32
7870                                 ZIndex   int16
7871                                 Text2    string
7872                         }))(obj)).Offset)[local171]
7873                         write32(w, math.Float32bits(x))
7874                 }
7875         }
7876         if err := pcall(func() {
7877                 ((*(*(struct {
7878                         ID HUDID
7879
7880                         Type HUDType
7881
7882                         Pos      [2]float32
7883                         Name     string
7884                         Scale    [2]float32
7885                         Text     string
7886                         Number   uint32
7887                         Item     uint32
7888                         Dir      uint32
7889                         Align    [2]float32
7890                         Offset   [2]float32
7891                         WorldPos Pos
7892                         Size     [2]int32
7893                         ZIndex   int16
7894                         Text2    string
7895                 }))(obj)).WorldPos).serialize(w)
7896         }); err != nil {
7897                 if err == io.EOF {
7898                         chk(io.EOF)
7899                 }
7900                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
7901         }
7902         for local172 := range (*(*(struct {
7903                 ID HUDID
7904
7905                 Type HUDType
7906
7907                 Pos      [2]float32
7908                 Name     string
7909                 Scale    [2]float32
7910                 Text     string
7911                 Number   uint32
7912                 Item     uint32
7913                 Dir      uint32
7914                 Align    [2]float32
7915                 Offset   [2]float32
7916                 WorldPos Pos
7917                 Size     [2]int32
7918                 ZIndex   int16
7919                 Text2    string
7920         }))(obj)).Size {
7921                 {
7922                         x := ((*(*(struct {
7923                                 ID HUDID
7924
7925                                 Type HUDType
7926
7927                                 Pos      [2]float32
7928                                 Name     string
7929                                 Scale    [2]float32
7930                                 Text     string
7931                                 Number   uint32
7932                                 Item     uint32
7933                                 Dir      uint32
7934                                 Align    [2]float32
7935                                 Offset   [2]float32
7936                                 WorldPos Pos
7937                                 Size     [2]int32
7938                                 ZIndex   int16
7939                                 Text2    string
7940                         }))(obj)).Size)[local172]
7941                         write32(w, uint32(x))
7942                 }
7943         }
7944         {
7945                 x := (*(*(struct {
7946                         ID HUDID
7947
7948                         Type HUDType
7949
7950                         Pos      [2]float32
7951                         Name     string
7952                         Scale    [2]float32
7953                         Text     string
7954                         Number   uint32
7955                         Item     uint32
7956                         Dir      uint32
7957                         Align    [2]float32
7958                         Offset   [2]float32
7959                         WorldPos Pos
7960                         Size     [2]int32
7961                         ZIndex   int16
7962                         Text2    string
7963                 }))(obj)).ZIndex
7964                 write16(w, uint16(x))
7965         }
7966         if len(([]byte((*(*(struct {
7967                 ID HUDID
7968
7969                 Type HUDType
7970
7971                 Pos      [2]float32
7972                 Name     string
7973                 Scale    [2]float32
7974                 Text     string
7975                 Number   uint32
7976                 Item     uint32
7977                 Dir      uint32
7978                 Align    [2]float32
7979                 Offset   [2]float32
7980                 WorldPos Pos
7981                 Size     [2]int32
7982                 ZIndex   int16
7983                 Text2    string
7984         }))(obj)).Text2))) > math.MaxUint16 {
7985                 chk(ErrTooLong)
7986         }
7987         {
7988                 x := uint16(len(([]byte((*(*(struct {
7989                         ID HUDID
7990
7991                         Type HUDType
7992
7993                         Pos      [2]float32
7994                         Name     string
7995                         Scale    [2]float32
7996                         Text     string
7997                         Number   uint32
7998                         Item     uint32
7999                         Dir      uint32
8000                         Align    [2]float32
8001                         Offset   [2]float32
8002                         WorldPos Pos
8003                         Size     [2]int32
8004                         ZIndex   int16
8005                         Text2    string
8006                 }))(obj)).Text2))))
8007                 write16(w, uint16(x))
8008         }
8009         {
8010                 _, err := w.Write(([]byte((*(*(struct {
8011                         ID HUDID
8012
8013                         Type HUDType
8014
8015                         Pos      [2]float32
8016                         Name     string
8017                         Scale    [2]float32
8018                         Text     string
8019                         Number   uint32
8020                         Item     uint32
8021                         Dir      uint32
8022                         Align    [2]float32
8023                         Offset   [2]float32
8024                         WorldPos Pos
8025                         Size     [2]int32
8026                         ZIndex   int16
8027                         Text2    string
8028                 }))(obj)).Text2))[:])
8029                 chk(err)
8030         }
8031 }
8032
8033 func (obj *ToCltAddHUD) deserialize(r io.Reader) {
8034         if err := pcall(func() {
8035                 ((*(*(struct {
8036                         ID HUDID
8037
8038                         Type HUDType
8039
8040                         Pos      [2]float32
8041                         Name     string
8042                         Scale    [2]float32
8043                         Text     string
8044                         Number   uint32
8045                         Item     uint32
8046                         Dir      uint32
8047                         Align    [2]float32
8048                         Offset   [2]float32
8049                         WorldPos Pos
8050                         Size     [2]int32
8051                         ZIndex   int16
8052                         Text2    string
8053                 }))(obj)).ID).deserialize(r)
8054         }); err != nil {
8055                 if err == io.EOF {
8056                         chk(io.EOF)
8057                 }
8058                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
8059         }
8060         if err := pcall(func() {
8061                 ((*(*(struct {
8062                         ID HUDID
8063
8064                         Type HUDType
8065
8066                         Pos      [2]float32
8067                         Name     string
8068                         Scale    [2]float32
8069                         Text     string
8070                         Number   uint32
8071                         Item     uint32
8072                         Dir      uint32
8073                         Align    [2]float32
8074                         Offset   [2]float32
8075                         WorldPos Pos
8076                         Size     [2]int32
8077                         ZIndex   int16
8078                         Text2    string
8079                 }))(obj)).Type).deserialize(r)
8080         }); err != nil {
8081                 if err == io.EOF {
8082                         chk(io.EOF)
8083                 }
8084                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
8085         }
8086         for local173 := range (*(*(struct {
8087                 ID HUDID
8088
8089                 Type HUDType
8090
8091                 Pos      [2]float32
8092                 Name     string
8093                 Scale    [2]float32
8094                 Text     string
8095                 Number   uint32
8096                 Item     uint32
8097                 Dir      uint32
8098                 Align    [2]float32
8099                 Offset   [2]float32
8100                 WorldPos Pos
8101                 Size     [2]int32
8102                 ZIndex   int16
8103                 Text2    string
8104         }))(obj)).Pos {
8105                 {
8106                         p := &((*(*(struct {
8107                                 ID HUDID
8108
8109                                 Type HUDType
8110
8111                                 Pos      [2]float32
8112                                 Name     string
8113                                 Scale    [2]float32
8114                                 Text     string
8115                                 Number   uint32
8116                                 Item     uint32
8117                                 Dir      uint32
8118                                 Align    [2]float32
8119                                 Offset   [2]float32
8120                                 WorldPos Pos
8121                                 Size     [2]int32
8122                                 ZIndex   int16
8123                                 Text2    string
8124                         }))(obj)).Pos)[local173]
8125                         *p = math.Float32frombits(read32(r))
8126                 }
8127         }
8128         var local174 []uint8
8129         var local175 uint16
8130         {
8131                 p := &local175
8132                 *p = read16(r)
8133         }
8134         (local174) = make([]uint8, local175)
8135         {
8136                 _, err := io.ReadFull(r, (local174)[:])
8137                 chk(err)
8138         }
8139         ((*(*(struct {
8140                 ID HUDID
8141
8142                 Type HUDType
8143
8144                 Pos      [2]float32
8145                 Name     string
8146                 Scale    [2]float32
8147                 Text     string
8148                 Number   uint32
8149                 Item     uint32
8150                 Dir      uint32
8151                 Align    [2]float32
8152                 Offset   [2]float32
8153                 WorldPos Pos
8154                 Size     [2]int32
8155                 ZIndex   int16
8156                 Text2    string
8157         }))(obj)).Name) = string(local174)
8158         for local176 := range (*(*(struct {
8159                 ID HUDID
8160
8161                 Type HUDType
8162
8163                 Pos      [2]float32
8164                 Name     string
8165                 Scale    [2]float32
8166                 Text     string
8167                 Number   uint32
8168                 Item     uint32
8169                 Dir      uint32
8170                 Align    [2]float32
8171                 Offset   [2]float32
8172                 WorldPos Pos
8173                 Size     [2]int32
8174                 ZIndex   int16
8175                 Text2    string
8176         }))(obj)).Scale {
8177                 {
8178                         p := &((*(*(struct {
8179                                 ID HUDID
8180
8181                                 Type HUDType
8182
8183                                 Pos      [2]float32
8184                                 Name     string
8185                                 Scale    [2]float32
8186                                 Text     string
8187                                 Number   uint32
8188                                 Item     uint32
8189                                 Dir      uint32
8190                                 Align    [2]float32
8191                                 Offset   [2]float32
8192                                 WorldPos Pos
8193                                 Size     [2]int32
8194                                 ZIndex   int16
8195                                 Text2    string
8196                         }))(obj)).Scale)[local176]
8197                         *p = math.Float32frombits(read32(r))
8198                 }
8199         }
8200         var local177 []uint8
8201         var local178 uint16
8202         {
8203                 p := &local178
8204                 *p = read16(r)
8205         }
8206         (local177) = make([]uint8, local178)
8207         {
8208                 _, err := io.ReadFull(r, (local177)[:])
8209                 chk(err)
8210         }
8211         ((*(*(struct {
8212                 ID HUDID
8213
8214                 Type HUDType
8215
8216                 Pos      [2]float32
8217                 Name     string
8218                 Scale    [2]float32
8219                 Text     string
8220                 Number   uint32
8221                 Item     uint32
8222                 Dir      uint32
8223                 Align    [2]float32
8224                 Offset   [2]float32
8225                 WorldPos Pos
8226                 Size     [2]int32
8227                 ZIndex   int16
8228                 Text2    string
8229         }))(obj)).Text) = string(local177)
8230         {
8231                 p := &(*(*(struct {
8232                         ID HUDID
8233
8234                         Type HUDType
8235
8236                         Pos      [2]float32
8237                         Name     string
8238                         Scale    [2]float32
8239                         Text     string
8240                         Number   uint32
8241                         Item     uint32
8242                         Dir      uint32
8243                         Align    [2]float32
8244                         Offset   [2]float32
8245                         WorldPos Pos
8246                         Size     [2]int32
8247                         ZIndex   int16
8248                         Text2    string
8249                 }))(obj)).Number
8250                 *p = read32(r)
8251         }
8252         {
8253                 p := &(*(*(struct {
8254                         ID HUDID
8255
8256                         Type HUDType
8257
8258                         Pos      [2]float32
8259                         Name     string
8260                         Scale    [2]float32
8261                         Text     string
8262                         Number   uint32
8263                         Item     uint32
8264                         Dir      uint32
8265                         Align    [2]float32
8266                         Offset   [2]float32
8267                         WorldPos Pos
8268                         Size     [2]int32
8269                         ZIndex   int16
8270                         Text2    string
8271                 }))(obj)).Item
8272                 *p = read32(r)
8273         }
8274         {
8275                 p := &(*(*(struct {
8276                         ID HUDID
8277
8278                         Type HUDType
8279
8280                         Pos      [2]float32
8281                         Name     string
8282                         Scale    [2]float32
8283                         Text     string
8284                         Number   uint32
8285                         Item     uint32
8286                         Dir      uint32
8287                         Align    [2]float32
8288                         Offset   [2]float32
8289                         WorldPos Pos
8290                         Size     [2]int32
8291                         ZIndex   int16
8292                         Text2    string
8293                 }))(obj)).Dir
8294                 *p = read32(r)
8295         }
8296         for local179 := range (*(*(struct {
8297                 ID HUDID
8298
8299                 Type HUDType
8300
8301                 Pos      [2]float32
8302                 Name     string
8303                 Scale    [2]float32
8304                 Text     string
8305                 Number   uint32
8306                 Item     uint32
8307                 Dir      uint32
8308                 Align    [2]float32
8309                 Offset   [2]float32
8310                 WorldPos Pos
8311                 Size     [2]int32
8312                 ZIndex   int16
8313                 Text2    string
8314         }))(obj)).Align {
8315                 {
8316                         p := &((*(*(struct {
8317                                 ID HUDID
8318
8319                                 Type HUDType
8320
8321                                 Pos      [2]float32
8322                                 Name     string
8323                                 Scale    [2]float32
8324                                 Text     string
8325                                 Number   uint32
8326                                 Item     uint32
8327                                 Dir      uint32
8328                                 Align    [2]float32
8329                                 Offset   [2]float32
8330                                 WorldPos Pos
8331                                 Size     [2]int32
8332                                 ZIndex   int16
8333                                 Text2    string
8334                         }))(obj)).Align)[local179]
8335                         *p = math.Float32frombits(read32(r))
8336                 }
8337         }
8338         for local180 := range (*(*(struct {
8339                 ID HUDID
8340
8341                 Type HUDType
8342
8343                 Pos      [2]float32
8344                 Name     string
8345                 Scale    [2]float32
8346                 Text     string
8347                 Number   uint32
8348                 Item     uint32
8349                 Dir      uint32
8350                 Align    [2]float32
8351                 Offset   [2]float32
8352                 WorldPos Pos
8353                 Size     [2]int32
8354                 ZIndex   int16
8355                 Text2    string
8356         }))(obj)).Offset {
8357                 {
8358                         p := &((*(*(struct {
8359                                 ID HUDID
8360
8361                                 Type HUDType
8362
8363                                 Pos      [2]float32
8364                                 Name     string
8365                                 Scale    [2]float32
8366                                 Text     string
8367                                 Number   uint32
8368                                 Item     uint32
8369                                 Dir      uint32
8370                                 Align    [2]float32
8371                                 Offset   [2]float32
8372                                 WorldPos Pos
8373                                 Size     [2]int32
8374                                 ZIndex   int16
8375                                 Text2    string
8376                         }))(obj)).Offset)[local180]
8377                         *p = math.Float32frombits(read32(r))
8378                 }
8379         }
8380         if err := pcall(func() {
8381                 ((*(*(struct {
8382                         ID HUDID
8383
8384                         Type HUDType
8385
8386                         Pos      [2]float32
8387                         Name     string
8388                         Scale    [2]float32
8389                         Text     string
8390                         Number   uint32
8391                         Item     uint32
8392                         Dir      uint32
8393                         Align    [2]float32
8394                         Offset   [2]float32
8395                         WorldPos Pos
8396                         Size     [2]int32
8397                         ZIndex   int16
8398                         Text2    string
8399                 }))(obj)).WorldPos).deserialize(r)
8400         }); err != nil {
8401                 if err == io.EOF {
8402                         chk(io.EOF)
8403                 }
8404                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
8405         }
8406         for local181 := range (*(*(struct {
8407                 ID HUDID
8408
8409                 Type HUDType
8410
8411                 Pos      [2]float32
8412                 Name     string
8413                 Scale    [2]float32
8414                 Text     string
8415                 Number   uint32
8416                 Item     uint32
8417                 Dir      uint32
8418                 Align    [2]float32
8419                 Offset   [2]float32
8420                 WorldPos Pos
8421                 Size     [2]int32
8422                 ZIndex   int16
8423                 Text2    string
8424         }))(obj)).Size {
8425                 {
8426                         p := &((*(*(struct {
8427                                 ID HUDID
8428
8429                                 Type HUDType
8430
8431                                 Pos      [2]float32
8432                                 Name     string
8433                                 Scale    [2]float32
8434                                 Text     string
8435                                 Number   uint32
8436                                 Item     uint32
8437                                 Dir      uint32
8438                                 Align    [2]float32
8439                                 Offset   [2]float32
8440                                 WorldPos Pos
8441                                 Size     [2]int32
8442                                 ZIndex   int16
8443                                 Text2    string
8444                         }))(obj)).Size)[local181]
8445                         *p = int32(read32(r))
8446                 }
8447         }
8448         {
8449                 p := &(*(*(struct {
8450                         ID HUDID
8451
8452                         Type HUDType
8453
8454                         Pos      [2]float32
8455                         Name     string
8456                         Scale    [2]float32
8457                         Text     string
8458                         Number   uint32
8459                         Item     uint32
8460                         Dir      uint32
8461                         Align    [2]float32
8462                         Offset   [2]float32
8463                         WorldPos Pos
8464                         Size     [2]int32
8465                         ZIndex   int16
8466                         Text2    string
8467                 }))(obj)).ZIndex
8468                 *p = int16(read16(r))
8469         }
8470         var local182 []uint8
8471         var local183 uint16
8472         {
8473                 p := &local183
8474                 *p = read16(r)
8475         }
8476         (local182) = make([]uint8, local183)
8477         {
8478                 _, err := io.ReadFull(r, (local182)[:])
8479                 chk(err)
8480         }
8481         ((*(*(struct {
8482                 ID HUDID
8483
8484                 Type HUDType
8485
8486                 Pos      [2]float32
8487                 Name     string
8488                 Scale    [2]float32
8489                 Text     string
8490                 Number   uint32
8491                 Item     uint32
8492                 Dir      uint32
8493                 Align    [2]float32
8494                 Offset   [2]float32
8495                 WorldPos Pos
8496                 Size     [2]int32
8497                 ZIndex   int16
8498                 Text2    string
8499         }))(obj)).Text2) = string(local182)
8500 }
8501
8502 func (obj *ToCltRmHUD) serialize(w io.Writer) {
8503         if err := pcall(func() {
8504                 ((*(*(struct {
8505                         ID HUDID
8506                 }))(obj)).ID).serialize(w)
8507         }); err != nil {
8508                 if err == io.EOF {
8509                         chk(io.EOF)
8510                 }
8511                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
8512         }
8513 }
8514
8515 func (obj *ToCltRmHUD) deserialize(r io.Reader) {
8516         if err := pcall(func() {
8517                 ((*(*(struct {
8518                         ID HUDID
8519                 }))(obj)).ID).deserialize(r)
8520         }); err != nil {
8521                 if err == io.EOF {
8522                         chk(io.EOF)
8523                 }
8524                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
8525         }
8526 }
8527
8528 func (obj *ToCltChangeHUD) serialize(w io.Writer) {
8529         if err := pcall(func() {
8530                 ((*(*(struct {
8531                         ID HUDID
8532
8533                         Field HUDField
8534
8535                         //mt:if %s.Field == HUDPos
8536                         Pos [2]float32
8537
8538                         //mt:if %s.Field == HUDName
8539                         Name string
8540
8541                         //mt:if %s.Field == HUDScale
8542                         Scale [2]float32
8543
8544                         //mt:if %s.Field == HUDText
8545                         Text string
8546
8547                         //mt:if %s.Field == HUDNumber
8548                         Number uint32
8549
8550                         //mt:if %s.Field == HUDItem
8551                         Item uint32
8552
8553                         //mt:if %s.Field == HUDDir
8554                         Dir uint32
8555
8556                         //mt:if %s.Field == HUDAlign
8557                         Align [2]float32
8558
8559                         //mt:if %s.Field == HUDOffset
8560                         Offset [2]float32
8561
8562                         //mt:if %s.Field == HUDWorldPos
8563                         WorldPos Pos
8564
8565                         //mt:if %s.Field == HUDSize
8566                         Size [2]int32
8567
8568                         //mt:if %s.Field == HUDZIndex
8569                         ZIndex uint32
8570
8571                         //mt:if %s.Field == HUDText2
8572                         Text2 string
8573                 }))(obj)).ID).serialize(w)
8574         }); err != nil {
8575                 if err == io.EOF {
8576                         chk(io.EOF)
8577                 }
8578                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
8579         }
8580         if err := pcall(func() {
8581                 ((*(*(struct {
8582                         ID HUDID
8583
8584                         Field HUDField
8585
8586                         //mt:if %s.Field == HUDPos
8587                         Pos [2]float32
8588
8589                         //mt:if %s.Field == HUDName
8590                         Name string
8591
8592                         //mt:if %s.Field == HUDScale
8593                         Scale [2]float32
8594
8595                         //mt:if %s.Field == HUDText
8596                         Text string
8597
8598                         //mt:if %s.Field == HUDNumber
8599                         Number uint32
8600
8601                         //mt:if %s.Field == HUDItem
8602                         Item uint32
8603
8604                         //mt:if %s.Field == HUDDir
8605                         Dir uint32
8606
8607                         //mt:if %s.Field == HUDAlign
8608                         Align [2]float32
8609
8610                         //mt:if %s.Field == HUDOffset
8611                         Offset [2]float32
8612
8613                         //mt:if %s.Field == HUDWorldPos
8614                         WorldPos Pos
8615
8616                         //mt:if %s.Field == HUDSize
8617                         Size [2]int32
8618
8619                         //mt:if %s.Field == HUDZIndex
8620                         ZIndex uint32
8621
8622                         //mt:if %s.Field == HUDText2
8623                         Text2 string
8624                 }))(obj)).Field).serialize(w)
8625         }); err != nil {
8626                 if err == io.EOF {
8627                         chk(io.EOF)
8628                 }
8629                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDField", err))
8630         }
8631         if !((*(*(struct {
8632                 ID HUDID
8633
8634                 Field HUDField
8635
8636                 //mt:if %s.Field == HUDPos
8637                 Pos [2]float32
8638
8639                 //mt:if %s.Field == HUDName
8640                 Name string
8641
8642                 //mt:if %s.Field == HUDScale
8643                 Scale [2]float32
8644
8645                 //mt:if %s.Field == HUDText
8646                 Text string
8647
8648                 //mt:if %s.Field == HUDNumber
8649                 Number uint32
8650
8651                 //mt:if %s.Field == HUDItem
8652                 Item uint32
8653
8654                 //mt:if %s.Field == HUDDir
8655                 Dir uint32
8656
8657                 //mt:if %s.Field == HUDAlign
8658                 Align [2]float32
8659
8660                 //mt:if %s.Field == HUDOffset
8661                 Offset [2]float32
8662
8663                 //mt:if %s.Field == HUDWorldPos
8664                 WorldPos Pos
8665
8666                 //mt:if %s.Field == HUDSize
8667                 Size [2]int32
8668
8669                 //mt:if %s.Field == HUDZIndex
8670                 ZIndex uint32
8671
8672                 //mt:if %s.Field == HUDText2
8673                 Text2 string
8674         }))(obj)).Field < hudMax) {
8675                 chk(errors.New("assertion failed: %s.Field < hudMax"))
8676         }
8677         if (*(*(struct {
8678                 ID HUDID
8679
8680                 Field HUDField
8681
8682                 //mt:if %s.Field == HUDPos
8683                 Pos [2]float32
8684
8685                 //mt:if %s.Field == HUDName
8686                 Name string
8687
8688                 //mt:if %s.Field == HUDScale
8689                 Scale [2]float32
8690
8691                 //mt:if %s.Field == HUDText
8692                 Text string
8693
8694                 //mt:if %s.Field == HUDNumber
8695                 Number uint32
8696
8697                 //mt:if %s.Field == HUDItem
8698                 Item uint32
8699
8700                 //mt:if %s.Field == HUDDir
8701                 Dir uint32
8702
8703                 //mt:if %s.Field == HUDAlign
8704                 Align [2]float32
8705
8706                 //mt:if %s.Field == HUDOffset
8707                 Offset [2]float32
8708
8709                 //mt:if %s.Field == HUDWorldPos
8710                 WorldPos Pos
8711
8712                 //mt:if %s.Field == HUDSize
8713                 Size [2]int32
8714
8715                 //mt:if %s.Field == HUDZIndex
8716                 ZIndex uint32
8717
8718                 //mt:if %s.Field == HUDText2
8719                 Text2 string
8720         }))(obj)).Field == HUDPos {
8721                 for local184 := range (*(*(struct {
8722                         ID HUDID
8723
8724                         Field HUDField
8725
8726                         //mt:if %s.Field == HUDPos
8727                         Pos [2]float32
8728
8729                         //mt:if %s.Field == HUDName
8730                         Name string
8731
8732                         //mt:if %s.Field == HUDScale
8733                         Scale [2]float32
8734
8735                         //mt:if %s.Field == HUDText
8736                         Text string
8737
8738                         //mt:if %s.Field == HUDNumber
8739                         Number uint32
8740
8741                         //mt:if %s.Field == HUDItem
8742                         Item uint32
8743
8744                         //mt:if %s.Field == HUDDir
8745                         Dir uint32
8746
8747                         //mt:if %s.Field == HUDAlign
8748                         Align [2]float32
8749
8750                         //mt:if %s.Field == HUDOffset
8751                         Offset [2]float32
8752
8753                         //mt:if %s.Field == HUDWorldPos
8754                         WorldPos Pos
8755
8756                         //mt:if %s.Field == HUDSize
8757                         Size [2]int32
8758
8759                         //mt:if %s.Field == HUDZIndex
8760                         ZIndex uint32
8761
8762                         //mt:if %s.Field == HUDText2
8763                         Text2 string
8764                 }))(obj)).Pos {
8765                         {
8766                                 x := ((*(*(struct {
8767                                         ID HUDID
8768
8769                                         Field HUDField
8770
8771                                         //mt:if %s.Field == HUDPos
8772                                         Pos [2]float32
8773
8774                                         //mt:if %s.Field == HUDName
8775                                         Name string
8776
8777                                         //mt:if %s.Field == HUDScale
8778                                         Scale [2]float32
8779
8780                                         //mt:if %s.Field == HUDText
8781                                         Text string
8782
8783                                         //mt:if %s.Field == HUDNumber
8784                                         Number uint32
8785
8786                                         //mt:if %s.Field == HUDItem
8787                                         Item uint32
8788
8789                                         //mt:if %s.Field == HUDDir
8790                                         Dir uint32
8791
8792                                         //mt:if %s.Field == HUDAlign
8793                                         Align [2]float32
8794
8795                                         //mt:if %s.Field == HUDOffset
8796                                         Offset [2]float32
8797
8798                                         //mt:if %s.Field == HUDWorldPos
8799                                         WorldPos Pos
8800
8801                                         //mt:if %s.Field == HUDSize
8802                                         Size [2]int32
8803
8804                                         //mt:if %s.Field == HUDZIndex
8805                                         ZIndex uint32
8806
8807                                         //mt:if %s.Field == HUDText2
8808                                         Text2 string
8809                                 }))(obj)).Pos)[local184]
8810                                 write32(w, math.Float32bits(x))
8811                         }
8812                 }
8813         }
8814         if (*(*(struct {
8815                 ID HUDID
8816
8817                 Field HUDField
8818
8819                 //mt:if %s.Field == HUDPos
8820                 Pos [2]float32
8821
8822                 //mt:if %s.Field == HUDName
8823                 Name string
8824
8825                 //mt:if %s.Field == HUDScale
8826                 Scale [2]float32
8827
8828                 //mt:if %s.Field == HUDText
8829                 Text string
8830
8831                 //mt:if %s.Field == HUDNumber
8832                 Number uint32
8833
8834                 //mt:if %s.Field == HUDItem
8835                 Item uint32
8836
8837                 //mt:if %s.Field == HUDDir
8838                 Dir uint32
8839
8840                 //mt:if %s.Field == HUDAlign
8841                 Align [2]float32
8842
8843                 //mt:if %s.Field == HUDOffset
8844                 Offset [2]float32
8845
8846                 //mt:if %s.Field == HUDWorldPos
8847                 WorldPos Pos
8848
8849                 //mt:if %s.Field == HUDSize
8850                 Size [2]int32
8851
8852                 //mt:if %s.Field == HUDZIndex
8853                 ZIndex uint32
8854
8855                 //mt:if %s.Field == HUDText2
8856                 Text2 string
8857         }))(obj)).Field == HUDName {
8858                 if len(([]byte((*(*(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 uint32
8898
8899                         //mt:if %s.Field == HUDText2
8900                         Text2 string
8901                 }))(obj)).Name))) > math.MaxUint16 {
8902                         chk(ErrTooLong)
8903                 }
8904                 {
8905                         x := uint16(len(([]byte((*(*(struct {
8906                                 ID HUDID
8907
8908                                 Field HUDField
8909
8910                                 //mt:if %s.Field == HUDPos
8911                                 Pos [2]float32
8912
8913                                 //mt:if %s.Field == HUDName
8914                                 Name string
8915
8916                                 //mt:if %s.Field == HUDScale
8917                                 Scale [2]float32
8918
8919                                 //mt:if %s.Field == HUDText
8920                                 Text string
8921
8922                                 //mt:if %s.Field == HUDNumber
8923                                 Number uint32
8924
8925                                 //mt:if %s.Field == HUDItem
8926                                 Item uint32
8927
8928                                 //mt:if %s.Field == HUDDir
8929                                 Dir uint32
8930
8931                                 //mt:if %s.Field == HUDAlign
8932                                 Align [2]float32
8933
8934                                 //mt:if %s.Field == HUDOffset
8935                                 Offset [2]float32
8936
8937                                 //mt:if %s.Field == HUDWorldPos
8938                                 WorldPos Pos
8939
8940                                 //mt:if %s.Field == HUDSize
8941                                 Size [2]int32
8942
8943                                 //mt:if %s.Field == HUDZIndex
8944                                 ZIndex uint32
8945
8946                                 //mt:if %s.Field == HUDText2
8947                                 Text2 string
8948                         }))(obj)).Name))))
8949                         write16(w, uint16(x))
8950                 }
8951                 {
8952                         _, err := w.Write(([]byte((*(*(struct {
8953                                 ID HUDID
8954
8955                                 Field HUDField
8956
8957                                 //mt:if %s.Field == HUDPos
8958                                 Pos [2]float32
8959
8960                                 //mt:if %s.Field == HUDName
8961                                 Name string
8962
8963                                 //mt:if %s.Field == HUDScale
8964                                 Scale [2]float32
8965
8966                                 //mt:if %s.Field == HUDText
8967                                 Text string
8968
8969                                 //mt:if %s.Field == HUDNumber
8970                                 Number uint32
8971
8972                                 //mt:if %s.Field == HUDItem
8973                                 Item uint32
8974
8975                                 //mt:if %s.Field == HUDDir
8976                                 Dir uint32
8977
8978                                 //mt:if %s.Field == HUDAlign
8979                                 Align [2]float32
8980
8981                                 //mt:if %s.Field == HUDOffset
8982                                 Offset [2]float32
8983
8984                                 //mt:if %s.Field == HUDWorldPos
8985                                 WorldPos Pos
8986
8987                                 //mt:if %s.Field == HUDSize
8988                                 Size [2]int32
8989
8990                                 //mt:if %s.Field == HUDZIndex
8991                                 ZIndex uint32
8992
8993                                 //mt:if %s.Field == HUDText2
8994                                 Text2 string
8995                         }))(obj)).Name))[:])
8996                         chk(err)
8997                 }
8998         }
8999         if (*(*(struct {
9000                 ID HUDID
9001
9002                 Field HUDField
9003
9004                 //mt:if %s.Field == HUDPos
9005                 Pos [2]float32
9006
9007                 //mt:if %s.Field == HUDName
9008                 Name string
9009
9010                 //mt:if %s.Field == HUDScale
9011                 Scale [2]float32
9012
9013                 //mt:if %s.Field == HUDText
9014                 Text string
9015
9016                 //mt:if %s.Field == HUDNumber
9017                 Number uint32
9018
9019                 //mt:if %s.Field == HUDItem
9020                 Item uint32
9021
9022                 //mt:if %s.Field == HUDDir
9023                 Dir uint32
9024
9025                 //mt:if %s.Field == HUDAlign
9026                 Align [2]float32
9027
9028                 //mt:if %s.Field == HUDOffset
9029                 Offset [2]float32
9030
9031                 //mt:if %s.Field == HUDWorldPos
9032                 WorldPos Pos
9033
9034                 //mt:if %s.Field == HUDSize
9035                 Size [2]int32
9036
9037                 //mt:if %s.Field == HUDZIndex
9038                 ZIndex uint32
9039
9040                 //mt:if %s.Field == HUDText2
9041                 Text2 string
9042         }))(obj)).Field == HUDScale {
9043                 for local185 := range (*(*(struct {
9044                         ID HUDID
9045
9046                         Field HUDField
9047
9048                         //mt:if %s.Field == HUDPos
9049                         Pos [2]float32
9050
9051                         //mt:if %s.Field == HUDName
9052                         Name string
9053
9054                         //mt:if %s.Field == HUDScale
9055                         Scale [2]float32
9056
9057                         //mt:if %s.Field == HUDText
9058                         Text string
9059
9060                         //mt:if %s.Field == HUDNumber
9061                         Number uint32
9062
9063                         //mt:if %s.Field == HUDItem
9064                         Item uint32
9065
9066                         //mt:if %s.Field == HUDDir
9067                         Dir uint32
9068
9069                         //mt:if %s.Field == HUDAlign
9070                         Align [2]float32
9071
9072                         //mt:if %s.Field == HUDOffset
9073                         Offset [2]float32
9074
9075                         //mt:if %s.Field == HUDWorldPos
9076                         WorldPos Pos
9077
9078                         //mt:if %s.Field == HUDSize
9079                         Size [2]int32
9080
9081                         //mt:if %s.Field == HUDZIndex
9082                         ZIndex uint32
9083
9084                         //mt:if %s.Field == HUDText2
9085                         Text2 string
9086                 }))(obj)).Scale {
9087                         {
9088                                 x := ((*(*(struct {
9089                                         ID HUDID
9090
9091                                         Field HUDField
9092
9093                                         //mt:if %s.Field == HUDPos
9094                                         Pos [2]float32
9095
9096                                         //mt:if %s.Field == HUDName
9097                                         Name string
9098
9099                                         //mt:if %s.Field == HUDScale
9100                                         Scale [2]float32
9101
9102                                         //mt:if %s.Field == HUDText
9103                                         Text string
9104
9105                                         //mt:if %s.Field == HUDNumber
9106                                         Number uint32
9107
9108                                         //mt:if %s.Field == HUDItem
9109                                         Item uint32
9110
9111                                         //mt:if %s.Field == HUDDir
9112                                         Dir uint32
9113
9114                                         //mt:if %s.Field == HUDAlign
9115                                         Align [2]float32
9116
9117                                         //mt:if %s.Field == HUDOffset
9118                                         Offset [2]float32
9119
9120                                         //mt:if %s.Field == HUDWorldPos
9121                                         WorldPos Pos
9122
9123                                         //mt:if %s.Field == HUDSize
9124                                         Size [2]int32
9125
9126                                         //mt:if %s.Field == HUDZIndex
9127                                         ZIndex uint32
9128
9129                                         //mt:if %s.Field == HUDText2
9130                                         Text2 string
9131                                 }))(obj)).Scale)[local185]
9132                                 write32(w, math.Float32bits(x))
9133                         }
9134                 }
9135         }
9136         if (*(*(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 uint32
9176
9177                 //mt:if %s.Field == HUDText2
9178                 Text2 string
9179         }))(obj)).Field == HUDText {
9180                 if len(([]byte((*(*(struct {
9181                         ID HUDID
9182
9183                         Field HUDField
9184
9185                         //mt:if %s.Field == HUDPos
9186                         Pos [2]float32
9187
9188                         //mt:if %s.Field == HUDName
9189                         Name string
9190
9191                         //mt:if %s.Field == HUDScale
9192                         Scale [2]float32
9193
9194                         //mt:if %s.Field == HUDText
9195                         Text string
9196
9197                         //mt:if %s.Field == HUDNumber
9198                         Number uint32
9199
9200                         //mt:if %s.Field == HUDItem
9201                         Item uint32
9202
9203                         //mt:if %s.Field == HUDDir
9204                         Dir uint32
9205
9206                         //mt:if %s.Field == HUDAlign
9207                         Align [2]float32
9208
9209                         //mt:if %s.Field == HUDOffset
9210                         Offset [2]float32
9211
9212                         //mt:if %s.Field == HUDWorldPos
9213                         WorldPos Pos
9214
9215                         //mt:if %s.Field == HUDSize
9216                         Size [2]int32
9217
9218                         //mt:if %s.Field == HUDZIndex
9219                         ZIndex uint32
9220
9221                         //mt:if %s.Field == HUDText2
9222                         Text2 string
9223                 }))(obj)).Text))) > math.MaxUint16 {
9224                         chk(ErrTooLong)
9225                 }
9226                 {
9227                         x := uint16(len(([]byte((*(*(struct {
9228                                 ID HUDID
9229
9230                                 Field HUDField
9231
9232                                 //mt:if %s.Field == HUDPos
9233                                 Pos [2]float32
9234
9235                                 //mt:if %s.Field == HUDName
9236                                 Name string
9237
9238                                 //mt:if %s.Field == HUDScale
9239                                 Scale [2]float32
9240
9241                                 //mt:if %s.Field == HUDText
9242                                 Text string
9243
9244                                 //mt:if %s.Field == HUDNumber
9245                                 Number uint32
9246
9247                                 //mt:if %s.Field == HUDItem
9248                                 Item uint32
9249
9250                                 //mt:if %s.Field == HUDDir
9251                                 Dir uint32
9252
9253                                 //mt:if %s.Field == HUDAlign
9254                                 Align [2]float32
9255
9256                                 //mt:if %s.Field == HUDOffset
9257                                 Offset [2]float32
9258
9259                                 //mt:if %s.Field == HUDWorldPos
9260                                 WorldPos Pos
9261
9262                                 //mt:if %s.Field == HUDSize
9263                                 Size [2]int32
9264
9265                                 //mt:if %s.Field == HUDZIndex
9266                                 ZIndex uint32
9267
9268                                 //mt:if %s.Field == HUDText2
9269                                 Text2 string
9270                         }))(obj)).Text))))
9271                         write16(w, uint16(x))
9272                 }
9273                 {
9274                         _, err := w.Write(([]byte((*(*(struct {
9275                                 ID HUDID
9276
9277                                 Field HUDField
9278
9279                                 //mt:if %s.Field == HUDPos
9280                                 Pos [2]float32
9281
9282                                 //mt:if %s.Field == HUDName
9283                                 Name string
9284
9285                                 //mt:if %s.Field == HUDScale
9286                                 Scale [2]float32
9287
9288                                 //mt:if %s.Field == HUDText
9289                                 Text string
9290
9291                                 //mt:if %s.Field == HUDNumber
9292                                 Number uint32
9293
9294                                 //mt:if %s.Field == HUDItem
9295                                 Item uint32
9296
9297                                 //mt:if %s.Field == HUDDir
9298                                 Dir uint32
9299
9300                                 //mt:if %s.Field == HUDAlign
9301                                 Align [2]float32
9302
9303                                 //mt:if %s.Field == HUDOffset
9304                                 Offset [2]float32
9305
9306                                 //mt:if %s.Field == HUDWorldPos
9307                                 WorldPos Pos
9308
9309                                 //mt:if %s.Field == HUDSize
9310                                 Size [2]int32
9311
9312                                 //mt:if %s.Field == HUDZIndex
9313                                 ZIndex uint32
9314
9315                                 //mt:if %s.Field == HUDText2
9316                                 Text2 string
9317                         }))(obj)).Text))[:])
9318                         chk(err)
9319                 }
9320         }
9321         if (*(*(struct {
9322                 ID HUDID
9323
9324                 Field HUDField
9325
9326                 //mt:if %s.Field == HUDPos
9327                 Pos [2]float32
9328
9329                 //mt:if %s.Field == HUDName
9330                 Name string
9331
9332                 //mt:if %s.Field == HUDScale
9333                 Scale [2]float32
9334
9335                 //mt:if %s.Field == HUDText
9336                 Text string
9337
9338                 //mt:if %s.Field == HUDNumber
9339                 Number uint32
9340
9341                 //mt:if %s.Field == HUDItem
9342                 Item uint32
9343
9344                 //mt:if %s.Field == HUDDir
9345                 Dir uint32
9346
9347                 //mt:if %s.Field == HUDAlign
9348                 Align [2]float32
9349
9350                 //mt:if %s.Field == HUDOffset
9351                 Offset [2]float32
9352
9353                 //mt:if %s.Field == HUDWorldPos
9354                 WorldPos Pos
9355
9356                 //mt:if %s.Field == HUDSize
9357                 Size [2]int32
9358
9359                 //mt:if %s.Field == HUDZIndex
9360                 ZIndex uint32
9361
9362                 //mt:if %s.Field == HUDText2
9363                 Text2 string
9364         }))(obj)).Field == HUDNumber {
9365                 {
9366                         x := (*(*(struct {
9367                                 ID HUDID
9368
9369                                 Field HUDField
9370
9371                                 //mt:if %s.Field == HUDPos
9372                                 Pos [2]float32
9373
9374                                 //mt:if %s.Field == HUDName
9375                                 Name string
9376
9377                                 //mt:if %s.Field == HUDScale
9378                                 Scale [2]float32
9379
9380                                 //mt:if %s.Field == HUDText
9381                                 Text string
9382
9383                                 //mt:if %s.Field == HUDNumber
9384                                 Number uint32
9385
9386                                 //mt:if %s.Field == HUDItem
9387                                 Item uint32
9388
9389                                 //mt:if %s.Field == HUDDir
9390                                 Dir uint32
9391
9392                                 //mt:if %s.Field == HUDAlign
9393                                 Align [2]float32
9394
9395                                 //mt:if %s.Field == HUDOffset
9396                                 Offset [2]float32
9397
9398                                 //mt:if %s.Field == HUDWorldPos
9399                                 WorldPos Pos
9400
9401                                 //mt:if %s.Field == HUDSize
9402                                 Size [2]int32
9403
9404                                 //mt:if %s.Field == HUDZIndex
9405                                 ZIndex uint32
9406
9407                                 //mt:if %s.Field == HUDText2
9408                                 Text2 string
9409                         }))(obj)).Number
9410                         write32(w, uint32(x))
9411                 }
9412         }
9413         if (*(*(struct {
9414                 ID HUDID
9415
9416                 Field HUDField
9417
9418                 //mt:if %s.Field == HUDPos
9419                 Pos [2]float32
9420
9421                 //mt:if %s.Field == HUDName
9422                 Name string
9423
9424                 //mt:if %s.Field == HUDScale
9425                 Scale [2]float32
9426
9427                 //mt:if %s.Field == HUDText
9428                 Text string
9429
9430                 //mt:if %s.Field == HUDNumber
9431                 Number uint32
9432
9433                 //mt:if %s.Field == HUDItem
9434                 Item uint32
9435
9436                 //mt:if %s.Field == HUDDir
9437                 Dir uint32
9438
9439                 //mt:if %s.Field == HUDAlign
9440                 Align [2]float32
9441
9442                 //mt:if %s.Field == HUDOffset
9443                 Offset [2]float32
9444
9445                 //mt:if %s.Field == HUDWorldPos
9446                 WorldPos Pos
9447
9448                 //mt:if %s.Field == HUDSize
9449                 Size [2]int32
9450
9451                 //mt:if %s.Field == HUDZIndex
9452                 ZIndex uint32
9453
9454                 //mt:if %s.Field == HUDText2
9455                 Text2 string
9456         }))(obj)).Field == HUDItem {
9457                 {
9458                         x := (*(*(struct {
9459                                 ID HUDID
9460
9461                                 Field HUDField
9462
9463                                 //mt:if %s.Field == HUDPos
9464                                 Pos [2]float32
9465
9466                                 //mt:if %s.Field == HUDName
9467                                 Name string
9468
9469                                 //mt:if %s.Field == HUDScale
9470                                 Scale [2]float32
9471
9472                                 //mt:if %s.Field == HUDText
9473                                 Text string
9474
9475                                 //mt:if %s.Field == HUDNumber
9476                                 Number uint32
9477
9478                                 //mt:if %s.Field == HUDItem
9479                                 Item uint32
9480
9481                                 //mt:if %s.Field == HUDDir
9482                                 Dir uint32
9483
9484                                 //mt:if %s.Field == HUDAlign
9485                                 Align [2]float32
9486
9487                                 //mt:if %s.Field == HUDOffset
9488                                 Offset [2]float32
9489
9490                                 //mt:if %s.Field == HUDWorldPos
9491                                 WorldPos Pos
9492
9493                                 //mt:if %s.Field == HUDSize
9494                                 Size [2]int32
9495
9496                                 //mt:if %s.Field == HUDZIndex
9497                                 ZIndex uint32
9498
9499                                 //mt:if %s.Field == HUDText2
9500                                 Text2 string
9501                         }))(obj)).Item
9502                         write32(w, uint32(x))
9503                 }
9504         }
9505         if (*(*(struct {
9506                 ID HUDID
9507
9508                 Field HUDField
9509
9510                 //mt:if %s.Field == HUDPos
9511                 Pos [2]float32
9512
9513                 //mt:if %s.Field == HUDName
9514                 Name string
9515
9516                 //mt:if %s.Field == HUDScale
9517                 Scale [2]float32
9518
9519                 //mt:if %s.Field == HUDText
9520                 Text string
9521
9522                 //mt:if %s.Field == HUDNumber
9523                 Number uint32
9524
9525                 //mt:if %s.Field == HUDItem
9526                 Item uint32
9527
9528                 //mt:if %s.Field == HUDDir
9529                 Dir uint32
9530
9531                 //mt:if %s.Field == HUDAlign
9532                 Align [2]float32
9533
9534                 //mt:if %s.Field == HUDOffset
9535                 Offset [2]float32
9536
9537                 //mt:if %s.Field == HUDWorldPos
9538                 WorldPos Pos
9539
9540                 //mt:if %s.Field == HUDSize
9541                 Size [2]int32
9542
9543                 //mt:if %s.Field == HUDZIndex
9544                 ZIndex uint32
9545
9546                 //mt:if %s.Field == HUDText2
9547                 Text2 string
9548         }))(obj)).Field == HUDDir {
9549                 {
9550                         x := (*(*(struct {
9551                                 ID HUDID
9552
9553                                 Field HUDField
9554
9555                                 //mt:if %s.Field == HUDPos
9556                                 Pos [2]float32
9557
9558                                 //mt:if %s.Field == HUDName
9559                                 Name string
9560
9561                                 //mt:if %s.Field == HUDScale
9562                                 Scale [2]float32
9563
9564                                 //mt:if %s.Field == HUDText
9565                                 Text string
9566
9567                                 //mt:if %s.Field == HUDNumber
9568                                 Number uint32
9569
9570                                 //mt:if %s.Field == HUDItem
9571                                 Item uint32
9572
9573                                 //mt:if %s.Field == HUDDir
9574                                 Dir uint32
9575
9576                                 //mt:if %s.Field == HUDAlign
9577                                 Align [2]float32
9578
9579                                 //mt:if %s.Field == HUDOffset
9580                                 Offset [2]float32
9581
9582                                 //mt:if %s.Field == HUDWorldPos
9583                                 WorldPos Pos
9584
9585                                 //mt:if %s.Field == HUDSize
9586                                 Size [2]int32
9587
9588                                 //mt:if %s.Field == HUDZIndex
9589                                 ZIndex uint32
9590
9591                                 //mt:if %s.Field == HUDText2
9592                                 Text2 string
9593                         }))(obj)).Dir
9594                         write32(w, uint32(x))
9595                 }
9596         }
9597         if (*(*(struct {
9598                 ID HUDID
9599
9600                 Field HUDField
9601
9602                 //mt:if %s.Field == HUDPos
9603                 Pos [2]float32
9604
9605                 //mt:if %s.Field == HUDName
9606                 Name string
9607
9608                 //mt:if %s.Field == HUDScale
9609                 Scale [2]float32
9610
9611                 //mt:if %s.Field == HUDText
9612                 Text string
9613
9614                 //mt:if %s.Field == HUDNumber
9615                 Number uint32
9616
9617                 //mt:if %s.Field == HUDItem
9618                 Item uint32
9619
9620                 //mt:if %s.Field == HUDDir
9621                 Dir uint32
9622
9623                 //mt:if %s.Field == HUDAlign
9624                 Align [2]float32
9625
9626                 //mt:if %s.Field == HUDOffset
9627                 Offset [2]float32
9628
9629                 //mt:if %s.Field == HUDWorldPos
9630                 WorldPos Pos
9631
9632                 //mt:if %s.Field == HUDSize
9633                 Size [2]int32
9634
9635                 //mt:if %s.Field == HUDZIndex
9636                 ZIndex uint32
9637
9638                 //mt:if %s.Field == HUDText2
9639                 Text2 string
9640         }))(obj)).Field == HUDAlign {
9641                 for local186 := range (*(*(struct {
9642                         ID HUDID
9643
9644                         Field HUDField
9645
9646                         //mt:if %s.Field == HUDPos
9647                         Pos [2]float32
9648
9649                         //mt:if %s.Field == HUDName
9650                         Name string
9651
9652                         //mt:if %s.Field == HUDScale
9653                         Scale [2]float32
9654
9655                         //mt:if %s.Field == HUDText
9656                         Text string
9657
9658                         //mt:if %s.Field == HUDNumber
9659                         Number uint32
9660
9661                         //mt:if %s.Field == HUDItem
9662                         Item uint32
9663
9664                         //mt:if %s.Field == HUDDir
9665                         Dir uint32
9666
9667                         //mt:if %s.Field == HUDAlign
9668                         Align [2]float32
9669
9670                         //mt:if %s.Field == HUDOffset
9671                         Offset [2]float32
9672
9673                         //mt:if %s.Field == HUDWorldPos
9674                         WorldPos Pos
9675
9676                         //mt:if %s.Field == HUDSize
9677                         Size [2]int32
9678
9679                         //mt:if %s.Field == HUDZIndex
9680                         ZIndex uint32
9681
9682                         //mt:if %s.Field == HUDText2
9683                         Text2 string
9684                 }))(obj)).Align {
9685                         {
9686                                 x := ((*(*(struct {
9687                                         ID HUDID
9688
9689                                         Field HUDField
9690
9691                                         //mt:if %s.Field == HUDPos
9692                                         Pos [2]float32
9693
9694                                         //mt:if %s.Field == HUDName
9695                                         Name string
9696
9697                                         //mt:if %s.Field == HUDScale
9698                                         Scale [2]float32
9699
9700                                         //mt:if %s.Field == HUDText
9701                                         Text string
9702
9703                                         //mt:if %s.Field == HUDNumber
9704                                         Number uint32
9705
9706                                         //mt:if %s.Field == HUDItem
9707                                         Item uint32
9708
9709                                         //mt:if %s.Field == HUDDir
9710                                         Dir uint32
9711
9712                                         //mt:if %s.Field == HUDAlign
9713                                         Align [2]float32
9714
9715                                         //mt:if %s.Field == HUDOffset
9716                                         Offset [2]float32
9717
9718                                         //mt:if %s.Field == HUDWorldPos
9719                                         WorldPos Pos
9720
9721                                         //mt:if %s.Field == HUDSize
9722                                         Size [2]int32
9723
9724                                         //mt:if %s.Field == HUDZIndex
9725                                         ZIndex uint32
9726
9727                                         //mt:if %s.Field == HUDText2
9728                                         Text2 string
9729                                 }))(obj)).Align)[local186]
9730                                 write32(w, math.Float32bits(x))
9731                         }
9732                 }
9733         }
9734         if (*(*(struct {
9735                 ID HUDID
9736
9737                 Field HUDField
9738
9739                 //mt:if %s.Field == HUDPos
9740                 Pos [2]float32
9741
9742                 //mt:if %s.Field == HUDName
9743                 Name string
9744
9745                 //mt:if %s.Field == HUDScale
9746                 Scale [2]float32
9747
9748                 //mt:if %s.Field == HUDText
9749                 Text string
9750
9751                 //mt:if %s.Field == HUDNumber
9752                 Number uint32
9753
9754                 //mt:if %s.Field == HUDItem
9755                 Item uint32
9756
9757                 //mt:if %s.Field == HUDDir
9758                 Dir uint32
9759
9760                 //mt:if %s.Field == HUDAlign
9761                 Align [2]float32
9762
9763                 //mt:if %s.Field == HUDOffset
9764                 Offset [2]float32
9765
9766                 //mt:if %s.Field == HUDWorldPos
9767                 WorldPos Pos
9768
9769                 //mt:if %s.Field == HUDSize
9770                 Size [2]int32
9771
9772                 //mt:if %s.Field == HUDZIndex
9773                 ZIndex uint32
9774
9775                 //mt:if %s.Field == HUDText2
9776                 Text2 string
9777         }))(obj)).Field == HUDOffset {
9778                 for local187 := range (*(*(struct {
9779                         ID HUDID
9780
9781                         Field HUDField
9782
9783                         //mt:if %s.Field == HUDPos
9784                         Pos [2]float32
9785
9786                         //mt:if %s.Field == HUDName
9787                         Name string
9788
9789                         //mt:if %s.Field == HUDScale
9790                         Scale [2]float32
9791
9792                         //mt:if %s.Field == HUDText
9793                         Text string
9794
9795                         //mt:if %s.Field == HUDNumber
9796                         Number uint32
9797
9798                         //mt:if %s.Field == HUDItem
9799                         Item uint32
9800
9801                         //mt:if %s.Field == HUDDir
9802                         Dir uint32
9803
9804                         //mt:if %s.Field == HUDAlign
9805                         Align [2]float32
9806
9807                         //mt:if %s.Field == HUDOffset
9808                         Offset [2]float32
9809
9810                         //mt:if %s.Field == HUDWorldPos
9811                         WorldPos Pos
9812
9813                         //mt:if %s.Field == HUDSize
9814                         Size [2]int32
9815
9816                         //mt:if %s.Field == HUDZIndex
9817                         ZIndex uint32
9818
9819                         //mt:if %s.Field == HUDText2
9820                         Text2 string
9821                 }))(obj)).Offset {
9822                         {
9823                                 x := ((*(*(struct {
9824                                         ID HUDID
9825
9826                                         Field HUDField
9827
9828                                         //mt:if %s.Field == HUDPos
9829                                         Pos [2]float32
9830
9831                                         //mt:if %s.Field == HUDName
9832                                         Name string
9833
9834                                         //mt:if %s.Field == HUDScale
9835                                         Scale [2]float32
9836
9837                                         //mt:if %s.Field == HUDText
9838                                         Text string
9839
9840                                         //mt:if %s.Field == HUDNumber
9841                                         Number uint32
9842
9843                                         //mt:if %s.Field == HUDItem
9844                                         Item uint32
9845
9846                                         //mt:if %s.Field == HUDDir
9847                                         Dir uint32
9848
9849                                         //mt:if %s.Field == HUDAlign
9850                                         Align [2]float32
9851
9852                                         //mt:if %s.Field == HUDOffset
9853                                         Offset [2]float32
9854
9855                                         //mt:if %s.Field == HUDWorldPos
9856                                         WorldPos Pos
9857
9858                                         //mt:if %s.Field == HUDSize
9859                                         Size [2]int32
9860
9861                                         //mt:if %s.Field == HUDZIndex
9862                                         ZIndex uint32
9863
9864                                         //mt:if %s.Field == HUDText2
9865                                         Text2 string
9866                                 }))(obj)).Offset)[local187]
9867                                 write32(w, math.Float32bits(x))
9868                         }
9869                 }
9870         }
9871         if (*(*(struct {
9872                 ID HUDID
9873
9874                 Field HUDField
9875
9876                 //mt:if %s.Field == HUDPos
9877                 Pos [2]float32
9878
9879                 //mt:if %s.Field == HUDName
9880                 Name string
9881
9882                 //mt:if %s.Field == HUDScale
9883                 Scale [2]float32
9884
9885                 //mt:if %s.Field == HUDText
9886                 Text string
9887
9888                 //mt:if %s.Field == HUDNumber
9889                 Number uint32
9890
9891                 //mt:if %s.Field == HUDItem
9892                 Item uint32
9893
9894                 //mt:if %s.Field == HUDDir
9895                 Dir uint32
9896
9897                 //mt:if %s.Field == HUDAlign
9898                 Align [2]float32
9899
9900                 //mt:if %s.Field == HUDOffset
9901                 Offset [2]float32
9902
9903                 //mt:if %s.Field == HUDWorldPos
9904                 WorldPos Pos
9905
9906                 //mt:if %s.Field == HUDSize
9907                 Size [2]int32
9908
9909                 //mt:if %s.Field == HUDZIndex
9910                 ZIndex uint32
9911
9912                 //mt:if %s.Field == HUDText2
9913                 Text2 string
9914         }))(obj)).Field == HUDWorldPos {
9915                 if err := pcall(func() {
9916                         ((*(*(struct {
9917                                 ID HUDID
9918
9919                                 Field HUDField
9920
9921                                 //mt:if %s.Field == HUDPos
9922                                 Pos [2]float32
9923
9924                                 //mt:if %s.Field == HUDName
9925                                 Name string
9926
9927                                 //mt:if %s.Field == HUDScale
9928                                 Scale [2]float32
9929
9930                                 //mt:if %s.Field == HUDText
9931                                 Text string
9932
9933                                 //mt:if %s.Field == HUDNumber
9934                                 Number uint32
9935
9936                                 //mt:if %s.Field == HUDItem
9937                                 Item uint32
9938
9939                                 //mt:if %s.Field == HUDDir
9940                                 Dir uint32
9941
9942                                 //mt:if %s.Field == HUDAlign
9943                                 Align [2]float32
9944
9945                                 //mt:if %s.Field == HUDOffset
9946                                 Offset [2]float32
9947
9948                                 //mt:if %s.Field == HUDWorldPos
9949                                 WorldPos Pos
9950
9951                                 //mt:if %s.Field == HUDSize
9952                                 Size [2]int32
9953
9954                                 //mt:if %s.Field == HUDZIndex
9955                                 ZIndex uint32
9956
9957                                 //mt:if %s.Field == HUDText2
9958                                 Text2 string
9959                         }))(obj)).WorldPos).serialize(w)
9960                 }); err != nil {
9961                         if err == io.EOF {
9962                                 chk(io.EOF)
9963                         }
9964                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
9965                 }
9966         }
9967         if (*(*(struct {
9968                 ID HUDID
9969
9970                 Field HUDField
9971
9972                 //mt:if %s.Field == HUDPos
9973                 Pos [2]float32
9974
9975                 //mt:if %s.Field == HUDName
9976                 Name string
9977
9978                 //mt:if %s.Field == HUDScale
9979                 Scale [2]float32
9980
9981                 //mt:if %s.Field == HUDText
9982                 Text string
9983
9984                 //mt:if %s.Field == HUDNumber
9985                 Number uint32
9986
9987                 //mt:if %s.Field == HUDItem
9988                 Item uint32
9989
9990                 //mt:if %s.Field == HUDDir
9991                 Dir uint32
9992
9993                 //mt:if %s.Field == HUDAlign
9994                 Align [2]float32
9995
9996                 //mt:if %s.Field == HUDOffset
9997                 Offset [2]float32
9998
9999                 //mt:if %s.Field == HUDWorldPos
10000                 WorldPos Pos
10001
10002                 //mt:if %s.Field == HUDSize
10003                 Size [2]int32
10004
10005                 //mt:if %s.Field == HUDZIndex
10006                 ZIndex uint32
10007
10008                 //mt:if %s.Field == HUDText2
10009                 Text2 string
10010         }))(obj)).Field == HUDSize {
10011                 for local188 := range (*(*(struct {
10012                         ID HUDID
10013
10014                         Field HUDField
10015
10016                         //mt:if %s.Field == HUDPos
10017                         Pos [2]float32
10018
10019                         //mt:if %s.Field == HUDName
10020                         Name string
10021
10022                         //mt:if %s.Field == HUDScale
10023                         Scale [2]float32
10024
10025                         //mt:if %s.Field == HUDText
10026                         Text string
10027
10028                         //mt:if %s.Field == HUDNumber
10029                         Number uint32
10030
10031                         //mt:if %s.Field == HUDItem
10032                         Item uint32
10033
10034                         //mt:if %s.Field == HUDDir
10035                         Dir uint32
10036
10037                         //mt:if %s.Field == HUDAlign
10038                         Align [2]float32
10039
10040                         //mt:if %s.Field == HUDOffset
10041                         Offset [2]float32
10042
10043                         //mt:if %s.Field == HUDWorldPos
10044                         WorldPos Pos
10045
10046                         //mt:if %s.Field == HUDSize
10047                         Size [2]int32
10048
10049                         //mt:if %s.Field == HUDZIndex
10050                         ZIndex uint32
10051
10052                         //mt:if %s.Field == HUDText2
10053                         Text2 string
10054                 }))(obj)).Size {
10055                         {
10056                                 x := ((*(*(struct {
10057                                         ID HUDID
10058
10059                                         Field HUDField
10060
10061                                         //mt:if %s.Field == HUDPos
10062                                         Pos [2]float32
10063
10064                                         //mt:if %s.Field == HUDName
10065                                         Name string
10066
10067                                         //mt:if %s.Field == HUDScale
10068                                         Scale [2]float32
10069
10070                                         //mt:if %s.Field == HUDText
10071                                         Text string
10072
10073                                         //mt:if %s.Field == HUDNumber
10074                                         Number uint32
10075
10076                                         //mt:if %s.Field == HUDItem
10077                                         Item uint32
10078
10079                                         //mt:if %s.Field == HUDDir
10080                                         Dir uint32
10081
10082                                         //mt:if %s.Field == HUDAlign
10083                                         Align [2]float32
10084
10085                                         //mt:if %s.Field == HUDOffset
10086                                         Offset [2]float32
10087
10088                                         //mt:if %s.Field == HUDWorldPos
10089                                         WorldPos Pos
10090
10091                                         //mt:if %s.Field == HUDSize
10092                                         Size [2]int32
10093
10094                                         //mt:if %s.Field == HUDZIndex
10095                                         ZIndex uint32
10096
10097                                         //mt:if %s.Field == HUDText2
10098                                         Text2 string
10099                                 }))(obj)).Size)[local188]
10100                                 write32(w, uint32(x))
10101                         }
10102                 }
10103         }
10104         if (*(*(struct {
10105                 ID HUDID
10106
10107                 Field HUDField
10108
10109                 //mt:if %s.Field == HUDPos
10110                 Pos [2]float32
10111
10112                 //mt:if %s.Field == HUDName
10113                 Name string
10114
10115                 //mt:if %s.Field == HUDScale
10116                 Scale [2]float32
10117
10118                 //mt:if %s.Field == HUDText
10119                 Text string
10120
10121                 //mt:if %s.Field == HUDNumber
10122                 Number uint32
10123
10124                 //mt:if %s.Field == HUDItem
10125                 Item uint32
10126
10127                 //mt:if %s.Field == HUDDir
10128                 Dir uint32
10129
10130                 //mt:if %s.Field == HUDAlign
10131                 Align [2]float32
10132
10133                 //mt:if %s.Field == HUDOffset
10134                 Offset [2]float32
10135
10136                 //mt:if %s.Field == HUDWorldPos
10137                 WorldPos Pos
10138
10139                 //mt:if %s.Field == HUDSize
10140                 Size [2]int32
10141
10142                 //mt:if %s.Field == HUDZIndex
10143                 ZIndex uint32
10144
10145                 //mt:if %s.Field == HUDText2
10146                 Text2 string
10147         }))(obj)).Field == HUDZIndex {
10148                 {
10149                         x := (*(*(struct {
10150                                 ID HUDID
10151
10152                                 Field HUDField
10153
10154                                 //mt:if %s.Field == HUDPos
10155                                 Pos [2]float32
10156
10157                                 //mt:if %s.Field == HUDName
10158                                 Name string
10159
10160                                 //mt:if %s.Field == HUDScale
10161                                 Scale [2]float32
10162
10163                                 //mt:if %s.Field == HUDText
10164                                 Text string
10165
10166                                 //mt:if %s.Field == HUDNumber
10167                                 Number uint32
10168
10169                                 //mt:if %s.Field == HUDItem
10170                                 Item uint32
10171
10172                                 //mt:if %s.Field == HUDDir
10173                                 Dir uint32
10174
10175                                 //mt:if %s.Field == HUDAlign
10176                                 Align [2]float32
10177
10178                                 //mt:if %s.Field == HUDOffset
10179                                 Offset [2]float32
10180
10181                                 //mt:if %s.Field == HUDWorldPos
10182                                 WorldPos Pos
10183
10184                                 //mt:if %s.Field == HUDSize
10185                                 Size [2]int32
10186
10187                                 //mt:if %s.Field == HUDZIndex
10188                                 ZIndex uint32
10189
10190                                 //mt:if %s.Field == HUDText2
10191                                 Text2 string
10192                         }))(obj)).ZIndex
10193                         write32(w, uint32(x))
10194                 }
10195         }
10196         if (*(*(struct {
10197                 ID HUDID
10198
10199                 Field HUDField
10200
10201                 //mt:if %s.Field == HUDPos
10202                 Pos [2]float32
10203
10204                 //mt:if %s.Field == HUDName
10205                 Name string
10206
10207                 //mt:if %s.Field == HUDScale
10208                 Scale [2]float32
10209
10210                 //mt:if %s.Field == HUDText
10211                 Text string
10212
10213                 //mt:if %s.Field == HUDNumber
10214                 Number uint32
10215
10216                 //mt:if %s.Field == HUDItem
10217                 Item uint32
10218
10219                 //mt:if %s.Field == HUDDir
10220                 Dir uint32
10221
10222                 //mt:if %s.Field == HUDAlign
10223                 Align [2]float32
10224
10225                 //mt:if %s.Field == HUDOffset
10226                 Offset [2]float32
10227
10228                 //mt:if %s.Field == HUDWorldPos
10229                 WorldPos Pos
10230
10231                 //mt:if %s.Field == HUDSize
10232                 Size [2]int32
10233
10234                 //mt:if %s.Field == HUDZIndex
10235                 ZIndex uint32
10236
10237                 //mt:if %s.Field == HUDText2
10238                 Text2 string
10239         }))(obj)).Field == HUDText2 {
10240                 if len(([]byte((*(*(struct {
10241                         ID HUDID
10242
10243                         Field HUDField
10244
10245                         //mt:if %s.Field == HUDPos
10246                         Pos [2]float32
10247
10248                         //mt:if %s.Field == HUDName
10249                         Name string
10250
10251                         //mt:if %s.Field == HUDScale
10252                         Scale [2]float32
10253
10254                         //mt:if %s.Field == HUDText
10255                         Text string
10256
10257                         //mt:if %s.Field == HUDNumber
10258                         Number uint32
10259
10260                         //mt:if %s.Field == HUDItem
10261                         Item uint32
10262
10263                         //mt:if %s.Field == HUDDir
10264                         Dir uint32
10265
10266                         //mt:if %s.Field == HUDAlign
10267                         Align [2]float32
10268
10269                         //mt:if %s.Field == HUDOffset
10270                         Offset [2]float32
10271
10272                         //mt:if %s.Field == HUDWorldPos
10273                         WorldPos Pos
10274
10275                         //mt:if %s.Field == HUDSize
10276                         Size [2]int32
10277
10278                         //mt:if %s.Field == HUDZIndex
10279                         ZIndex uint32
10280
10281                         //mt:if %s.Field == HUDText2
10282                         Text2 string
10283                 }))(obj)).Text2))) > math.MaxUint16 {
10284                         chk(ErrTooLong)
10285                 }
10286                 {
10287                         x := uint16(len(([]byte((*(*(struct {
10288                                 ID HUDID
10289
10290                                 Field HUDField
10291
10292                                 //mt:if %s.Field == HUDPos
10293                                 Pos [2]float32
10294
10295                                 //mt:if %s.Field == HUDName
10296                                 Name string
10297
10298                                 //mt:if %s.Field == HUDScale
10299                                 Scale [2]float32
10300
10301                                 //mt:if %s.Field == HUDText
10302                                 Text string
10303
10304                                 //mt:if %s.Field == HUDNumber
10305                                 Number uint32
10306
10307                                 //mt:if %s.Field == HUDItem
10308                                 Item uint32
10309
10310                                 //mt:if %s.Field == HUDDir
10311                                 Dir uint32
10312
10313                                 //mt:if %s.Field == HUDAlign
10314                                 Align [2]float32
10315
10316                                 //mt:if %s.Field == HUDOffset
10317                                 Offset [2]float32
10318
10319                                 //mt:if %s.Field == HUDWorldPos
10320                                 WorldPos Pos
10321
10322                                 //mt:if %s.Field == HUDSize
10323                                 Size [2]int32
10324
10325                                 //mt:if %s.Field == HUDZIndex
10326                                 ZIndex uint32
10327
10328                                 //mt:if %s.Field == HUDText2
10329                                 Text2 string
10330                         }))(obj)).Text2))))
10331                         write16(w, uint16(x))
10332                 }
10333                 {
10334                         _, err := w.Write(([]byte((*(*(struct {
10335                                 ID HUDID
10336
10337                                 Field HUDField
10338
10339                                 //mt:if %s.Field == HUDPos
10340                                 Pos [2]float32
10341
10342                                 //mt:if %s.Field == HUDName
10343                                 Name string
10344
10345                                 //mt:if %s.Field == HUDScale
10346                                 Scale [2]float32
10347
10348                                 //mt:if %s.Field == HUDText
10349                                 Text string
10350
10351                                 //mt:if %s.Field == HUDNumber
10352                                 Number uint32
10353
10354                                 //mt:if %s.Field == HUDItem
10355                                 Item uint32
10356
10357                                 //mt:if %s.Field == HUDDir
10358                                 Dir uint32
10359
10360                                 //mt:if %s.Field == HUDAlign
10361                                 Align [2]float32
10362
10363                                 //mt:if %s.Field == HUDOffset
10364                                 Offset [2]float32
10365
10366                                 //mt:if %s.Field == HUDWorldPos
10367                                 WorldPos Pos
10368
10369                                 //mt:if %s.Field == HUDSize
10370                                 Size [2]int32
10371
10372                                 //mt:if %s.Field == HUDZIndex
10373                                 ZIndex uint32
10374
10375                                 //mt:if %s.Field == HUDText2
10376                                 Text2 string
10377                         }))(obj)).Text2))[:])
10378                         chk(err)
10379                 }
10380         }
10381 }
10382
10383 func (obj *ToCltChangeHUD) deserialize(r io.Reader) {
10384         if err := pcall(func() {
10385                 ((*(*(struct {
10386                         ID HUDID
10387
10388                         Field HUDField
10389
10390                         //mt:if %s.Field == HUDPos
10391                         Pos [2]float32
10392
10393                         //mt:if %s.Field == HUDName
10394                         Name string
10395
10396                         //mt:if %s.Field == HUDScale
10397                         Scale [2]float32
10398
10399                         //mt:if %s.Field == HUDText
10400                         Text string
10401
10402                         //mt:if %s.Field == HUDNumber
10403                         Number uint32
10404
10405                         //mt:if %s.Field == HUDItem
10406                         Item uint32
10407
10408                         //mt:if %s.Field == HUDDir
10409                         Dir uint32
10410
10411                         //mt:if %s.Field == HUDAlign
10412                         Align [2]float32
10413
10414                         //mt:if %s.Field == HUDOffset
10415                         Offset [2]float32
10416
10417                         //mt:if %s.Field == HUDWorldPos
10418                         WorldPos Pos
10419
10420                         //mt:if %s.Field == HUDSize
10421                         Size [2]int32
10422
10423                         //mt:if %s.Field == HUDZIndex
10424                         ZIndex uint32
10425
10426                         //mt:if %s.Field == HUDText2
10427                         Text2 string
10428                 }))(obj)).ID).deserialize(r)
10429         }); err != nil {
10430                 if err == io.EOF {
10431                         chk(io.EOF)
10432                 }
10433                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
10434         }
10435         if err := pcall(func() {
10436                 ((*(*(struct {
10437                         ID HUDID
10438
10439                         Field HUDField
10440
10441                         //mt:if %s.Field == HUDPos
10442                         Pos [2]float32
10443
10444                         //mt:if %s.Field == HUDName
10445                         Name string
10446
10447                         //mt:if %s.Field == HUDScale
10448                         Scale [2]float32
10449
10450                         //mt:if %s.Field == HUDText
10451                         Text string
10452
10453                         //mt:if %s.Field == HUDNumber
10454                         Number uint32
10455
10456                         //mt:if %s.Field == HUDItem
10457                         Item uint32
10458
10459                         //mt:if %s.Field == HUDDir
10460                         Dir uint32
10461
10462                         //mt:if %s.Field == HUDAlign
10463                         Align [2]float32
10464
10465                         //mt:if %s.Field == HUDOffset
10466                         Offset [2]float32
10467
10468                         //mt:if %s.Field == HUDWorldPos
10469                         WorldPos Pos
10470
10471                         //mt:if %s.Field == HUDSize
10472                         Size [2]int32
10473
10474                         //mt:if %s.Field == HUDZIndex
10475                         ZIndex uint32
10476
10477                         //mt:if %s.Field == HUDText2
10478                         Text2 string
10479                 }))(obj)).Field).deserialize(r)
10480         }); err != nil {
10481                 if err == io.EOF {
10482                         chk(io.EOF)
10483                 }
10484                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDField", err))
10485         }
10486         if !((*(*(struct {
10487                 ID HUDID
10488
10489                 Field HUDField
10490
10491                 //mt:if %s.Field == HUDPos
10492                 Pos [2]float32
10493
10494                 //mt:if %s.Field == HUDName
10495                 Name string
10496
10497                 //mt:if %s.Field == HUDScale
10498                 Scale [2]float32
10499
10500                 //mt:if %s.Field == HUDText
10501                 Text string
10502
10503                 //mt:if %s.Field == HUDNumber
10504                 Number uint32
10505
10506                 //mt:if %s.Field == HUDItem
10507                 Item uint32
10508
10509                 //mt:if %s.Field == HUDDir
10510                 Dir uint32
10511
10512                 //mt:if %s.Field == HUDAlign
10513                 Align [2]float32
10514
10515                 //mt:if %s.Field == HUDOffset
10516                 Offset [2]float32
10517
10518                 //mt:if %s.Field == HUDWorldPos
10519                 WorldPos Pos
10520
10521                 //mt:if %s.Field == HUDSize
10522                 Size [2]int32
10523
10524                 //mt:if %s.Field == HUDZIndex
10525                 ZIndex uint32
10526
10527                 //mt:if %s.Field == HUDText2
10528                 Text2 string
10529         }))(obj)).Field < hudMax) {
10530                 chk(errors.New("assertion failed: %s.Field < hudMax"))
10531         }
10532         if (*(*(struct {
10533                 ID HUDID
10534
10535                 Field HUDField
10536
10537                 //mt:if %s.Field == HUDPos
10538                 Pos [2]float32
10539
10540                 //mt:if %s.Field == HUDName
10541                 Name string
10542
10543                 //mt:if %s.Field == HUDScale
10544                 Scale [2]float32
10545
10546                 //mt:if %s.Field == HUDText
10547                 Text string
10548
10549                 //mt:if %s.Field == HUDNumber
10550                 Number uint32
10551
10552                 //mt:if %s.Field == HUDItem
10553                 Item uint32
10554
10555                 //mt:if %s.Field == HUDDir
10556                 Dir uint32
10557
10558                 //mt:if %s.Field == HUDAlign
10559                 Align [2]float32
10560
10561                 //mt:if %s.Field == HUDOffset
10562                 Offset [2]float32
10563
10564                 //mt:if %s.Field == HUDWorldPos
10565                 WorldPos Pos
10566
10567                 //mt:if %s.Field == HUDSize
10568                 Size [2]int32
10569
10570                 //mt:if %s.Field == HUDZIndex
10571                 ZIndex uint32
10572
10573                 //mt:if %s.Field == HUDText2
10574                 Text2 string
10575         }))(obj)).Field == HUDPos {
10576                 for local189 := range (*(*(struct {
10577                         ID HUDID
10578
10579                         Field HUDField
10580
10581                         //mt:if %s.Field == HUDPos
10582                         Pos [2]float32
10583
10584                         //mt:if %s.Field == HUDName
10585                         Name string
10586
10587                         //mt:if %s.Field == HUDScale
10588                         Scale [2]float32
10589
10590                         //mt:if %s.Field == HUDText
10591                         Text string
10592
10593                         //mt:if %s.Field == HUDNumber
10594                         Number uint32
10595
10596                         //mt:if %s.Field == HUDItem
10597                         Item uint32
10598
10599                         //mt:if %s.Field == HUDDir
10600                         Dir uint32
10601
10602                         //mt:if %s.Field == HUDAlign
10603                         Align [2]float32
10604
10605                         //mt:if %s.Field == HUDOffset
10606                         Offset [2]float32
10607
10608                         //mt:if %s.Field == HUDWorldPos
10609                         WorldPos Pos
10610
10611                         //mt:if %s.Field == HUDSize
10612                         Size [2]int32
10613
10614                         //mt:if %s.Field == HUDZIndex
10615                         ZIndex uint32
10616
10617                         //mt:if %s.Field == HUDText2
10618                         Text2 string
10619                 }))(obj)).Pos {
10620                         {
10621                                 p := &((*(*(struct {
10622                                         ID HUDID
10623
10624                                         Field HUDField
10625
10626                                         //mt:if %s.Field == HUDPos
10627                                         Pos [2]float32
10628
10629                                         //mt:if %s.Field == HUDName
10630                                         Name string
10631
10632                                         //mt:if %s.Field == HUDScale
10633                                         Scale [2]float32
10634
10635                                         //mt:if %s.Field == HUDText
10636                                         Text string
10637
10638                                         //mt:if %s.Field == HUDNumber
10639                                         Number uint32
10640
10641                                         //mt:if %s.Field == HUDItem
10642                                         Item uint32
10643
10644                                         //mt:if %s.Field == HUDDir
10645                                         Dir uint32
10646
10647                                         //mt:if %s.Field == HUDAlign
10648                                         Align [2]float32
10649
10650                                         //mt:if %s.Field == HUDOffset
10651                                         Offset [2]float32
10652
10653                                         //mt:if %s.Field == HUDWorldPos
10654                                         WorldPos Pos
10655
10656                                         //mt:if %s.Field == HUDSize
10657                                         Size [2]int32
10658
10659                                         //mt:if %s.Field == HUDZIndex
10660                                         ZIndex uint32
10661
10662                                         //mt:if %s.Field == HUDText2
10663                                         Text2 string
10664                                 }))(obj)).Pos)[local189]
10665                                 *p = math.Float32frombits(read32(r))
10666                         }
10667                 }
10668         }
10669         if (*(*(struct {
10670                 ID HUDID
10671
10672                 Field HUDField
10673
10674                 //mt:if %s.Field == HUDPos
10675                 Pos [2]float32
10676
10677                 //mt:if %s.Field == HUDName
10678                 Name string
10679
10680                 //mt:if %s.Field == HUDScale
10681                 Scale [2]float32
10682
10683                 //mt:if %s.Field == HUDText
10684                 Text string
10685
10686                 //mt:if %s.Field == HUDNumber
10687                 Number uint32
10688
10689                 //mt:if %s.Field == HUDItem
10690                 Item uint32
10691
10692                 //mt:if %s.Field == HUDDir
10693                 Dir uint32
10694
10695                 //mt:if %s.Field == HUDAlign
10696                 Align [2]float32
10697
10698                 //mt:if %s.Field == HUDOffset
10699                 Offset [2]float32
10700
10701                 //mt:if %s.Field == HUDWorldPos
10702                 WorldPos Pos
10703
10704                 //mt:if %s.Field == HUDSize
10705                 Size [2]int32
10706
10707                 //mt:if %s.Field == HUDZIndex
10708                 ZIndex uint32
10709
10710                 //mt:if %s.Field == HUDText2
10711                 Text2 string
10712         }))(obj)).Field == HUDName {
10713                 var local190 []uint8
10714                 var local191 uint16
10715                 {
10716                         p := &local191
10717                         *p = read16(r)
10718                 }
10719                 (local190) = make([]uint8, local191)
10720                 {
10721                         _, err := io.ReadFull(r, (local190)[:])
10722                         chk(err)
10723                 }
10724                 ((*(*(struct {
10725                         ID HUDID
10726
10727                         Field HUDField
10728
10729                         //mt:if %s.Field == HUDPos
10730                         Pos [2]float32
10731
10732                         //mt:if %s.Field == HUDName
10733                         Name string
10734
10735                         //mt:if %s.Field == HUDScale
10736                         Scale [2]float32
10737
10738                         //mt:if %s.Field == HUDText
10739                         Text string
10740
10741                         //mt:if %s.Field == HUDNumber
10742                         Number uint32
10743
10744                         //mt:if %s.Field == HUDItem
10745                         Item uint32
10746
10747                         //mt:if %s.Field == HUDDir
10748                         Dir uint32
10749
10750                         //mt:if %s.Field == HUDAlign
10751                         Align [2]float32
10752
10753                         //mt:if %s.Field == HUDOffset
10754                         Offset [2]float32
10755
10756                         //mt:if %s.Field == HUDWorldPos
10757                         WorldPos Pos
10758
10759                         //mt:if %s.Field == HUDSize
10760                         Size [2]int32
10761
10762                         //mt:if %s.Field == HUDZIndex
10763                         ZIndex uint32
10764
10765                         //mt:if %s.Field == HUDText2
10766                         Text2 string
10767                 }))(obj)).Name) = string(local190)
10768         }
10769         if (*(*(struct {
10770                 ID HUDID
10771
10772                 Field HUDField
10773
10774                 //mt:if %s.Field == HUDPos
10775                 Pos [2]float32
10776
10777                 //mt:if %s.Field == HUDName
10778                 Name string
10779
10780                 //mt:if %s.Field == HUDScale
10781                 Scale [2]float32
10782
10783                 //mt:if %s.Field == HUDText
10784                 Text string
10785
10786                 //mt:if %s.Field == HUDNumber
10787                 Number uint32
10788
10789                 //mt:if %s.Field == HUDItem
10790                 Item uint32
10791
10792                 //mt:if %s.Field == HUDDir
10793                 Dir uint32
10794
10795                 //mt:if %s.Field == HUDAlign
10796                 Align [2]float32
10797
10798                 //mt:if %s.Field == HUDOffset
10799                 Offset [2]float32
10800
10801                 //mt:if %s.Field == HUDWorldPos
10802                 WorldPos Pos
10803
10804                 //mt:if %s.Field == HUDSize
10805                 Size [2]int32
10806
10807                 //mt:if %s.Field == HUDZIndex
10808                 ZIndex uint32
10809
10810                 //mt:if %s.Field == HUDText2
10811                 Text2 string
10812         }))(obj)).Field == HUDScale {
10813                 for local192 := range (*(*(struct {
10814                         ID HUDID
10815
10816                         Field HUDField
10817
10818                         //mt:if %s.Field == HUDPos
10819                         Pos [2]float32
10820
10821                         //mt:if %s.Field == HUDName
10822                         Name string
10823
10824                         //mt:if %s.Field == HUDScale
10825                         Scale [2]float32
10826
10827                         //mt:if %s.Field == HUDText
10828                         Text string
10829
10830                         //mt:if %s.Field == HUDNumber
10831                         Number uint32
10832
10833                         //mt:if %s.Field == HUDItem
10834                         Item uint32
10835
10836                         //mt:if %s.Field == HUDDir
10837                         Dir uint32
10838
10839                         //mt:if %s.Field == HUDAlign
10840                         Align [2]float32
10841
10842                         //mt:if %s.Field == HUDOffset
10843                         Offset [2]float32
10844
10845                         //mt:if %s.Field == HUDWorldPos
10846                         WorldPos Pos
10847
10848                         //mt:if %s.Field == HUDSize
10849                         Size [2]int32
10850
10851                         //mt:if %s.Field == HUDZIndex
10852                         ZIndex uint32
10853
10854                         //mt:if %s.Field == HUDText2
10855                         Text2 string
10856                 }))(obj)).Scale {
10857                         {
10858                                 p := &((*(*(struct {
10859                                         ID HUDID
10860
10861                                         Field HUDField
10862
10863                                         //mt:if %s.Field == HUDPos
10864                                         Pos [2]float32
10865
10866                                         //mt:if %s.Field == HUDName
10867                                         Name string
10868
10869                                         //mt:if %s.Field == HUDScale
10870                                         Scale [2]float32
10871
10872                                         //mt:if %s.Field == HUDText
10873                                         Text string
10874
10875                                         //mt:if %s.Field == HUDNumber
10876                                         Number uint32
10877
10878                                         //mt:if %s.Field == HUDItem
10879                                         Item uint32
10880
10881                                         //mt:if %s.Field == HUDDir
10882                                         Dir uint32
10883
10884                                         //mt:if %s.Field == HUDAlign
10885                                         Align [2]float32
10886
10887                                         //mt:if %s.Field == HUDOffset
10888                                         Offset [2]float32
10889
10890                                         //mt:if %s.Field == HUDWorldPos
10891                                         WorldPos Pos
10892
10893                                         //mt:if %s.Field == HUDSize
10894                                         Size [2]int32
10895
10896                                         //mt:if %s.Field == HUDZIndex
10897                                         ZIndex uint32
10898
10899                                         //mt:if %s.Field == HUDText2
10900                                         Text2 string
10901                                 }))(obj)).Scale)[local192]
10902                                 *p = math.Float32frombits(read32(r))
10903                         }
10904                 }
10905         }
10906         if (*(*(struct {
10907                 ID HUDID
10908
10909                 Field HUDField
10910
10911                 //mt:if %s.Field == HUDPos
10912                 Pos [2]float32
10913
10914                 //mt:if %s.Field == HUDName
10915                 Name string
10916
10917                 //mt:if %s.Field == HUDScale
10918                 Scale [2]float32
10919
10920                 //mt:if %s.Field == HUDText
10921                 Text string
10922
10923                 //mt:if %s.Field == HUDNumber
10924                 Number uint32
10925
10926                 //mt:if %s.Field == HUDItem
10927                 Item uint32
10928
10929                 //mt:if %s.Field == HUDDir
10930                 Dir uint32
10931
10932                 //mt:if %s.Field == HUDAlign
10933                 Align [2]float32
10934
10935                 //mt:if %s.Field == HUDOffset
10936                 Offset [2]float32
10937
10938                 //mt:if %s.Field == HUDWorldPos
10939                 WorldPos Pos
10940
10941                 //mt:if %s.Field == HUDSize
10942                 Size [2]int32
10943
10944                 //mt:if %s.Field == HUDZIndex
10945                 ZIndex uint32
10946
10947                 //mt:if %s.Field == HUDText2
10948                 Text2 string
10949         }))(obj)).Field == HUDText {
10950                 var local193 []uint8
10951                 var local194 uint16
10952                 {
10953                         p := &local194
10954                         *p = read16(r)
10955                 }
10956                 (local193) = make([]uint8, local194)
10957                 {
10958                         _, err := io.ReadFull(r, (local193)[:])
10959                         chk(err)
10960                 }
10961                 ((*(*(struct {
10962                         ID HUDID
10963
10964                         Field HUDField
10965
10966                         //mt:if %s.Field == HUDPos
10967                         Pos [2]float32
10968
10969                         //mt:if %s.Field == HUDName
10970                         Name string
10971
10972                         //mt:if %s.Field == HUDScale
10973                         Scale [2]float32
10974
10975                         //mt:if %s.Field == HUDText
10976                         Text string
10977
10978                         //mt:if %s.Field == HUDNumber
10979                         Number uint32
10980
10981                         //mt:if %s.Field == HUDItem
10982                         Item uint32
10983
10984                         //mt:if %s.Field == HUDDir
10985                         Dir uint32
10986
10987                         //mt:if %s.Field == HUDAlign
10988                         Align [2]float32
10989
10990                         //mt:if %s.Field == HUDOffset
10991                         Offset [2]float32
10992
10993                         //mt:if %s.Field == HUDWorldPos
10994                         WorldPos Pos
10995
10996                         //mt:if %s.Field == HUDSize
10997                         Size [2]int32
10998
10999                         //mt:if %s.Field == HUDZIndex
11000                         ZIndex uint32
11001
11002                         //mt:if %s.Field == HUDText2
11003                         Text2 string
11004                 }))(obj)).Text) = string(local193)
11005         }
11006         if (*(*(struct {
11007                 ID HUDID
11008
11009                 Field HUDField
11010
11011                 //mt:if %s.Field == HUDPos
11012                 Pos [2]float32
11013
11014                 //mt:if %s.Field == HUDName
11015                 Name string
11016
11017                 //mt:if %s.Field == HUDScale
11018                 Scale [2]float32
11019
11020                 //mt:if %s.Field == HUDText
11021                 Text string
11022
11023                 //mt:if %s.Field == HUDNumber
11024                 Number uint32
11025
11026                 //mt:if %s.Field == HUDItem
11027                 Item uint32
11028
11029                 //mt:if %s.Field == HUDDir
11030                 Dir uint32
11031
11032                 //mt:if %s.Field == HUDAlign
11033                 Align [2]float32
11034
11035                 //mt:if %s.Field == HUDOffset
11036                 Offset [2]float32
11037
11038                 //mt:if %s.Field == HUDWorldPos
11039                 WorldPos Pos
11040
11041                 //mt:if %s.Field == HUDSize
11042                 Size [2]int32
11043
11044                 //mt:if %s.Field == HUDZIndex
11045                 ZIndex uint32
11046
11047                 //mt:if %s.Field == HUDText2
11048                 Text2 string
11049         }))(obj)).Field == HUDNumber {
11050                 {
11051                         p := &(*(*(struct {
11052                                 ID HUDID
11053
11054                                 Field HUDField
11055
11056                                 //mt:if %s.Field == HUDPos
11057                                 Pos [2]float32
11058
11059                                 //mt:if %s.Field == HUDName
11060                                 Name string
11061
11062                                 //mt:if %s.Field == HUDScale
11063                                 Scale [2]float32
11064
11065                                 //mt:if %s.Field == HUDText
11066                                 Text string
11067
11068                                 //mt:if %s.Field == HUDNumber
11069                                 Number uint32
11070
11071                                 //mt:if %s.Field == HUDItem
11072                                 Item uint32
11073
11074                                 //mt:if %s.Field == HUDDir
11075                                 Dir uint32
11076
11077                                 //mt:if %s.Field == HUDAlign
11078                                 Align [2]float32
11079
11080                                 //mt:if %s.Field == HUDOffset
11081                                 Offset [2]float32
11082
11083                                 //mt:if %s.Field == HUDWorldPos
11084                                 WorldPos Pos
11085
11086                                 //mt:if %s.Field == HUDSize
11087                                 Size [2]int32
11088
11089                                 //mt:if %s.Field == HUDZIndex
11090                                 ZIndex uint32
11091
11092                                 //mt:if %s.Field == HUDText2
11093                                 Text2 string
11094                         }))(obj)).Number
11095                         *p = read32(r)
11096                 }
11097         }
11098         if (*(*(struct {
11099                 ID HUDID
11100
11101                 Field HUDField
11102
11103                 //mt:if %s.Field == HUDPos
11104                 Pos [2]float32
11105
11106                 //mt:if %s.Field == HUDName
11107                 Name string
11108
11109                 //mt:if %s.Field == HUDScale
11110                 Scale [2]float32
11111
11112                 //mt:if %s.Field == HUDText
11113                 Text string
11114
11115                 //mt:if %s.Field == HUDNumber
11116                 Number uint32
11117
11118                 //mt:if %s.Field == HUDItem
11119                 Item uint32
11120
11121                 //mt:if %s.Field == HUDDir
11122                 Dir uint32
11123
11124                 //mt:if %s.Field == HUDAlign
11125                 Align [2]float32
11126
11127                 //mt:if %s.Field == HUDOffset
11128                 Offset [2]float32
11129
11130                 //mt:if %s.Field == HUDWorldPos
11131                 WorldPos Pos
11132
11133                 //mt:if %s.Field == HUDSize
11134                 Size [2]int32
11135
11136                 //mt:if %s.Field == HUDZIndex
11137                 ZIndex uint32
11138
11139                 //mt:if %s.Field == HUDText2
11140                 Text2 string
11141         }))(obj)).Field == HUDItem {
11142                 {
11143                         p := &(*(*(struct {
11144                                 ID HUDID
11145
11146                                 Field HUDField
11147
11148                                 //mt:if %s.Field == HUDPos
11149                                 Pos [2]float32
11150
11151                                 //mt:if %s.Field == HUDName
11152                                 Name string
11153
11154                                 //mt:if %s.Field == HUDScale
11155                                 Scale [2]float32
11156
11157                                 //mt:if %s.Field == HUDText
11158                                 Text string
11159
11160                                 //mt:if %s.Field == HUDNumber
11161                                 Number uint32
11162
11163                                 //mt:if %s.Field == HUDItem
11164                                 Item uint32
11165
11166                                 //mt:if %s.Field == HUDDir
11167                                 Dir uint32
11168
11169                                 //mt:if %s.Field == HUDAlign
11170                                 Align [2]float32
11171
11172                                 //mt:if %s.Field == HUDOffset
11173                                 Offset [2]float32
11174
11175                                 //mt:if %s.Field == HUDWorldPos
11176                                 WorldPos Pos
11177
11178                                 //mt:if %s.Field == HUDSize
11179                                 Size [2]int32
11180
11181                                 //mt:if %s.Field == HUDZIndex
11182                                 ZIndex uint32
11183
11184                                 //mt:if %s.Field == HUDText2
11185                                 Text2 string
11186                         }))(obj)).Item
11187                         *p = read32(r)
11188                 }
11189         }
11190         if (*(*(struct {
11191                 ID HUDID
11192
11193                 Field HUDField
11194
11195                 //mt:if %s.Field == HUDPos
11196                 Pos [2]float32
11197
11198                 //mt:if %s.Field == HUDName
11199                 Name string
11200
11201                 //mt:if %s.Field == HUDScale
11202                 Scale [2]float32
11203
11204                 //mt:if %s.Field == HUDText
11205                 Text string
11206
11207                 //mt:if %s.Field == HUDNumber
11208                 Number uint32
11209
11210                 //mt:if %s.Field == HUDItem
11211                 Item uint32
11212
11213                 //mt:if %s.Field == HUDDir
11214                 Dir uint32
11215
11216                 //mt:if %s.Field == HUDAlign
11217                 Align [2]float32
11218
11219                 //mt:if %s.Field == HUDOffset
11220                 Offset [2]float32
11221
11222                 //mt:if %s.Field == HUDWorldPos
11223                 WorldPos Pos
11224
11225                 //mt:if %s.Field == HUDSize
11226                 Size [2]int32
11227
11228                 //mt:if %s.Field == HUDZIndex
11229                 ZIndex uint32
11230
11231                 //mt:if %s.Field == HUDText2
11232                 Text2 string
11233         }))(obj)).Field == HUDDir {
11234                 {
11235                         p := &(*(*(struct {
11236                                 ID HUDID
11237
11238                                 Field HUDField
11239
11240                                 //mt:if %s.Field == HUDPos
11241                                 Pos [2]float32
11242
11243                                 //mt:if %s.Field == HUDName
11244                                 Name string
11245
11246                                 //mt:if %s.Field == HUDScale
11247                                 Scale [2]float32
11248
11249                                 //mt:if %s.Field == HUDText
11250                                 Text string
11251
11252                                 //mt:if %s.Field == HUDNumber
11253                                 Number uint32
11254
11255                                 //mt:if %s.Field == HUDItem
11256                                 Item uint32
11257
11258                                 //mt:if %s.Field == HUDDir
11259                                 Dir uint32
11260
11261                                 //mt:if %s.Field == HUDAlign
11262                                 Align [2]float32
11263
11264                                 //mt:if %s.Field == HUDOffset
11265                                 Offset [2]float32
11266
11267                                 //mt:if %s.Field == HUDWorldPos
11268                                 WorldPos Pos
11269
11270                                 //mt:if %s.Field == HUDSize
11271                                 Size [2]int32
11272
11273                                 //mt:if %s.Field == HUDZIndex
11274                                 ZIndex uint32
11275
11276                                 //mt:if %s.Field == HUDText2
11277                                 Text2 string
11278                         }))(obj)).Dir
11279                         *p = read32(r)
11280                 }
11281         }
11282         if (*(*(struct {
11283                 ID HUDID
11284
11285                 Field HUDField
11286
11287                 //mt:if %s.Field == HUDPos
11288                 Pos [2]float32
11289
11290                 //mt:if %s.Field == HUDName
11291                 Name string
11292
11293                 //mt:if %s.Field == HUDScale
11294                 Scale [2]float32
11295
11296                 //mt:if %s.Field == HUDText
11297                 Text string
11298
11299                 //mt:if %s.Field == HUDNumber
11300                 Number uint32
11301
11302                 //mt:if %s.Field == HUDItem
11303                 Item uint32
11304
11305                 //mt:if %s.Field == HUDDir
11306                 Dir uint32
11307
11308                 //mt:if %s.Field == HUDAlign
11309                 Align [2]float32
11310
11311                 //mt:if %s.Field == HUDOffset
11312                 Offset [2]float32
11313
11314                 //mt:if %s.Field == HUDWorldPos
11315                 WorldPos Pos
11316
11317                 //mt:if %s.Field == HUDSize
11318                 Size [2]int32
11319
11320                 //mt:if %s.Field == HUDZIndex
11321                 ZIndex uint32
11322
11323                 //mt:if %s.Field == HUDText2
11324                 Text2 string
11325         }))(obj)).Field == HUDAlign {
11326                 for local195 := range (*(*(struct {
11327                         ID HUDID
11328
11329                         Field HUDField
11330
11331                         //mt:if %s.Field == HUDPos
11332                         Pos [2]float32
11333
11334                         //mt:if %s.Field == HUDName
11335                         Name string
11336
11337                         //mt:if %s.Field == HUDScale
11338                         Scale [2]float32
11339
11340                         //mt:if %s.Field == HUDText
11341                         Text string
11342
11343                         //mt:if %s.Field == HUDNumber
11344                         Number uint32
11345
11346                         //mt:if %s.Field == HUDItem
11347                         Item uint32
11348
11349                         //mt:if %s.Field == HUDDir
11350                         Dir uint32
11351
11352                         //mt:if %s.Field == HUDAlign
11353                         Align [2]float32
11354
11355                         //mt:if %s.Field == HUDOffset
11356                         Offset [2]float32
11357
11358                         //mt:if %s.Field == HUDWorldPos
11359                         WorldPos Pos
11360
11361                         //mt:if %s.Field == HUDSize
11362                         Size [2]int32
11363
11364                         //mt:if %s.Field == HUDZIndex
11365                         ZIndex uint32
11366
11367                         //mt:if %s.Field == HUDText2
11368                         Text2 string
11369                 }))(obj)).Align {
11370                         {
11371                                 p := &((*(*(struct {
11372                                         ID HUDID
11373
11374                                         Field HUDField
11375
11376                                         //mt:if %s.Field == HUDPos
11377                                         Pos [2]float32
11378
11379                                         //mt:if %s.Field == HUDName
11380                                         Name string
11381
11382                                         //mt:if %s.Field == HUDScale
11383                                         Scale [2]float32
11384
11385                                         //mt:if %s.Field == HUDText
11386                                         Text string
11387
11388                                         //mt:if %s.Field == HUDNumber
11389                                         Number uint32
11390
11391                                         //mt:if %s.Field == HUDItem
11392                                         Item uint32
11393
11394                                         //mt:if %s.Field == HUDDir
11395                                         Dir uint32
11396
11397                                         //mt:if %s.Field == HUDAlign
11398                                         Align [2]float32
11399
11400                                         //mt:if %s.Field == HUDOffset
11401                                         Offset [2]float32
11402
11403                                         //mt:if %s.Field == HUDWorldPos
11404                                         WorldPos Pos
11405
11406                                         //mt:if %s.Field == HUDSize
11407                                         Size [2]int32
11408
11409                                         //mt:if %s.Field == HUDZIndex
11410                                         ZIndex uint32
11411
11412                                         //mt:if %s.Field == HUDText2
11413                                         Text2 string
11414                                 }))(obj)).Align)[local195]
11415                                 *p = math.Float32frombits(read32(r))
11416                         }
11417                 }
11418         }
11419         if (*(*(struct {
11420                 ID HUDID
11421
11422                 Field HUDField
11423
11424                 //mt:if %s.Field == HUDPos
11425                 Pos [2]float32
11426
11427                 //mt:if %s.Field == HUDName
11428                 Name string
11429
11430                 //mt:if %s.Field == HUDScale
11431                 Scale [2]float32
11432
11433                 //mt:if %s.Field == HUDText
11434                 Text string
11435
11436                 //mt:if %s.Field == HUDNumber
11437                 Number uint32
11438
11439                 //mt:if %s.Field == HUDItem
11440                 Item uint32
11441
11442                 //mt:if %s.Field == HUDDir
11443                 Dir uint32
11444
11445                 //mt:if %s.Field == HUDAlign
11446                 Align [2]float32
11447
11448                 //mt:if %s.Field == HUDOffset
11449                 Offset [2]float32
11450
11451                 //mt:if %s.Field == HUDWorldPos
11452                 WorldPos Pos
11453
11454                 //mt:if %s.Field == HUDSize
11455                 Size [2]int32
11456
11457                 //mt:if %s.Field == HUDZIndex
11458                 ZIndex uint32
11459
11460                 //mt:if %s.Field == HUDText2
11461                 Text2 string
11462         }))(obj)).Field == HUDOffset {
11463                 for local196 := range (*(*(struct {
11464                         ID HUDID
11465
11466                         Field HUDField
11467
11468                         //mt:if %s.Field == HUDPos
11469                         Pos [2]float32
11470
11471                         //mt:if %s.Field == HUDName
11472                         Name string
11473
11474                         //mt:if %s.Field == HUDScale
11475                         Scale [2]float32
11476
11477                         //mt:if %s.Field == HUDText
11478                         Text string
11479
11480                         //mt:if %s.Field == HUDNumber
11481                         Number uint32
11482
11483                         //mt:if %s.Field == HUDItem
11484                         Item uint32
11485
11486                         //mt:if %s.Field == HUDDir
11487                         Dir uint32
11488
11489                         //mt:if %s.Field == HUDAlign
11490                         Align [2]float32
11491
11492                         //mt:if %s.Field == HUDOffset
11493                         Offset [2]float32
11494
11495                         //mt:if %s.Field == HUDWorldPos
11496                         WorldPos Pos
11497
11498                         //mt:if %s.Field == HUDSize
11499                         Size [2]int32
11500
11501                         //mt:if %s.Field == HUDZIndex
11502                         ZIndex uint32
11503
11504                         //mt:if %s.Field == HUDText2
11505                         Text2 string
11506                 }))(obj)).Offset {
11507                         {
11508                                 p := &((*(*(struct {
11509                                         ID HUDID
11510
11511                                         Field HUDField
11512
11513                                         //mt:if %s.Field == HUDPos
11514                                         Pos [2]float32
11515
11516                                         //mt:if %s.Field == HUDName
11517                                         Name string
11518
11519                                         //mt:if %s.Field == HUDScale
11520                                         Scale [2]float32
11521
11522                                         //mt:if %s.Field == HUDText
11523                                         Text string
11524
11525                                         //mt:if %s.Field == HUDNumber
11526                                         Number uint32
11527
11528                                         //mt:if %s.Field == HUDItem
11529                                         Item uint32
11530
11531                                         //mt:if %s.Field == HUDDir
11532                                         Dir uint32
11533
11534                                         //mt:if %s.Field == HUDAlign
11535                                         Align [2]float32
11536
11537                                         //mt:if %s.Field == HUDOffset
11538                                         Offset [2]float32
11539
11540                                         //mt:if %s.Field == HUDWorldPos
11541                                         WorldPos Pos
11542
11543                                         //mt:if %s.Field == HUDSize
11544                                         Size [2]int32
11545
11546                                         //mt:if %s.Field == HUDZIndex
11547                                         ZIndex uint32
11548
11549                                         //mt:if %s.Field == HUDText2
11550                                         Text2 string
11551                                 }))(obj)).Offset)[local196]
11552                                 *p = math.Float32frombits(read32(r))
11553                         }
11554                 }
11555         }
11556         if (*(*(struct {
11557                 ID HUDID
11558
11559                 Field HUDField
11560
11561                 //mt:if %s.Field == HUDPos
11562                 Pos [2]float32
11563
11564                 //mt:if %s.Field == HUDName
11565                 Name string
11566
11567                 //mt:if %s.Field == HUDScale
11568                 Scale [2]float32
11569
11570                 //mt:if %s.Field == HUDText
11571                 Text string
11572
11573                 //mt:if %s.Field == HUDNumber
11574                 Number uint32
11575
11576                 //mt:if %s.Field == HUDItem
11577                 Item uint32
11578
11579                 //mt:if %s.Field == HUDDir
11580                 Dir uint32
11581
11582                 //mt:if %s.Field == HUDAlign
11583                 Align [2]float32
11584
11585                 //mt:if %s.Field == HUDOffset
11586                 Offset [2]float32
11587
11588                 //mt:if %s.Field == HUDWorldPos
11589                 WorldPos Pos
11590
11591                 //mt:if %s.Field == HUDSize
11592                 Size [2]int32
11593
11594                 //mt:if %s.Field == HUDZIndex
11595                 ZIndex uint32
11596
11597                 //mt:if %s.Field == HUDText2
11598                 Text2 string
11599         }))(obj)).Field == HUDWorldPos {
11600                 if err := pcall(func() {
11601                         ((*(*(struct {
11602                                 ID HUDID
11603
11604                                 Field HUDField
11605
11606                                 //mt:if %s.Field == HUDPos
11607                                 Pos [2]float32
11608
11609                                 //mt:if %s.Field == HUDName
11610                                 Name string
11611
11612                                 //mt:if %s.Field == HUDScale
11613                                 Scale [2]float32
11614
11615                                 //mt:if %s.Field == HUDText
11616                                 Text string
11617
11618                                 //mt:if %s.Field == HUDNumber
11619                                 Number uint32
11620
11621                                 //mt:if %s.Field == HUDItem
11622                                 Item uint32
11623
11624                                 //mt:if %s.Field == HUDDir
11625                                 Dir uint32
11626
11627                                 //mt:if %s.Field == HUDAlign
11628                                 Align [2]float32
11629
11630                                 //mt:if %s.Field == HUDOffset
11631                                 Offset [2]float32
11632
11633                                 //mt:if %s.Field == HUDWorldPos
11634                                 WorldPos Pos
11635
11636                                 //mt:if %s.Field == HUDSize
11637                                 Size [2]int32
11638
11639                                 //mt:if %s.Field == HUDZIndex
11640                                 ZIndex uint32
11641
11642                                 //mt:if %s.Field == HUDText2
11643                                 Text2 string
11644                         }))(obj)).WorldPos).deserialize(r)
11645                 }); err != nil {
11646                         if err == io.EOF {
11647                                 chk(io.EOF)
11648                         }
11649                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
11650                 }
11651         }
11652         if (*(*(struct {
11653                 ID HUDID
11654
11655                 Field HUDField
11656
11657                 //mt:if %s.Field == HUDPos
11658                 Pos [2]float32
11659
11660                 //mt:if %s.Field == HUDName
11661                 Name string
11662
11663                 //mt:if %s.Field == HUDScale
11664                 Scale [2]float32
11665
11666                 //mt:if %s.Field == HUDText
11667                 Text string
11668
11669                 //mt:if %s.Field == HUDNumber
11670                 Number uint32
11671
11672                 //mt:if %s.Field == HUDItem
11673                 Item uint32
11674
11675                 //mt:if %s.Field == HUDDir
11676                 Dir uint32
11677
11678                 //mt:if %s.Field == HUDAlign
11679                 Align [2]float32
11680
11681                 //mt:if %s.Field == HUDOffset
11682                 Offset [2]float32
11683
11684                 //mt:if %s.Field == HUDWorldPos
11685                 WorldPos Pos
11686
11687                 //mt:if %s.Field == HUDSize
11688                 Size [2]int32
11689
11690                 //mt:if %s.Field == HUDZIndex
11691                 ZIndex uint32
11692
11693                 //mt:if %s.Field == HUDText2
11694                 Text2 string
11695         }))(obj)).Field == HUDSize {
11696                 for local197 := range (*(*(struct {
11697                         ID HUDID
11698
11699                         Field HUDField
11700
11701                         //mt:if %s.Field == HUDPos
11702                         Pos [2]float32
11703
11704                         //mt:if %s.Field == HUDName
11705                         Name string
11706
11707                         //mt:if %s.Field == HUDScale
11708                         Scale [2]float32
11709
11710                         //mt:if %s.Field == HUDText
11711                         Text string
11712
11713                         //mt:if %s.Field == HUDNumber
11714                         Number uint32
11715
11716                         //mt:if %s.Field == HUDItem
11717                         Item uint32
11718
11719                         //mt:if %s.Field == HUDDir
11720                         Dir uint32
11721
11722                         //mt:if %s.Field == HUDAlign
11723                         Align [2]float32
11724
11725                         //mt:if %s.Field == HUDOffset
11726                         Offset [2]float32
11727
11728                         //mt:if %s.Field == HUDWorldPos
11729                         WorldPos Pos
11730
11731                         //mt:if %s.Field == HUDSize
11732                         Size [2]int32
11733
11734                         //mt:if %s.Field == HUDZIndex
11735                         ZIndex uint32
11736
11737                         //mt:if %s.Field == HUDText2
11738                         Text2 string
11739                 }))(obj)).Size {
11740                         {
11741                                 p := &((*(*(struct {
11742                                         ID HUDID
11743
11744                                         Field HUDField
11745
11746                                         //mt:if %s.Field == HUDPos
11747                                         Pos [2]float32
11748
11749                                         //mt:if %s.Field == HUDName
11750                                         Name string
11751
11752                                         //mt:if %s.Field == HUDScale
11753                                         Scale [2]float32
11754
11755                                         //mt:if %s.Field == HUDText
11756                                         Text string
11757
11758                                         //mt:if %s.Field == HUDNumber
11759                                         Number uint32
11760
11761                                         //mt:if %s.Field == HUDItem
11762                                         Item uint32
11763
11764                                         //mt:if %s.Field == HUDDir
11765                                         Dir uint32
11766
11767                                         //mt:if %s.Field == HUDAlign
11768                                         Align [2]float32
11769
11770                                         //mt:if %s.Field == HUDOffset
11771                                         Offset [2]float32
11772
11773                                         //mt:if %s.Field == HUDWorldPos
11774                                         WorldPos Pos
11775
11776                                         //mt:if %s.Field == HUDSize
11777                                         Size [2]int32
11778
11779                                         //mt:if %s.Field == HUDZIndex
11780                                         ZIndex uint32
11781
11782                                         //mt:if %s.Field == HUDText2
11783                                         Text2 string
11784                                 }))(obj)).Size)[local197]
11785                                 *p = int32(read32(r))
11786                         }
11787                 }
11788         }
11789         if (*(*(struct {
11790                 ID HUDID
11791
11792                 Field HUDField
11793
11794                 //mt:if %s.Field == HUDPos
11795                 Pos [2]float32
11796
11797                 //mt:if %s.Field == HUDName
11798                 Name string
11799
11800                 //mt:if %s.Field == HUDScale
11801                 Scale [2]float32
11802
11803                 //mt:if %s.Field == HUDText
11804                 Text string
11805
11806                 //mt:if %s.Field == HUDNumber
11807                 Number uint32
11808
11809                 //mt:if %s.Field == HUDItem
11810                 Item uint32
11811
11812                 //mt:if %s.Field == HUDDir
11813                 Dir uint32
11814
11815                 //mt:if %s.Field == HUDAlign
11816                 Align [2]float32
11817
11818                 //mt:if %s.Field == HUDOffset
11819                 Offset [2]float32
11820
11821                 //mt:if %s.Field == HUDWorldPos
11822                 WorldPos Pos
11823
11824                 //mt:if %s.Field == HUDSize
11825                 Size [2]int32
11826
11827                 //mt:if %s.Field == HUDZIndex
11828                 ZIndex uint32
11829
11830                 //mt:if %s.Field == HUDText2
11831                 Text2 string
11832         }))(obj)).Field == HUDZIndex {
11833                 {
11834                         p := &(*(*(struct {
11835                                 ID HUDID
11836
11837                                 Field HUDField
11838
11839                                 //mt:if %s.Field == HUDPos
11840                                 Pos [2]float32
11841
11842                                 //mt:if %s.Field == HUDName
11843                                 Name string
11844
11845                                 //mt:if %s.Field == HUDScale
11846                                 Scale [2]float32
11847
11848                                 //mt:if %s.Field == HUDText
11849                                 Text string
11850
11851                                 //mt:if %s.Field == HUDNumber
11852                                 Number uint32
11853
11854                                 //mt:if %s.Field == HUDItem
11855                                 Item uint32
11856
11857                                 //mt:if %s.Field == HUDDir
11858                                 Dir uint32
11859
11860                                 //mt:if %s.Field == HUDAlign
11861                                 Align [2]float32
11862
11863                                 //mt:if %s.Field == HUDOffset
11864                                 Offset [2]float32
11865
11866                                 //mt:if %s.Field == HUDWorldPos
11867                                 WorldPos Pos
11868
11869                                 //mt:if %s.Field == HUDSize
11870                                 Size [2]int32
11871
11872                                 //mt:if %s.Field == HUDZIndex
11873                                 ZIndex uint32
11874
11875                                 //mt:if %s.Field == HUDText2
11876                                 Text2 string
11877                         }))(obj)).ZIndex
11878                         *p = read32(r)
11879                 }
11880         }
11881         if (*(*(struct {
11882                 ID HUDID
11883
11884                 Field HUDField
11885
11886                 //mt:if %s.Field == HUDPos
11887                 Pos [2]float32
11888
11889                 //mt:if %s.Field == HUDName
11890                 Name string
11891
11892                 //mt:if %s.Field == HUDScale
11893                 Scale [2]float32
11894
11895                 //mt:if %s.Field == HUDText
11896                 Text string
11897
11898                 //mt:if %s.Field == HUDNumber
11899                 Number uint32
11900
11901                 //mt:if %s.Field == HUDItem
11902                 Item uint32
11903
11904                 //mt:if %s.Field == HUDDir
11905                 Dir uint32
11906
11907                 //mt:if %s.Field == HUDAlign
11908                 Align [2]float32
11909
11910                 //mt:if %s.Field == HUDOffset
11911                 Offset [2]float32
11912
11913                 //mt:if %s.Field == HUDWorldPos
11914                 WorldPos Pos
11915
11916                 //mt:if %s.Field == HUDSize
11917                 Size [2]int32
11918
11919                 //mt:if %s.Field == HUDZIndex
11920                 ZIndex uint32
11921
11922                 //mt:if %s.Field == HUDText2
11923                 Text2 string
11924         }))(obj)).Field == HUDText2 {
11925                 var local198 []uint8
11926                 var local199 uint16
11927                 {
11928                         p := &local199
11929                         *p = read16(r)
11930                 }
11931                 (local198) = make([]uint8, local199)
11932                 {
11933                         _, err := io.ReadFull(r, (local198)[:])
11934                         chk(err)
11935                 }
11936                 ((*(*(struct {
11937                         ID HUDID
11938
11939                         Field HUDField
11940
11941                         //mt:if %s.Field == HUDPos
11942                         Pos [2]float32
11943
11944                         //mt:if %s.Field == HUDName
11945                         Name string
11946
11947                         //mt:if %s.Field == HUDScale
11948                         Scale [2]float32
11949
11950                         //mt:if %s.Field == HUDText
11951                         Text string
11952
11953                         //mt:if %s.Field == HUDNumber
11954                         Number uint32
11955
11956                         //mt:if %s.Field == HUDItem
11957                         Item uint32
11958
11959                         //mt:if %s.Field == HUDDir
11960                         Dir uint32
11961
11962                         //mt:if %s.Field == HUDAlign
11963                         Align [2]float32
11964
11965                         //mt:if %s.Field == HUDOffset
11966                         Offset [2]float32
11967
11968                         //mt:if %s.Field == HUDWorldPos
11969                         WorldPos Pos
11970
11971                         //mt:if %s.Field == HUDSize
11972                         Size [2]int32
11973
11974                         //mt:if %s.Field == HUDZIndex
11975                         ZIndex uint32
11976
11977                         //mt:if %s.Field == HUDText2
11978                         Text2 string
11979                 }))(obj)).Text2) = string(local198)
11980         }
11981 }
11982
11983 func (obj *ToCltHUDFlags) serialize(w io.Writer) {
11984         if err := pcall(func() {
11985                 ((*(*(struct {
11986                         // &^= Mask
11987                         // |= Flags
11988                         Flags, Mask HUDFlags
11989                 }))(obj)).Flags).serialize(w)
11990         }); err != nil {
11991                 if err == io.EOF {
11992                         chk(io.EOF)
11993                 }
11994                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
11995         }
11996         if err := pcall(func() {
11997                 ((*(*(struct {
11998                         // &^= Mask
11999                         // |= Flags
12000                         Flags, Mask HUDFlags
12001                 }))(obj)).Mask).serialize(w)
12002         }); err != nil {
12003                 if err == io.EOF {
12004                         chk(io.EOF)
12005                 }
12006                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
12007         }
12008 }
12009
12010 func (obj *ToCltHUDFlags) deserialize(r io.Reader) {
12011         if err := pcall(func() {
12012                 ((*(*(struct {
12013                         // &^= Mask
12014                         // |= Flags
12015                         Flags, Mask HUDFlags
12016                 }))(obj)).Flags).deserialize(r)
12017         }); err != nil {
12018                 if err == io.EOF {
12019                         chk(io.EOF)
12020                 }
12021                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
12022         }
12023         if err := pcall(func() {
12024                 ((*(*(struct {
12025                         // &^= Mask
12026                         // |= Flags
12027                         Flags, Mask HUDFlags
12028                 }))(obj)).Mask).deserialize(r)
12029         }); err != nil {
12030                 if err == io.EOF {
12031                         chk(io.EOF)
12032                 }
12033                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
12034         }
12035 }
12036
12037 func (obj *ToCltSetHotbarParam) serialize(w io.Writer) {
12038         if err := pcall(func() {
12039                 ((*(*(struct {
12040                         Param HotbarParam
12041
12042                         //mt:if %s.Param == HotbarSize
12043                         //mt:const uint16(4) // Size of Size field.
12044                         Size int32
12045
12046                         //mt:if %s.Param != HotbarSize
12047                         Img Texture
12048                 }))(obj)).Param).serialize(w)
12049         }); err != nil {
12050                 if err == io.EOF {
12051                         chk(io.EOF)
12052                 }
12053                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HotbarParam", err))
12054         }
12055         if (*(*(struct {
12056                 Param HotbarParam
12057
12058                 //mt:if %s.Param == HotbarSize
12059                 //mt:const uint16(4) // Size of Size field.
12060                 Size int32
12061
12062                 //mt:if %s.Param != HotbarSize
12063                 Img Texture
12064         }))(obj)).Param == HotbarSize {
12065                 {
12066                         local200 := uint16(4) // Size of Size field.
12067                         {
12068                                 x := local200
12069                                 write16(w, uint16(x))
12070                         }
12071                 }
12072                 {
12073                         x := (*(*(struct {
12074                                 Param HotbarParam
12075
12076                                 //mt:if %s.Param == HotbarSize
12077                                 //mt:const uint16(4) // Size of Size field.
12078                                 Size int32
12079
12080                                 //mt:if %s.Param != HotbarSize
12081                                 Img Texture
12082                         }))(obj)).Size
12083                         write32(w, uint32(x))
12084                 }
12085         }
12086         if (*(*(struct {
12087                 Param HotbarParam
12088
12089                 //mt:if %s.Param == HotbarSize
12090                 //mt:const uint16(4) // Size of Size field.
12091                 Size int32
12092
12093                 //mt:if %s.Param != HotbarSize
12094                 Img Texture
12095         }))(obj)).Param != HotbarSize {
12096                 if err := pcall(func() {
12097                         ((*(*(struct {
12098                                 Param HotbarParam
12099
12100                                 //mt:if %s.Param == HotbarSize
12101                                 //mt:const uint16(4) // Size of Size field.
12102                                 Size int32
12103
12104                                 //mt:if %s.Param != HotbarSize
12105                                 Img Texture
12106                         }))(obj)).Img).serialize(w)
12107                 }); err != nil {
12108                         if err == io.EOF {
12109                                 chk(io.EOF)
12110                         }
12111                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12112                 }
12113         }
12114 }
12115
12116 func (obj *ToCltSetHotbarParam) deserialize(r io.Reader) {
12117         if err := pcall(func() {
12118                 ((*(*(struct {
12119                         Param HotbarParam
12120
12121                         //mt:if %s.Param == HotbarSize
12122                         //mt:const uint16(4) // Size of Size field.
12123                         Size int32
12124
12125                         //mt:if %s.Param != HotbarSize
12126                         Img Texture
12127                 }))(obj)).Param).deserialize(r)
12128         }); err != nil {
12129                 if err == io.EOF {
12130                         chk(io.EOF)
12131                 }
12132                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HotbarParam", err))
12133         }
12134         if (*(*(struct {
12135                 Param HotbarParam
12136
12137                 //mt:if %s.Param == HotbarSize
12138                 //mt:const uint16(4) // Size of Size field.
12139                 Size int32
12140
12141                 //mt:if %s.Param != HotbarSize
12142                 Img Texture
12143         }))(obj)).Param == HotbarSize {
12144                 {
12145                         var local201 uint16
12146                         {
12147                                 p := &local201
12148                                 *p = read16(r)
12149                         }
12150                         if local201 != (4) {
12151                                 chk(fmt.Errorf("const %v: %v", 4, local201))
12152                         }
12153                 }
12154                 {
12155                         p := &(*(*(struct {
12156                                 Param HotbarParam
12157
12158                                 //mt:if %s.Param == HotbarSize
12159                                 //mt:const uint16(4) // Size of Size field.
12160                                 Size int32
12161
12162                                 //mt:if %s.Param != HotbarSize
12163                                 Img Texture
12164                         }))(obj)).Size
12165                         *p = int32(read32(r))
12166                 }
12167         }
12168         if (*(*(struct {
12169                 Param HotbarParam
12170
12171                 //mt:if %s.Param == HotbarSize
12172                 //mt:const uint16(4) // Size of Size field.
12173                 Size int32
12174
12175                 //mt:if %s.Param != HotbarSize
12176                 Img Texture
12177         }))(obj)).Param != HotbarSize {
12178                 if err := pcall(func() {
12179                         ((*(*(struct {
12180                                 Param HotbarParam
12181
12182                                 //mt:if %s.Param == HotbarSize
12183                                 //mt:const uint16(4) // Size of Size field.
12184                                 Size int32
12185
12186                                 //mt:if %s.Param != HotbarSize
12187                                 Img Texture
12188                         }))(obj)).Img).deserialize(r)
12189                 }); err != nil {
12190                         if err == io.EOF {
12191                                 chk(io.EOF)
12192                         }
12193                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12194                 }
12195         }
12196 }
12197
12198 func (obj *ToCltBreath) serialize(w io.Writer) {
12199         {
12200                 x := (*(*(struct {
12201                         Breath uint16
12202                 }))(obj)).Breath
12203                 write16(w, uint16(x))
12204         }
12205 }
12206
12207 func (obj *ToCltBreath) deserialize(r io.Reader) {
12208         {
12209                 p := &(*(*(struct {
12210                         Breath uint16
12211                 }))(obj)).Breath
12212                 *p = read16(r)
12213         }
12214 }
12215
12216 func (obj *ToCltSkyParams) serialize(w io.Writer) {
12217         {
12218                 x := (*(*(struct {
12219                         BgColor     color.NRGBA
12220                         Type        string
12221                         Clouds      bool
12222                         SunFogTint  color.NRGBA
12223                         MoonFogTint color.NRGBA
12224                         FogTintType string
12225
12226                         //mt:if %s.Type == "skybox"
12227                         Textures []Texture
12228
12229                         //mt:if %s.Type == "regular"
12230                         DaySky, DayHorizon,
12231                         DawnSky, DawnHorizon,
12232                         NightSky, NightHorizon,
12233                         Indoor color.NRGBA
12234                 }))(obj)).BgColor
12235                 w.Write([]byte{x.A, x.R, x.G, x.B})
12236         }
12237         if len(([]byte((*(*(struct {
12238                 BgColor     color.NRGBA
12239                 Type        string
12240                 Clouds      bool
12241                 SunFogTint  color.NRGBA
12242                 MoonFogTint color.NRGBA
12243                 FogTintType string
12244
12245                 //mt:if %s.Type == "skybox"
12246                 Textures []Texture
12247
12248                 //mt:if %s.Type == "regular"
12249                 DaySky, DayHorizon,
12250                 DawnSky, DawnHorizon,
12251                 NightSky, NightHorizon,
12252                 Indoor color.NRGBA
12253         }))(obj)).Type))) > math.MaxUint16 {
12254                 chk(ErrTooLong)
12255         }
12256         {
12257                 x := uint16(len(([]byte((*(*(struct {
12258                         BgColor     color.NRGBA
12259                         Type        string
12260                         Clouds      bool
12261                         SunFogTint  color.NRGBA
12262                         MoonFogTint color.NRGBA
12263                         FogTintType string
12264
12265                         //mt:if %s.Type == "skybox"
12266                         Textures []Texture
12267
12268                         //mt:if %s.Type == "regular"
12269                         DaySky, DayHorizon,
12270                         DawnSky, DawnHorizon,
12271                         NightSky, NightHorizon,
12272                         Indoor color.NRGBA
12273                 }))(obj)).Type))))
12274                 write16(w, uint16(x))
12275         }
12276         {
12277                 _, err := w.Write(([]byte((*(*(struct {
12278                         BgColor     color.NRGBA
12279                         Type        string
12280                         Clouds      bool
12281                         SunFogTint  color.NRGBA
12282                         MoonFogTint color.NRGBA
12283                         FogTintType string
12284
12285                         //mt:if %s.Type == "skybox"
12286                         Textures []Texture
12287
12288                         //mt:if %s.Type == "regular"
12289                         DaySky, DayHorizon,
12290                         DawnSky, DawnHorizon,
12291                         NightSky, NightHorizon,
12292                         Indoor color.NRGBA
12293                 }))(obj)).Type))[:])
12294                 chk(err)
12295         }
12296         {
12297                 x := (*(*(struct {
12298                         BgColor     color.NRGBA
12299                         Type        string
12300                         Clouds      bool
12301                         SunFogTint  color.NRGBA
12302                         MoonFogTint color.NRGBA
12303                         FogTintType string
12304
12305                         //mt:if %s.Type == "skybox"
12306                         Textures []Texture
12307
12308                         //mt:if %s.Type == "regular"
12309                         DaySky, DayHorizon,
12310                         DawnSky, DawnHorizon,
12311                         NightSky, NightHorizon,
12312                         Indoor color.NRGBA
12313                 }))(obj)).Clouds
12314                 if x {
12315                         write8(w, 1)
12316                 } else {
12317                         write8(w, 0)
12318                 }
12319         }
12320         {
12321                 x := (*(*(struct {
12322                         BgColor     color.NRGBA
12323                         Type        string
12324                         Clouds      bool
12325                         SunFogTint  color.NRGBA
12326                         MoonFogTint color.NRGBA
12327                         FogTintType string
12328
12329                         //mt:if %s.Type == "skybox"
12330                         Textures []Texture
12331
12332                         //mt:if %s.Type == "regular"
12333                         DaySky, DayHorizon,
12334                         DawnSky, DawnHorizon,
12335                         NightSky, NightHorizon,
12336                         Indoor color.NRGBA
12337                 }))(obj)).SunFogTint
12338                 w.Write([]byte{x.A, x.R, x.G, x.B})
12339         }
12340         {
12341                 x := (*(*(struct {
12342                         BgColor     color.NRGBA
12343                         Type        string
12344                         Clouds      bool
12345                         SunFogTint  color.NRGBA
12346                         MoonFogTint color.NRGBA
12347                         FogTintType string
12348
12349                         //mt:if %s.Type == "skybox"
12350                         Textures []Texture
12351
12352                         //mt:if %s.Type == "regular"
12353                         DaySky, DayHorizon,
12354                         DawnSky, DawnHorizon,
12355                         NightSky, NightHorizon,
12356                         Indoor color.NRGBA
12357                 }))(obj)).MoonFogTint
12358                 w.Write([]byte{x.A, x.R, x.G, x.B})
12359         }
12360         if len(([]byte((*(*(struct {
12361                 BgColor     color.NRGBA
12362                 Type        string
12363                 Clouds      bool
12364                 SunFogTint  color.NRGBA
12365                 MoonFogTint color.NRGBA
12366                 FogTintType string
12367
12368                 //mt:if %s.Type == "skybox"
12369                 Textures []Texture
12370
12371                 //mt:if %s.Type == "regular"
12372                 DaySky, DayHorizon,
12373                 DawnSky, DawnHorizon,
12374                 NightSky, NightHorizon,
12375                 Indoor color.NRGBA
12376         }))(obj)).FogTintType))) > math.MaxUint16 {
12377                 chk(ErrTooLong)
12378         }
12379         {
12380                 x := uint16(len(([]byte((*(*(struct {
12381                         BgColor     color.NRGBA
12382                         Type        string
12383                         Clouds      bool
12384                         SunFogTint  color.NRGBA
12385                         MoonFogTint color.NRGBA
12386                         FogTintType string
12387
12388                         //mt:if %s.Type == "skybox"
12389                         Textures []Texture
12390
12391                         //mt:if %s.Type == "regular"
12392                         DaySky, DayHorizon,
12393                         DawnSky, DawnHorizon,
12394                         NightSky, NightHorizon,
12395                         Indoor color.NRGBA
12396                 }))(obj)).FogTintType))))
12397                 write16(w, uint16(x))
12398         }
12399         {
12400                 _, err := w.Write(([]byte((*(*(struct {
12401                         BgColor     color.NRGBA
12402                         Type        string
12403                         Clouds      bool
12404                         SunFogTint  color.NRGBA
12405                         MoonFogTint color.NRGBA
12406                         FogTintType string
12407
12408                         //mt:if %s.Type == "skybox"
12409                         Textures []Texture
12410
12411                         //mt:if %s.Type == "regular"
12412                         DaySky, DayHorizon,
12413                         DawnSky, DawnHorizon,
12414                         NightSky, NightHorizon,
12415                         Indoor color.NRGBA
12416                 }))(obj)).FogTintType))[:])
12417                 chk(err)
12418         }
12419         if (*(*(struct {
12420                 BgColor     color.NRGBA
12421                 Type        string
12422                 Clouds      bool
12423                 SunFogTint  color.NRGBA
12424                 MoonFogTint color.NRGBA
12425                 FogTintType string
12426
12427                 //mt:if %s.Type == "skybox"
12428                 Textures []Texture
12429
12430                 //mt:if %s.Type == "regular"
12431                 DaySky, DayHorizon,
12432                 DawnSky, DawnHorizon,
12433                 NightSky, NightHorizon,
12434                 Indoor color.NRGBA
12435         }))(obj)).Type == "skybox" {
12436                 if len(((*(*(struct {
12437                         BgColor     color.NRGBA
12438                         Type        string
12439                         Clouds      bool
12440                         SunFogTint  color.NRGBA
12441                         MoonFogTint color.NRGBA
12442                         FogTintType string
12443
12444                         //mt:if %s.Type == "skybox"
12445                         Textures []Texture
12446
12447                         //mt:if %s.Type == "regular"
12448                         DaySky, DayHorizon,
12449                         DawnSky, DawnHorizon,
12450                         NightSky, NightHorizon,
12451                         Indoor color.NRGBA
12452                 }))(obj)).Textures)) > math.MaxUint16 {
12453                         chk(ErrTooLong)
12454                 }
12455                 {
12456                         x := uint16(len(((*(*(struct {
12457                                 BgColor     color.NRGBA
12458                                 Type        string
12459                                 Clouds      bool
12460                                 SunFogTint  color.NRGBA
12461                                 MoonFogTint color.NRGBA
12462                                 FogTintType string
12463
12464                                 //mt:if %s.Type == "skybox"
12465                                 Textures []Texture
12466
12467                                 //mt:if %s.Type == "regular"
12468                                 DaySky, DayHorizon,
12469                                 DawnSky, DawnHorizon,
12470                                 NightSky, NightHorizon,
12471                                 Indoor color.NRGBA
12472                         }))(obj)).Textures)))
12473                         write16(w, uint16(x))
12474                 }
12475                 for local202 := range (*(*(struct {
12476                         BgColor     color.NRGBA
12477                         Type        string
12478                         Clouds      bool
12479                         SunFogTint  color.NRGBA
12480                         MoonFogTint color.NRGBA
12481                         FogTintType string
12482
12483                         //mt:if %s.Type == "skybox"
12484                         Textures []Texture
12485
12486                         //mt:if %s.Type == "regular"
12487                         DaySky, DayHorizon,
12488                         DawnSky, DawnHorizon,
12489                         NightSky, NightHorizon,
12490                         Indoor color.NRGBA
12491                 }))(obj)).Textures {
12492                         if err := pcall(func() {
12493                                 (((*(*(struct {
12494                                         BgColor     color.NRGBA
12495                                         Type        string
12496                                         Clouds      bool
12497                                         SunFogTint  color.NRGBA
12498                                         MoonFogTint color.NRGBA
12499                                         FogTintType string
12500
12501                                         //mt:if %s.Type == "skybox"
12502                                         Textures []Texture
12503
12504                                         //mt:if %s.Type == "regular"
12505                                         DaySky, DayHorizon,
12506                                         DawnSky, DawnHorizon,
12507                                         NightSky, NightHorizon,
12508                                         Indoor color.NRGBA
12509                                 }))(obj)).Textures)[local202]).serialize(w)
12510                         }); err != nil {
12511                                 if err == io.EOF {
12512                                         chk(io.EOF)
12513                                 }
12514                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12515                         }
12516                 }
12517         }
12518         if (*(*(struct {
12519                 BgColor     color.NRGBA
12520                 Type        string
12521                 Clouds      bool
12522                 SunFogTint  color.NRGBA
12523                 MoonFogTint color.NRGBA
12524                 FogTintType string
12525
12526                 //mt:if %s.Type == "skybox"
12527                 Textures []Texture
12528
12529                 //mt:if %s.Type == "regular"
12530                 DaySky, DayHorizon,
12531                 DawnSky, DawnHorizon,
12532                 NightSky, NightHorizon,
12533                 Indoor color.NRGBA
12534         }))(obj)).Type == "regular" {
12535                 {
12536                         x := (*(*(struct {
12537                                 BgColor     color.NRGBA
12538                                 Type        string
12539                                 Clouds      bool
12540                                 SunFogTint  color.NRGBA
12541                                 MoonFogTint color.NRGBA
12542                                 FogTintType string
12543
12544                                 //mt:if %s.Type == "skybox"
12545                                 Textures []Texture
12546
12547                                 //mt:if %s.Type == "regular"
12548                                 DaySky, DayHorizon,
12549                                 DawnSky, DawnHorizon,
12550                                 NightSky, NightHorizon,
12551                                 Indoor color.NRGBA
12552                         }))(obj)).DaySky
12553                         w.Write([]byte{x.A, x.R, x.G, x.B})
12554                 }
12555                 {
12556                         x := (*(*(struct {
12557                                 BgColor     color.NRGBA
12558                                 Type        string
12559                                 Clouds      bool
12560                                 SunFogTint  color.NRGBA
12561                                 MoonFogTint color.NRGBA
12562                                 FogTintType string
12563
12564                                 //mt:if %s.Type == "skybox"
12565                                 Textures []Texture
12566
12567                                 //mt:if %s.Type == "regular"
12568                                 DaySky, DayHorizon,
12569                                 DawnSky, DawnHorizon,
12570                                 NightSky, NightHorizon,
12571                                 Indoor color.NRGBA
12572                         }))(obj)).DayHorizon
12573                         w.Write([]byte{x.A, x.R, x.G, x.B})
12574                 }
12575                 {
12576                         x := (*(*(struct {
12577                                 BgColor     color.NRGBA
12578                                 Type        string
12579                                 Clouds      bool
12580                                 SunFogTint  color.NRGBA
12581                                 MoonFogTint color.NRGBA
12582                                 FogTintType string
12583
12584                                 //mt:if %s.Type == "skybox"
12585                                 Textures []Texture
12586
12587                                 //mt:if %s.Type == "regular"
12588                                 DaySky, DayHorizon,
12589                                 DawnSky, DawnHorizon,
12590                                 NightSky, NightHorizon,
12591                                 Indoor color.NRGBA
12592                         }))(obj)).DawnSky
12593                         w.Write([]byte{x.A, x.R, x.G, x.B})
12594                 }
12595                 {
12596                         x := (*(*(struct {
12597                                 BgColor     color.NRGBA
12598                                 Type        string
12599                                 Clouds      bool
12600                                 SunFogTint  color.NRGBA
12601                                 MoonFogTint color.NRGBA
12602                                 FogTintType string
12603
12604                                 //mt:if %s.Type == "skybox"
12605                                 Textures []Texture
12606
12607                                 //mt:if %s.Type == "regular"
12608                                 DaySky, DayHorizon,
12609                                 DawnSky, DawnHorizon,
12610                                 NightSky, NightHorizon,
12611                                 Indoor color.NRGBA
12612                         }))(obj)).DawnHorizon
12613                         w.Write([]byte{x.A, x.R, x.G, x.B})
12614                 }
12615                 {
12616                         x := (*(*(struct {
12617                                 BgColor     color.NRGBA
12618                                 Type        string
12619                                 Clouds      bool
12620                                 SunFogTint  color.NRGBA
12621                                 MoonFogTint color.NRGBA
12622                                 FogTintType string
12623
12624                                 //mt:if %s.Type == "skybox"
12625                                 Textures []Texture
12626
12627                                 //mt:if %s.Type == "regular"
12628                                 DaySky, DayHorizon,
12629                                 DawnSky, DawnHorizon,
12630                                 NightSky, NightHorizon,
12631                                 Indoor color.NRGBA
12632                         }))(obj)).NightSky
12633                         w.Write([]byte{x.A, x.R, x.G, x.B})
12634                 }
12635                 {
12636                         x := (*(*(struct {
12637                                 BgColor     color.NRGBA
12638                                 Type        string
12639                                 Clouds      bool
12640                                 SunFogTint  color.NRGBA
12641                                 MoonFogTint color.NRGBA
12642                                 FogTintType string
12643
12644                                 //mt:if %s.Type == "skybox"
12645                                 Textures []Texture
12646
12647                                 //mt:if %s.Type == "regular"
12648                                 DaySky, DayHorizon,
12649                                 DawnSky, DawnHorizon,
12650                                 NightSky, NightHorizon,
12651                                 Indoor color.NRGBA
12652                         }))(obj)).NightHorizon
12653                         w.Write([]byte{x.A, x.R, x.G, x.B})
12654                 }
12655                 {
12656                         x := (*(*(struct {
12657                                 BgColor     color.NRGBA
12658                                 Type        string
12659                                 Clouds      bool
12660                                 SunFogTint  color.NRGBA
12661                                 MoonFogTint color.NRGBA
12662                                 FogTintType string
12663
12664                                 //mt:if %s.Type == "skybox"
12665                                 Textures []Texture
12666
12667                                 //mt:if %s.Type == "regular"
12668                                 DaySky, DayHorizon,
12669                                 DawnSky, DawnHorizon,
12670                                 NightSky, NightHorizon,
12671                                 Indoor color.NRGBA
12672                         }))(obj)).Indoor
12673                         w.Write([]byte{x.A, x.R, x.G, x.B})
12674                 }
12675         }
12676 }
12677
12678 func (obj *ToCltSkyParams) deserialize(r io.Reader) {
12679         {
12680                 p := &(*(*(struct {
12681                         BgColor     color.NRGBA
12682                         Type        string
12683                         Clouds      bool
12684                         SunFogTint  color.NRGBA
12685                         MoonFogTint color.NRGBA
12686                         FogTintType string
12687
12688                         //mt:if %s.Type == "skybox"
12689                         Textures []Texture
12690
12691                         //mt:if %s.Type == "regular"
12692                         DaySky, DayHorizon,
12693                         DawnSky, DawnHorizon,
12694                         NightSky, NightHorizon,
12695                         Indoor color.NRGBA
12696                 }))(obj)).BgColor
12697                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12698         }
12699         var local203 []uint8
12700         var local204 uint16
12701         {
12702                 p := &local204
12703                 *p = read16(r)
12704         }
12705         (local203) = make([]uint8, local204)
12706         {
12707                 _, err := io.ReadFull(r, (local203)[:])
12708                 chk(err)
12709         }
12710         ((*(*(struct {
12711                 BgColor     color.NRGBA
12712                 Type        string
12713                 Clouds      bool
12714                 SunFogTint  color.NRGBA
12715                 MoonFogTint color.NRGBA
12716                 FogTintType string
12717
12718                 //mt:if %s.Type == "skybox"
12719                 Textures []Texture
12720
12721                 //mt:if %s.Type == "regular"
12722                 DaySky, DayHorizon,
12723                 DawnSky, DawnHorizon,
12724                 NightSky, NightHorizon,
12725                 Indoor color.NRGBA
12726         }))(obj)).Type) = string(local203)
12727         {
12728                 p := &(*(*(struct {
12729                         BgColor     color.NRGBA
12730                         Type        string
12731                         Clouds      bool
12732                         SunFogTint  color.NRGBA
12733                         MoonFogTint color.NRGBA
12734                         FogTintType string
12735
12736                         //mt:if %s.Type == "skybox"
12737                         Textures []Texture
12738
12739                         //mt:if %s.Type == "regular"
12740                         DaySky, DayHorizon,
12741                         DawnSky, DawnHorizon,
12742                         NightSky, NightHorizon,
12743                         Indoor color.NRGBA
12744                 }))(obj)).Clouds
12745                 switch n := read8(r); n {
12746                 case 0:
12747                         *p = false
12748                 case 1:
12749                         *p = true
12750                 default:
12751                         chk(fmt.Errorf("invalid bool: %d", n))
12752                 }
12753         }
12754         {
12755                 p := &(*(*(struct {
12756                         BgColor     color.NRGBA
12757                         Type        string
12758                         Clouds      bool
12759                         SunFogTint  color.NRGBA
12760                         MoonFogTint color.NRGBA
12761                         FogTintType string
12762
12763                         //mt:if %s.Type == "skybox"
12764                         Textures []Texture
12765
12766                         //mt:if %s.Type == "regular"
12767                         DaySky, DayHorizon,
12768                         DawnSky, DawnHorizon,
12769                         NightSky, NightHorizon,
12770                         Indoor color.NRGBA
12771                 }))(obj)).SunFogTint
12772                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12773         }
12774         {
12775                 p := &(*(*(struct {
12776                         BgColor     color.NRGBA
12777                         Type        string
12778                         Clouds      bool
12779                         SunFogTint  color.NRGBA
12780                         MoonFogTint color.NRGBA
12781                         FogTintType string
12782
12783                         //mt:if %s.Type == "skybox"
12784                         Textures []Texture
12785
12786                         //mt:if %s.Type == "regular"
12787                         DaySky, DayHorizon,
12788                         DawnSky, DawnHorizon,
12789                         NightSky, NightHorizon,
12790                         Indoor color.NRGBA
12791                 }))(obj)).MoonFogTint
12792                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12793         }
12794         var local205 []uint8
12795         var local206 uint16
12796         {
12797                 p := &local206
12798                 *p = read16(r)
12799         }
12800         (local205) = make([]uint8, local206)
12801         {
12802                 _, err := io.ReadFull(r, (local205)[:])
12803                 chk(err)
12804         }
12805         ((*(*(struct {
12806                 BgColor     color.NRGBA
12807                 Type        string
12808                 Clouds      bool
12809                 SunFogTint  color.NRGBA
12810                 MoonFogTint color.NRGBA
12811                 FogTintType string
12812
12813                 //mt:if %s.Type == "skybox"
12814                 Textures []Texture
12815
12816                 //mt:if %s.Type == "regular"
12817                 DaySky, DayHorizon,
12818                 DawnSky, DawnHorizon,
12819                 NightSky, NightHorizon,
12820                 Indoor color.NRGBA
12821         }))(obj)).FogTintType) = string(local205)
12822         if (*(*(struct {
12823                 BgColor     color.NRGBA
12824                 Type        string
12825                 Clouds      bool
12826                 SunFogTint  color.NRGBA
12827                 MoonFogTint color.NRGBA
12828                 FogTintType string
12829
12830                 //mt:if %s.Type == "skybox"
12831                 Textures []Texture
12832
12833                 //mt:if %s.Type == "regular"
12834                 DaySky, DayHorizon,
12835                 DawnSky, DawnHorizon,
12836                 NightSky, NightHorizon,
12837                 Indoor color.NRGBA
12838         }))(obj)).Type == "skybox" {
12839                 var local207 uint16
12840                 {
12841                         p := &local207
12842                         *p = read16(r)
12843                 }
12844                 ((*(*(struct {
12845                         BgColor     color.NRGBA
12846                         Type        string
12847                         Clouds      bool
12848                         SunFogTint  color.NRGBA
12849                         MoonFogTint color.NRGBA
12850                         FogTintType string
12851
12852                         //mt:if %s.Type == "skybox"
12853                         Textures []Texture
12854
12855                         //mt:if %s.Type == "regular"
12856                         DaySky, DayHorizon,
12857                         DawnSky, DawnHorizon,
12858                         NightSky, NightHorizon,
12859                         Indoor color.NRGBA
12860                 }))(obj)).Textures) = make([]Texture, local207)
12861                 for local208 := range (*(*(struct {
12862                         BgColor     color.NRGBA
12863                         Type        string
12864                         Clouds      bool
12865                         SunFogTint  color.NRGBA
12866                         MoonFogTint color.NRGBA
12867                         FogTintType string
12868
12869                         //mt:if %s.Type == "skybox"
12870                         Textures []Texture
12871
12872                         //mt:if %s.Type == "regular"
12873                         DaySky, DayHorizon,
12874                         DawnSky, DawnHorizon,
12875                         NightSky, NightHorizon,
12876                         Indoor color.NRGBA
12877                 }))(obj)).Textures {
12878                         if err := pcall(func() {
12879                                 (((*(*(struct {
12880                                         BgColor     color.NRGBA
12881                                         Type        string
12882                                         Clouds      bool
12883                                         SunFogTint  color.NRGBA
12884                                         MoonFogTint color.NRGBA
12885                                         FogTintType string
12886
12887                                         //mt:if %s.Type == "skybox"
12888                                         Textures []Texture
12889
12890                                         //mt:if %s.Type == "regular"
12891                                         DaySky, DayHorizon,
12892                                         DawnSky, DawnHorizon,
12893                                         NightSky, NightHorizon,
12894                                         Indoor color.NRGBA
12895                                 }))(obj)).Textures)[local208]).deserialize(r)
12896                         }); err != nil {
12897                                 if err == io.EOF {
12898                                         chk(io.EOF)
12899                                 }
12900                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12901                         }
12902                 }
12903         }
12904         if (*(*(struct {
12905                 BgColor     color.NRGBA
12906                 Type        string
12907                 Clouds      bool
12908                 SunFogTint  color.NRGBA
12909                 MoonFogTint color.NRGBA
12910                 FogTintType string
12911
12912                 //mt:if %s.Type == "skybox"
12913                 Textures []Texture
12914
12915                 //mt:if %s.Type == "regular"
12916                 DaySky, DayHorizon,
12917                 DawnSky, DawnHorizon,
12918                 NightSky, NightHorizon,
12919                 Indoor color.NRGBA
12920         }))(obj)).Type == "regular" {
12921                 {
12922                         p := &(*(*(struct {
12923                                 BgColor     color.NRGBA
12924                                 Type        string
12925                                 Clouds      bool
12926                                 SunFogTint  color.NRGBA
12927                                 MoonFogTint color.NRGBA
12928                                 FogTintType string
12929
12930                                 //mt:if %s.Type == "skybox"
12931                                 Textures []Texture
12932
12933                                 //mt:if %s.Type == "regular"
12934                                 DaySky, DayHorizon,
12935                                 DawnSky, DawnHorizon,
12936                                 NightSky, NightHorizon,
12937                                 Indoor color.NRGBA
12938                         }))(obj)).DaySky
12939                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12940                 }
12941                 {
12942                         p := &(*(*(struct {
12943                                 BgColor     color.NRGBA
12944                                 Type        string
12945                                 Clouds      bool
12946                                 SunFogTint  color.NRGBA
12947                                 MoonFogTint color.NRGBA
12948                                 FogTintType string
12949
12950                                 //mt:if %s.Type == "skybox"
12951                                 Textures []Texture
12952
12953                                 //mt:if %s.Type == "regular"
12954                                 DaySky, DayHorizon,
12955                                 DawnSky, DawnHorizon,
12956                                 NightSky, NightHorizon,
12957                                 Indoor color.NRGBA
12958                         }))(obj)).DayHorizon
12959                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12960                 }
12961                 {
12962                         p := &(*(*(struct {
12963                                 BgColor     color.NRGBA
12964                                 Type        string
12965                                 Clouds      bool
12966                                 SunFogTint  color.NRGBA
12967                                 MoonFogTint color.NRGBA
12968                                 FogTintType string
12969
12970                                 //mt:if %s.Type == "skybox"
12971                                 Textures []Texture
12972
12973                                 //mt:if %s.Type == "regular"
12974                                 DaySky, DayHorizon,
12975                                 DawnSky, DawnHorizon,
12976                                 NightSky, NightHorizon,
12977                                 Indoor color.NRGBA
12978                         }))(obj)).DawnSky
12979                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12980                 }
12981                 {
12982                         p := &(*(*(struct {
12983                                 BgColor     color.NRGBA
12984                                 Type        string
12985                                 Clouds      bool
12986                                 SunFogTint  color.NRGBA
12987                                 MoonFogTint color.NRGBA
12988                                 FogTintType string
12989
12990                                 //mt:if %s.Type == "skybox"
12991                                 Textures []Texture
12992
12993                                 //mt:if %s.Type == "regular"
12994                                 DaySky, DayHorizon,
12995                                 DawnSky, DawnHorizon,
12996                                 NightSky, NightHorizon,
12997                                 Indoor color.NRGBA
12998                         }))(obj)).DawnHorizon
12999                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13000                 }
13001                 {
13002                         p := &(*(*(struct {
13003                                 BgColor     color.NRGBA
13004                                 Type        string
13005                                 Clouds      bool
13006                                 SunFogTint  color.NRGBA
13007                                 MoonFogTint color.NRGBA
13008                                 FogTintType string
13009
13010                                 //mt:if %s.Type == "skybox"
13011                                 Textures []Texture
13012
13013                                 //mt:if %s.Type == "regular"
13014                                 DaySky, DayHorizon,
13015                                 DawnSky, DawnHorizon,
13016                                 NightSky, NightHorizon,
13017                                 Indoor color.NRGBA
13018                         }))(obj)).NightSky
13019                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13020                 }
13021                 {
13022                         p := &(*(*(struct {
13023                                 BgColor     color.NRGBA
13024                                 Type        string
13025                                 Clouds      bool
13026                                 SunFogTint  color.NRGBA
13027                                 MoonFogTint color.NRGBA
13028                                 FogTintType string
13029
13030                                 //mt:if %s.Type == "skybox"
13031                                 Textures []Texture
13032
13033                                 //mt:if %s.Type == "regular"
13034                                 DaySky, DayHorizon,
13035                                 DawnSky, DawnHorizon,
13036                                 NightSky, NightHorizon,
13037                                 Indoor color.NRGBA
13038                         }))(obj)).NightHorizon
13039                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13040                 }
13041                 {
13042                         p := &(*(*(struct {
13043                                 BgColor     color.NRGBA
13044                                 Type        string
13045                                 Clouds      bool
13046                                 SunFogTint  color.NRGBA
13047                                 MoonFogTint color.NRGBA
13048                                 FogTintType string
13049
13050                                 //mt:if %s.Type == "skybox"
13051                                 Textures []Texture
13052
13053                                 //mt:if %s.Type == "regular"
13054                                 DaySky, DayHorizon,
13055                                 DawnSky, DawnHorizon,
13056                                 NightSky, NightHorizon,
13057                                 Indoor color.NRGBA
13058                         }))(obj)).Indoor
13059                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13060                 }
13061         }
13062 }
13063
13064 func (obj *ToCltOverrideDayNightRatio) serialize(w io.Writer) {
13065         {
13066                 x := (*(*(struct {
13067                         Override bool
13068                         Ratio    uint16
13069                 }))(obj)).Override
13070                 if x {
13071                         write8(w, 1)
13072                 } else {
13073                         write8(w, 0)
13074                 }
13075         }
13076         {
13077                 x := (*(*(struct {
13078                         Override bool
13079                         Ratio    uint16
13080                 }))(obj)).Ratio
13081                 write16(w, uint16(x))
13082         }
13083 }
13084
13085 func (obj *ToCltOverrideDayNightRatio) deserialize(r io.Reader) {
13086         {
13087                 p := &(*(*(struct {
13088                         Override bool
13089                         Ratio    uint16
13090                 }))(obj)).Override
13091                 switch n := read8(r); n {
13092                 case 0:
13093                         *p = false
13094                 case 1:
13095                         *p = true
13096                 default:
13097                         chk(fmt.Errorf("invalid bool: %d", n))
13098                 }
13099         }
13100         {
13101                 p := &(*(*(struct {
13102                         Override bool
13103                         Ratio    uint16
13104                 }))(obj)).Ratio
13105                 *p = read16(r)
13106         }
13107 }
13108
13109 func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
13110         for local209 := range (*(*(struct {
13111                 Idle, Walk, Dig, WalkDig [2]int32
13112                 Speed                    float32
13113         }))(obj)).Idle {
13114                 {
13115                         x := ((*(*(struct {
13116                                 Idle, Walk, Dig, WalkDig [2]int32
13117                                 Speed                    float32
13118                         }))(obj)).Idle)[local209]
13119                         write32(w, uint32(x))
13120                 }
13121         }
13122         for local210 := range (*(*(struct {
13123                 Idle, Walk, Dig, WalkDig [2]int32
13124                 Speed                    float32
13125         }))(obj)).Walk {
13126                 {
13127                         x := ((*(*(struct {
13128                                 Idle, Walk, Dig, WalkDig [2]int32
13129                                 Speed                    float32
13130                         }))(obj)).Walk)[local210]
13131                         write32(w, uint32(x))
13132                 }
13133         }
13134         for local211 := range (*(*(struct {
13135                 Idle, Walk, Dig, WalkDig [2]int32
13136                 Speed                    float32
13137         }))(obj)).Dig {
13138                 {
13139                         x := ((*(*(struct {
13140                                 Idle, Walk, Dig, WalkDig [2]int32
13141                                 Speed                    float32
13142                         }))(obj)).Dig)[local211]
13143                         write32(w, uint32(x))
13144                 }
13145         }
13146         for local212 := range (*(*(struct {
13147                 Idle, Walk, Dig, WalkDig [2]int32
13148                 Speed                    float32
13149         }))(obj)).WalkDig {
13150                 {
13151                         x := ((*(*(struct {
13152                                 Idle, Walk, Dig, WalkDig [2]int32
13153                                 Speed                    float32
13154                         }))(obj)).WalkDig)[local212]
13155                         write32(w, uint32(x))
13156                 }
13157         }
13158         {
13159                 x := (*(*(struct {
13160                         Idle, Walk, Dig, WalkDig [2]int32
13161                         Speed                    float32
13162                 }))(obj)).Speed
13163                 write32(w, math.Float32bits(x))
13164         }
13165 }
13166
13167 func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
13168         for local213 := range (*(*(struct {
13169                 Idle, Walk, Dig, WalkDig [2]int32
13170                 Speed                    float32
13171         }))(obj)).Idle {
13172                 {
13173                         p := &((*(*(struct {
13174                                 Idle, Walk, Dig, WalkDig [2]int32
13175                                 Speed                    float32
13176                         }))(obj)).Idle)[local213]
13177                         *p = int32(read32(r))
13178                 }
13179         }
13180         for local214 := range (*(*(struct {
13181                 Idle, Walk, Dig, WalkDig [2]int32
13182                 Speed                    float32
13183         }))(obj)).Walk {
13184                 {
13185                         p := &((*(*(struct {
13186                                 Idle, Walk, Dig, WalkDig [2]int32
13187                                 Speed                    float32
13188                         }))(obj)).Walk)[local214]
13189                         *p = int32(read32(r))
13190                 }
13191         }
13192         for local215 := range (*(*(struct {
13193                 Idle, Walk, Dig, WalkDig [2]int32
13194                 Speed                    float32
13195         }))(obj)).Dig {
13196                 {
13197                         p := &((*(*(struct {
13198                                 Idle, Walk, Dig, WalkDig [2]int32
13199                                 Speed                    float32
13200                         }))(obj)).Dig)[local215]
13201                         *p = int32(read32(r))
13202                 }
13203         }
13204         for local216 := range (*(*(struct {
13205                 Idle, Walk, Dig, WalkDig [2]int32
13206                 Speed                    float32
13207         }))(obj)).WalkDig {
13208                 {
13209                         p := &((*(*(struct {
13210                                 Idle, Walk, Dig, WalkDig [2]int32
13211                                 Speed                    float32
13212                         }))(obj)).WalkDig)[local216]
13213                         *p = int32(read32(r))
13214                 }
13215         }
13216         {
13217                 p := &(*(*(struct {
13218                         Idle, Walk, Dig, WalkDig [2]int32
13219                         Speed                    float32
13220                 }))(obj)).Speed
13221                 *p = math.Float32frombits(read32(r))
13222         }
13223 }
13224
13225 func (obj *ToCltEyeOffset) serialize(w io.Writer) {
13226         if err := pcall(func() {
13227                 ((*(*(struct {
13228                         First, Third Vec
13229                 }))(obj)).First).serialize(w)
13230         }); err != nil {
13231                 if err == io.EOF {
13232                         chk(io.EOF)
13233                 }
13234                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
13235         }
13236         if err := pcall(func() {
13237                 ((*(*(struct {
13238                         First, Third Vec
13239                 }))(obj)).Third).serialize(w)
13240         }); err != nil {
13241                 if err == io.EOF {
13242                         chk(io.EOF)
13243                 }
13244                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
13245         }
13246 }
13247
13248 func (obj *ToCltEyeOffset) deserialize(r io.Reader) {
13249         if err := pcall(func() {
13250                 ((*(*(struct {
13251                         First, Third Vec
13252                 }))(obj)).First).deserialize(r)
13253         }); err != nil {
13254                 if err == io.EOF {
13255                         chk(io.EOF)
13256                 }
13257                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
13258         }
13259         if err := pcall(func() {
13260                 ((*(*(struct {
13261                         First, Third Vec
13262                 }))(obj)).Third).deserialize(r)
13263         }); err != nil {
13264                 if err == io.EOF {
13265                         chk(io.EOF)
13266                 }
13267                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
13268         }
13269 }
13270
13271 func (obj *ToCltDelParticleSpawner) serialize(w io.Writer) {
13272         if err := pcall(func() {
13273                 ((*(*(struct {
13274                         ID ParticleSpawnerID
13275                 }))(obj)).ID).serialize(w)
13276         }); err != nil {
13277                 if err == io.EOF {
13278                         chk(io.EOF)
13279                 }
13280                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
13281         }
13282 }
13283
13284 func (obj *ToCltDelParticleSpawner) deserialize(r io.Reader) {
13285         if err := pcall(func() {
13286                 ((*(*(struct {
13287                         ID ParticleSpawnerID
13288                 }))(obj)).ID).deserialize(r)
13289         }); err != nil {
13290                 if err == io.EOF {
13291                         chk(io.EOF)
13292                 }
13293                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
13294         }
13295 }
13296
13297 func (obj *ToCltCloudParams) serialize(w io.Writer) {
13298         {
13299                 x := (*(*(struct {
13300                         Density      float32
13301                         DiffuseColor color.NRGBA
13302                         AmbientColor color.NRGBA
13303                         Height       float32
13304                         Thickness    float32
13305                         Speed        [2]float32
13306                 }))(obj)).Density
13307                 write32(w, math.Float32bits(x))
13308         }
13309         {
13310                 x := (*(*(struct {
13311                         Density      float32
13312                         DiffuseColor color.NRGBA
13313                         AmbientColor color.NRGBA
13314                         Height       float32
13315                         Thickness    float32
13316                         Speed        [2]float32
13317                 }))(obj)).DiffuseColor
13318                 w.Write([]byte{x.A, x.R, x.G, x.B})
13319         }
13320         {
13321                 x := (*(*(struct {
13322                         Density      float32
13323                         DiffuseColor color.NRGBA
13324                         AmbientColor color.NRGBA
13325                         Height       float32
13326                         Thickness    float32
13327                         Speed        [2]float32
13328                 }))(obj)).AmbientColor
13329                 w.Write([]byte{x.A, x.R, x.G, x.B})
13330         }
13331         {
13332                 x := (*(*(struct {
13333                         Density      float32
13334                         DiffuseColor color.NRGBA
13335                         AmbientColor color.NRGBA
13336                         Height       float32
13337                         Thickness    float32
13338                         Speed        [2]float32
13339                 }))(obj)).Height
13340                 write32(w, math.Float32bits(x))
13341         }
13342         {
13343                 x := (*(*(struct {
13344                         Density      float32
13345                         DiffuseColor color.NRGBA
13346                         AmbientColor color.NRGBA
13347                         Height       float32
13348                         Thickness    float32
13349                         Speed        [2]float32
13350                 }))(obj)).Thickness
13351                 write32(w, math.Float32bits(x))
13352         }
13353         for local217 := range (*(*(struct {
13354                 Density      float32
13355                 DiffuseColor color.NRGBA
13356                 AmbientColor color.NRGBA
13357                 Height       float32
13358                 Thickness    float32
13359                 Speed        [2]float32
13360         }))(obj)).Speed {
13361                 {
13362                         x := ((*(*(struct {
13363                                 Density      float32
13364                                 DiffuseColor color.NRGBA
13365                                 AmbientColor color.NRGBA
13366                                 Height       float32
13367                                 Thickness    float32
13368                                 Speed        [2]float32
13369                         }))(obj)).Speed)[local217]
13370                         write32(w, math.Float32bits(x))
13371                 }
13372         }
13373 }
13374
13375 func (obj *ToCltCloudParams) deserialize(r io.Reader) {
13376         {
13377                 p := &(*(*(struct {
13378                         Density      float32
13379                         DiffuseColor color.NRGBA
13380                         AmbientColor color.NRGBA
13381                         Height       float32
13382                         Thickness    float32
13383                         Speed        [2]float32
13384                 }))(obj)).Density
13385                 *p = math.Float32frombits(read32(r))
13386         }
13387         {
13388                 p := &(*(*(struct {
13389                         Density      float32
13390                         DiffuseColor color.NRGBA
13391                         AmbientColor color.NRGBA
13392                         Height       float32
13393                         Thickness    float32
13394                         Speed        [2]float32
13395                 }))(obj)).DiffuseColor
13396                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13397         }
13398         {
13399                 p := &(*(*(struct {
13400                         Density      float32
13401                         DiffuseColor color.NRGBA
13402                         AmbientColor color.NRGBA
13403                         Height       float32
13404                         Thickness    float32
13405                         Speed        [2]float32
13406                 }))(obj)).AmbientColor
13407                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13408         }
13409         {
13410                 p := &(*(*(struct {
13411                         Density      float32
13412                         DiffuseColor color.NRGBA
13413                         AmbientColor color.NRGBA
13414                         Height       float32
13415                         Thickness    float32
13416                         Speed        [2]float32
13417                 }))(obj)).Height
13418                 *p = math.Float32frombits(read32(r))
13419         }
13420         {
13421                 p := &(*(*(struct {
13422                         Density      float32
13423                         DiffuseColor color.NRGBA
13424                         AmbientColor color.NRGBA
13425                         Height       float32
13426                         Thickness    float32
13427                         Speed        [2]float32
13428                 }))(obj)).Thickness
13429                 *p = math.Float32frombits(read32(r))
13430         }
13431         for local218 := range (*(*(struct {
13432                 Density      float32
13433                 DiffuseColor color.NRGBA
13434                 AmbientColor color.NRGBA
13435                 Height       float32
13436                 Thickness    float32
13437                 Speed        [2]float32
13438         }))(obj)).Speed {
13439                 {
13440                         p := &((*(*(struct {
13441                                 Density      float32
13442                                 DiffuseColor color.NRGBA
13443                                 AmbientColor color.NRGBA
13444                                 Height       float32
13445                                 Thickness    float32
13446                                 Speed        [2]float32
13447                         }))(obj)).Speed)[local218]
13448                         *p = math.Float32frombits(read32(r))
13449                 }
13450         }
13451 }
13452
13453 func (obj *ToCltFadeSound) serialize(w io.Writer) {
13454         if err := pcall(func() {
13455                 ((*(*(struct {
13456                         ID   SoundID
13457                         Step float32
13458                         Gain float32
13459                 }))(obj)).ID).serialize(w)
13460         }); err != nil {
13461                 if err == io.EOF {
13462                         chk(io.EOF)
13463                 }
13464                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
13465         }
13466         {
13467                 x := (*(*(struct {
13468                         ID   SoundID
13469                         Step float32
13470                         Gain float32
13471                 }))(obj)).Step
13472                 write32(w, math.Float32bits(x))
13473         }
13474         {
13475                 x := (*(*(struct {
13476                         ID   SoundID
13477                         Step float32
13478                         Gain float32
13479                 }))(obj)).Gain
13480                 write32(w, math.Float32bits(x))
13481         }
13482 }
13483
13484 func (obj *ToCltFadeSound) deserialize(r io.Reader) {
13485         if err := pcall(func() {
13486                 ((*(*(struct {
13487                         ID   SoundID
13488                         Step float32
13489                         Gain float32
13490                 }))(obj)).ID).deserialize(r)
13491         }); err != nil {
13492                 if err == io.EOF {
13493                         chk(io.EOF)
13494                 }
13495                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
13496         }
13497         {
13498                 p := &(*(*(struct {
13499                         ID   SoundID
13500                         Step float32
13501                         Gain float32
13502                 }))(obj)).Step
13503                 *p = math.Float32frombits(read32(r))
13504         }
13505         {
13506                 p := &(*(*(struct {
13507                         ID   SoundID
13508                         Step float32
13509                         Gain float32
13510                 }))(obj)).Gain
13511                 *p = math.Float32frombits(read32(r))
13512         }
13513 }
13514
13515 func (obj *ToCltUpdatePlayerList) serialize(w io.Writer) {
13516         if err := pcall(func() {
13517                 ((*(*(struct {
13518                         Type    PlayerListUpdateType
13519                         Players []string
13520                 }))(obj)).Type).serialize(w)
13521         }); err != nil {
13522                 if err == io.EOF {
13523                         chk(io.EOF)
13524                 }
13525                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
13526         }
13527         if len(((*(*(struct {
13528                 Type    PlayerListUpdateType
13529                 Players []string
13530         }))(obj)).Players)) > math.MaxUint16 {
13531                 chk(ErrTooLong)
13532         }
13533         {
13534                 x := uint16(len(((*(*(struct {
13535                         Type    PlayerListUpdateType
13536                         Players []string
13537                 }))(obj)).Players)))
13538                 write16(w, uint16(x))
13539         }
13540         for local219 := range (*(*(struct {
13541                 Type    PlayerListUpdateType
13542                 Players []string
13543         }))(obj)).Players {
13544                 if len(([]byte(((*(*(struct {
13545                         Type    PlayerListUpdateType
13546                         Players []string
13547                 }))(obj)).Players)[local219]))) > math.MaxUint16 {
13548                         chk(ErrTooLong)
13549                 }
13550                 {
13551                         x := uint16(len(([]byte(((*(*(struct {
13552                                 Type    PlayerListUpdateType
13553                                 Players []string
13554                         }))(obj)).Players)[local219]))))
13555                         write16(w, uint16(x))
13556                 }
13557                 {
13558                         _, err := w.Write(([]byte(((*(*(struct {
13559                                 Type    PlayerListUpdateType
13560                                 Players []string
13561                         }))(obj)).Players)[local219]))[:])
13562                         chk(err)
13563                 }
13564         }
13565 }
13566
13567 func (obj *ToCltUpdatePlayerList) deserialize(r io.Reader) {
13568         if err := pcall(func() {
13569                 ((*(*(struct {
13570                         Type    PlayerListUpdateType
13571                         Players []string
13572                 }))(obj)).Type).deserialize(r)
13573         }); err != nil {
13574                 if err == io.EOF {
13575                         chk(io.EOF)
13576                 }
13577                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
13578         }
13579         var local220 uint16
13580         {
13581                 p := &local220
13582                 *p = read16(r)
13583         }
13584         ((*(*(struct {
13585                 Type    PlayerListUpdateType
13586                 Players []string
13587         }))(obj)).Players) = make([]string, local220)
13588         for local221 := range (*(*(struct {
13589                 Type    PlayerListUpdateType
13590                 Players []string
13591         }))(obj)).Players {
13592                 var local222 []uint8
13593                 var local223 uint16
13594                 {
13595                         p := &local223
13596                         *p = read16(r)
13597                 }
13598                 (local222) = make([]uint8, local223)
13599                 {
13600                         _, err := io.ReadFull(r, (local222)[:])
13601                         chk(err)
13602                 }
13603                 (((*(*(struct {
13604                         Type    PlayerListUpdateType
13605                         Players []string
13606                 }))(obj)).Players)[local221]) = string(local222)
13607         }
13608 }
13609
13610 func (obj *ToCltModChanMsg) serialize(w io.Writer) {
13611         if len(([]byte((*(*(struct {
13612                 Channel string
13613                 Sender  string
13614                 Msg     string
13615         }))(obj)).Channel))) > math.MaxUint16 {
13616                 chk(ErrTooLong)
13617         }
13618         {
13619                 x := uint16(len(([]byte((*(*(struct {
13620                         Channel string
13621                         Sender  string
13622                         Msg     string
13623                 }))(obj)).Channel))))
13624                 write16(w, uint16(x))
13625         }
13626         {
13627                 _, err := w.Write(([]byte((*(*(struct {
13628                         Channel string
13629                         Sender  string
13630                         Msg     string
13631                 }))(obj)).Channel))[:])
13632                 chk(err)
13633         }
13634         if len(([]byte((*(*(struct {
13635                 Channel string
13636                 Sender  string
13637                 Msg     string
13638         }))(obj)).Sender))) > math.MaxUint16 {
13639                 chk(ErrTooLong)
13640         }
13641         {
13642                 x := uint16(len(([]byte((*(*(struct {
13643                         Channel string
13644                         Sender  string
13645                         Msg     string
13646                 }))(obj)).Sender))))
13647                 write16(w, uint16(x))
13648         }
13649         {
13650                 _, err := w.Write(([]byte((*(*(struct {
13651                         Channel string
13652                         Sender  string
13653                         Msg     string
13654                 }))(obj)).Sender))[:])
13655                 chk(err)
13656         }
13657         if len(([]byte((*(*(struct {
13658                 Channel string
13659                 Sender  string
13660                 Msg     string
13661         }))(obj)).Msg))) > math.MaxUint16 {
13662                 chk(ErrTooLong)
13663         }
13664         {
13665                 x := uint16(len(([]byte((*(*(struct {
13666                         Channel string
13667                         Sender  string
13668                         Msg     string
13669                 }))(obj)).Msg))))
13670                 write16(w, uint16(x))
13671         }
13672         {
13673                 _, err := w.Write(([]byte((*(*(struct {
13674                         Channel string
13675                         Sender  string
13676                         Msg     string
13677                 }))(obj)).Msg))[:])
13678                 chk(err)
13679         }
13680 }
13681
13682 func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
13683         var local224 []uint8
13684         var local225 uint16
13685         {
13686                 p := &local225
13687                 *p = read16(r)
13688         }
13689         (local224) = make([]uint8, local225)
13690         {
13691                 _, err := io.ReadFull(r, (local224)[:])
13692                 chk(err)
13693         }
13694         ((*(*(struct {
13695                 Channel string
13696                 Sender  string
13697                 Msg     string
13698         }))(obj)).Channel) = string(local224)
13699         var local226 []uint8
13700         var local227 uint16
13701         {
13702                 p := &local227
13703                 *p = read16(r)
13704         }
13705         (local226) = make([]uint8, local227)
13706         {
13707                 _, err := io.ReadFull(r, (local226)[:])
13708                 chk(err)
13709         }
13710         ((*(*(struct {
13711                 Channel string
13712                 Sender  string
13713                 Msg     string
13714         }))(obj)).Sender) = string(local226)
13715         var local228 []uint8
13716         var local229 uint16
13717         {
13718                 p := &local229
13719                 *p = read16(r)
13720         }
13721         (local228) = make([]uint8, local229)
13722         {
13723                 _, err := io.ReadFull(r, (local228)[:])
13724                 chk(err)
13725         }
13726         ((*(*(struct {
13727                 Channel string
13728                 Sender  string
13729                 Msg     string
13730         }))(obj)).Msg) = string(local228)
13731 }
13732
13733 func (obj *ToCltModChanSig) serialize(w io.Writer) {
13734         if err := pcall(func() {
13735                 ((*(*(struct {
13736                         Signal  ModChanSig
13737                         Channel string
13738                 }))(obj)).Signal).serialize(w)
13739         }); err != nil {
13740                 if err == io.EOF {
13741                         chk(io.EOF)
13742                 }
13743                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
13744         }
13745         if len(([]byte((*(*(struct {
13746                 Signal  ModChanSig
13747                 Channel string
13748         }))(obj)).Channel))) > math.MaxUint16 {
13749                 chk(ErrTooLong)
13750         }
13751         {
13752                 x := uint16(len(([]byte((*(*(struct {
13753                         Signal  ModChanSig
13754                         Channel string
13755                 }))(obj)).Channel))))
13756                 write16(w, uint16(x))
13757         }
13758         {
13759                 _, err := w.Write(([]byte((*(*(struct {
13760                         Signal  ModChanSig
13761                         Channel string
13762                 }))(obj)).Channel))[:])
13763                 chk(err)
13764         }
13765 }
13766
13767 func (obj *ToCltModChanSig) deserialize(r io.Reader) {
13768         if err := pcall(func() {
13769                 ((*(*(struct {
13770                         Signal  ModChanSig
13771                         Channel string
13772                 }))(obj)).Signal).deserialize(r)
13773         }); err != nil {
13774                 if err == io.EOF {
13775                         chk(io.EOF)
13776                 }
13777                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
13778         }
13779         var local230 []uint8
13780         var local231 uint16
13781         {
13782                 p := &local231
13783                 *p = read16(r)
13784         }
13785         (local230) = make([]uint8, local231)
13786         {
13787                 _, err := io.ReadFull(r, (local230)[:])
13788                 chk(err)
13789         }
13790         ((*(*(struct {
13791                 Signal  ModChanSig
13792                 Channel string
13793         }))(obj)).Channel) = string(local230)
13794 }
13795
13796 func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
13797         {
13798                 ow := w
13799                 w := new(bytes.Buffer)
13800                 {
13801                         x := (*(*(struct {
13802                                 //mt:lenhdr 32
13803                                 Changed map[[3]int16]*NodeMeta
13804                         }))(obj)).Changed
13805                         {
13806                                 w := zlib.NewWriter(w)
13807                                 if x == nil {
13808                                         write8(w, 0)
13809                                 } else {
13810                                         write8(w, 2)
13811                                         if len(x) > math.MaxUint16 {
13812                                                 chk(ErrTooLong)
13813                                         }
13814                                         write16(w, uint16(len(x)))
13815                                         keys := make([][3]int16, 0, len(x))
13816                                         for key := range x {
13817                                                 keys = append(keys, key)
13818                                         }
13819                                         sort.Slice(keys, func(i, j int) bool {
13820                                                 p, q := keys[i], keys[j]
13821                                                 for i := range p {
13822                                                         switch {
13823                                                         case p[i] < q[i]:
13824                                                                 return true
13825                                                         case p[i] > q[i]:
13826                                                                 return false
13827                                                         }
13828                                                 }
13829                                                 return false
13830                                         })
13831                                         for _, key := range keys {
13832                                                 for _, n := range key {
13833                                                         write16(w, uint16(n))
13834                                                 }
13835                                                 chk(serialize(w, x[key]))
13836                                         }
13837                                 }
13838                                 chk(w.Close())
13839                         }
13840                 }
13841                 {
13842                         buf := w
13843                         w := ow
13844                         if len((buf.Bytes())) > math.MaxUint32 {
13845                                 chk(ErrTooLong)
13846                         }
13847                         {
13848                                 x := uint32(len((buf.Bytes())))
13849                                 write32(w, uint32(x))
13850                         }
13851                         {
13852                                 _, err := w.Write((buf.Bytes())[:])
13853                                 chk(err)
13854                         }
13855                 }
13856         }
13857 }
13858
13859 func (obj *ToCltNodeMetasChanged) deserialize(r io.Reader) {
13860         {
13861                 var n uint32
13862                 {
13863                         p := &n
13864                         *p = read32(r)
13865                 }
13866                 r := &io.LimitedReader{r, int64(n)}
13867                 {
13868                         p := &(*(*(struct {
13869                                 //mt:lenhdr 32
13870                                 Changed map[[3]int16]*NodeMeta
13871                         }))(obj)).Changed
13872                         {
13873                                 r, err := zlib.NewReader(byteReader{r})
13874                                 chk(err)
13875                                 switch ver := read8(r); ver {
13876                                 case 0:
13877                                         *p = nil
13878                                 case 2:
13879                                         n := read16(r)
13880                                         *p = make(map[[3]int16]*NodeMeta, n)
13881                                         for ; n > 0; n-- {
13882                                                 var pos [3]int16
13883                                                 for i := range pos {
13884                                                         pos[i] = int16(read16(r))
13885                                                 }
13886                                                 nm := new(NodeMeta)
13887                                                 chk(deserialize(r, nm))
13888                                                 (*p)[pos] = nm
13889                                         }
13890                                 default:
13891                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
13892                                 }
13893                                 chk(r.Close())
13894                         }
13895                 }
13896                 if r.N > 0 {
13897                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
13898                 }
13899         }
13900 }
13901
13902 func (obj *ToCltSunParams) serialize(w io.Writer) {
13903         {
13904                 x := (*(*(struct {
13905                         Visible bool
13906                         Texture
13907                         ToneMap Texture
13908                         Rise    Texture
13909                         Rising  bool
13910                         Size    float32
13911                 }))(obj)).Visible
13912                 if x {
13913                         write8(w, 1)
13914                 } else {
13915                         write8(w, 0)
13916                 }
13917         }
13918         if err := pcall(func() {
13919                 ((*(*(struct {
13920                         Visible bool
13921                         Texture
13922                         ToneMap Texture
13923                         Rise    Texture
13924                         Rising  bool
13925                         Size    float32
13926                 }))(obj)).Texture).serialize(w)
13927         }); err != nil {
13928                 if err == io.EOF {
13929                         chk(io.EOF)
13930                 }
13931                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13932         }
13933         if err := pcall(func() {
13934                 ((*(*(struct {
13935                         Visible bool
13936                         Texture
13937                         ToneMap Texture
13938                         Rise    Texture
13939                         Rising  bool
13940                         Size    float32
13941                 }))(obj)).ToneMap).serialize(w)
13942         }); err != nil {
13943                 if err == io.EOF {
13944                         chk(io.EOF)
13945                 }
13946                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13947         }
13948         if err := pcall(func() {
13949                 ((*(*(struct {
13950                         Visible bool
13951                         Texture
13952                         ToneMap Texture
13953                         Rise    Texture
13954                         Rising  bool
13955                         Size    float32
13956                 }))(obj)).Rise).serialize(w)
13957         }); err != nil {
13958                 if err == io.EOF {
13959                         chk(io.EOF)
13960                 }
13961                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13962         }
13963         {
13964                 x := (*(*(struct {
13965                         Visible bool
13966                         Texture
13967                         ToneMap Texture
13968                         Rise    Texture
13969                         Rising  bool
13970                         Size    float32
13971                 }))(obj)).Rising
13972                 if x {
13973                         write8(w, 1)
13974                 } else {
13975                         write8(w, 0)
13976                 }
13977         }
13978         {
13979                 x := (*(*(struct {
13980                         Visible bool
13981                         Texture
13982                         ToneMap Texture
13983                         Rise    Texture
13984                         Rising  bool
13985                         Size    float32
13986                 }))(obj)).Size
13987                 write32(w, math.Float32bits(x))
13988         }
13989 }
13990
13991 func (obj *ToCltSunParams) deserialize(r io.Reader) {
13992         {
13993                 p := &(*(*(struct {
13994                         Visible bool
13995                         Texture
13996                         ToneMap Texture
13997                         Rise    Texture
13998                         Rising  bool
13999                         Size    float32
14000                 }))(obj)).Visible
14001                 switch n := read8(r); n {
14002                 case 0:
14003                         *p = false
14004                 case 1:
14005                         *p = true
14006                 default:
14007                         chk(fmt.Errorf("invalid bool: %d", n))
14008                 }
14009         }
14010         if err := pcall(func() {
14011                 ((*(*(struct {
14012                         Visible bool
14013                         Texture
14014                         ToneMap Texture
14015                         Rise    Texture
14016                         Rising  bool
14017                         Size    float32
14018                 }))(obj)).Texture).deserialize(r)
14019         }); err != nil {
14020                 if err == io.EOF {
14021                         chk(io.EOF)
14022                 }
14023                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14024         }
14025         if err := pcall(func() {
14026                 ((*(*(struct {
14027                         Visible bool
14028                         Texture
14029                         ToneMap Texture
14030                         Rise    Texture
14031                         Rising  bool
14032                         Size    float32
14033                 }))(obj)).ToneMap).deserialize(r)
14034         }); err != nil {
14035                 if err == io.EOF {
14036                         chk(io.EOF)
14037                 }
14038                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14039         }
14040         if err := pcall(func() {
14041                 ((*(*(struct {
14042                         Visible bool
14043                         Texture
14044                         ToneMap Texture
14045                         Rise    Texture
14046                         Rising  bool
14047                         Size    float32
14048                 }))(obj)).Rise).deserialize(r)
14049         }); err != nil {
14050                 if err == io.EOF {
14051                         chk(io.EOF)
14052                 }
14053                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14054         }
14055         {
14056                 p := &(*(*(struct {
14057                         Visible bool
14058                         Texture
14059                         ToneMap Texture
14060                         Rise    Texture
14061                         Rising  bool
14062                         Size    float32
14063                 }))(obj)).Rising
14064                 switch n := read8(r); n {
14065                 case 0:
14066                         *p = false
14067                 case 1:
14068                         *p = true
14069                 default:
14070                         chk(fmt.Errorf("invalid bool: %d", n))
14071                 }
14072         }
14073         {
14074                 p := &(*(*(struct {
14075                         Visible bool
14076                         Texture
14077                         ToneMap Texture
14078                         Rise    Texture
14079                         Rising  bool
14080                         Size    float32
14081                 }))(obj)).Size
14082                 *p = math.Float32frombits(read32(r))
14083         }
14084 }
14085
14086 func (obj *ToCltMoonParams) serialize(w io.Writer) {
14087         {
14088                 x := (*(*(struct {
14089                         Visible bool
14090                         Texture
14091                         ToneMap Texture
14092                         Size    float32
14093                 }))(obj)).Visible
14094                 if x {
14095                         write8(w, 1)
14096                 } else {
14097                         write8(w, 0)
14098                 }
14099         }
14100         if err := pcall(func() {
14101                 ((*(*(struct {
14102                         Visible bool
14103                         Texture
14104                         ToneMap Texture
14105                         Size    float32
14106                 }))(obj)).Texture).serialize(w)
14107         }); err != nil {
14108                 if err == io.EOF {
14109                         chk(io.EOF)
14110                 }
14111                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14112         }
14113         if err := pcall(func() {
14114                 ((*(*(struct {
14115                         Visible bool
14116                         Texture
14117                         ToneMap Texture
14118                         Size    float32
14119                 }))(obj)).ToneMap).serialize(w)
14120         }); err != nil {
14121                 if err == io.EOF {
14122                         chk(io.EOF)
14123                 }
14124                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14125         }
14126         {
14127                 x := (*(*(struct {
14128                         Visible bool
14129                         Texture
14130                         ToneMap Texture
14131                         Size    float32
14132                 }))(obj)).Size
14133                 write32(w, math.Float32bits(x))
14134         }
14135 }
14136
14137 func (obj *ToCltMoonParams) deserialize(r io.Reader) {
14138         {
14139                 p := &(*(*(struct {
14140                         Visible bool
14141                         Texture
14142                         ToneMap Texture
14143                         Size    float32
14144                 }))(obj)).Visible
14145                 switch n := read8(r); n {
14146                 case 0:
14147                         *p = false
14148                 case 1:
14149                         *p = true
14150                 default:
14151                         chk(fmt.Errorf("invalid bool: %d", n))
14152                 }
14153         }
14154         if err := pcall(func() {
14155                 ((*(*(struct {
14156                         Visible bool
14157                         Texture
14158                         ToneMap Texture
14159                         Size    float32
14160                 }))(obj)).Texture).deserialize(r)
14161         }); err != nil {
14162                 if err == io.EOF {
14163                         chk(io.EOF)
14164                 }
14165                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14166         }
14167         if err := pcall(func() {
14168                 ((*(*(struct {
14169                         Visible bool
14170                         Texture
14171                         ToneMap Texture
14172                         Size    float32
14173                 }))(obj)).ToneMap).deserialize(r)
14174         }); err != nil {
14175                 if err == io.EOF {
14176                         chk(io.EOF)
14177                 }
14178                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14179         }
14180         {
14181                 p := &(*(*(struct {
14182                         Visible bool
14183                         Texture
14184                         ToneMap Texture
14185                         Size    float32
14186                 }))(obj)).Size
14187                 *p = math.Float32frombits(read32(r))
14188         }
14189 }
14190
14191 func (obj *ToCltStarParams) serialize(w io.Writer) {
14192         {
14193                 x := (*(*(struct {
14194                         Visible bool
14195                         Count   uint32
14196                         Color   color.NRGBA
14197                         Size    float32
14198                 }))(obj)).Visible
14199                 if x {
14200                         write8(w, 1)
14201                 } else {
14202                         write8(w, 0)
14203                 }
14204         }
14205         {
14206                 x := (*(*(struct {
14207                         Visible bool
14208                         Count   uint32
14209                         Color   color.NRGBA
14210                         Size    float32
14211                 }))(obj)).Count
14212                 write32(w, uint32(x))
14213         }
14214         {
14215                 x := (*(*(struct {
14216                         Visible bool
14217                         Count   uint32
14218                         Color   color.NRGBA
14219                         Size    float32
14220                 }))(obj)).Color
14221                 w.Write([]byte{x.A, x.R, x.G, x.B})
14222         }
14223         {
14224                 x := (*(*(struct {
14225                         Visible bool
14226                         Count   uint32
14227                         Color   color.NRGBA
14228                         Size    float32
14229                 }))(obj)).Size
14230                 write32(w, math.Float32bits(x))
14231         }
14232 }
14233
14234 func (obj *ToCltStarParams) deserialize(r io.Reader) {
14235         {
14236                 p := &(*(*(struct {
14237                         Visible bool
14238                         Count   uint32
14239                         Color   color.NRGBA
14240                         Size    float32
14241                 }))(obj)).Visible
14242                 switch n := read8(r); n {
14243                 case 0:
14244                         *p = false
14245                 case 1:
14246                         *p = true
14247                 default:
14248                         chk(fmt.Errorf("invalid bool: %d", n))
14249                 }
14250         }
14251         {
14252                 p := &(*(*(struct {
14253                         Visible bool
14254                         Count   uint32
14255                         Color   color.NRGBA
14256                         Size    float32
14257                 }))(obj)).Count
14258                 *p = read32(r)
14259         }
14260         {
14261                 p := &(*(*(struct {
14262                         Visible bool
14263                         Count   uint32
14264                         Color   color.NRGBA
14265                         Size    float32
14266                 }))(obj)).Color
14267                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
14268         }
14269         {
14270                 p := &(*(*(struct {
14271                         Visible bool
14272                         Count   uint32
14273                         Color   color.NRGBA
14274                         Size    float32
14275                 }))(obj)).Size
14276                 *p = math.Float32frombits(read32(r))
14277         }
14278 }
14279
14280 func (obj *ToCltSRPBytesSaltB) serialize(w io.Writer) {
14281         if len(((*(*(struct {
14282                 Salt, B []byte
14283         }))(obj)).Salt)) > math.MaxUint16 {
14284                 chk(ErrTooLong)
14285         }
14286         {
14287                 x := uint16(len(((*(*(struct {
14288                         Salt, B []byte
14289                 }))(obj)).Salt)))
14290                 write16(w, uint16(x))
14291         }
14292         {
14293                 _, err := w.Write(((*(*(struct {
14294                         Salt, B []byte
14295                 }))(obj)).Salt)[:])
14296                 chk(err)
14297         }
14298         if len(((*(*(struct {
14299                 Salt, B []byte
14300         }))(obj)).B)) > math.MaxUint16 {
14301                 chk(ErrTooLong)
14302         }
14303         {
14304                 x := uint16(len(((*(*(struct {
14305                         Salt, B []byte
14306                 }))(obj)).B)))
14307                 write16(w, uint16(x))
14308         }
14309         {
14310                 _, err := w.Write(((*(*(struct {
14311                         Salt, B []byte
14312                 }))(obj)).B)[:])
14313                 chk(err)
14314         }
14315 }
14316
14317 func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
14318         var local232 uint16
14319         {
14320                 p := &local232
14321                 *p = read16(r)
14322         }
14323         ((*(*(struct {
14324                 Salt, B []byte
14325         }))(obj)).Salt) = make([]byte, local232)
14326         {
14327                 _, err := io.ReadFull(r, ((*(*(struct {
14328                         Salt, B []byte
14329                 }))(obj)).Salt)[:])
14330                 chk(err)
14331         }
14332         var local233 uint16
14333         {
14334                 p := &local233
14335                 *p = read16(r)
14336         }
14337         ((*(*(struct {
14338                 Salt, B []byte
14339         }))(obj)).B) = make([]byte, local233)
14340         {
14341                 _, err := io.ReadFull(r, ((*(*(struct {
14342                         Salt, B []byte
14343                 }))(obj)).B)[:])
14344                 chk(err)
14345         }
14346 }
14347
14348 func (obj *ToCltFormspecPrepend) serialize(w io.Writer) {
14349         if len(([]byte((*(*(struct {
14350                 Prepend string
14351         }))(obj)).Prepend))) > math.MaxUint16 {
14352                 chk(ErrTooLong)
14353         }
14354         {
14355                 x := uint16(len(([]byte((*(*(struct {
14356                         Prepend string
14357                 }))(obj)).Prepend))))
14358                 write16(w, uint16(x))
14359         }
14360         {
14361                 _, err := w.Write(([]byte((*(*(struct {
14362                         Prepend string
14363                 }))(obj)).Prepend))[:])
14364                 chk(err)
14365         }
14366 }
14367
14368 func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
14369         var local234 []uint8
14370         var local235 uint16
14371         {
14372                 p := &local235
14373                 *p = read16(r)
14374         }
14375         (local234) = make([]uint8, local235)
14376         {
14377                 _, err := io.ReadFull(r, (local234)[:])
14378                 chk(err)
14379         }
14380         ((*(*(struct {
14381                 Prepend string
14382         }))(obj)).Prepend) = string(local234)
14383 }
14384
14385 func (obj *AOCmdProps) serialize(w io.Writer) {
14386         if err := pcall(func() {
14387                 ((*(*(struct {
14388                         Props AOProps
14389                 }))(obj)).Props).serialize(w)
14390         }); err != nil {
14391                 if err == io.EOF {
14392                         chk(io.EOF)
14393                 }
14394                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOProps", err))
14395         }
14396 }
14397
14398 func (obj *AOCmdProps) deserialize(r io.Reader) {
14399         if err := pcall(func() {
14400                 ((*(*(struct {
14401                         Props AOProps
14402                 }))(obj)).Props).deserialize(r)
14403         }); err != nil {
14404                 if err == io.EOF {
14405                         chk(io.EOF)
14406                 }
14407                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOProps", err))
14408         }
14409 }
14410
14411 func (obj *AOCmdPos) serialize(w io.Writer) {
14412         if err := pcall(func() {
14413                 ((*(*(struct {
14414                         Pos AOPos
14415                 }))(obj)).Pos).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.AOPos", err))
14421         }
14422 }
14423
14424 func (obj *AOCmdPos) deserialize(r io.Reader) {
14425         if err := pcall(func() {
14426                 ((*(*(struct {
14427                         Pos AOPos
14428                 }))(obj)).Pos).deserialize(r)
14429         }); err != nil {
14430                 if err == io.EOF {
14431                         chk(io.EOF)
14432                 }
14433                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPos", err))
14434         }
14435 }
14436
14437 func (obj *AOCmdTextureMod) serialize(w io.Writer) {
14438         if err := pcall(func() {
14439                 ((*(*(struct {
14440                         Mod Texture // suffix
14441                 }))(obj)).Mod).serialize(w)
14442         }); err != nil {
14443                 if err == io.EOF {
14444                         chk(io.EOF)
14445                 }
14446                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14447         }
14448 }
14449
14450 func (obj *AOCmdTextureMod) deserialize(r io.Reader) {
14451         if err := pcall(func() {
14452                 ((*(*(struct {
14453                         Mod Texture // suffix
14454                 }))(obj)).Mod).deserialize(r)
14455         }); err != nil {
14456                 if err == io.EOF {
14457                         chk(io.EOF)
14458                 }
14459                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14460         }
14461 }
14462
14463 func (obj *AOCmdSprite) serialize(w io.Writer) {
14464         if err := pcall(func() {
14465                 ((*(*(struct {
14466                         Sprite AOSprite
14467                 }))(obj)).Sprite).serialize(w)
14468         }); err != nil {
14469                 if err == io.EOF {
14470                         chk(io.EOF)
14471                 }
14472                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOSprite", err))
14473         }
14474 }
14475
14476 func (obj *AOCmdSprite) deserialize(r io.Reader) {
14477         if err := pcall(func() {
14478                 ((*(*(struct {
14479                         Sprite AOSprite
14480                 }))(obj)).Sprite).deserialize(r)
14481         }); err != nil {
14482                 if err == io.EOF {
14483                         chk(io.EOF)
14484                 }
14485                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOSprite", err))
14486         }
14487 }
14488
14489 func (obj *AOCmdHP) serialize(w io.Writer) {
14490         {
14491                 x := (*(*(struct {
14492                         HP uint16
14493                 }))(obj)).HP
14494                 write16(w, uint16(x))
14495         }
14496 }
14497
14498 func (obj *AOCmdHP) deserialize(r io.Reader) {
14499         {
14500                 p := &(*(*(struct {
14501                         HP uint16
14502                 }))(obj)).HP
14503                 *p = read16(r)
14504         }
14505 }
14506
14507 func (obj *AOCmdArmorGroups) serialize(w io.Writer) {
14508         if len(((*(*(struct {
14509                 Armor []Group
14510         }))(obj)).Armor)) > math.MaxUint16 {
14511                 chk(ErrTooLong)
14512         }
14513         {
14514                 x := uint16(len(((*(*(struct {
14515                         Armor []Group
14516                 }))(obj)).Armor)))
14517                 write16(w, uint16(x))
14518         }
14519         for local236 := range (*(*(struct {
14520                 Armor []Group
14521         }))(obj)).Armor {
14522                 if err := pcall(func() {
14523                         (((*(*(struct {
14524                                 Armor []Group
14525                         }))(obj)).Armor)[local236]).serialize(w)
14526                 }); err != nil {
14527                         if err == io.EOF {
14528                                 chk(io.EOF)
14529                         }
14530                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
14531                 }
14532         }
14533 }
14534
14535 func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
14536         var local237 uint16
14537         {
14538                 p := &local237
14539                 *p = read16(r)
14540         }
14541         ((*(*(struct {
14542                 Armor []Group
14543         }))(obj)).Armor) = make([]Group, local237)
14544         for local238 := range (*(*(struct {
14545                 Armor []Group
14546         }))(obj)).Armor {
14547                 if err := pcall(func() {
14548                         (((*(*(struct {
14549                                 Armor []Group
14550                         }))(obj)).Armor)[local238]).deserialize(r)
14551                 }); err != nil {
14552                         if err == io.EOF {
14553                                 chk(io.EOF)
14554                         }
14555                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
14556                 }
14557         }
14558 }
14559
14560 func (obj *AOCmdAnim) serialize(w io.Writer) {
14561         if err := pcall(func() {
14562                 ((*(*(struct {
14563                         Anim AOAnim
14564                 }))(obj)).Anim).serialize(w)
14565         }); err != nil {
14566                 if err == io.EOF {
14567                         chk(io.EOF)
14568                 }
14569                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAnim", err))
14570         }
14571 }
14572
14573 func (obj *AOCmdAnim) deserialize(r io.Reader) {
14574         if err := pcall(func() {
14575                 ((*(*(struct {
14576                         Anim AOAnim
14577                 }))(obj)).Anim).deserialize(r)
14578         }); err != nil {
14579                 if err == io.EOF {
14580                         chk(io.EOF)
14581                 }
14582                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAnim", err))
14583         }
14584 }
14585
14586 func (obj *AOCmdBonePos) serialize(w io.Writer) {
14587         if len(([]byte((*(*(struct {
14588                 Bone string
14589                 Pos  AOBonePos
14590         }))(obj)).Bone))) > math.MaxUint16 {
14591                 chk(ErrTooLong)
14592         }
14593         {
14594                 x := uint16(len(([]byte((*(*(struct {
14595                         Bone string
14596                         Pos  AOBonePos
14597                 }))(obj)).Bone))))
14598                 write16(w, uint16(x))
14599         }
14600         {
14601                 _, err := w.Write(([]byte((*(*(struct {
14602                         Bone string
14603                         Pos  AOBonePos
14604                 }))(obj)).Bone))[:])
14605                 chk(err)
14606         }
14607         if err := pcall(func() {
14608                 ((*(*(struct {
14609                         Bone string
14610                         Pos  AOBonePos
14611                 }))(obj)).Pos).serialize(w)
14612         }); err != nil {
14613                 if err == io.EOF {
14614                         chk(io.EOF)
14615                 }
14616                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOBonePos", err))
14617         }
14618 }
14619
14620 func (obj *AOCmdBonePos) deserialize(r io.Reader) {
14621         var local239 []uint8
14622         var local240 uint16
14623         {
14624                 p := &local240
14625                 *p = read16(r)
14626         }
14627         (local239) = make([]uint8, local240)
14628         {
14629                 _, err := io.ReadFull(r, (local239)[:])
14630                 chk(err)
14631         }
14632         ((*(*(struct {
14633                 Bone string
14634                 Pos  AOBonePos
14635         }))(obj)).Bone) = string(local239)
14636         if err := pcall(func() {
14637                 ((*(*(struct {
14638                         Bone string
14639                         Pos  AOBonePos
14640                 }))(obj)).Pos).deserialize(r)
14641         }); err != nil {
14642                 if err == io.EOF {
14643                         chk(io.EOF)
14644                 }
14645                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOBonePos", err))
14646         }
14647 }
14648
14649 func (obj *AOCmdAttach) serialize(w io.Writer) {
14650         if err := pcall(func() {
14651                 ((*(*(struct {
14652                         Attach AOAttach
14653                 }))(obj)).Attach).serialize(w)
14654         }); err != nil {
14655                 if err == io.EOF {
14656                         chk(io.EOF)
14657                 }
14658                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAttach", err))
14659         }
14660 }
14661
14662 func (obj *AOCmdAttach) deserialize(r io.Reader) {
14663         if err := pcall(func() {
14664                 ((*(*(struct {
14665                         Attach AOAttach
14666                 }))(obj)).Attach).deserialize(r)
14667         }); err != nil {
14668                 if err == io.EOF {
14669                         chk(io.EOF)
14670                 }
14671                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAttach", err))
14672         }
14673 }
14674
14675 func (obj *AOCmdPhysOverride) serialize(w io.Writer) {
14676         if err := pcall(func() {
14677                 ((*(*(struct {
14678                         Phys AOPhysOverride
14679                 }))(obj)).Phys).serialize(w)
14680         }); err != nil {
14681                 if err == io.EOF {
14682                         chk(io.EOF)
14683                 }
14684                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPhysOverride", err))
14685         }
14686 }
14687
14688 func (obj *AOCmdPhysOverride) deserialize(r io.Reader) {
14689         if err := pcall(func() {
14690                 ((*(*(struct {
14691                         Phys AOPhysOverride
14692                 }))(obj)).Phys).deserialize(r)
14693         }); err != nil {
14694                 if err == io.EOF {
14695                         chk(io.EOF)
14696                 }
14697                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPhysOverride", err))
14698         }
14699 }
14700
14701 func (obj *AOCmdSpawnInfant) serialize(w io.Writer) {
14702         if err := pcall(func() {
14703                 ((*(*(struct {
14704                         ID AOID
14705                 }))(obj)).ID).serialize(w)
14706         }); err != nil {
14707                 if err == io.EOF {
14708                         chk(io.EOF)
14709                 }
14710                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
14711         }
14712         {
14713                 local241 := genericCAO
14714                 if err := pcall(func() {
14715                         (local241).serialize(w)
14716                 }); err != nil {
14717                         if err == io.EOF {
14718                                 chk(io.EOF)
14719                         }
14720                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
14721                 }
14722         }
14723 }
14724
14725 func (obj *AOCmdSpawnInfant) deserialize(r io.Reader) {
14726         if err := pcall(func() {
14727                 ((*(*(struct {
14728                         ID AOID
14729                 }))(obj)).ID).deserialize(r)
14730         }); err != nil {
14731                 if err == io.EOF {
14732                         chk(io.EOF)
14733                 }
14734                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
14735         }
14736         {
14737                 var local242 aoType
14738                 if err := pcall(func() {
14739                         (local242).deserialize(r)
14740                 }); err != nil {
14741                         if err == io.EOF {
14742                                 chk(io.EOF)
14743                         }
14744                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
14745                 }
14746                 if local242 != (101) {
14747                         chk(fmt.Errorf("const %v: %v", 101, local242))
14748                 }
14749         }
14750 }
14751
14752 func (obj *AOCmdAnimSpeed) serialize(w io.Writer) {
14753         {
14754                 x := (*(*(struct {
14755                         Speed float32
14756                 }))(obj)).Speed
14757                 write32(w, math.Float32bits(x))
14758         }
14759 }
14760
14761 func (obj *AOCmdAnimSpeed) deserialize(r io.Reader) {
14762         {
14763                 p := &(*(*(struct {
14764                         Speed float32
14765                 }))(obj)).Speed
14766                 *p = math.Float32frombits(read32(r))
14767         }
14768 }
14769
14770 func (obj *NodeMeta) serialize(w io.Writer) {
14771         if len(((*(*(struct {
14772                 //mt:len32
14773                 Fields []NodeMetaField
14774
14775                 Inv Inv
14776         }))(obj)).Fields)) > math.MaxUint32 {
14777                 chk(ErrTooLong)
14778         }
14779         {
14780                 x := uint32(len(((*(*(struct {
14781                         //mt:len32
14782                         Fields []NodeMetaField
14783
14784                         Inv Inv
14785                 }))(obj)).Fields)))
14786                 write32(w, uint32(x))
14787         }
14788         for local243 := range (*(*(struct {
14789                 //mt:len32
14790                 Fields []NodeMetaField
14791
14792                 Inv Inv
14793         }))(obj)).Fields {
14794                 if err := pcall(func() {
14795                         (((*(*(struct {
14796                                 //mt:len32
14797                                 Fields []NodeMetaField
14798
14799                                 Inv Inv
14800                         }))(obj)).Fields)[local243]).serialize(w)
14801                 }); err != nil {
14802                         if err == io.EOF {
14803                                 chk(io.EOF)
14804                         }
14805                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeMetaField", err))
14806                 }
14807         }
14808         chk(((*(*(struct {
14809                 //mt:len32
14810                 Fields []NodeMetaField
14811
14812                 Inv Inv
14813         }))(obj)).Inv).Serialize(w))
14814 }
14815
14816 func (obj *NodeMeta) deserialize(r io.Reader) {
14817         var local244 uint32
14818         {
14819                 p := &local244
14820                 *p = read32(r)
14821         }
14822         ((*(*(struct {
14823                 //mt:len32
14824                 Fields []NodeMetaField
14825
14826                 Inv Inv
14827         }))(obj)).Fields) = make([]NodeMetaField, local244)
14828         for local245 := range (*(*(struct {
14829                 //mt:len32
14830                 Fields []NodeMetaField
14831
14832                 Inv Inv
14833         }))(obj)).Fields {
14834                 if err := pcall(func() {
14835                         (((*(*(struct {
14836                                 //mt:len32
14837                                 Fields []NodeMetaField
14838
14839                                 Inv Inv
14840                         }))(obj)).Fields)[local245]).deserialize(r)
14841                 }); err != nil {
14842                         if err == io.EOF {
14843                                 chk(io.EOF)
14844                         }
14845                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeMetaField", err))
14846                 }
14847         }
14848         chk(((*(*(struct {
14849                 //mt:len32
14850                 Fields []NodeMetaField
14851
14852                 Inv Inv
14853         }))(obj)).Inv).Deserialize(r))
14854 }
14855
14856 func (obj *MinimapMode) serialize(w io.Writer) {
14857         if err := pcall(func() {
14858                 ((*(*(struct {
14859                         Type  MinimapType
14860                         Label string
14861                         Size  uint16
14862                         Texture
14863                         Scale uint16
14864                 }))(obj)).Type).serialize(w)
14865         }); err != nil {
14866                 if err == io.EOF {
14867                         chk(io.EOF)
14868                 }
14869                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
14870         }
14871         if len(([]byte((*(*(struct {
14872                 Type  MinimapType
14873                 Label string
14874                 Size  uint16
14875                 Texture
14876                 Scale uint16
14877         }))(obj)).Label))) > math.MaxUint16 {
14878                 chk(ErrTooLong)
14879         }
14880         {
14881                 x := uint16(len(([]byte((*(*(struct {
14882                         Type  MinimapType
14883                         Label string
14884                         Size  uint16
14885                         Texture
14886                         Scale uint16
14887                 }))(obj)).Label))))
14888                 write16(w, uint16(x))
14889         }
14890         {
14891                 _, err := w.Write(([]byte((*(*(struct {
14892                         Type  MinimapType
14893                         Label string
14894                         Size  uint16
14895                         Texture
14896                         Scale uint16
14897                 }))(obj)).Label))[:])
14898                 chk(err)
14899         }
14900         {
14901                 x := (*(*(struct {
14902                         Type  MinimapType
14903                         Label string
14904                         Size  uint16
14905                         Texture
14906                         Scale uint16
14907                 }))(obj)).Size
14908                 write16(w, uint16(x))
14909         }
14910         if err := pcall(func() {
14911                 ((*(*(struct {
14912                         Type  MinimapType
14913                         Label string
14914                         Size  uint16
14915                         Texture
14916                         Scale uint16
14917                 }))(obj)).Texture).serialize(w)
14918         }); err != nil {
14919                 if err == io.EOF {
14920                         chk(io.EOF)
14921                 }
14922                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14923         }
14924         {
14925                 x := (*(*(struct {
14926                         Type  MinimapType
14927                         Label string
14928                         Size  uint16
14929                         Texture
14930                         Scale uint16
14931                 }))(obj)).Scale
14932                 write16(w, uint16(x))
14933         }
14934 }
14935
14936 func (obj *MinimapMode) deserialize(r io.Reader) {
14937         if err := pcall(func() {
14938                 ((*(*(struct {
14939                         Type  MinimapType
14940                         Label string
14941                         Size  uint16
14942                         Texture
14943                         Scale uint16
14944                 }))(obj)).Type).deserialize(r)
14945         }); err != nil {
14946                 if err == io.EOF {
14947                         chk(io.EOF)
14948                 }
14949                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
14950         }
14951         var local246 []uint8
14952         var local247 uint16
14953         {
14954                 p := &local247
14955                 *p = read16(r)
14956         }
14957         (local246) = make([]uint8, local247)
14958         {
14959                 _, err := io.ReadFull(r, (local246)[:])
14960                 chk(err)
14961         }
14962         ((*(*(struct {
14963                 Type  MinimapType
14964                 Label string
14965                 Size  uint16
14966                 Texture
14967                 Scale uint16
14968         }))(obj)).Label) = string(local246)
14969         {
14970                 p := &(*(*(struct {
14971                         Type  MinimapType
14972                         Label string
14973                         Size  uint16
14974                         Texture
14975                         Scale uint16
14976                 }))(obj)).Size
14977                 *p = read16(r)
14978         }
14979         if err := pcall(func() {
14980                 ((*(*(struct {
14981                         Type  MinimapType
14982                         Label string
14983                         Size  uint16
14984                         Texture
14985                         Scale uint16
14986                 }))(obj)).Texture).deserialize(r)
14987         }); err != nil {
14988                 if err == io.EOF {
14989                         chk(io.EOF)
14990                 }
14991                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
14992         }
14993         {
14994                 p := &(*(*(struct {
14995                         Type  MinimapType
14996                         Label string
14997                         Size  uint16
14998                         Texture
14999                         Scale uint16
15000                 }))(obj)).Scale
15001                 *p = read16(r)
15002         }
15003 }
15004
15005 func (obj *NodeDef) serialize(w io.Writer) {
15006         if err := pcall(func() {
15007                 ((*(*(struct {
15008                         Param0 Content
15009
15010                         Name   string
15011                         Groups []Group
15012
15013                         P1Type   Param1Type
15014                         P2Type   Param2Type
15015                         DrawType DrawType
15016
15017                         Mesh  string
15018                         Scale float32
15019                         //mt:const uint8(6)
15020                         Tiles        [6]TileDef
15021                         OverlayTiles [6]TileDef
15022                         //mt:const uint8(6)
15023                         SpecialTiles [6]TileDef
15024
15025                         Color   color.NRGBA
15026                         Palette Texture
15027
15028                         Waving       WaveType
15029                         ConnectSides uint8
15030                         ConnectTo    []Content
15031                         InsideTint   color.NRGBA
15032                         Level        uint8 // Must be < 128.
15033
15034                         Translucent bool // Sunlight is scattered and becomes normal light.
15035                         Transparent bool // Sunlight isn't scattered.
15036                         LightSrc    uint8
15037
15038                         GndContent   bool
15039                         Collides     bool
15040                         Pointable    bool
15041                         Diggable     bool
15042                         Climbable    bool
15043                         Replaceable  bool
15044                         OnRightClick bool
15045
15046                         DmgPerSec int32
15047
15048                         LiquidType   LiquidType
15049                         FlowingAlt   string
15050                         SrcAlt       string
15051                         Viscosity    uint8 // 0-7
15052                         LiqRenewable bool
15053                         FlowRange    uint8
15054                         DrownDmg     uint8
15055                         Floodable    bool
15056
15057                         DrawBox, ColBox, SelBox NodeBox
15058
15059                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15060
15061                         LegacyFaceDir bool
15062                         LegacyMounted bool
15063
15064                         DigPredict string
15065
15066                         MaxLvl uint8
15067
15068                         AlphaUse
15069                 }))(obj)).Param0).serialize(w)
15070         }); err != nil {
15071                 if err == io.EOF {
15072                         chk(io.EOF)
15073                 }
15074                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
15075         }
15076         {
15077                 ow := w
15078                 w := new(bytes.Buffer)
15079                 {
15080                         local248 := uint8(13)
15081                         {
15082                                 x := local248
15083                                 write8(w, uint8(x))
15084                         }
15085                 }
15086                 if len(([]byte((*(*(struct {
15087                         Param0 Content
15088
15089                         Name   string
15090                         Groups []Group
15091
15092                         P1Type   Param1Type
15093                         P2Type   Param2Type
15094                         DrawType DrawType
15095
15096                         Mesh  string
15097                         Scale float32
15098                         //mt:const uint8(6)
15099                         Tiles        [6]TileDef
15100                         OverlayTiles [6]TileDef
15101                         //mt:const uint8(6)
15102                         SpecialTiles [6]TileDef
15103
15104                         Color   color.NRGBA
15105                         Palette Texture
15106
15107                         Waving       WaveType
15108                         ConnectSides uint8
15109                         ConnectTo    []Content
15110                         InsideTint   color.NRGBA
15111                         Level        uint8 // Must be < 128.
15112
15113                         Translucent bool // Sunlight is scattered and becomes normal light.
15114                         Transparent bool // Sunlight isn't scattered.
15115                         LightSrc    uint8
15116
15117                         GndContent   bool
15118                         Collides     bool
15119                         Pointable    bool
15120                         Diggable     bool
15121                         Climbable    bool
15122                         Replaceable  bool
15123                         OnRightClick bool
15124
15125                         DmgPerSec int32
15126
15127                         LiquidType   LiquidType
15128                         FlowingAlt   string
15129                         SrcAlt       string
15130                         Viscosity    uint8 // 0-7
15131                         LiqRenewable bool
15132                         FlowRange    uint8
15133                         DrownDmg     uint8
15134                         Floodable    bool
15135
15136                         DrawBox, ColBox, SelBox NodeBox
15137
15138                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15139
15140                         LegacyFaceDir bool
15141                         LegacyMounted bool
15142
15143                         DigPredict string
15144
15145                         MaxLvl uint8
15146
15147                         AlphaUse
15148                 }))(obj)).Name))) > math.MaxUint16 {
15149                         chk(ErrTooLong)
15150                 }
15151                 {
15152                         x := uint16(len(([]byte((*(*(struct {
15153                                 Param0 Content
15154
15155                                 Name   string
15156                                 Groups []Group
15157
15158                                 P1Type   Param1Type
15159                                 P2Type   Param2Type
15160                                 DrawType DrawType
15161
15162                                 Mesh  string
15163                                 Scale float32
15164                                 //mt:const uint8(6)
15165                                 Tiles        [6]TileDef
15166                                 OverlayTiles [6]TileDef
15167                                 //mt:const uint8(6)
15168                                 SpecialTiles [6]TileDef
15169
15170                                 Color   color.NRGBA
15171                                 Palette Texture
15172
15173                                 Waving       WaveType
15174                                 ConnectSides uint8
15175                                 ConnectTo    []Content
15176                                 InsideTint   color.NRGBA
15177                                 Level        uint8 // Must be < 128.
15178
15179                                 Translucent bool // Sunlight is scattered and becomes normal light.
15180                                 Transparent bool // Sunlight isn't scattered.
15181                                 LightSrc    uint8
15182
15183                                 GndContent   bool
15184                                 Collides     bool
15185                                 Pointable    bool
15186                                 Diggable     bool
15187                                 Climbable    bool
15188                                 Replaceable  bool
15189                                 OnRightClick bool
15190
15191                                 DmgPerSec int32
15192
15193                                 LiquidType   LiquidType
15194                                 FlowingAlt   string
15195                                 SrcAlt       string
15196                                 Viscosity    uint8 // 0-7
15197                                 LiqRenewable bool
15198                                 FlowRange    uint8
15199                                 DrownDmg     uint8
15200                                 Floodable    bool
15201
15202                                 DrawBox, ColBox, SelBox NodeBox
15203
15204                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15205
15206                                 LegacyFaceDir bool
15207                                 LegacyMounted bool
15208
15209                                 DigPredict string
15210
15211                                 MaxLvl uint8
15212
15213                                 AlphaUse
15214                         }))(obj)).Name))))
15215                         write16(w, uint16(x))
15216                 }
15217                 {
15218                         _, err := w.Write(([]byte((*(*(struct {
15219                                 Param0 Content
15220
15221                                 Name   string
15222                                 Groups []Group
15223
15224                                 P1Type   Param1Type
15225                                 P2Type   Param2Type
15226                                 DrawType DrawType
15227
15228                                 Mesh  string
15229                                 Scale float32
15230                                 //mt:const uint8(6)
15231                                 Tiles        [6]TileDef
15232                                 OverlayTiles [6]TileDef
15233                                 //mt:const uint8(6)
15234                                 SpecialTiles [6]TileDef
15235
15236                                 Color   color.NRGBA
15237                                 Palette Texture
15238
15239                                 Waving       WaveType
15240                                 ConnectSides uint8
15241                                 ConnectTo    []Content
15242                                 InsideTint   color.NRGBA
15243                                 Level        uint8 // Must be < 128.
15244
15245                                 Translucent bool // Sunlight is scattered and becomes normal light.
15246                                 Transparent bool // Sunlight isn't scattered.
15247                                 LightSrc    uint8
15248
15249                                 GndContent   bool
15250                                 Collides     bool
15251                                 Pointable    bool
15252                                 Diggable     bool
15253                                 Climbable    bool
15254                                 Replaceable  bool
15255                                 OnRightClick bool
15256
15257                                 DmgPerSec int32
15258
15259                                 LiquidType   LiquidType
15260                                 FlowingAlt   string
15261                                 SrcAlt       string
15262                                 Viscosity    uint8 // 0-7
15263                                 LiqRenewable bool
15264                                 FlowRange    uint8
15265                                 DrownDmg     uint8
15266                                 Floodable    bool
15267
15268                                 DrawBox, ColBox, SelBox NodeBox
15269
15270                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15271
15272                                 LegacyFaceDir bool
15273                                 LegacyMounted bool
15274
15275                                 DigPredict string
15276
15277                                 MaxLvl uint8
15278
15279                                 AlphaUse
15280                         }))(obj)).Name))[:])
15281                         chk(err)
15282                 }
15283                 if len(((*(*(struct {
15284                         Param0 Content
15285
15286                         Name   string
15287                         Groups []Group
15288
15289                         P1Type   Param1Type
15290                         P2Type   Param2Type
15291                         DrawType DrawType
15292
15293                         Mesh  string
15294                         Scale float32
15295                         //mt:const uint8(6)
15296                         Tiles        [6]TileDef
15297                         OverlayTiles [6]TileDef
15298                         //mt:const uint8(6)
15299                         SpecialTiles [6]TileDef
15300
15301                         Color   color.NRGBA
15302                         Palette Texture
15303
15304                         Waving       WaveType
15305                         ConnectSides uint8
15306                         ConnectTo    []Content
15307                         InsideTint   color.NRGBA
15308                         Level        uint8 // Must be < 128.
15309
15310                         Translucent bool // Sunlight is scattered and becomes normal light.
15311                         Transparent bool // Sunlight isn't scattered.
15312                         LightSrc    uint8
15313
15314                         GndContent   bool
15315                         Collides     bool
15316                         Pointable    bool
15317                         Diggable     bool
15318                         Climbable    bool
15319                         Replaceable  bool
15320                         OnRightClick bool
15321
15322                         DmgPerSec int32
15323
15324                         LiquidType   LiquidType
15325                         FlowingAlt   string
15326                         SrcAlt       string
15327                         Viscosity    uint8 // 0-7
15328                         LiqRenewable bool
15329                         FlowRange    uint8
15330                         DrownDmg     uint8
15331                         Floodable    bool
15332
15333                         DrawBox, ColBox, SelBox NodeBox
15334
15335                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15336
15337                         LegacyFaceDir bool
15338                         LegacyMounted bool
15339
15340                         DigPredict string
15341
15342                         MaxLvl uint8
15343
15344                         AlphaUse
15345                 }))(obj)).Groups)) > math.MaxUint16 {
15346                         chk(ErrTooLong)
15347                 }
15348                 {
15349                         x := uint16(len(((*(*(struct {
15350                                 Param0 Content
15351
15352                                 Name   string
15353                                 Groups []Group
15354
15355                                 P1Type   Param1Type
15356                                 P2Type   Param2Type
15357                                 DrawType DrawType
15358
15359                                 Mesh  string
15360                                 Scale float32
15361                                 //mt:const uint8(6)
15362                                 Tiles        [6]TileDef
15363                                 OverlayTiles [6]TileDef
15364                                 //mt:const uint8(6)
15365                                 SpecialTiles [6]TileDef
15366
15367                                 Color   color.NRGBA
15368                                 Palette Texture
15369
15370                                 Waving       WaveType
15371                                 ConnectSides uint8
15372                                 ConnectTo    []Content
15373                                 InsideTint   color.NRGBA
15374                                 Level        uint8 // Must be < 128.
15375
15376                                 Translucent bool // Sunlight is scattered and becomes normal light.
15377                                 Transparent bool // Sunlight isn't scattered.
15378                                 LightSrc    uint8
15379
15380                                 GndContent   bool
15381                                 Collides     bool
15382                                 Pointable    bool
15383                                 Diggable     bool
15384                                 Climbable    bool
15385                                 Replaceable  bool
15386                                 OnRightClick bool
15387
15388                                 DmgPerSec int32
15389
15390                                 LiquidType   LiquidType
15391                                 FlowingAlt   string
15392                                 SrcAlt       string
15393                                 Viscosity    uint8 // 0-7
15394                                 LiqRenewable bool
15395                                 FlowRange    uint8
15396                                 DrownDmg     uint8
15397                                 Floodable    bool
15398
15399                                 DrawBox, ColBox, SelBox NodeBox
15400
15401                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15402
15403                                 LegacyFaceDir bool
15404                                 LegacyMounted bool
15405
15406                                 DigPredict string
15407
15408                                 MaxLvl uint8
15409
15410                                 AlphaUse
15411                         }))(obj)).Groups)))
15412                         write16(w, uint16(x))
15413                 }
15414                 for local249 := range (*(*(struct {
15415                         Param0 Content
15416
15417                         Name   string
15418                         Groups []Group
15419
15420                         P1Type   Param1Type
15421                         P2Type   Param2Type
15422                         DrawType DrawType
15423
15424                         Mesh  string
15425                         Scale float32
15426                         //mt:const uint8(6)
15427                         Tiles        [6]TileDef
15428                         OverlayTiles [6]TileDef
15429                         //mt:const uint8(6)
15430                         SpecialTiles [6]TileDef
15431
15432                         Color   color.NRGBA
15433                         Palette Texture
15434
15435                         Waving       WaveType
15436                         ConnectSides uint8
15437                         ConnectTo    []Content
15438                         InsideTint   color.NRGBA
15439                         Level        uint8 // Must be < 128.
15440
15441                         Translucent bool // Sunlight is scattered and becomes normal light.
15442                         Transparent bool // Sunlight isn't scattered.
15443                         LightSrc    uint8
15444
15445                         GndContent   bool
15446                         Collides     bool
15447                         Pointable    bool
15448                         Diggable     bool
15449                         Climbable    bool
15450                         Replaceable  bool
15451                         OnRightClick bool
15452
15453                         DmgPerSec int32
15454
15455                         LiquidType   LiquidType
15456                         FlowingAlt   string
15457                         SrcAlt       string
15458                         Viscosity    uint8 // 0-7
15459                         LiqRenewable bool
15460                         FlowRange    uint8
15461                         DrownDmg     uint8
15462                         Floodable    bool
15463
15464                         DrawBox, ColBox, SelBox NodeBox
15465
15466                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15467
15468                         LegacyFaceDir bool
15469                         LegacyMounted bool
15470
15471                         DigPredict string
15472
15473                         MaxLvl uint8
15474
15475                         AlphaUse
15476                 }))(obj)).Groups {
15477                         if err := pcall(func() {
15478                                 (((*(*(struct {
15479                                         Param0 Content
15480
15481                                         Name   string
15482                                         Groups []Group
15483
15484                                         P1Type   Param1Type
15485                                         P2Type   Param2Type
15486                                         DrawType DrawType
15487
15488                                         Mesh  string
15489                                         Scale float32
15490                                         //mt:const uint8(6)
15491                                         Tiles        [6]TileDef
15492                                         OverlayTiles [6]TileDef
15493                                         //mt:const uint8(6)
15494                                         SpecialTiles [6]TileDef
15495
15496                                         Color   color.NRGBA
15497                                         Palette Texture
15498
15499                                         Waving       WaveType
15500                                         ConnectSides uint8
15501                                         ConnectTo    []Content
15502                                         InsideTint   color.NRGBA
15503                                         Level        uint8 // Must be < 128.
15504
15505                                         Translucent bool // Sunlight is scattered and becomes normal light.
15506                                         Transparent bool // Sunlight isn't scattered.
15507                                         LightSrc    uint8
15508
15509                                         GndContent   bool
15510                                         Collides     bool
15511                                         Pointable    bool
15512                                         Diggable     bool
15513                                         Climbable    bool
15514                                         Replaceable  bool
15515                                         OnRightClick bool
15516
15517                                         DmgPerSec int32
15518
15519                                         LiquidType   LiquidType
15520                                         FlowingAlt   string
15521                                         SrcAlt       string
15522                                         Viscosity    uint8 // 0-7
15523                                         LiqRenewable bool
15524                                         FlowRange    uint8
15525                                         DrownDmg     uint8
15526                                         Floodable    bool
15527
15528                                         DrawBox, ColBox, SelBox NodeBox
15529
15530                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15531
15532                                         LegacyFaceDir bool
15533                                         LegacyMounted bool
15534
15535                                         DigPredict string
15536
15537                                         MaxLvl uint8
15538
15539                                         AlphaUse
15540                                 }))(obj)).Groups)[local249]).serialize(w)
15541                         }); err != nil {
15542                                 if err == io.EOF {
15543                                         chk(io.EOF)
15544                                 }
15545                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
15546                         }
15547                 }
15548                 if err := pcall(func() {
15549                         ((*(*(struct {
15550                                 Param0 Content
15551
15552                                 Name   string
15553                                 Groups []Group
15554
15555                                 P1Type   Param1Type
15556                                 P2Type   Param2Type
15557                                 DrawType DrawType
15558
15559                                 Mesh  string
15560                                 Scale float32
15561                                 //mt:const uint8(6)
15562                                 Tiles        [6]TileDef
15563                                 OverlayTiles [6]TileDef
15564                                 //mt:const uint8(6)
15565                                 SpecialTiles [6]TileDef
15566
15567                                 Color   color.NRGBA
15568                                 Palette Texture
15569
15570                                 Waving       WaveType
15571                                 ConnectSides uint8
15572                                 ConnectTo    []Content
15573                                 InsideTint   color.NRGBA
15574                                 Level        uint8 // Must be < 128.
15575
15576                                 Translucent bool // Sunlight is scattered and becomes normal light.
15577                                 Transparent bool // Sunlight isn't scattered.
15578                                 LightSrc    uint8
15579
15580                                 GndContent   bool
15581                                 Collides     bool
15582                                 Pointable    bool
15583                                 Diggable     bool
15584                                 Climbable    bool
15585                                 Replaceable  bool
15586                                 OnRightClick bool
15587
15588                                 DmgPerSec int32
15589
15590                                 LiquidType   LiquidType
15591                                 FlowingAlt   string
15592                                 SrcAlt       string
15593                                 Viscosity    uint8 // 0-7
15594                                 LiqRenewable bool
15595                                 FlowRange    uint8
15596                                 DrownDmg     uint8
15597                                 Floodable    bool
15598
15599                                 DrawBox, ColBox, SelBox NodeBox
15600
15601                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15602
15603                                 LegacyFaceDir bool
15604                                 LegacyMounted bool
15605
15606                                 DigPredict string
15607
15608                                 MaxLvl uint8
15609
15610                                 AlphaUse
15611                         }))(obj)).P1Type).serialize(w)
15612                 }); err != nil {
15613                         if err == io.EOF {
15614                                 chk(io.EOF)
15615                         }
15616                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param1Type", err))
15617                 }
15618                 if err := pcall(func() {
15619                         ((*(*(struct {
15620                                 Param0 Content
15621
15622                                 Name   string
15623                                 Groups []Group
15624
15625                                 P1Type   Param1Type
15626                                 P2Type   Param2Type
15627                                 DrawType DrawType
15628
15629                                 Mesh  string
15630                                 Scale float32
15631                                 //mt:const uint8(6)
15632                                 Tiles        [6]TileDef
15633                                 OverlayTiles [6]TileDef
15634                                 //mt:const uint8(6)
15635                                 SpecialTiles [6]TileDef
15636
15637                                 Color   color.NRGBA
15638                                 Palette Texture
15639
15640                                 Waving       WaveType
15641                                 ConnectSides uint8
15642                                 ConnectTo    []Content
15643                                 InsideTint   color.NRGBA
15644                                 Level        uint8 // Must be < 128.
15645
15646                                 Translucent bool // Sunlight is scattered and becomes normal light.
15647                                 Transparent bool // Sunlight isn't scattered.
15648                                 LightSrc    uint8
15649
15650                                 GndContent   bool
15651                                 Collides     bool
15652                                 Pointable    bool
15653                                 Diggable     bool
15654                                 Climbable    bool
15655                                 Replaceable  bool
15656                                 OnRightClick bool
15657
15658                                 DmgPerSec int32
15659
15660                                 LiquidType   LiquidType
15661                                 FlowingAlt   string
15662                                 SrcAlt       string
15663                                 Viscosity    uint8 // 0-7
15664                                 LiqRenewable bool
15665                                 FlowRange    uint8
15666                                 DrownDmg     uint8
15667                                 Floodable    bool
15668
15669                                 DrawBox, ColBox, SelBox NodeBox
15670
15671                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15672
15673                                 LegacyFaceDir bool
15674                                 LegacyMounted bool
15675
15676                                 DigPredict string
15677
15678                                 MaxLvl uint8
15679
15680                                 AlphaUse
15681                         }))(obj)).P2Type).serialize(w)
15682                 }); err != nil {
15683                         if err == io.EOF {
15684                                 chk(io.EOF)
15685                         }
15686                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param2Type", err))
15687                 }
15688                 if err := pcall(func() {
15689                         ((*(*(struct {
15690                                 Param0 Content
15691
15692                                 Name   string
15693                                 Groups []Group
15694
15695                                 P1Type   Param1Type
15696                                 P2Type   Param2Type
15697                                 DrawType DrawType
15698
15699                                 Mesh  string
15700                                 Scale float32
15701                                 //mt:const uint8(6)
15702                                 Tiles        [6]TileDef
15703                                 OverlayTiles [6]TileDef
15704                                 //mt:const uint8(6)
15705                                 SpecialTiles [6]TileDef
15706
15707                                 Color   color.NRGBA
15708                                 Palette Texture
15709
15710                                 Waving       WaveType
15711                                 ConnectSides uint8
15712                                 ConnectTo    []Content
15713                                 InsideTint   color.NRGBA
15714                                 Level        uint8 // Must be < 128.
15715
15716                                 Translucent bool // Sunlight is scattered and becomes normal light.
15717                                 Transparent bool // Sunlight isn't scattered.
15718                                 LightSrc    uint8
15719
15720                                 GndContent   bool
15721                                 Collides     bool
15722                                 Pointable    bool
15723                                 Diggable     bool
15724                                 Climbable    bool
15725                                 Replaceable  bool
15726                                 OnRightClick bool
15727
15728                                 DmgPerSec int32
15729
15730                                 LiquidType   LiquidType
15731                                 FlowingAlt   string
15732                                 SrcAlt       string
15733                                 Viscosity    uint8 // 0-7
15734                                 LiqRenewable bool
15735                                 FlowRange    uint8
15736                                 DrownDmg     uint8
15737                                 Floodable    bool
15738
15739                                 DrawBox, ColBox, SelBox NodeBox
15740
15741                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15742
15743                                 LegacyFaceDir bool
15744                                 LegacyMounted bool
15745
15746                                 DigPredict string
15747
15748                                 MaxLvl uint8
15749
15750                                 AlphaUse
15751                         }))(obj)).DrawType).serialize(w)
15752                 }); err != nil {
15753                         if err == io.EOF {
15754                                 chk(io.EOF)
15755                         }
15756                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
15757                 }
15758                 if len(([]byte((*(*(struct {
15759                         Param0 Content
15760
15761                         Name   string
15762                         Groups []Group
15763
15764                         P1Type   Param1Type
15765                         P2Type   Param2Type
15766                         DrawType DrawType
15767
15768                         Mesh  string
15769                         Scale float32
15770                         //mt:const uint8(6)
15771                         Tiles        [6]TileDef
15772                         OverlayTiles [6]TileDef
15773                         //mt:const uint8(6)
15774                         SpecialTiles [6]TileDef
15775
15776                         Color   color.NRGBA
15777                         Palette Texture
15778
15779                         Waving       WaveType
15780                         ConnectSides uint8
15781                         ConnectTo    []Content
15782                         InsideTint   color.NRGBA
15783                         Level        uint8 // Must be < 128.
15784
15785                         Translucent bool // Sunlight is scattered and becomes normal light.
15786                         Transparent bool // Sunlight isn't scattered.
15787                         LightSrc    uint8
15788
15789                         GndContent   bool
15790                         Collides     bool
15791                         Pointable    bool
15792                         Diggable     bool
15793                         Climbable    bool
15794                         Replaceable  bool
15795                         OnRightClick bool
15796
15797                         DmgPerSec int32
15798
15799                         LiquidType   LiquidType
15800                         FlowingAlt   string
15801                         SrcAlt       string
15802                         Viscosity    uint8 // 0-7
15803                         LiqRenewable bool
15804                         FlowRange    uint8
15805                         DrownDmg     uint8
15806                         Floodable    bool
15807
15808                         DrawBox, ColBox, SelBox NodeBox
15809
15810                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15811
15812                         LegacyFaceDir bool
15813                         LegacyMounted bool
15814
15815                         DigPredict string
15816
15817                         MaxLvl uint8
15818
15819                         AlphaUse
15820                 }))(obj)).Mesh))) > math.MaxUint16 {
15821                         chk(ErrTooLong)
15822                 }
15823                 {
15824                         x := uint16(len(([]byte((*(*(struct {
15825                                 Param0 Content
15826
15827                                 Name   string
15828                                 Groups []Group
15829
15830                                 P1Type   Param1Type
15831                                 P2Type   Param2Type
15832                                 DrawType DrawType
15833
15834                                 Mesh  string
15835                                 Scale float32
15836                                 //mt:const uint8(6)
15837                                 Tiles        [6]TileDef
15838                                 OverlayTiles [6]TileDef
15839                                 //mt:const uint8(6)
15840                                 SpecialTiles [6]TileDef
15841
15842                                 Color   color.NRGBA
15843                                 Palette Texture
15844
15845                                 Waving       WaveType
15846                                 ConnectSides uint8
15847                                 ConnectTo    []Content
15848                                 InsideTint   color.NRGBA
15849                                 Level        uint8 // Must be < 128.
15850
15851                                 Translucent bool // Sunlight is scattered and becomes normal light.
15852                                 Transparent bool // Sunlight isn't scattered.
15853                                 LightSrc    uint8
15854
15855                                 GndContent   bool
15856                                 Collides     bool
15857                                 Pointable    bool
15858                                 Diggable     bool
15859                                 Climbable    bool
15860                                 Replaceable  bool
15861                                 OnRightClick bool
15862
15863                                 DmgPerSec int32
15864
15865                                 LiquidType   LiquidType
15866                                 FlowingAlt   string
15867                                 SrcAlt       string
15868                                 Viscosity    uint8 // 0-7
15869                                 LiqRenewable bool
15870                                 FlowRange    uint8
15871                                 DrownDmg     uint8
15872                                 Floodable    bool
15873
15874                                 DrawBox, ColBox, SelBox NodeBox
15875
15876                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15877
15878                                 LegacyFaceDir bool
15879                                 LegacyMounted bool
15880
15881                                 DigPredict string
15882
15883                                 MaxLvl uint8
15884
15885                                 AlphaUse
15886                         }))(obj)).Mesh))))
15887                         write16(w, uint16(x))
15888                 }
15889                 {
15890                         _, err := w.Write(([]byte((*(*(struct {
15891                                 Param0 Content
15892
15893                                 Name   string
15894                                 Groups []Group
15895
15896                                 P1Type   Param1Type
15897                                 P2Type   Param2Type
15898                                 DrawType DrawType
15899
15900                                 Mesh  string
15901                                 Scale float32
15902                                 //mt:const uint8(6)
15903                                 Tiles        [6]TileDef
15904                                 OverlayTiles [6]TileDef
15905                                 //mt:const uint8(6)
15906                                 SpecialTiles [6]TileDef
15907
15908                                 Color   color.NRGBA
15909                                 Palette Texture
15910
15911                                 Waving       WaveType
15912                                 ConnectSides uint8
15913                                 ConnectTo    []Content
15914                                 InsideTint   color.NRGBA
15915                                 Level        uint8 // Must be < 128.
15916
15917                                 Translucent bool // Sunlight is scattered and becomes normal light.
15918                                 Transparent bool // Sunlight isn't scattered.
15919                                 LightSrc    uint8
15920
15921                                 GndContent   bool
15922                                 Collides     bool
15923                                 Pointable    bool
15924                                 Diggable     bool
15925                                 Climbable    bool
15926                                 Replaceable  bool
15927                                 OnRightClick bool
15928
15929                                 DmgPerSec int32
15930
15931                                 LiquidType   LiquidType
15932                                 FlowingAlt   string
15933                                 SrcAlt       string
15934                                 Viscosity    uint8 // 0-7
15935                                 LiqRenewable bool
15936                                 FlowRange    uint8
15937                                 DrownDmg     uint8
15938                                 Floodable    bool
15939
15940                                 DrawBox, ColBox, SelBox NodeBox
15941
15942                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15943
15944                                 LegacyFaceDir bool
15945                                 LegacyMounted bool
15946
15947                                 DigPredict string
15948
15949                                 MaxLvl uint8
15950
15951                                 AlphaUse
15952                         }))(obj)).Mesh))[:])
15953                         chk(err)
15954                 }
15955                 {
15956                         x := (*(*(struct {
15957                                 Param0 Content
15958
15959                                 Name   string
15960                                 Groups []Group
15961
15962                                 P1Type   Param1Type
15963                                 P2Type   Param2Type
15964                                 DrawType DrawType
15965
15966                                 Mesh  string
15967                                 Scale float32
15968                                 //mt:const uint8(6)
15969                                 Tiles        [6]TileDef
15970                                 OverlayTiles [6]TileDef
15971                                 //mt:const uint8(6)
15972                                 SpecialTiles [6]TileDef
15973
15974                                 Color   color.NRGBA
15975                                 Palette Texture
15976
15977                                 Waving       WaveType
15978                                 ConnectSides uint8
15979                                 ConnectTo    []Content
15980                                 InsideTint   color.NRGBA
15981                                 Level        uint8 // Must be < 128.
15982
15983                                 Translucent bool // Sunlight is scattered and becomes normal light.
15984                                 Transparent bool // Sunlight isn't scattered.
15985                                 LightSrc    uint8
15986
15987                                 GndContent   bool
15988                                 Collides     bool
15989                                 Pointable    bool
15990                                 Diggable     bool
15991                                 Climbable    bool
15992                                 Replaceable  bool
15993                                 OnRightClick bool
15994
15995                                 DmgPerSec int32
15996
15997                                 LiquidType   LiquidType
15998                                 FlowingAlt   string
15999                                 SrcAlt       string
16000                                 Viscosity    uint8 // 0-7
16001                                 LiqRenewable bool
16002                                 FlowRange    uint8
16003                                 DrownDmg     uint8
16004                                 Floodable    bool
16005
16006                                 DrawBox, ColBox, SelBox NodeBox
16007
16008                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16009
16010                                 LegacyFaceDir bool
16011                                 LegacyMounted bool
16012
16013                                 DigPredict string
16014
16015                                 MaxLvl uint8
16016
16017                                 AlphaUse
16018                         }))(obj)).Scale
16019                         write32(w, math.Float32bits(x))
16020                 }
16021                 {
16022                         local250 := uint8(6)
16023                         {
16024                                 x := local250
16025                                 write8(w, uint8(x))
16026                         }
16027                 }
16028                 for local251 := range (*(*(struct {
16029                         Param0 Content
16030
16031                         Name   string
16032                         Groups []Group
16033
16034                         P1Type   Param1Type
16035                         P2Type   Param2Type
16036                         DrawType DrawType
16037
16038                         Mesh  string
16039                         Scale float32
16040                         //mt:const uint8(6)
16041                         Tiles        [6]TileDef
16042                         OverlayTiles [6]TileDef
16043                         //mt:const uint8(6)
16044                         SpecialTiles [6]TileDef
16045
16046                         Color   color.NRGBA
16047                         Palette Texture
16048
16049                         Waving       WaveType
16050                         ConnectSides uint8
16051                         ConnectTo    []Content
16052                         InsideTint   color.NRGBA
16053                         Level        uint8 // Must be < 128.
16054
16055                         Translucent bool // Sunlight is scattered and becomes normal light.
16056                         Transparent bool // Sunlight isn't scattered.
16057                         LightSrc    uint8
16058
16059                         GndContent   bool
16060                         Collides     bool
16061                         Pointable    bool
16062                         Diggable     bool
16063                         Climbable    bool
16064                         Replaceable  bool
16065                         OnRightClick bool
16066
16067                         DmgPerSec int32
16068
16069                         LiquidType   LiquidType
16070                         FlowingAlt   string
16071                         SrcAlt       string
16072                         Viscosity    uint8 // 0-7
16073                         LiqRenewable bool
16074                         FlowRange    uint8
16075                         DrownDmg     uint8
16076                         Floodable    bool
16077
16078                         DrawBox, ColBox, SelBox NodeBox
16079
16080                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16081
16082                         LegacyFaceDir bool
16083                         LegacyMounted bool
16084
16085                         DigPredict string
16086
16087                         MaxLvl uint8
16088
16089                         AlphaUse
16090                 }))(obj)).Tiles {
16091                         if err := pcall(func() {
16092                                 (((*(*(struct {
16093                                         Param0 Content
16094
16095                                         Name   string
16096                                         Groups []Group
16097
16098                                         P1Type   Param1Type
16099                                         P2Type   Param2Type
16100                                         DrawType DrawType
16101
16102                                         Mesh  string
16103                                         Scale float32
16104                                         //mt:const uint8(6)
16105                                         Tiles        [6]TileDef
16106                                         OverlayTiles [6]TileDef
16107                                         //mt:const uint8(6)
16108                                         SpecialTiles [6]TileDef
16109
16110                                         Color   color.NRGBA
16111                                         Palette Texture
16112
16113                                         Waving       WaveType
16114                                         ConnectSides uint8
16115                                         ConnectTo    []Content
16116                                         InsideTint   color.NRGBA
16117                                         Level        uint8 // Must be < 128.
16118
16119                                         Translucent bool // Sunlight is scattered and becomes normal light.
16120                                         Transparent bool // Sunlight isn't scattered.
16121                                         LightSrc    uint8
16122
16123                                         GndContent   bool
16124                                         Collides     bool
16125                                         Pointable    bool
16126                                         Diggable     bool
16127                                         Climbable    bool
16128                                         Replaceable  bool
16129                                         OnRightClick bool
16130
16131                                         DmgPerSec int32
16132
16133                                         LiquidType   LiquidType
16134                                         FlowingAlt   string
16135                                         SrcAlt       string
16136                                         Viscosity    uint8 // 0-7
16137                                         LiqRenewable bool
16138                                         FlowRange    uint8
16139                                         DrownDmg     uint8
16140                                         Floodable    bool
16141
16142                                         DrawBox, ColBox, SelBox NodeBox
16143
16144                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16145
16146                                         LegacyFaceDir bool
16147                                         LegacyMounted bool
16148
16149                                         DigPredict string
16150
16151                                         MaxLvl uint8
16152
16153                                         AlphaUse
16154                                 }))(obj)).Tiles)[local251]).serialize(w)
16155                         }); err != nil {
16156                                 if err == io.EOF {
16157                                         chk(io.EOF)
16158                                 }
16159                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
16160                         }
16161                 }
16162                 for local252 := range (*(*(struct {
16163                         Param0 Content
16164
16165                         Name   string
16166                         Groups []Group
16167
16168                         P1Type   Param1Type
16169                         P2Type   Param2Type
16170                         DrawType DrawType
16171
16172                         Mesh  string
16173                         Scale float32
16174                         //mt:const uint8(6)
16175                         Tiles        [6]TileDef
16176                         OverlayTiles [6]TileDef
16177                         //mt:const uint8(6)
16178                         SpecialTiles [6]TileDef
16179
16180                         Color   color.NRGBA
16181                         Palette Texture
16182
16183                         Waving       WaveType
16184                         ConnectSides uint8
16185                         ConnectTo    []Content
16186                         InsideTint   color.NRGBA
16187                         Level        uint8 // Must be < 128.
16188
16189                         Translucent bool // Sunlight is scattered and becomes normal light.
16190                         Transparent bool // Sunlight isn't scattered.
16191                         LightSrc    uint8
16192
16193                         GndContent   bool
16194                         Collides     bool
16195                         Pointable    bool
16196                         Diggable     bool
16197                         Climbable    bool
16198                         Replaceable  bool
16199                         OnRightClick bool
16200
16201                         DmgPerSec int32
16202
16203                         LiquidType   LiquidType
16204                         FlowingAlt   string
16205                         SrcAlt       string
16206                         Viscosity    uint8 // 0-7
16207                         LiqRenewable bool
16208                         FlowRange    uint8
16209                         DrownDmg     uint8
16210                         Floodable    bool
16211
16212                         DrawBox, ColBox, SelBox NodeBox
16213
16214                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16215
16216                         LegacyFaceDir bool
16217                         LegacyMounted bool
16218
16219                         DigPredict string
16220
16221                         MaxLvl uint8
16222
16223                         AlphaUse
16224                 }))(obj)).OverlayTiles {
16225                         if err := pcall(func() {
16226                                 (((*(*(struct {
16227                                         Param0 Content
16228
16229                                         Name   string
16230                                         Groups []Group
16231
16232                                         P1Type   Param1Type
16233                                         P2Type   Param2Type
16234                                         DrawType DrawType
16235
16236                                         Mesh  string
16237                                         Scale float32
16238                                         //mt:const uint8(6)
16239                                         Tiles        [6]TileDef
16240                                         OverlayTiles [6]TileDef
16241                                         //mt:const uint8(6)
16242                                         SpecialTiles [6]TileDef
16243
16244                                         Color   color.NRGBA
16245                                         Palette Texture
16246
16247                                         Waving       WaveType
16248                                         ConnectSides uint8
16249                                         ConnectTo    []Content
16250                                         InsideTint   color.NRGBA
16251                                         Level        uint8 // Must be < 128.
16252
16253                                         Translucent bool // Sunlight is scattered and becomes normal light.
16254                                         Transparent bool // Sunlight isn't scattered.
16255                                         LightSrc    uint8
16256
16257                                         GndContent   bool
16258                                         Collides     bool
16259                                         Pointable    bool
16260                                         Diggable     bool
16261                                         Climbable    bool
16262                                         Replaceable  bool
16263                                         OnRightClick bool
16264
16265                                         DmgPerSec int32
16266
16267                                         LiquidType   LiquidType
16268                                         FlowingAlt   string
16269                                         SrcAlt       string
16270                                         Viscosity    uint8 // 0-7
16271                                         LiqRenewable bool
16272                                         FlowRange    uint8
16273                                         DrownDmg     uint8
16274                                         Floodable    bool
16275
16276                                         DrawBox, ColBox, SelBox NodeBox
16277
16278                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16279
16280                                         LegacyFaceDir bool
16281                                         LegacyMounted bool
16282
16283                                         DigPredict string
16284
16285                                         MaxLvl uint8
16286
16287                                         AlphaUse
16288                                 }))(obj)).OverlayTiles)[local252]).serialize(w)
16289                         }); err != nil {
16290                                 if err == io.EOF {
16291                                         chk(io.EOF)
16292                                 }
16293                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
16294                         }
16295                 }
16296                 {
16297                         local253 := uint8(6)
16298                         {
16299                                 x := local253
16300                                 write8(w, uint8(x))
16301                         }
16302                 }
16303                 for local254 := range (*(*(struct {
16304                         Param0 Content
16305
16306                         Name   string
16307                         Groups []Group
16308
16309                         P1Type   Param1Type
16310                         P2Type   Param2Type
16311                         DrawType DrawType
16312
16313                         Mesh  string
16314                         Scale float32
16315                         //mt:const uint8(6)
16316                         Tiles        [6]TileDef
16317                         OverlayTiles [6]TileDef
16318                         //mt:const uint8(6)
16319                         SpecialTiles [6]TileDef
16320
16321                         Color   color.NRGBA
16322                         Palette Texture
16323
16324                         Waving       WaveType
16325                         ConnectSides uint8
16326                         ConnectTo    []Content
16327                         InsideTint   color.NRGBA
16328                         Level        uint8 // Must be < 128.
16329
16330                         Translucent bool // Sunlight is scattered and becomes normal light.
16331                         Transparent bool // Sunlight isn't scattered.
16332                         LightSrc    uint8
16333
16334                         GndContent   bool
16335                         Collides     bool
16336                         Pointable    bool
16337                         Diggable     bool
16338                         Climbable    bool
16339                         Replaceable  bool
16340                         OnRightClick bool
16341
16342                         DmgPerSec int32
16343
16344                         LiquidType   LiquidType
16345                         FlowingAlt   string
16346                         SrcAlt       string
16347                         Viscosity    uint8 // 0-7
16348                         LiqRenewable bool
16349                         FlowRange    uint8
16350                         DrownDmg     uint8
16351                         Floodable    bool
16352
16353                         DrawBox, ColBox, SelBox NodeBox
16354
16355                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16356
16357                         LegacyFaceDir bool
16358                         LegacyMounted bool
16359
16360                         DigPredict string
16361
16362                         MaxLvl uint8
16363
16364                         AlphaUse
16365                 }))(obj)).SpecialTiles {
16366                         if err := pcall(func() {
16367                                 (((*(*(struct {
16368                                         Param0 Content
16369
16370                                         Name   string
16371                                         Groups []Group
16372
16373                                         P1Type   Param1Type
16374                                         P2Type   Param2Type
16375                                         DrawType DrawType
16376
16377                                         Mesh  string
16378                                         Scale float32
16379                                         //mt:const uint8(6)
16380                                         Tiles        [6]TileDef
16381                                         OverlayTiles [6]TileDef
16382                                         //mt:const uint8(6)
16383                                         SpecialTiles [6]TileDef
16384
16385                                         Color   color.NRGBA
16386                                         Palette Texture
16387
16388                                         Waving       WaveType
16389                                         ConnectSides uint8
16390                                         ConnectTo    []Content
16391                                         InsideTint   color.NRGBA
16392                                         Level        uint8 // Must be < 128.
16393
16394                                         Translucent bool // Sunlight is scattered and becomes normal light.
16395                                         Transparent bool // Sunlight isn't scattered.
16396                                         LightSrc    uint8
16397
16398                                         GndContent   bool
16399                                         Collides     bool
16400                                         Pointable    bool
16401                                         Diggable     bool
16402                                         Climbable    bool
16403                                         Replaceable  bool
16404                                         OnRightClick bool
16405
16406                                         DmgPerSec int32
16407
16408                                         LiquidType   LiquidType
16409                                         FlowingAlt   string
16410                                         SrcAlt       string
16411                                         Viscosity    uint8 // 0-7
16412                                         LiqRenewable bool
16413                                         FlowRange    uint8
16414                                         DrownDmg     uint8
16415                                         Floodable    bool
16416
16417                                         DrawBox, ColBox, SelBox NodeBox
16418
16419                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16420
16421                                         LegacyFaceDir bool
16422                                         LegacyMounted bool
16423
16424                                         DigPredict string
16425
16426                                         MaxLvl uint8
16427
16428                                         AlphaUse
16429                                 }))(obj)).SpecialTiles)[local254]).serialize(w)
16430                         }); err != nil {
16431                                 if err == io.EOF {
16432                                         chk(io.EOF)
16433                                 }
16434                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
16435                         }
16436                 }
16437                 {
16438                         x := (*(*(struct {
16439                                 Param0 Content
16440
16441                                 Name   string
16442                                 Groups []Group
16443
16444                                 P1Type   Param1Type
16445                                 P2Type   Param2Type
16446                                 DrawType DrawType
16447
16448                                 Mesh  string
16449                                 Scale float32
16450                                 //mt:const uint8(6)
16451                                 Tiles        [6]TileDef
16452                                 OverlayTiles [6]TileDef
16453                                 //mt:const uint8(6)
16454                                 SpecialTiles [6]TileDef
16455
16456                                 Color   color.NRGBA
16457                                 Palette Texture
16458
16459                                 Waving       WaveType
16460                                 ConnectSides uint8
16461                                 ConnectTo    []Content
16462                                 InsideTint   color.NRGBA
16463                                 Level        uint8 // Must be < 128.
16464
16465                                 Translucent bool // Sunlight is scattered and becomes normal light.
16466                                 Transparent bool // Sunlight isn't scattered.
16467                                 LightSrc    uint8
16468
16469                                 GndContent   bool
16470                                 Collides     bool
16471                                 Pointable    bool
16472                                 Diggable     bool
16473                                 Climbable    bool
16474                                 Replaceable  bool
16475                                 OnRightClick bool
16476
16477                                 DmgPerSec int32
16478
16479                                 LiquidType   LiquidType
16480                                 FlowingAlt   string
16481                                 SrcAlt       string
16482                                 Viscosity    uint8 // 0-7
16483                                 LiqRenewable bool
16484                                 FlowRange    uint8
16485                                 DrownDmg     uint8
16486                                 Floodable    bool
16487
16488                                 DrawBox, ColBox, SelBox NodeBox
16489
16490                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16491
16492                                 LegacyFaceDir bool
16493                                 LegacyMounted bool
16494
16495                                 DigPredict string
16496
16497                                 MaxLvl uint8
16498
16499                                 AlphaUse
16500                         }))(obj)).Color
16501                         w.Write([]byte{x.A, x.R, x.G, x.B})
16502                 }
16503                 if err := pcall(func() {
16504                         ((*(*(struct {
16505                                 Param0 Content
16506
16507                                 Name   string
16508                                 Groups []Group
16509
16510                                 P1Type   Param1Type
16511                                 P2Type   Param2Type
16512                                 DrawType DrawType
16513
16514                                 Mesh  string
16515                                 Scale float32
16516                                 //mt:const uint8(6)
16517                                 Tiles        [6]TileDef
16518                                 OverlayTiles [6]TileDef
16519                                 //mt:const uint8(6)
16520                                 SpecialTiles [6]TileDef
16521
16522                                 Color   color.NRGBA
16523                                 Palette Texture
16524
16525                                 Waving       WaveType
16526                                 ConnectSides uint8
16527                                 ConnectTo    []Content
16528                                 InsideTint   color.NRGBA
16529                                 Level        uint8 // Must be < 128.
16530
16531                                 Translucent bool // Sunlight is scattered and becomes normal light.
16532                                 Transparent bool // Sunlight isn't scattered.
16533                                 LightSrc    uint8
16534
16535                                 GndContent   bool
16536                                 Collides     bool
16537                                 Pointable    bool
16538                                 Diggable     bool
16539                                 Climbable    bool
16540                                 Replaceable  bool
16541                                 OnRightClick bool
16542
16543                                 DmgPerSec int32
16544
16545                                 LiquidType   LiquidType
16546                                 FlowingAlt   string
16547                                 SrcAlt       string
16548                                 Viscosity    uint8 // 0-7
16549                                 LiqRenewable bool
16550                                 FlowRange    uint8
16551                                 DrownDmg     uint8
16552                                 Floodable    bool
16553
16554                                 DrawBox, ColBox, SelBox NodeBox
16555
16556                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16557
16558                                 LegacyFaceDir bool
16559                                 LegacyMounted bool
16560
16561                                 DigPredict string
16562
16563                                 MaxLvl uint8
16564
16565                                 AlphaUse
16566                         }))(obj)).Palette).serialize(w)
16567                 }); err != nil {
16568                         if err == io.EOF {
16569                                 chk(io.EOF)
16570                         }
16571                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
16572                 }
16573                 if err := pcall(func() {
16574                         ((*(*(struct {
16575                                 Param0 Content
16576
16577                                 Name   string
16578                                 Groups []Group
16579
16580                                 P1Type   Param1Type
16581                                 P2Type   Param2Type
16582                                 DrawType DrawType
16583
16584                                 Mesh  string
16585                                 Scale float32
16586                                 //mt:const uint8(6)
16587                                 Tiles        [6]TileDef
16588                                 OverlayTiles [6]TileDef
16589                                 //mt:const uint8(6)
16590                                 SpecialTiles [6]TileDef
16591
16592                                 Color   color.NRGBA
16593                                 Palette Texture
16594
16595                                 Waving       WaveType
16596                                 ConnectSides uint8
16597                                 ConnectTo    []Content
16598                                 InsideTint   color.NRGBA
16599                                 Level        uint8 // Must be < 128.
16600
16601                                 Translucent bool // Sunlight is scattered and becomes normal light.
16602                                 Transparent bool // Sunlight isn't scattered.
16603                                 LightSrc    uint8
16604
16605                                 GndContent   bool
16606                                 Collides     bool
16607                                 Pointable    bool
16608                                 Diggable     bool
16609                                 Climbable    bool
16610                                 Replaceable  bool
16611                                 OnRightClick bool
16612
16613                                 DmgPerSec int32
16614
16615                                 LiquidType   LiquidType
16616                                 FlowingAlt   string
16617                                 SrcAlt       string
16618                                 Viscosity    uint8 // 0-7
16619                                 LiqRenewable bool
16620                                 FlowRange    uint8
16621                                 DrownDmg     uint8
16622                                 Floodable    bool
16623
16624                                 DrawBox, ColBox, SelBox NodeBox
16625
16626                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16627
16628                                 LegacyFaceDir bool
16629                                 LegacyMounted bool
16630
16631                                 DigPredict string
16632
16633                                 MaxLvl uint8
16634
16635                                 AlphaUse
16636                         }))(obj)).Waving).serialize(w)
16637                 }); err != nil {
16638                         if err == io.EOF {
16639                                 chk(io.EOF)
16640                         }
16641                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.WaveType", err))
16642                 }
16643                 {
16644                         x := (*(*(struct {
16645                                 Param0 Content
16646
16647                                 Name   string
16648                                 Groups []Group
16649
16650                                 P1Type   Param1Type
16651                                 P2Type   Param2Type
16652                                 DrawType DrawType
16653
16654                                 Mesh  string
16655                                 Scale float32
16656                                 //mt:const uint8(6)
16657                                 Tiles        [6]TileDef
16658                                 OverlayTiles [6]TileDef
16659                                 //mt:const uint8(6)
16660                                 SpecialTiles [6]TileDef
16661
16662                                 Color   color.NRGBA
16663                                 Palette Texture
16664
16665                                 Waving       WaveType
16666                                 ConnectSides uint8
16667                                 ConnectTo    []Content
16668                                 InsideTint   color.NRGBA
16669                                 Level        uint8 // Must be < 128.
16670
16671                                 Translucent bool // Sunlight is scattered and becomes normal light.
16672                                 Transparent bool // Sunlight isn't scattered.
16673                                 LightSrc    uint8
16674
16675                                 GndContent   bool
16676                                 Collides     bool
16677                                 Pointable    bool
16678                                 Diggable     bool
16679                                 Climbable    bool
16680                                 Replaceable  bool
16681                                 OnRightClick bool
16682
16683                                 DmgPerSec int32
16684
16685                                 LiquidType   LiquidType
16686                                 FlowingAlt   string
16687                                 SrcAlt       string
16688                                 Viscosity    uint8 // 0-7
16689                                 LiqRenewable bool
16690                                 FlowRange    uint8
16691                                 DrownDmg     uint8
16692                                 Floodable    bool
16693
16694                                 DrawBox, ColBox, SelBox NodeBox
16695
16696                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16697
16698                                 LegacyFaceDir bool
16699                                 LegacyMounted bool
16700
16701                                 DigPredict string
16702
16703                                 MaxLvl uint8
16704
16705                                 AlphaUse
16706                         }))(obj)).ConnectSides
16707                         write8(w, uint8(x))
16708                 }
16709                 if len(((*(*(struct {
16710                         Param0 Content
16711
16712                         Name   string
16713                         Groups []Group
16714
16715                         P1Type   Param1Type
16716                         P2Type   Param2Type
16717                         DrawType DrawType
16718
16719                         Mesh  string
16720                         Scale float32
16721                         //mt:const uint8(6)
16722                         Tiles        [6]TileDef
16723                         OverlayTiles [6]TileDef
16724                         //mt:const uint8(6)
16725                         SpecialTiles [6]TileDef
16726
16727                         Color   color.NRGBA
16728                         Palette Texture
16729
16730                         Waving       WaveType
16731                         ConnectSides uint8
16732                         ConnectTo    []Content
16733                         InsideTint   color.NRGBA
16734                         Level        uint8 // Must be < 128.
16735
16736                         Translucent bool // Sunlight is scattered and becomes normal light.
16737                         Transparent bool // Sunlight isn't scattered.
16738                         LightSrc    uint8
16739
16740                         GndContent   bool
16741                         Collides     bool
16742                         Pointable    bool
16743                         Diggable     bool
16744                         Climbable    bool
16745                         Replaceable  bool
16746                         OnRightClick bool
16747
16748                         DmgPerSec int32
16749
16750                         LiquidType   LiquidType
16751                         FlowingAlt   string
16752                         SrcAlt       string
16753                         Viscosity    uint8 // 0-7
16754                         LiqRenewable bool
16755                         FlowRange    uint8
16756                         DrownDmg     uint8
16757                         Floodable    bool
16758
16759                         DrawBox, ColBox, SelBox NodeBox
16760
16761                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16762
16763                         LegacyFaceDir bool
16764                         LegacyMounted bool
16765
16766                         DigPredict string
16767
16768                         MaxLvl uint8
16769
16770                         AlphaUse
16771                 }))(obj)).ConnectTo)) > math.MaxUint16 {
16772                         chk(ErrTooLong)
16773                 }
16774                 {
16775                         x := uint16(len(((*(*(struct {
16776                                 Param0 Content
16777
16778                                 Name   string
16779                                 Groups []Group
16780
16781                                 P1Type   Param1Type
16782                                 P2Type   Param2Type
16783                                 DrawType DrawType
16784
16785                                 Mesh  string
16786                                 Scale float32
16787                                 //mt:const uint8(6)
16788                                 Tiles        [6]TileDef
16789                                 OverlayTiles [6]TileDef
16790                                 //mt:const uint8(6)
16791                                 SpecialTiles [6]TileDef
16792
16793                                 Color   color.NRGBA
16794                                 Palette Texture
16795
16796                                 Waving       WaveType
16797                                 ConnectSides uint8
16798                                 ConnectTo    []Content
16799                                 InsideTint   color.NRGBA
16800                                 Level        uint8 // Must be < 128.
16801
16802                                 Translucent bool // Sunlight is scattered and becomes normal light.
16803                                 Transparent bool // Sunlight isn't scattered.
16804                                 LightSrc    uint8
16805
16806                                 GndContent   bool
16807                                 Collides     bool
16808                                 Pointable    bool
16809                                 Diggable     bool
16810                                 Climbable    bool
16811                                 Replaceable  bool
16812                                 OnRightClick bool
16813
16814                                 DmgPerSec int32
16815
16816                                 LiquidType   LiquidType
16817                                 FlowingAlt   string
16818                                 SrcAlt       string
16819                                 Viscosity    uint8 // 0-7
16820                                 LiqRenewable bool
16821                                 FlowRange    uint8
16822                                 DrownDmg     uint8
16823                                 Floodable    bool
16824
16825                                 DrawBox, ColBox, SelBox NodeBox
16826
16827                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16828
16829                                 LegacyFaceDir bool
16830                                 LegacyMounted bool
16831
16832                                 DigPredict string
16833
16834                                 MaxLvl uint8
16835
16836                                 AlphaUse
16837                         }))(obj)).ConnectTo)))
16838                         write16(w, uint16(x))
16839                 }
16840                 for local255 := range (*(*(struct {
16841                         Param0 Content
16842
16843                         Name   string
16844                         Groups []Group
16845
16846                         P1Type   Param1Type
16847                         P2Type   Param2Type
16848                         DrawType DrawType
16849
16850                         Mesh  string
16851                         Scale float32
16852                         //mt:const uint8(6)
16853                         Tiles        [6]TileDef
16854                         OverlayTiles [6]TileDef
16855                         //mt:const uint8(6)
16856                         SpecialTiles [6]TileDef
16857
16858                         Color   color.NRGBA
16859                         Palette Texture
16860
16861                         Waving       WaveType
16862                         ConnectSides uint8
16863                         ConnectTo    []Content
16864                         InsideTint   color.NRGBA
16865                         Level        uint8 // Must be < 128.
16866
16867                         Translucent bool // Sunlight is scattered and becomes normal light.
16868                         Transparent bool // Sunlight isn't scattered.
16869                         LightSrc    uint8
16870
16871                         GndContent   bool
16872                         Collides     bool
16873                         Pointable    bool
16874                         Diggable     bool
16875                         Climbable    bool
16876                         Replaceable  bool
16877                         OnRightClick bool
16878
16879                         DmgPerSec int32
16880
16881                         LiquidType   LiquidType
16882                         FlowingAlt   string
16883                         SrcAlt       string
16884                         Viscosity    uint8 // 0-7
16885                         LiqRenewable bool
16886                         FlowRange    uint8
16887                         DrownDmg     uint8
16888                         Floodable    bool
16889
16890                         DrawBox, ColBox, SelBox NodeBox
16891
16892                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16893
16894                         LegacyFaceDir bool
16895                         LegacyMounted bool
16896
16897                         DigPredict string
16898
16899                         MaxLvl uint8
16900
16901                         AlphaUse
16902                 }))(obj)).ConnectTo {
16903                         if err := pcall(func() {
16904                                 (((*(*(struct {
16905                                         Param0 Content
16906
16907                                         Name   string
16908                                         Groups []Group
16909
16910                                         P1Type   Param1Type
16911                                         P2Type   Param2Type
16912                                         DrawType DrawType
16913
16914                                         Mesh  string
16915                                         Scale float32
16916                                         //mt:const uint8(6)
16917                                         Tiles        [6]TileDef
16918                                         OverlayTiles [6]TileDef
16919                                         //mt:const uint8(6)
16920                                         SpecialTiles [6]TileDef
16921
16922                                         Color   color.NRGBA
16923                                         Palette Texture
16924
16925                                         Waving       WaveType
16926                                         ConnectSides uint8
16927                                         ConnectTo    []Content
16928                                         InsideTint   color.NRGBA
16929                                         Level        uint8 // Must be < 128.
16930
16931                                         Translucent bool // Sunlight is scattered and becomes normal light.
16932                                         Transparent bool // Sunlight isn't scattered.
16933                                         LightSrc    uint8
16934
16935                                         GndContent   bool
16936                                         Collides     bool
16937                                         Pointable    bool
16938                                         Diggable     bool
16939                                         Climbable    bool
16940                                         Replaceable  bool
16941                                         OnRightClick bool
16942
16943                                         DmgPerSec int32
16944
16945                                         LiquidType   LiquidType
16946                                         FlowingAlt   string
16947                                         SrcAlt       string
16948                                         Viscosity    uint8 // 0-7
16949                                         LiqRenewable bool
16950                                         FlowRange    uint8
16951                                         DrownDmg     uint8
16952                                         Floodable    bool
16953
16954                                         DrawBox, ColBox, SelBox NodeBox
16955
16956                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16957
16958                                         LegacyFaceDir bool
16959                                         LegacyMounted bool
16960
16961                                         DigPredict string
16962
16963                                         MaxLvl uint8
16964
16965                                         AlphaUse
16966                                 }))(obj)).ConnectTo)[local255]).serialize(w)
16967                         }); err != nil {
16968                                 if err == io.EOF {
16969                                         chk(io.EOF)
16970                                 }
16971                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
16972                         }
16973                 }
16974                 {
16975                         x := (*(*(struct {
16976                                 Param0 Content
16977
16978                                 Name   string
16979                                 Groups []Group
16980
16981                                 P1Type   Param1Type
16982                                 P2Type   Param2Type
16983                                 DrawType DrawType
16984
16985                                 Mesh  string
16986                                 Scale float32
16987                                 //mt:const uint8(6)
16988                                 Tiles        [6]TileDef
16989                                 OverlayTiles [6]TileDef
16990                                 //mt:const uint8(6)
16991                                 SpecialTiles [6]TileDef
16992
16993                                 Color   color.NRGBA
16994                                 Palette Texture
16995
16996                                 Waving       WaveType
16997                                 ConnectSides uint8
16998                                 ConnectTo    []Content
16999                                 InsideTint   color.NRGBA
17000                                 Level        uint8 // Must be < 128.
17001
17002                                 Translucent bool // Sunlight is scattered and becomes normal light.
17003                                 Transparent bool // Sunlight isn't scattered.
17004                                 LightSrc    uint8
17005
17006                                 GndContent   bool
17007                                 Collides     bool
17008                                 Pointable    bool
17009                                 Diggable     bool
17010                                 Climbable    bool
17011                                 Replaceable  bool
17012                                 OnRightClick bool
17013
17014                                 DmgPerSec int32
17015
17016                                 LiquidType   LiquidType
17017                                 FlowingAlt   string
17018                                 SrcAlt       string
17019                                 Viscosity    uint8 // 0-7
17020                                 LiqRenewable bool
17021                                 FlowRange    uint8
17022                                 DrownDmg     uint8
17023                                 Floodable    bool
17024
17025                                 DrawBox, ColBox, SelBox NodeBox
17026
17027                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17028
17029                                 LegacyFaceDir bool
17030                                 LegacyMounted bool
17031
17032                                 DigPredict string
17033
17034                                 MaxLvl uint8
17035
17036                                 AlphaUse
17037                         }))(obj)).InsideTint
17038                         w.Write([]byte{x.A, x.R, x.G, x.B})
17039                 }
17040                 {
17041                         x := (*(*(struct {
17042                                 Param0 Content
17043
17044                                 Name   string
17045                                 Groups []Group
17046
17047                                 P1Type   Param1Type
17048                                 P2Type   Param2Type
17049                                 DrawType DrawType
17050
17051                                 Mesh  string
17052                                 Scale float32
17053                                 //mt:const uint8(6)
17054                                 Tiles        [6]TileDef
17055                                 OverlayTiles [6]TileDef
17056                                 //mt:const uint8(6)
17057                                 SpecialTiles [6]TileDef
17058
17059                                 Color   color.NRGBA
17060                                 Palette Texture
17061
17062                                 Waving       WaveType
17063                                 ConnectSides uint8
17064                                 ConnectTo    []Content
17065                                 InsideTint   color.NRGBA
17066                                 Level        uint8 // Must be < 128.
17067
17068                                 Translucent bool // Sunlight is scattered and becomes normal light.
17069                                 Transparent bool // Sunlight isn't scattered.
17070                                 LightSrc    uint8
17071
17072                                 GndContent   bool
17073                                 Collides     bool
17074                                 Pointable    bool
17075                                 Diggable     bool
17076                                 Climbable    bool
17077                                 Replaceable  bool
17078                                 OnRightClick bool
17079
17080                                 DmgPerSec int32
17081
17082                                 LiquidType   LiquidType
17083                                 FlowingAlt   string
17084                                 SrcAlt       string
17085                                 Viscosity    uint8 // 0-7
17086                                 LiqRenewable bool
17087                                 FlowRange    uint8
17088                                 DrownDmg     uint8
17089                                 Floodable    bool
17090
17091                                 DrawBox, ColBox, SelBox NodeBox
17092
17093                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17094
17095                                 LegacyFaceDir bool
17096                                 LegacyMounted bool
17097
17098                                 DigPredict string
17099
17100                                 MaxLvl uint8
17101
17102                                 AlphaUse
17103                         }))(obj)).Level
17104                         write8(w, uint8(x))
17105                 }
17106                 {
17107                         x := (*(*(struct {
17108                                 Param0 Content
17109
17110                                 Name   string
17111                                 Groups []Group
17112
17113                                 P1Type   Param1Type
17114                                 P2Type   Param2Type
17115                                 DrawType DrawType
17116
17117                                 Mesh  string
17118                                 Scale float32
17119                                 //mt:const uint8(6)
17120                                 Tiles        [6]TileDef
17121                                 OverlayTiles [6]TileDef
17122                                 //mt:const uint8(6)
17123                                 SpecialTiles [6]TileDef
17124
17125                                 Color   color.NRGBA
17126                                 Palette Texture
17127
17128                                 Waving       WaveType
17129                                 ConnectSides uint8
17130                                 ConnectTo    []Content
17131                                 InsideTint   color.NRGBA
17132                                 Level        uint8 // Must be < 128.
17133
17134                                 Translucent bool // Sunlight is scattered and becomes normal light.
17135                                 Transparent bool // Sunlight isn't scattered.
17136                                 LightSrc    uint8
17137
17138                                 GndContent   bool
17139                                 Collides     bool
17140                                 Pointable    bool
17141                                 Diggable     bool
17142                                 Climbable    bool
17143                                 Replaceable  bool
17144                                 OnRightClick bool
17145
17146                                 DmgPerSec int32
17147
17148                                 LiquidType   LiquidType
17149                                 FlowingAlt   string
17150                                 SrcAlt       string
17151                                 Viscosity    uint8 // 0-7
17152                                 LiqRenewable bool
17153                                 FlowRange    uint8
17154                                 DrownDmg     uint8
17155                                 Floodable    bool
17156
17157                                 DrawBox, ColBox, SelBox NodeBox
17158
17159                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17160
17161                                 LegacyFaceDir bool
17162                                 LegacyMounted bool
17163
17164                                 DigPredict string
17165
17166                                 MaxLvl uint8
17167
17168                                 AlphaUse
17169                         }))(obj)).Translucent
17170                         if x {
17171                                 write8(w, 1)
17172                         } else {
17173                                 write8(w, 0)
17174                         }
17175                 }
17176                 {
17177                         x := (*(*(struct {
17178                                 Param0 Content
17179
17180                                 Name   string
17181                                 Groups []Group
17182
17183                                 P1Type   Param1Type
17184                                 P2Type   Param2Type
17185                                 DrawType DrawType
17186
17187                                 Mesh  string
17188                                 Scale float32
17189                                 //mt:const uint8(6)
17190                                 Tiles        [6]TileDef
17191                                 OverlayTiles [6]TileDef
17192                                 //mt:const uint8(6)
17193                                 SpecialTiles [6]TileDef
17194
17195                                 Color   color.NRGBA
17196                                 Palette Texture
17197
17198                                 Waving       WaveType
17199                                 ConnectSides uint8
17200                                 ConnectTo    []Content
17201                                 InsideTint   color.NRGBA
17202                                 Level        uint8 // Must be < 128.
17203
17204                                 Translucent bool // Sunlight is scattered and becomes normal light.
17205                                 Transparent bool // Sunlight isn't scattered.
17206                                 LightSrc    uint8
17207
17208                                 GndContent   bool
17209                                 Collides     bool
17210                                 Pointable    bool
17211                                 Diggable     bool
17212                                 Climbable    bool
17213                                 Replaceable  bool
17214                                 OnRightClick bool
17215
17216                                 DmgPerSec int32
17217
17218                                 LiquidType   LiquidType
17219                                 FlowingAlt   string
17220                                 SrcAlt       string
17221                                 Viscosity    uint8 // 0-7
17222                                 LiqRenewable bool
17223                                 FlowRange    uint8
17224                                 DrownDmg     uint8
17225                                 Floodable    bool
17226
17227                                 DrawBox, ColBox, SelBox NodeBox
17228
17229                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17230
17231                                 LegacyFaceDir bool
17232                                 LegacyMounted bool
17233
17234                                 DigPredict string
17235
17236                                 MaxLvl uint8
17237
17238                                 AlphaUse
17239                         }))(obj)).Transparent
17240                         if x {
17241                                 write8(w, 1)
17242                         } else {
17243                                 write8(w, 0)
17244                         }
17245                 }
17246                 {
17247                         x := (*(*(struct {
17248                                 Param0 Content
17249
17250                                 Name   string
17251                                 Groups []Group
17252
17253                                 P1Type   Param1Type
17254                                 P2Type   Param2Type
17255                                 DrawType DrawType
17256
17257                                 Mesh  string
17258                                 Scale float32
17259                                 //mt:const uint8(6)
17260                                 Tiles        [6]TileDef
17261                                 OverlayTiles [6]TileDef
17262                                 //mt:const uint8(6)
17263                                 SpecialTiles [6]TileDef
17264
17265                                 Color   color.NRGBA
17266                                 Palette Texture
17267
17268                                 Waving       WaveType
17269                                 ConnectSides uint8
17270                                 ConnectTo    []Content
17271                                 InsideTint   color.NRGBA
17272                                 Level        uint8 // Must be < 128.
17273
17274                                 Translucent bool // Sunlight is scattered and becomes normal light.
17275                                 Transparent bool // Sunlight isn't scattered.
17276                                 LightSrc    uint8
17277
17278                                 GndContent   bool
17279                                 Collides     bool
17280                                 Pointable    bool
17281                                 Diggable     bool
17282                                 Climbable    bool
17283                                 Replaceable  bool
17284                                 OnRightClick bool
17285
17286                                 DmgPerSec int32
17287
17288                                 LiquidType   LiquidType
17289                                 FlowingAlt   string
17290                                 SrcAlt       string
17291                                 Viscosity    uint8 // 0-7
17292                                 LiqRenewable bool
17293                                 FlowRange    uint8
17294                                 DrownDmg     uint8
17295                                 Floodable    bool
17296
17297                                 DrawBox, ColBox, SelBox NodeBox
17298
17299                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17300
17301                                 LegacyFaceDir bool
17302                                 LegacyMounted bool
17303
17304                                 DigPredict string
17305
17306                                 MaxLvl uint8
17307
17308                                 AlphaUse
17309                         }))(obj)).LightSrc
17310                         write8(w, uint8(x))
17311                 }
17312                 {
17313                         x := (*(*(struct {
17314                                 Param0 Content
17315
17316                                 Name   string
17317                                 Groups []Group
17318
17319                                 P1Type   Param1Type
17320                                 P2Type   Param2Type
17321                                 DrawType DrawType
17322
17323                                 Mesh  string
17324                                 Scale float32
17325                                 //mt:const uint8(6)
17326                                 Tiles        [6]TileDef
17327                                 OverlayTiles [6]TileDef
17328                                 //mt:const uint8(6)
17329                                 SpecialTiles [6]TileDef
17330
17331                                 Color   color.NRGBA
17332                                 Palette Texture
17333
17334                                 Waving       WaveType
17335                                 ConnectSides uint8
17336                                 ConnectTo    []Content
17337                                 InsideTint   color.NRGBA
17338                                 Level        uint8 // Must be < 128.
17339
17340                                 Translucent bool // Sunlight is scattered and becomes normal light.
17341                                 Transparent bool // Sunlight isn't scattered.
17342                                 LightSrc    uint8
17343
17344                                 GndContent   bool
17345                                 Collides     bool
17346                                 Pointable    bool
17347                                 Diggable     bool
17348                                 Climbable    bool
17349                                 Replaceable  bool
17350                                 OnRightClick bool
17351
17352                                 DmgPerSec int32
17353
17354                                 LiquidType   LiquidType
17355                                 FlowingAlt   string
17356                                 SrcAlt       string
17357                                 Viscosity    uint8 // 0-7
17358                                 LiqRenewable bool
17359                                 FlowRange    uint8
17360                                 DrownDmg     uint8
17361                                 Floodable    bool
17362
17363                                 DrawBox, ColBox, SelBox NodeBox
17364
17365                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17366
17367                                 LegacyFaceDir bool
17368                                 LegacyMounted bool
17369
17370                                 DigPredict string
17371
17372                                 MaxLvl uint8
17373
17374                                 AlphaUse
17375                         }))(obj)).GndContent
17376                         if x {
17377                                 write8(w, 1)
17378                         } else {
17379                                 write8(w, 0)
17380                         }
17381                 }
17382                 {
17383                         x := (*(*(struct {
17384                                 Param0 Content
17385
17386                                 Name   string
17387                                 Groups []Group
17388
17389                                 P1Type   Param1Type
17390                                 P2Type   Param2Type
17391                                 DrawType DrawType
17392
17393                                 Mesh  string
17394                                 Scale float32
17395                                 //mt:const uint8(6)
17396                                 Tiles        [6]TileDef
17397                                 OverlayTiles [6]TileDef
17398                                 //mt:const uint8(6)
17399                                 SpecialTiles [6]TileDef
17400
17401                                 Color   color.NRGBA
17402                                 Palette Texture
17403
17404                                 Waving       WaveType
17405                                 ConnectSides uint8
17406                                 ConnectTo    []Content
17407                                 InsideTint   color.NRGBA
17408                                 Level        uint8 // Must be < 128.
17409
17410                                 Translucent bool // Sunlight is scattered and becomes normal light.
17411                                 Transparent bool // Sunlight isn't scattered.
17412                                 LightSrc    uint8
17413
17414                                 GndContent   bool
17415                                 Collides     bool
17416                                 Pointable    bool
17417                                 Diggable     bool
17418                                 Climbable    bool
17419                                 Replaceable  bool
17420                                 OnRightClick bool
17421
17422                                 DmgPerSec int32
17423
17424                                 LiquidType   LiquidType
17425                                 FlowingAlt   string
17426                                 SrcAlt       string
17427                                 Viscosity    uint8 // 0-7
17428                                 LiqRenewable bool
17429                                 FlowRange    uint8
17430                                 DrownDmg     uint8
17431                                 Floodable    bool
17432
17433                                 DrawBox, ColBox, SelBox NodeBox
17434
17435                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17436
17437                                 LegacyFaceDir bool
17438                                 LegacyMounted bool
17439
17440                                 DigPredict string
17441
17442                                 MaxLvl uint8
17443
17444                                 AlphaUse
17445                         }))(obj)).Collides
17446                         if x {
17447                                 write8(w, 1)
17448                         } else {
17449                                 write8(w, 0)
17450                         }
17451                 }
17452                 {
17453                         x := (*(*(struct {
17454                                 Param0 Content
17455
17456                                 Name   string
17457                                 Groups []Group
17458
17459                                 P1Type   Param1Type
17460                                 P2Type   Param2Type
17461                                 DrawType DrawType
17462
17463                                 Mesh  string
17464                                 Scale float32
17465                                 //mt:const uint8(6)
17466                                 Tiles        [6]TileDef
17467                                 OverlayTiles [6]TileDef
17468                                 //mt:const uint8(6)
17469                                 SpecialTiles [6]TileDef
17470
17471                                 Color   color.NRGBA
17472                                 Palette Texture
17473
17474                                 Waving       WaveType
17475                                 ConnectSides uint8
17476                                 ConnectTo    []Content
17477                                 InsideTint   color.NRGBA
17478                                 Level        uint8 // Must be < 128.
17479
17480                                 Translucent bool // Sunlight is scattered and becomes normal light.
17481                                 Transparent bool // Sunlight isn't scattered.
17482                                 LightSrc    uint8
17483
17484                                 GndContent   bool
17485                                 Collides     bool
17486                                 Pointable    bool
17487                                 Diggable     bool
17488                                 Climbable    bool
17489                                 Replaceable  bool
17490                                 OnRightClick bool
17491
17492                                 DmgPerSec int32
17493
17494                                 LiquidType   LiquidType
17495                                 FlowingAlt   string
17496                                 SrcAlt       string
17497                                 Viscosity    uint8 // 0-7
17498                                 LiqRenewable bool
17499                                 FlowRange    uint8
17500                                 DrownDmg     uint8
17501                                 Floodable    bool
17502
17503                                 DrawBox, ColBox, SelBox NodeBox
17504
17505                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17506
17507                                 LegacyFaceDir bool
17508                                 LegacyMounted bool
17509
17510                                 DigPredict string
17511
17512                                 MaxLvl uint8
17513
17514                                 AlphaUse
17515                         }))(obj)).Pointable
17516                         if x {
17517                                 write8(w, 1)
17518                         } else {
17519                                 write8(w, 0)
17520                         }
17521                 }
17522                 {
17523                         x := (*(*(struct {
17524                                 Param0 Content
17525
17526                                 Name   string
17527                                 Groups []Group
17528
17529                                 P1Type   Param1Type
17530                                 P2Type   Param2Type
17531                                 DrawType DrawType
17532
17533                                 Mesh  string
17534                                 Scale float32
17535                                 //mt:const uint8(6)
17536                                 Tiles        [6]TileDef
17537                                 OverlayTiles [6]TileDef
17538                                 //mt:const uint8(6)
17539                                 SpecialTiles [6]TileDef
17540
17541                                 Color   color.NRGBA
17542                                 Palette Texture
17543
17544                                 Waving       WaveType
17545                                 ConnectSides uint8
17546                                 ConnectTo    []Content
17547                                 InsideTint   color.NRGBA
17548                                 Level        uint8 // Must be < 128.
17549
17550                                 Translucent bool // Sunlight is scattered and becomes normal light.
17551                                 Transparent bool // Sunlight isn't scattered.
17552                                 LightSrc    uint8
17553
17554                                 GndContent   bool
17555                                 Collides     bool
17556                                 Pointable    bool
17557                                 Diggable     bool
17558                                 Climbable    bool
17559                                 Replaceable  bool
17560                                 OnRightClick bool
17561
17562                                 DmgPerSec int32
17563
17564                                 LiquidType   LiquidType
17565                                 FlowingAlt   string
17566                                 SrcAlt       string
17567                                 Viscosity    uint8 // 0-7
17568                                 LiqRenewable bool
17569                                 FlowRange    uint8
17570                                 DrownDmg     uint8
17571                                 Floodable    bool
17572
17573                                 DrawBox, ColBox, SelBox NodeBox
17574
17575                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17576
17577                                 LegacyFaceDir bool
17578                                 LegacyMounted bool
17579
17580                                 DigPredict string
17581
17582                                 MaxLvl uint8
17583
17584                                 AlphaUse
17585                         }))(obj)).Diggable
17586                         if x {
17587                                 write8(w, 1)
17588                         } else {
17589                                 write8(w, 0)
17590                         }
17591                 }
17592                 {
17593                         x := (*(*(struct {
17594                                 Param0 Content
17595
17596                                 Name   string
17597                                 Groups []Group
17598
17599                                 P1Type   Param1Type
17600                                 P2Type   Param2Type
17601                                 DrawType DrawType
17602
17603                                 Mesh  string
17604                                 Scale float32
17605                                 //mt:const uint8(6)
17606                                 Tiles        [6]TileDef
17607                                 OverlayTiles [6]TileDef
17608                                 //mt:const uint8(6)
17609                                 SpecialTiles [6]TileDef
17610
17611                                 Color   color.NRGBA
17612                                 Palette Texture
17613
17614                                 Waving       WaveType
17615                                 ConnectSides uint8
17616                                 ConnectTo    []Content
17617                                 InsideTint   color.NRGBA
17618                                 Level        uint8 // Must be < 128.
17619
17620                                 Translucent bool // Sunlight is scattered and becomes normal light.
17621                                 Transparent bool // Sunlight isn't scattered.
17622                                 LightSrc    uint8
17623
17624                                 GndContent   bool
17625                                 Collides     bool
17626                                 Pointable    bool
17627                                 Diggable     bool
17628                                 Climbable    bool
17629                                 Replaceable  bool
17630                                 OnRightClick bool
17631
17632                                 DmgPerSec int32
17633
17634                                 LiquidType   LiquidType
17635                                 FlowingAlt   string
17636                                 SrcAlt       string
17637                                 Viscosity    uint8 // 0-7
17638                                 LiqRenewable bool
17639                                 FlowRange    uint8
17640                                 DrownDmg     uint8
17641                                 Floodable    bool
17642
17643                                 DrawBox, ColBox, SelBox NodeBox
17644
17645                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17646
17647                                 LegacyFaceDir bool
17648                                 LegacyMounted bool
17649
17650                                 DigPredict string
17651
17652                                 MaxLvl uint8
17653
17654                                 AlphaUse
17655                         }))(obj)).Climbable
17656                         if x {
17657                                 write8(w, 1)
17658                         } else {
17659                                 write8(w, 0)
17660                         }
17661                 }
17662                 {
17663                         x := (*(*(struct {
17664                                 Param0 Content
17665
17666                                 Name   string
17667                                 Groups []Group
17668
17669                                 P1Type   Param1Type
17670                                 P2Type   Param2Type
17671                                 DrawType DrawType
17672
17673                                 Mesh  string
17674                                 Scale float32
17675                                 //mt:const uint8(6)
17676                                 Tiles        [6]TileDef
17677                                 OverlayTiles [6]TileDef
17678                                 //mt:const uint8(6)
17679                                 SpecialTiles [6]TileDef
17680
17681                                 Color   color.NRGBA
17682                                 Palette Texture
17683
17684                                 Waving       WaveType
17685                                 ConnectSides uint8
17686                                 ConnectTo    []Content
17687                                 InsideTint   color.NRGBA
17688                                 Level        uint8 // Must be < 128.
17689
17690                                 Translucent bool // Sunlight is scattered and becomes normal light.
17691                                 Transparent bool // Sunlight isn't scattered.
17692                                 LightSrc    uint8
17693
17694                                 GndContent   bool
17695                                 Collides     bool
17696                                 Pointable    bool
17697                                 Diggable     bool
17698                                 Climbable    bool
17699                                 Replaceable  bool
17700                                 OnRightClick bool
17701
17702                                 DmgPerSec int32
17703
17704                                 LiquidType   LiquidType
17705                                 FlowingAlt   string
17706                                 SrcAlt       string
17707                                 Viscosity    uint8 // 0-7
17708                                 LiqRenewable bool
17709                                 FlowRange    uint8
17710                                 DrownDmg     uint8
17711                                 Floodable    bool
17712
17713                                 DrawBox, ColBox, SelBox NodeBox
17714
17715                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17716
17717                                 LegacyFaceDir bool
17718                                 LegacyMounted bool
17719
17720                                 DigPredict string
17721
17722                                 MaxLvl uint8
17723
17724                                 AlphaUse
17725                         }))(obj)).Replaceable
17726                         if x {
17727                                 write8(w, 1)
17728                         } else {
17729                                 write8(w, 0)
17730                         }
17731                 }
17732                 {
17733                         x := (*(*(struct {
17734                                 Param0 Content
17735
17736                                 Name   string
17737                                 Groups []Group
17738
17739                                 P1Type   Param1Type
17740                                 P2Type   Param2Type
17741                                 DrawType DrawType
17742
17743                                 Mesh  string
17744                                 Scale float32
17745                                 //mt:const uint8(6)
17746                                 Tiles        [6]TileDef
17747                                 OverlayTiles [6]TileDef
17748                                 //mt:const uint8(6)
17749                                 SpecialTiles [6]TileDef
17750
17751                                 Color   color.NRGBA
17752                                 Palette Texture
17753
17754                                 Waving       WaveType
17755                                 ConnectSides uint8
17756                                 ConnectTo    []Content
17757                                 InsideTint   color.NRGBA
17758                                 Level        uint8 // Must be < 128.
17759
17760                                 Translucent bool // Sunlight is scattered and becomes normal light.
17761                                 Transparent bool // Sunlight isn't scattered.
17762                                 LightSrc    uint8
17763
17764                                 GndContent   bool
17765                                 Collides     bool
17766                                 Pointable    bool
17767                                 Diggable     bool
17768                                 Climbable    bool
17769                                 Replaceable  bool
17770                                 OnRightClick bool
17771
17772                                 DmgPerSec int32
17773
17774                                 LiquidType   LiquidType
17775                                 FlowingAlt   string
17776                                 SrcAlt       string
17777                                 Viscosity    uint8 // 0-7
17778                                 LiqRenewable bool
17779                                 FlowRange    uint8
17780                                 DrownDmg     uint8
17781                                 Floodable    bool
17782
17783                                 DrawBox, ColBox, SelBox NodeBox
17784
17785                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17786
17787                                 LegacyFaceDir bool
17788                                 LegacyMounted bool
17789
17790                                 DigPredict string
17791
17792                                 MaxLvl uint8
17793
17794                                 AlphaUse
17795                         }))(obj)).OnRightClick
17796                         if x {
17797                                 write8(w, 1)
17798                         } else {
17799                                 write8(w, 0)
17800                         }
17801                 }
17802                 {
17803                         x := (*(*(struct {
17804                                 Param0 Content
17805
17806                                 Name   string
17807                                 Groups []Group
17808
17809                                 P1Type   Param1Type
17810                                 P2Type   Param2Type
17811                                 DrawType DrawType
17812
17813                                 Mesh  string
17814                                 Scale float32
17815                                 //mt:const uint8(6)
17816                                 Tiles        [6]TileDef
17817                                 OverlayTiles [6]TileDef
17818                                 //mt:const uint8(6)
17819                                 SpecialTiles [6]TileDef
17820
17821                                 Color   color.NRGBA
17822                                 Palette Texture
17823
17824                                 Waving       WaveType
17825                                 ConnectSides uint8
17826                                 ConnectTo    []Content
17827                                 InsideTint   color.NRGBA
17828                                 Level        uint8 // Must be < 128.
17829
17830                                 Translucent bool // Sunlight is scattered and becomes normal light.
17831                                 Transparent bool // Sunlight isn't scattered.
17832                                 LightSrc    uint8
17833
17834                                 GndContent   bool
17835                                 Collides     bool
17836                                 Pointable    bool
17837                                 Diggable     bool
17838                                 Climbable    bool
17839                                 Replaceable  bool
17840                                 OnRightClick bool
17841
17842                                 DmgPerSec int32
17843
17844                                 LiquidType   LiquidType
17845                                 FlowingAlt   string
17846                                 SrcAlt       string
17847                                 Viscosity    uint8 // 0-7
17848                                 LiqRenewable bool
17849                                 FlowRange    uint8
17850                                 DrownDmg     uint8
17851                                 Floodable    bool
17852
17853                                 DrawBox, ColBox, SelBox NodeBox
17854
17855                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17856
17857                                 LegacyFaceDir bool
17858                                 LegacyMounted bool
17859
17860                                 DigPredict string
17861
17862                                 MaxLvl uint8
17863
17864                                 AlphaUse
17865                         }))(obj)).DmgPerSec
17866                         write32(w, uint32(x))
17867                 }
17868                 if err := pcall(func() {
17869                         ((*(*(struct {
17870                                 Param0 Content
17871
17872                                 Name   string
17873                                 Groups []Group
17874
17875                                 P1Type   Param1Type
17876                                 P2Type   Param2Type
17877                                 DrawType DrawType
17878
17879                                 Mesh  string
17880                                 Scale float32
17881                                 //mt:const uint8(6)
17882                                 Tiles        [6]TileDef
17883                                 OverlayTiles [6]TileDef
17884                                 //mt:const uint8(6)
17885                                 SpecialTiles [6]TileDef
17886
17887                                 Color   color.NRGBA
17888                                 Palette Texture
17889
17890                                 Waving       WaveType
17891                                 ConnectSides uint8
17892                                 ConnectTo    []Content
17893                                 InsideTint   color.NRGBA
17894                                 Level        uint8 // Must be < 128.
17895
17896                                 Translucent bool // Sunlight is scattered and becomes normal light.
17897                                 Transparent bool // Sunlight isn't scattered.
17898                                 LightSrc    uint8
17899
17900                                 GndContent   bool
17901                                 Collides     bool
17902                                 Pointable    bool
17903                                 Diggable     bool
17904                                 Climbable    bool
17905                                 Replaceable  bool
17906                                 OnRightClick bool
17907
17908                                 DmgPerSec int32
17909
17910                                 LiquidType   LiquidType
17911                                 FlowingAlt   string
17912                                 SrcAlt       string
17913                                 Viscosity    uint8 // 0-7
17914                                 LiqRenewable bool
17915                                 FlowRange    uint8
17916                                 DrownDmg     uint8
17917                                 Floodable    bool
17918
17919                                 DrawBox, ColBox, SelBox NodeBox
17920
17921                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17922
17923                                 LegacyFaceDir bool
17924                                 LegacyMounted bool
17925
17926                                 DigPredict string
17927
17928                                 MaxLvl uint8
17929
17930                                 AlphaUse
17931                         }))(obj)).LiquidType).serialize(w)
17932                 }); err != nil {
17933                         if err == io.EOF {
17934                                 chk(io.EOF)
17935                         }
17936                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
17937                 }
17938                 if len(([]byte((*(*(struct {
17939                         Param0 Content
17940
17941                         Name   string
17942                         Groups []Group
17943
17944                         P1Type   Param1Type
17945                         P2Type   Param2Type
17946                         DrawType DrawType
17947
17948                         Mesh  string
17949                         Scale float32
17950                         //mt:const uint8(6)
17951                         Tiles        [6]TileDef
17952                         OverlayTiles [6]TileDef
17953                         //mt:const uint8(6)
17954                         SpecialTiles [6]TileDef
17955
17956                         Color   color.NRGBA
17957                         Palette Texture
17958
17959                         Waving       WaveType
17960                         ConnectSides uint8
17961                         ConnectTo    []Content
17962                         InsideTint   color.NRGBA
17963                         Level        uint8 // Must be < 128.
17964
17965                         Translucent bool // Sunlight is scattered and becomes normal light.
17966                         Transparent bool // Sunlight isn't scattered.
17967                         LightSrc    uint8
17968
17969                         GndContent   bool
17970                         Collides     bool
17971                         Pointable    bool
17972                         Diggable     bool
17973                         Climbable    bool
17974                         Replaceable  bool
17975                         OnRightClick bool
17976
17977                         DmgPerSec int32
17978
17979                         LiquidType   LiquidType
17980                         FlowingAlt   string
17981                         SrcAlt       string
17982                         Viscosity    uint8 // 0-7
17983                         LiqRenewable bool
17984                         FlowRange    uint8
17985                         DrownDmg     uint8
17986                         Floodable    bool
17987
17988                         DrawBox, ColBox, SelBox NodeBox
17989
17990                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17991
17992                         LegacyFaceDir bool
17993                         LegacyMounted bool
17994
17995                         DigPredict string
17996
17997                         MaxLvl uint8
17998
17999                         AlphaUse
18000                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
18001                         chk(ErrTooLong)
18002                 }
18003                 {
18004                         x := uint16(len(([]byte((*(*(struct {
18005                                 Param0 Content
18006
18007                                 Name   string
18008                                 Groups []Group
18009
18010                                 P1Type   Param1Type
18011                                 P2Type   Param2Type
18012                                 DrawType DrawType
18013
18014                                 Mesh  string
18015                                 Scale float32
18016                                 //mt:const uint8(6)
18017                                 Tiles        [6]TileDef
18018                                 OverlayTiles [6]TileDef
18019                                 //mt:const uint8(6)
18020                                 SpecialTiles [6]TileDef
18021
18022                                 Color   color.NRGBA
18023                                 Palette Texture
18024
18025                                 Waving       WaveType
18026                                 ConnectSides uint8
18027                                 ConnectTo    []Content
18028                                 InsideTint   color.NRGBA
18029                                 Level        uint8 // Must be < 128.
18030
18031                                 Translucent bool // Sunlight is scattered and becomes normal light.
18032                                 Transparent bool // Sunlight isn't scattered.
18033                                 LightSrc    uint8
18034
18035                                 GndContent   bool
18036                                 Collides     bool
18037                                 Pointable    bool
18038                                 Diggable     bool
18039                                 Climbable    bool
18040                                 Replaceable  bool
18041                                 OnRightClick bool
18042
18043                                 DmgPerSec int32
18044
18045                                 LiquidType   LiquidType
18046                                 FlowingAlt   string
18047                                 SrcAlt       string
18048                                 Viscosity    uint8 // 0-7
18049                                 LiqRenewable bool
18050                                 FlowRange    uint8
18051                                 DrownDmg     uint8
18052                                 Floodable    bool
18053
18054                                 DrawBox, ColBox, SelBox NodeBox
18055
18056                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18057
18058                                 LegacyFaceDir bool
18059                                 LegacyMounted bool
18060
18061                                 DigPredict string
18062
18063                                 MaxLvl uint8
18064
18065                                 AlphaUse
18066                         }))(obj)).FlowingAlt))))
18067                         write16(w, uint16(x))
18068                 }
18069                 {
18070                         _, err := w.Write(([]byte((*(*(struct {
18071                                 Param0 Content
18072
18073                                 Name   string
18074                                 Groups []Group
18075
18076                                 P1Type   Param1Type
18077                                 P2Type   Param2Type
18078                                 DrawType DrawType
18079
18080                                 Mesh  string
18081                                 Scale float32
18082                                 //mt:const uint8(6)
18083                                 Tiles        [6]TileDef
18084                                 OverlayTiles [6]TileDef
18085                                 //mt:const uint8(6)
18086                                 SpecialTiles [6]TileDef
18087
18088                                 Color   color.NRGBA
18089                                 Palette Texture
18090
18091                                 Waving       WaveType
18092                                 ConnectSides uint8
18093                                 ConnectTo    []Content
18094                                 InsideTint   color.NRGBA
18095                                 Level        uint8 // Must be < 128.
18096
18097                                 Translucent bool // Sunlight is scattered and becomes normal light.
18098                                 Transparent bool // Sunlight isn't scattered.
18099                                 LightSrc    uint8
18100
18101                                 GndContent   bool
18102                                 Collides     bool
18103                                 Pointable    bool
18104                                 Diggable     bool
18105                                 Climbable    bool
18106                                 Replaceable  bool
18107                                 OnRightClick bool
18108
18109                                 DmgPerSec int32
18110
18111                                 LiquidType   LiquidType
18112                                 FlowingAlt   string
18113                                 SrcAlt       string
18114                                 Viscosity    uint8 // 0-7
18115                                 LiqRenewable bool
18116                                 FlowRange    uint8
18117                                 DrownDmg     uint8
18118                                 Floodable    bool
18119
18120                                 DrawBox, ColBox, SelBox NodeBox
18121
18122                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18123
18124                                 LegacyFaceDir bool
18125                                 LegacyMounted bool
18126
18127                                 DigPredict string
18128
18129                                 MaxLvl uint8
18130
18131                                 AlphaUse
18132                         }))(obj)).FlowingAlt))[:])
18133                         chk(err)
18134                 }
18135                 if len(([]byte((*(*(struct {
18136                         Param0 Content
18137
18138                         Name   string
18139                         Groups []Group
18140
18141                         P1Type   Param1Type
18142                         P2Type   Param2Type
18143                         DrawType DrawType
18144
18145                         Mesh  string
18146                         Scale float32
18147                         //mt:const uint8(6)
18148                         Tiles        [6]TileDef
18149                         OverlayTiles [6]TileDef
18150                         //mt:const uint8(6)
18151                         SpecialTiles [6]TileDef
18152
18153                         Color   color.NRGBA
18154                         Palette Texture
18155
18156                         Waving       WaveType
18157                         ConnectSides uint8
18158                         ConnectTo    []Content
18159                         InsideTint   color.NRGBA
18160                         Level        uint8 // Must be < 128.
18161
18162                         Translucent bool // Sunlight is scattered and becomes normal light.
18163                         Transparent bool // Sunlight isn't scattered.
18164                         LightSrc    uint8
18165
18166                         GndContent   bool
18167                         Collides     bool
18168                         Pointable    bool
18169                         Diggable     bool
18170                         Climbable    bool
18171                         Replaceable  bool
18172                         OnRightClick bool
18173
18174                         DmgPerSec int32
18175
18176                         LiquidType   LiquidType
18177                         FlowingAlt   string
18178                         SrcAlt       string
18179                         Viscosity    uint8 // 0-7
18180                         LiqRenewable bool
18181                         FlowRange    uint8
18182                         DrownDmg     uint8
18183                         Floodable    bool
18184
18185                         DrawBox, ColBox, SelBox NodeBox
18186
18187                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18188
18189                         LegacyFaceDir bool
18190                         LegacyMounted bool
18191
18192                         DigPredict string
18193
18194                         MaxLvl uint8
18195
18196                         AlphaUse
18197                 }))(obj)).SrcAlt))) > math.MaxUint16 {
18198                         chk(ErrTooLong)
18199                 }
18200                 {
18201                         x := uint16(len(([]byte((*(*(struct {
18202                                 Param0 Content
18203
18204                                 Name   string
18205                                 Groups []Group
18206
18207                                 P1Type   Param1Type
18208                                 P2Type   Param2Type
18209                                 DrawType DrawType
18210
18211                                 Mesh  string
18212                                 Scale float32
18213                                 //mt:const uint8(6)
18214                                 Tiles        [6]TileDef
18215                                 OverlayTiles [6]TileDef
18216                                 //mt:const uint8(6)
18217                                 SpecialTiles [6]TileDef
18218
18219                                 Color   color.NRGBA
18220                                 Palette Texture
18221
18222                                 Waving       WaveType
18223                                 ConnectSides uint8
18224                                 ConnectTo    []Content
18225                                 InsideTint   color.NRGBA
18226                                 Level        uint8 // Must be < 128.
18227
18228                                 Translucent bool // Sunlight is scattered and becomes normal light.
18229                                 Transparent bool // Sunlight isn't scattered.
18230                                 LightSrc    uint8
18231
18232                                 GndContent   bool
18233                                 Collides     bool
18234                                 Pointable    bool
18235                                 Diggable     bool
18236                                 Climbable    bool
18237                                 Replaceable  bool
18238                                 OnRightClick bool
18239
18240                                 DmgPerSec int32
18241
18242                                 LiquidType   LiquidType
18243                                 FlowingAlt   string
18244                                 SrcAlt       string
18245                                 Viscosity    uint8 // 0-7
18246                                 LiqRenewable bool
18247                                 FlowRange    uint8
18248                                 DrownDmg     uint8
18249                                 Floodable    bool
18250
18251                                 DrawBox, ColBox, SelBox NodeBox
18252
18253                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18254
18255                                 LegacyFaceDir bool
18256                                 LegacyMounted bool
18257
18258                                 DigPredict string
18259
18260                                 MaxLvl uint8
18261
18262                                 AlphaUse
18263                         }))(obj)).SrcAlt))))
18264                         write16(w, uint16(x))
18265                 }
18266                 {
18267                         _, err := w.Write(([]byte((*(*(struct {
18268                                 Param0 Content
18269
18270                                 Name   string
18271                                 Groups []Group
18272
18273                                 P1Type   Param1Type
18274                                 P2Type   Param2Type
18275                                 DrawType DrawType
18276
18277                                 Mesh  string
18278                                 Scale float32
18279                                 //mt:const uint8(6)
18280                                 Tiles        [6]TileDef
18281                                 OverlayTiles [6]TileDef
18282                                 //mt:const uint8(6)
18283                                 SpecialTiles [6]TileDef
18284
18285                                 Color   color.NRGBA
18286                                 Palette Texture
18287
18288                                 Waving       WaveType
18289                                 ConnectSides uint8
18290                                 ConnectTo    []Content
18291                                 InsideTint   color.NRGBA
18292                                 Level        uint8 // Must be < 128.
18293
18294                                 Translucent bool // Sunlight is scattered and becomes normal light.
18295                                 Transparent bool // Sunlight isn't scattered.
18296                                 LightSrc    uint8
18297
18298                                 GndContent   bool
18299                                 Collides     bool
18300                                 Pointable    bool
18301                                 Diggable     bool
18302                                 Climbable    bool
18303                                 Replaceable  bool
18304                                 OnRightClick bool
18305
18306                                 DmgPerSec int32
18307
18308                                 LiquidType   LiquidType
18309                                 FlowingAlt   string
18310                                 SrcAlt       string
18311                                 Viscosity    uint8 // 0-7
18312                                 LiqRenewable bool
18313                                 FlowRange    uint8
18314                                 DrownDmg     uint8
18315                                 Floodable    bool
18316
18317                                 DrawBox, ColBox, SelBox NodeBox
18318
18319                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18320
18321                                 LegacyFaceDir bool
18322                                 LegacyMounted bool
18323
18324                                 DigPredict string
18325
18326                                 MaxLvl uint8
18327
18328                                 AlphaUse
18329                         }))(obj)).SrcAlt))[:])
18330                         chk(err)
18331                 }
18332                 {
18333                         x := (*(*(struct {
18334                                 Param0 Content
18335
18336                                 Name   string
18337                                 Groups []Group
18338
18339                                 P1Type   Param1Type
18340                                 P2Type   Param2Type
18341                                 DrawType DrawType
18342
18343                                 Mesh  string
18344                                 Scale float32
18345                                 //mt:const uint8(6)
18346                                 Tiles        [6]TileDef
18347                                 OverlayTiles [6]TileDef
18348                                 //mt:const uint8(6)
18349                                 SpecialTiles [6]TileDef
18350
18351                                 Color   color.NRGBA
18352                                 Palette Texture
18353
18354                                 Waving       WaveType
18355                                 ConnectSides uint8
18356                                 ConnectTo    []Content
18357                                 InsideTint   color.NRGBA
18358                                 Level        uint8 // Must be < 128.
18359
18360                                 Translucent bool // Sunlight is scattered and becomes normal light.
18361                                 Transparent bool // Sunlight isn't scattered.
18362                                 LightSrc    uint8
18363
18364                                 GndContent   bool
18365                                 Collides     bool
18366                                 Pointable    bool
18367                                 Diggable     bool
18368                                 Climbable    bool
18369                                 Replaceable  bool
18370                                 OnRightClick bool
18371
18372                                 DmgPerSec int32
18373
18374                                 LiquidType   LiquidType
18375                                 FlowingAlt   string
18376                                 SrcAlt       string
18377                                 Viscosity    uint8 // 0-7
18378                                 LiqRenewable bool
18379                                 FlowRange    uint8
18380                                 DrownDmg     uint8
18381                                 Floodable    bool
18382
18383                                 DrawBox, ColBox, SelBox NodeBox
18384
18385                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18386
18387                                 LegacyFaceDir bool
18388                                 LegacyMounted bool
18389
18390                                 DigPredict string
18391
18392                                 MaxLvl uint8
18393
18394                                 AlphaUse
18395                         }))(obj)).Viscosity
18396                         write8(w, uint8(x))
18397                 }
18398                 {
18399                         x := (*(*(struct {
18400                                 Param0 Content
18401
18402                                 Name   string
18403                                 Groups []Group
18404
18405                                 P1Type   Param1Type
18406                                 P2Type   Param2Type
18407                                 DrawType DrawType
18408
18409                                 Mesh  string
18410                                 Scale float32
18411                                 //mt:const uint8(6)
18412                                 Tiles        [6]TileDef
18413                                 OverlayTiles [6]TileDef
18414                                 //mt:const uint8(6)
18415                                 SpecialTiles [6]TileDef
18416
18417                                 Color   color.NRGBA
18418                                 Palette Texture
18419
18420                                 Waving       WaveType
18421                                 ConnectSides uint8
18422                                 ConnectTo    []Content
18423                                 InsideTint   color.NRGBA
18424                                 Level        uint8 // Must be < 128.
18425
18426                                 Translucent bool // Sunlight is scattered and becomes normal light.
18427                                 Transparent bool // Sunlight isn't scattered.
18428                                 LightSrc    uint8
18429
18430                                 GndContent   bool
18431                                 Collides     bool
18432                                 Pointable    bool
18433                                 Diggable     bool
18434                                 Climbable    bool
18435                                 Replaceable  bool
18436                                 OnRightClick bool
18437
18438                                 DmgPerSec int32
18439
18440                                 LiquidType   LiquidType
18441                                 FlowingAlt   string
18442                                 SrcAlt       string
18443                                 Viscosity    uint8 // 0-7
18444                                 LiqRenewable bool
18445                                 FlowRange    uint8
18446                                 DrownDmg     uint8
18447                                 Floodable    bool
18448
18449                                 DrawBox, ColBox, SelBox NodeBox
18450
18451                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18452
18453                                 LegacyFaceDir bool
18454                                 LegacyMounted bool
18455
18456                                 DigPredict string
18457
18458                                 MaxLvl uint8
18459
18460                                 AlphaUse
18461                         }))(obj)).LiqRenewable
18462                         if x {
18463                                 write8(w, 1)
18464                         } else {
18465                                 write8(w, 0)
18466                         }
18467                 }
18468                 {
18469                         x := (*(*(struct {
18470                                 Param0 Content
18471
18472                                 Name   string
18473                                 Groups []Group
18474
18475                                 P1Type   Param1Type
18476                                 P2Type   Param2Type
18477                                 DrawType DrawType
18478
18479                                 Mesh  string
18480                                 Scale float32
18481                                 //mt:const uint8(6)
18482                                 Tiles        [6]TileDef
18483                                 OverlayTiles [6]TileDef
18484                                 //mt:const uint8(6)
18485                                 SpecialTiles [6]TileDef
18486
18487                                 Color   color.NRGBA
18488                                 Palette Texture
18489
18490                                 Waving       WaveType
18491                                 ConnectSides uint8
18492                                 ConnectTo    []Content
18493                                 InsideTint   color.NRGBA
18494                                 Level        uint8 // Must be < 128.
18495
18496                                 Translucent bool // Sunlight is scattered and becomes normal light.
18497                                 Transparent bool // Sunlight isn't scattered.
18498                                 LightSrc    uint8
18499
18500                                 GndContent   bool
18501                                 Collides     bool
18502                                 Pointable    bool
18503                                 Diggable     bool
18504                                 Climbable    bool
18505                                 Replaceable  bool
18506                                 OnRightClick bool
18507
18508                                 DmgPerSec int32
18509
18510                                 LiquidType   LiquidType
18511                                 FlowingAlt   string
18512                                 SrcAlt       string
18513                                 Viscosity    uint8 // 0-7
18514                                 LiqRenewable bool
18515                                 FlowRange    uint8
18516                                 DrownDmg     uint8
18517                                 Floodable    bool
18518
18519                                 DrawBox, ColBox, SelBox NodeBox
18520
18521                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18522
18523                                 LegacyFaceDir bool
18524                                 LegacyMounted bool
18525
18526                                 DigPredict string
18527
18528                                 MaxLvl uint8
18529
18530                                 AlphaUse
18531                         }))(obj)).FlowRange
18532                         write8(w, uint8(x))
18533                 }
18534                 {
18535                         x := (*(*(struct {
18536                                 Param0 Content
18537
18538                                 Name   string
18539                                 Groups []Group
18540
18541                                 P1Type   Param1Type
18542                                 P2Type   Param2Type
18543                                 DrawType DrawType
18544
18545                                 Mesh  string
18546                                 Scale float32
18547                                 //mt:const uint8(6)
18548                                 Tiles        [6]TileDef
18549                                 OverlayTiles [6]TileDef
18550                                 //mt:const uint8(6)
18551                                 SpecialTiles [6]TileDef
18552
18553                                 Color   color.NRGBA
18554                                 Palette Texture
18555
18556                                 Waving       WaveType
18557                                 ConnectSides uint8
18558                                 ConnectTo    []Content
18559                                 InsideTint   color.NRGBA
18560                                 Level        uint8 // Must be < 128.
18561
18562                                 Translucent bool // Sunlight is scattered and becomes normal light.
18563                                 Transparent bool // Sunlight isn't scattered.
18564                                 LightSrc    uint8
18565
18566                                 GndContent   bool
18567                                 Collides     bool
18568                                 Pointable    bool
18569                                 Diggable     bool
18570                                 Climbable    bool
18571                                 Replaceable  bool
18572                                 OnRightClick bool
18573
18574                                 DmgPerSec int32
18575
18576                                 LiquidType   LiquidType
18577                                 FlowingAlt   string
18578                                 SrcAlt       string
18579                                 Viscosity    uint8 // 0-7
18580                                 LiqRenewable bool
18581                                 FlowRange    uint8
18582                                 DrownDmg     uint8
18583                                 Floodable    bool
18584
18585                                 DrawBox, ColBox, SelBox NodeBox
18586
18587                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18588
18589                                 LegacyFaceDir bool
18590                                 LegacyMounted bool
18591
18592                                 DigPredict string
18593
18594                                 MaxLvl uint8
18595
18596                                 AlphaUse
18597                         }))(obj)).DrownDmg
18598                         write8(w, uint8(x))
18599                 }
18600                 {
18601                         x := (*(*(struct {
18602                                 Param0 Content
18603
18604                                 Name   string
18605                                 Groups []Group
18606
18607                                 P1Type   Param1Type
18608                                 P2Type   Param2Type
18609                                 DrawType DrawType
18610
18611                                 Mesh  string
18612                                 Scale float32
18613                                 //mt:const uint8(6)
18614                                 Tiles        [6]TileDef
18615                                 OverlayTiles [6]TileDef
18616                                 //mt:const uint8(6)
18617                                 SpecialTiles [6]TileDef
18618
18619                                 Color   color.NRGBA
18620                                 Palette Texture
18621
18622                                 Waving       WaveType
18623                                 ConnectSides uint8
18624                                 ConnectTo    []Content
18625                                 InsideTint   color.NRGBA
18626                                 Level        uint8 // Must be < 128.
18627
18628                                 Translucent bool // Sunlight is scattered and becomes normal light.
18629                                 Transparent bool // Sunlight isn't scattered.
18630                                 LightSrc    uint8
18631
18632                                 GndContent   bool
18633                                 Collides     bool
18634                                 Pointable    bool
18635                                 Diggable     bool
18636                                 Climbable    bool
18637                                 Replaceable  bool
18638                                 OnRightClick bool
18639
18640                                 DmgPerSec int32
18641
18642                                 LiquidType   LiquidType
18643                                 FlowingAlt   string
18644                                 SrcAlt       string
18645                                 Viscosity    uint8 // 0-7
18646                                 LiqRenewable bool
18647                                 FlowRange    uint8
18648                                 DrownDmg     uint8
18649                                 Floodable    bool
18650
18651                                 DrawBox, ColBox, SelBox NodeBox
18652
18653                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18654
18655                                 LegacyFaceDir bool
18656                                 LegacyMounted bool
18657
18658                                 DigPredict string
18659
18660                                 MaxLvl uint8
18661
18662                                 AlphaUse
18663                         }))(obj)).Floodable
18664                         if x {
18665                                 write8(w, 1)
18666                         } else {
18667                                 write8(w, 0)
18668                         }
18669                 }
18670                 if err := pcall(func() {
18671                         ((*(*(struct {
18672                                 Param0 Content
18673
18674                                 Name   string
18675                                 Groups []Group
18676
18677                                 P1Type   Param1Type
18678                                 P2Type   Param2Type
18679                                 DrawType DrawType
18680
18681                                 Mesh  string
18682                                 Scale float32
18683                                 //mt:const uint8(6)
18684                                 Tiles        [6]TileDef
18685                                 OverlayTiles [6]TileDef
18686                                 //mt:const uint8(6)
18687                                 SpecialTiles [6]TileDef
18688
18689                                 Color   color.NRGBA
18690                                 Palette Texture
18691
18692                                 Waving       WaveType
18693                                 ConnectSides uint8
18694                                 ConnectTo    []Content
18695                                 InsideTint   color.NRGBA
18696                                 Level        uint8 // Must be < 128.
18697
18698                                 Translucent bool // Sunlight is scattered and becomes normal light.
18699                                 Transparent bool // Sunlight isn't scattered.
18700                                 LightSrc    uint8
18701
18702                                 GndContent   bool
18703                                 Collides     bool
18704                                 Pointable    bool
18705                                 Diggable     bool
18706                                 Climbable    bool
18707                                 Replaceable  bool
18708                                 OnRightClick bool
18709
18710                                 DmgPerSec int32
18711
18712                                 LiquidType   LiquidType
18713                                 FlowingAlt   string
18714                                 SrcAlt       string
18715                                 Viscosity    uint8 // 0-7
18716                                 LiqRenewable bool
18717                                 FlowRange    uint8
18718                                 DrownDmg     uint8
18719                                 Floodable    bool
18720
18721                                 DrawBox, ColBox, SelBox NodeBox
18722
18723                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18724
18725                                 LegacyFaceDir bool
18726                                 LegacyMounted bool
18727
18728                                 DigPredict string
18729
18730                                 MaxLvl uint8
18731
18732                                 AlphaUse
18733                         }))(obj)).DrawBox).serialize(w)
18734                 }); err != nil {
18735                         if err == io.EOF {
18736                                 chk(io.EOF)
18737                         }
18738                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
18739                 }
18740                 if err := pcall(func() {
18741                         ((*(*(struct {
18742                                 Param0 Content
18743
18744                                 Name   string
18745                                 Groups []Group
18746
18747                                 P1Type   Param1Type
18748                                 P2Type   Param2Type
18749                                 DrawType DrawType
18750
18751                                 Mesh  string
18752                                 Scale float32
18753                                 //mt:const uint8(6)
18754                                 Tiles        [6]TileDef
18755                                 OverlayTiles [6]TileDef
18756                                 //mt:const uint8(6)
18757                                 SpecialTiles [6]TileDef
18758
18759                                 Color   color.NRGBA
18760                                 Palette Texture
18761
18762                                 Waving       WaveType
18763                                 ConnectSides uint8
18764                                 ConnectTo    []Content
18765                                 InsideTint   color.NRGBA
18766                                 Level        uint8 // Must be < 128.
18767
18768                                 Translucent bool // Sunlight is scattered and becomes normal light.
18769                                 Transparent bool // Sunlight isn't scattered.
18770                                 LightSrc    uint8
18771
18772                                 GndContent   bool
18773                                 Collides     bool
18774                                 Pointable    bool
18775                                 Diggable     bool
18776                                 Climbable    bool
18777                                 Replaceable  bool
18778                                 OnRightClick bool
18779
18780                                 DmgPerSec int32
18781
18782                                 LiquidType   LiquidType
18783                                 FlowingAlt   string
18784                                 SrcAlt       string
18785                                 Viscosity    uint8 // 0-7
18786                                 LiqRenewable bool
18787                                 FlowRange    uint8
18788                                 DrownDmg     uint8
18789                                 Floodable    bool
18790
18791                                 DrawBox, ColBox, SelBox NodeBox
18792
18793                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18794
18795                                 LegacyFaceDir bool
18796                                 LegacyMounted bool
18797
18798                                 DigPredict string
18799
18800                                 MaxLvl uint8
18801
18802                                 AlphaUse
18803                         }))(obj)).ColBox).serialize(w)
18804                 }); err != nil {
18805                         if err == io.EOF {
18806                                 chk(io.EOF)
18807                         }
18808                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
18809                 }
18810                 if err := pcall(func() {
18811                         ((*(*(struct {
18812                                 Param0 Content
18813
18814                                 Name   string
18815                                 Groups []Group
18816
18817                                 P1Type   Param1Type
18818                                 P2Type   Param2Type
18819                                 DrawType DrawType
18820
18821                                 Mesh  string
18822                                 Scale float32
18823                                 //mt:const uint8(6)
18824                                 Tiles        [6]TileDef
18825                                 OverlayTiles [6]TileDef
18826                                 //mt:const uint8(6)
18827                                 SpecialTiles [6]TileDef
18828
18829                                 Color   color.NRGBA
18830                                 Palette Texture
18831
18832                                 Waving       WaveType
18833                                 ConnectSides uint8
18834                                 ConnectTo    []Content
18835                                 InsideTint   color.NRGBA
18836                                 Level        uint8 // Must be < 128.
18837
18838                                 Translucent bool // Sunlight is scattered and becomes normal light.
18839                                 Transparent bool // Sunlight isn't scattered.
18840                                 LightSrc    uint8
18841
18842                                 GndContent   bool
18843                                 Collides     bool
18844                                 Pointable    bool
18845                                 Diggable     bool
18846                                 Climbable    bool
18847                                 Replaceable  bool
18848                                 OnRightClick bool
18849
18850                                 DmgPerSec int32
18851
18852                                 LiquidType   LiquidType
18853                                 FlowingAlt   string
18854                                 SrcAlt       string
18855                                 Viscosity    uint8 // 0-7
18856                                 LiqRenewable bool
18857                                 FlowRange    uint8
18858                                 DrownDmg     uint8
18859                                 Floodable    bool
18860
18861                                 DrawBox, ColBox, SelBox NodeBox
18862
18863                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18864
18865                                 LegacyFaceDir bool
18866                                 LegacyMounted bool
18867
18868                                 DigPredict string
18869
18870                                 MaxLvl uint8
18871
18872                                 AlphaUse
18873                         }))(obj)).SelBox).serialize(w)
18874                 }); err != nil {
18875                         if err == io.EOF {
18876                                 chk(io.EOF)
18877                         }
18878                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
18879                 }
18880                 if err := pcall(func() {
18881                         ((*(*(struct {
18882                                 Param0 Content
18883
18884                                 Name   string
18885                                 Groups []Group
18886
18887                                 P1Type   Param1Type
18888                                 P2Type   Param2Type
18889                                 DrawType DrawType
18890
18891                                 Mesh  string
18892                                 Scale float32
18893                                 //mt:const uint8(6)
18894                                 Tiles        [6]TileDef
18895                                 OverlayTiles [6]TileDef
18896                                 //mt:const uint8(6)
18897                                 SpecialTiles [6]TileDef
18898
18899                                 Color   color.NRGBA
18900                                 Palette Texture
18901
18902                                 Waving       WaveType
18903                                 ConnectSides uint8
18904                                 ConnectTo    []Content
18905                                 InsideTint   color.NRGBA
18906                                 Level        uint8 // Must be < 128.
18907
18908                                 Translucent bool // Sunlight is scattered and becomes normal light.
18909                                 Transparent bool // Sunlight isn't scattered.
18910                                 LightSrc    uint8
18911
18912                                 GndContent   bool
18913                                 Collides     bool
18914                                 Pointable    bool
18915                                 Diggable     bool
18916                                 Climbable    bool
18917                                 Replaceable  bool
18918                                 OnRightClick bool
18919
18920                                 DmgPerSec int32
18921
18922                                 LiquidType   LiquidType
18923                                 FlowingAlt   string
18924                                 SrcAlt       string
18925                                 Viscosity    uint8 // 0-7
18926                                 LiqRenewable bool
18927                                 FlowRange    uint8
18928                                 DrownDmg     uint8
18929                                 Floodable    bool
18930
18931                                 DrawBox, ColBox, SelBox NodeBox
18932
18933                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18934
18935                                 LegacyFaceDir bool
18936                                 LegacyMounted bool
18937
18938                                 DigPredict string
18939
18940                                 MaxLvl uint8
18941
18942                                 AlphaUse
18943                         }))(obj)).FootstepSnd).serialize(w)
18944                 }); err != nil {
18945                         if err == io.EOF {
18946                                 chk(io.EOF)
18947                         }
18948                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
18949                 }
18950                 if err := pcall(func() {
18951                         ((*(*(struct {
18952                                 Param0 Content
18953
18954                                 Name   string
18955                                 Groups []Group
18956
18957                                 P1Type   Param1Type
18958                                 P2Type   Param2Type
18959                                 DrawType DrawType
18960
18961                                 Mesh  string
18962                                 Scale float32
18963                                 //mt:const uint8(6)
18964                                 Tiles        [6]TileDef
18965                                 OverlayTiles [6]TileDef
18966                                 //mt:const uint8(6)
18967                                 SpecialTiles [6]TileDef
18968
18969                                 Color   color.NRGBA
18970                                 Palette Texture
18971
18972                                 Waving       WaveType
18973                                 ConnectSides uint8
18974                                 ConnectTo    []Content
18975                                 InsideTint   color.NRGBA
18976                                 Level        uint8 // Must be < 128.
18977
18978                                 Translucent bool // Sunlight is scattered and becomes normal light.
18979                                 Transparent bool // Sunlight isn't scattered.
18980                                 LightSrc    uint8
18981
18982                                 GndContent   bool
18983                                 Collides     bool
18984                                 Pointable    bool
18985                                 Diggable     bool
18986                                 Climbable    bool
18987                                 Replaceable  bool
18988                                 OnRightClick bool
18989
18990                                 DmgPerSec int32
18991
18992                                 LiquidType   LiquidType
18993                                 FlowingAlt   string
18994                                 SrcAlt       string
18995                                 Viscosity    uint8 // 0-7
18996                                 LiqRenewable bool
18997                                 FlowRange    uint8
18998                                 DrownDmg     uint8
18999                                 Floodable    bool
19000
19001                                 DrawBox, ColBox, SelBox NodeBox
19002
19003                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19004
19005                                 LegacyFaceDir bool
19006                                 LegacyMounted bool
19007
19008                                 DigPredict string
19009
19010                                 MaxLvl uint8
19011
19012                                 AlphaUse
19013                         }))(obj)).DiggingSnd).serialize(w)
19014                 }); err != nil {
19015                         if err == io.EOF {
19016                                 chk(io.EOF)
19017                         }
19018                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
19019                 }
19020                 if err := pcall(func() {
19021                         ((*(*(struct {
19022                                 Param0 Content
19023
19024                                 Name   string
19025                                 Groups []Group
19026
19027                                 P1Type   Param1Type
19028                                 P2Type   Param2Type
19029                                 DrawType DrawType
19030
19031                                 Mesh  string
19032                                 Scale float32
19033                                 //mt:const uint8(6)
19034                                 Tiles        [6]TileDef
19035                                 OverlayTiles [6]TileDef
19036                                 //mt:const uint8(6)
19037                                 SpecialTiles [6]TileDef
19038
19039                                 Color   color.NRGBA
19040                                 Palette Texture
19041
19042                                 Waving       WaveType
19043                                 ConnectSides uint8
19044                                 ConnectTo    []Content
19045                                 InsideTint   color.NRGBA
19046                                 Level        uint8 // Must be < 128.
19047
19048                                 Translucent bool // Sunlight is scattered and becomes normal light.
19049                                 Transparent bool // Sunlight isn't scattered.
19050                                 LightSrc    uint8
19051
19052                                 GndContent   bool
19053                                 Collides     bool
19054                                 Pointable    bool
19055                                 Diggable     bool
19056                                 Climbable    bool
19057                                 Replaceable  bool
19058                                 OnRightClick bool
19059
19060                                 DmgPerSec int32
19061
19062                                 LiquidType   LiquidType
19063                                 FlowingAlt   string
19064                                 SrcAlt       string
19065                                 Viscosity    uint8 // 0-7
19066                                 LiqRenewable bool
19067                                 FlowRange    uint8
19068                                 DrownDmg     uint8
19069                                 Floodable    bool
19070
19071                                 DrawBox, ColBox, SelBox NodeBox
19072
19073                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19074
19075                                 LegacyFaceDir bool
19076                                 LegacyMounted bool
19077
19078                                 DigPredict string
19079
19080                                 MaxLvl uint8
19081
19082                                 AlphaUse
19083                         }))(obj)).DugSnd).serialize(w)
19084                 }); err != nil {
19085                         if err == io.EOF {
19086                                 chk(io.EOF)
19087                         }
19088                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
19089                 }
19090                 {
19091                         x := (*(*(struct {
19092                                 Param0 Content
19093
19094                                 Name   string
19095                                 Groups []Group
19096
19097                                 P1Type   Param1Type
19098                                 P2Type   Param2Type
19099                                 DrawType DrawType
19100
19101                                 Mesh  string
19102                                 Scale float32
19103                                 //mt:const uint8(6)
19104                                 Tiles        [6]TileDef
19105                                 OverlayTiles [6]TileDef
19106                                 //mt:const uint8(6)
19107                                 SpecialTiles [6]TileDef
19108
19109                                 Color   color.NRGBA
19110                                 Palette Texture
19111
19112                                 Waving       WaveType
19113                                 ConnectSides uint8
19114                                 ConnectTo    []Content
19115                                 InsideTint   color.NRGBA
19116                                 Level        uint8 // Must be < 128.
19117
19118                                 Translucent bool // Sunlight is scattered and becomes normal light.
19119                                 Transparent bool // Sunlight isn't scattered.
19120                                 LightSrc    uint8
19121
19122                                 GndContent   bool
19123                                 Collides     bool
19124                                 Pointable    bool
19125                                 Diggable     bool
19126                                 Climbable    bool
19127                                 Replaceable  bool
19128                                 OnRightClick bool
19129
19130                                 DmgPerSec int32
19131
19132                                 LiquidType   LiquidType
19133                                 FlowingAlt   string
19134                                 SrcAlt       string
19135                                 Viscosity    uint8 // 0-7
19136                                 LiqRenewable bool
19137                                 FlowRange    uint8
19138                                 DrownDmg     uint8
19139                                 Floodable    bool
19140
19141                                 DrawBox, ColBox, SelBox NodeBox
19142
19143                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19144
19145                                 LegacyFaceDir bool
19146                                 LegacyMounted bool
19147
19148                                 DigPredict string
19149
19150                                 MaxLvl uint8
19151
19152                                 AlphaUse
19153                         }))(obj)).LegacyFaceDir
19154                         if x {
19155                                 write8(w, 1)
19156                         } else {
19157                                 write8(w, 0)
19158                         }
19159                 }
19160                 {
19161                         x := (*(*(struct {
19162                                 Param0 Content
19163
19164                                 Name   string
19165                                 Groups []Group
19166
19167                                 P1Type   Param1Type
19168                                 P2Type   Param2Type
19169                                 DrawType DrawType
19170
19171                                 Mesh  string
19172                                 Scale float32
19173                                 //mt:const uint8(6)
19174                                 Tiles        [6]TileDef
19175                                 OverlayTiles [6]TileDef
19176                                 //mt:const uint8(6)
19177                                 SpecialTiles [6]TileDef
19178
19179                                 Color   color.NRGBA
19180                                 Palette Texture
19181
19182                                 Waving       WaveType
19183                                 ConnectSides uint8
19184                                 ConnectTo    []Content
19185                                 InsideTint   color.NRGBA
19186                                 Level        uint8 // Must be < 128.
19187
19188                                 Translucent bool // Sunlight is scattered and becomes normal light.
19189                                 Transparent bool // Sunlight isn't scattered.
19190                                 LightSrc    uint8
19191
19192                                 GndContent   bool
19193                                 Collides     bool
19194                                 Pointable    bool
19195                                 Diggable     bool
19196                                 Climbable    bool
19197                                 Replaceable  bool
19198                                 OnRightClick bool
19199
19200                                 DmgPerSec int32
19201
19202                                 LiquidType   LiquidType
19203                                 FlowingAlt   string
19204                                 SrcAlt       string
19205                                 Viscosity    uint8 // 0-7
19206                                 LiqRenewable bool
19207                                 FlowRange    uint8
19208                                 DrownDmg     uint8
19209                                 Floodable    bool
19210
19211                                 DrawBox, ColBox, SelBox NodeBox
19212
19213                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19214
19215                                 LegacyFaceDir bool
19216                                 LegacyMounted bool
19217
19218                                 DigPredict string
19219
19220                                 MaxLvl uint8
19221
19222                                 AlphaUse
19223                         }))(obj)).LegacyMounted
19224                         if x {
19225                                 write8(w, 1)
19226                         } else {
19227                                 write8(w, 0)
19228                         }
19229                 }
19230                 if len(([]byte((*(*(struct {
19231                         Param0 Content
19232
19233                         Name   string
19234                         Groups []Group
19235
19236                         P1Type   Param1Type
19237                         P2Type   Param2Type
19238                         DrawType DrawType
19239
19240                         Mesh  string
19241                         Scale float32
19242                         //mt:const uint8(6)
19243                         Tiles        [6]TileDef
19244                         OverlayTiles [6]TileDef
19245                         //mt:const uint8(6)
19246                         SpecialTiles [6]TileDef
19247
19248                         Color   color.NRGBA
19249                         Palette Texture
19250
19251                         Waving       WaveType
19252                         ConnectSides uint8
19253                         ConnectTo    []Content
19254                         InsideTint   color.NRGBA
19255                         Level        uint8 // Must be < 128.
19256
19257                         Translucent bool // Sunlight is scattered and becomes normal light.
19258                         Transparent bool // Sunlight isn't scattered.
19259                         LightSrc    uint8
19260
19261                         GndContent   bool
19262                         Collides     bool
19263                         Pointable    bool
19264                         Diggable     bool
19265                         Climbable    bool
19266                         Replaceable  bool
19267                         OnRightClick bool
19268
19269                         DmgPerSec int32
19270
19271                         LiquidType   LiquidType
19272                         FlowingAlt   string
19273                         SrcAlt       string
19274                         Viscosity    uint8 // 0-7
19275                         LiqRenewable bool
19276                         FlowRange    uint8
19277                         DrownDmg     uint8
19278                         Floodable    bool
19279
19280                         DrawBox, ColBox, SelBox NodeBox
19281
19282                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19283
19284                         LegacyFaceDir bool
19285                         LegacyMounted bool
19286
19287                         DigPredict string
19288
19289                         MaxLvl uint8
19290
19291                         AlphaUse
19292                 }))(obj)).DigPredict))) > math.MaxUint16 {
19293                         chk(ErrTooLong)
19294                 }
19295                 {
19296                         x := uint16(len(([]byte((*(*(struct {
19297                                 Param0 Content
19298
19299                                 Name   string
19300                                 Groups []Group
19301
19302                                 P1Type   Param1Type
19303                                 P2Type   Param2Type
19304                                 DrawType DrawType
19305
19306                                 Mesh  string
19307                                 Scale float32
19308                                 //mt:const uint8(6)
19309                                 Tiles        [6]TileDef
19310                                 OverlayTiles [6]TileDef
19311                                 //mt:const uint8(6)
19312                                 SpecialTiles [6]TileDef
19313
19314                                 Color   color.NRGBA
19315                                 Palette Texture
19316
19317                                 Waving       WaveType
19318                                 ConnectSides uint8
19319                                 ConnectTo    []Content
19320                                 InsideTint   color.NRGBA
19321                                 Level        uint8 // Must be < 128.
19322
19323                                 Translucent bool // Sunlight is scattered and becomes normal light.
19324                                 Transparent bool // Sunlight isn't scattered.
19325                                 LightSrc    uint8
19326
19327                                 GndContent   bool
19328                                 Collides     bool
19329                                 Pointable    bool
19330                                 Diggable     bool
19331                                 Climbable    bool
19332                                 Replaceable  bool
19333                                 OnRightClick bool
19334
19335                                 DmgPerSec int32
19336
19337                                 LiquidType   LiquidType
19338                                 FlowingAlt   string
19339                                 SrcAlt       string
19340                                 Viscosity    uint8 // 0-7
19341                                 LiqRenewable bool
19342                                 FlowRange    uint8
19343                                 DrownDmg     uint8
19344                                 Floodable    bool
19345
19346                                 DrawBox, ColBox, SelBox NodeBox
19347
19348                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19349
19350                                 LegacyFaceDir bool
19351                                 LegacyMounted bool
19352
19353                                 DigPredict string
19354
19355                                 MaxLvl uint8
19356
19357                                 AlphaUse
19358                         }))(obj)).DigPredict))))
19359                         write16(w, uint16(x))
19360                 }
19361                 {
19362                         _, err := w.Write(([]byte((*(*(struct {
19363                                 Param0 Content
19364
19365                                 Name   string
19366                                 Groups []Group
19367
19368                                 P1Type   Param1Type
19369                                 P2Type   Param2Type
19370                                 DrawType DrawType
19371
19372                                 Mesh  string
19373                                 Scale float32
19374                                 //mt:const uint8(6)
19375                                 Tiles        [6]TileDef
19376                                 OverlayTiles [6]TileDef
19377                                 //mt:const uint8(6)
19378                                 SpecialTiles [6]TileDef
19379
19380                                 Color   color.NRGBA
19381                                 Palette Texture
19382
19383                                 Waving       WaveType
19384                                 ConnectSides uint8
19385                                 ConnectTo    []Content
19386                                 InsideTint   color.NRGBA
19387                                 Level        uint8 // Must be < 128.
19388
19389                                 Translucent bool // Sunlight is scattered and becomes normal light.
19390                                 Transparent bool // Sunlight isn't scattered.
19391                                 LightSrc    uint8
19392
19393                                 GndContent   bool
19394                                 Collides     bool
19395                                 Pointable    bool
19396                                 Diggable     bool
19397                                 Climbable    bool
19398                                 Replaceable  bool
19399                                 OnRightClick bool
19400
19401                                 DmgPerSec int32
19402
19403                                 LiquidType   LiquidType
19404                                 FlowingAlt   string
19405                                 SrcAlt       string
19406                                 Viscosity    uint8 // 0-7
19407                                 LiqRenewable bool
19408                                 FlowRange    uint8
19409                                 DrownDmg     uint8
19410                                 Floodable    bool
19411
19412                                 DrawBox, ColBox, SelBox NodeBox
19413
19414                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19415
19416                                 LegacyFaceDir bool
19417                                 LegacyMounted bool
19418
19419                                 DigPredict string
19420
19421                                 MaxLvl uint8
19422
19423                                 AlphaUse
19424                         }))(obj)).DigPredict))[:])
19425                         chk(err)
19426                 }
19427                 {
19428                         x := (*(*(struct {
19429                                 Param0 Content
19430
19431                                 Name   string
19432                                 Groups []Group
19433
19434                                 P1Type   Param1Type
19435                                 P2Type   Param2Type
19436                                 DrawType DrawType
19437
19438                                 Mesh  string
19439                                 Scale float32
19440                                 //mt:const uint8(6)
19441                                 Tiles        [6]TileDef
19442                                 OverlayTiles [6]TileDef
19443                                 //mt:const uint8(6)
19444                                 SpecialTiles [6]TileDef
19445
19446                                 Color   color.NRGBA
19447                                 Palette Texture
19448
19449                                 Waving       WaveType
19450                                 ConnectSides uint8
19451                                 ConnectTo    []Content
19452                                 InsideTint   color.NRGBA
19453                                 Level        uint8 // Must be < 128.
19454
19455                                 Translucent bool // Sunlight is scattered and becomes normal light.
19456                                 Transparent bool // Sunlight isn't scattered.
19457                                 LightSrc    uint8
19458
19459                                 GndContent   bool
19460                                 Collides     bool
19461                                 Pointable    bool
19462                                 Diggable     bool
19463                                 Climbable    bool
19464                                 Replaceable  bool
19465                                 OnRightClick bool
19466
19467                                 DmgPerSec int32
19468
19469                                 LiquidType   LiquidType
19470                                 FlowingAlt   string
19471                                 SrcAlt       string
19472                                 Viscosity    uint8 // 0-7
19473                                 LiqRenewable bool
19474                                 FlowRange    uint8
19475                                 DrownDmg     uint8
19476                                 Floodable    bool
19477
19478                                 DrawBox, ColBox, SelBox NodeBox
19479
19480                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19481
19482                                 LegacyFaceDir bool
19483                                 LegacyMounted bool
19484
19485                                 DigPredict string
19486
19487                                 MaxLvl uint8
19488
19489                                 AlphaUse
19490                         }))(obj)).MaxLvl
19491                         write8(w, uint8(x))
19492                 }
19493                 if err := pcall(func() {
19494                         ((*(*(struct {
19495                                 Param0 Content
19496
19497                                 Name   string
19498                                 Groups []Group
19499
19500                                 P1Type   Param1Type
19501                                 P2Type   Param2Type
19502                                 DrawType DrawType
19503
19504                                 Mesh  string
19505                                 Scale float32
19506                                 //mt:const uint8(6)
19507                                 Tiles        [6]TileDef
19508                                 OverlayTiles [6]TileDef
19509                                 //mt:const uint8(6)
19510                                 SpecialTiles [6]TileDef
19511
19512                                 Color   color.NRGBA
19513                                 Palette Texture
19514
19515                                 Waving       WaveType
19516                                 ConnectSides uint8
19517                                 ConnectTo    []Content
19518                                 InsideTint   color.NRGBA
19519                                 Level        uint8 // Must be < 128.
19520
19521                                 Translucent bool // Sunlight is scattered and becomes normal light.
19522                                 Transparent bool // Sunlight isn't scattered.
19523                                 LightSrc    uint8
19524
19525                                 GndContent   bool
19526                                 Collides     bool
19527                                 Pointable    bool
19528                                 Diggable     bool
19529                                 Climbable    bool
19530                                 Replaceable  bool
19531                                 OnRightClick bool
19532
19533                                 DmgPerSec int32
19534
19535                                 LiquidType   LiquidType
19536                                 FlowingAlt   string
19537                                 SrcAlt       string
19538                                 Viscosity    uint8 // 0-7
19539                                 LiqRenewable bool
19540                                 FlowRange    uint8
19541                                 DrownDmg     uint8
19542                                 Floodable    bool
19543
19544                                 DrawBox, ColBox, SelBox NodeBox
19545
19546                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19547
19548                                 LegacyFaceDir bool
19549                                 LegacyMounted bool
19550
19551                                 DigPredict string
19552
19553                                 MaxLvl uint8
19554
19555                                 AlphaUse
19556                         }))(obj)).AlphaUse).serialize(w)
19557                 }); err != nil {
19558                         if err == io.EOF {
19559                                 chk(io.EOF)
19560                         }
19561                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlphaUse", err))
19562                 }
19563                 {
19564                         buf := w
19565                         w := ow
19566                         if len((buf.Bytes())) > math.MaxUint16 {
19567                                 chk(ErrTooLong)
19568                         }
19569                         {
19570                                 x := uint16(len((buf.Bytes())))
19571                                 write16(w, uint16(x))
19572                         }
19573                         {
19574                                 _, err := w.Write((buf.Bytes())[:])
19575                                 chk(err)
19576                         }
19577                 }
19578         }
19579 }
19580
19581 func (obj *NodeDef) deserialize(r io.Reader) {
19582         if err := pcall(func() {
19583                 ((*(*(struct {
19584                         Param0 Content
19585
19586                         Name   string
19587                         Groups []Group
19588
19589                         P1Type   Param1Type
19590                         P2Type   Param2Type
19591                         DrawType DrawType
19592
19593                         Mesh  string
19594                         Scale float32
19595                         //mt:const uint8(6)
19596                         Tiles        [6]TileDef
19597                         OverlayTiles [6]TileDef
19598                         //mt:const uint8(6)
19599                         SpecialTiles [6]TileDef
19600
19601                         Color   color.NRGBA
19602                         Palette Texture
19603
19604                         Waving       WaveType
19605                         ConnectSides uint8
19606                         ConnectTo    []Content
19607                         InsideTint   color.NRGBA
19608                         Level        uint8 // Must be < 128.
19609
19610                         Translucent bool // Sunlight is scattered and becomes normal light.
19611                         Transparent bool // Sunlight isn't scattered.
19612                         LightSrc    uint8
19613
19614                         GndContent   bool
19615                         Collides     bool
19616                         Pointable    bool
19617                         Diggable     bool
19618                         Climbable    bool
19619                         Replaceable  bool
19620                         OnRightClick bool
19621
19622                         DmgPerSec int32
19623
19624                         LiquidType   LiquidType
19625                         FlowingAlt   string
19626                         SrcAlt       string
19627                         Viscosity    uint8 // 0-7
19628                         LiqRenewable bool
19629                         FlowRange    uint8
19630                         DrownDmg     uint8
19631                         Floodable    bool
19632
19633                         DrawBox, ColBox, SelBox NodeBox
19634
19635                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19636
19637                         LegacyFaceDir bool
19638                         LegacyMounted bool
19639
19640                         DigPredict string
19641
19642                         MaxLvl uint8
19643
19644                         AlphaUse
19645                 }))(obj)).Param0).deserialize(r)
19646         }); err != nil {
19647                 if err == io.EOF {
19648                         chk(io.EOF)
19649                 }
19650                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
19651         }
19652         {
19653                 var n uint16
19654                 {
19655                         p := &n
19656                         *p = read16(r)
19657                 }
19658                 r := &io.LimitedReader{r, int64(n)}
19659                 {
19660                         var local256 uint8
19661                         {
19662                                 p := &local256
19663                                 *p = read8(r)
19664                         }
19665                         if local256 != (13) {
19666                                 chk(fmt.Errorf("const %v: %v", 13, local256))
19667                         }
19668                 }
19669                 var local257 []uint8
19670                 var local258 uint16
19671                 {
19672                         p := &local258
19673                         *p = read16(r)
19674                 }
19675                 (local257) = make([]uint8, local258)
19676                 {
19677                         _, err := io.ReadFull(r, (local257)[:])
19678                         chk(err)
19679                 }
19680                 ((*(*(struct {
19681                         Param0 Content
19682
19683                         Name   string
19684                         Groups []Group
19685
19686                         P1Type   Param1Type
19687                         P2Type   Param2Type
19688                         DrawType DrawType
19689
19690                         Mesh  string
19691                         Scale float32
19692                         //mt:const uint8(6)
19693                         Tiles        [6]TileDef
19694                         OverlayTiles [6]TileDef
19695                         //mt:const uint8(6)
19696                         SpecialTiles [6]TileDef
19697
19698                         Color   color.NRGBA
19699                         Palette Texture
19700
19701                         Waving       WaveType
19702                         ConnectSides uint8
19703                         ConnectTo    []Content
19704                         InsideTint   color.NRGBA
19705                         Level        uint8 // Must be < 128.
19706
19707                         Translucent bool // Sunlight is scattered and becomes normal light.
19708                         Transparent bool // Sunlight isn't scattered.
19709                         LightSrc    uint8
19710
19711                         GndContent   bool
19712                         Collides     bool
19713                         Pointable    bool
19714                         Diggable     bool
19715                         Climbable    bool
19716                         Replaceable  bool
19717                         OnRightClick bool
19718
19719                         DmgPerSec int32
19720
19721                         LiquidType   LiquidType
19722                         FlowingAlt   string
19723                         SrcAlt       string
19724                         Viscosity    uint8 // 0-7
19725                         LiqRenewable bool
19726                         FlowRange    uint8
19727                         DrownDmg     uint8
19728                         Floodable    bool
19729
19730                         DrawBox, ColBox, SelBox NodeBox
19731
19732                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19733
19734                         LegacyFaceDir bool
19735                         LegacyMounted bool
19736
19737                         DigPredict string
19738
19739                         MaxLvl uint8
19740
19741                         AlphaUse
19742                 }))(obj)).Name) = string(local257)
19743                 var local259 uint16
19744                 {
19745                         p := &local259
19746                         *p = read16(r)
19747                 }
19748                 ((*(*(struct {
19749                         Param0 Content
19750
19751                         Name   string
19752                         Groups []Group
19753
19754                         P1Type   Param1Type
19755                         P2Type   Param2Type
19756                         DrawType DrawType
19757
19758                         Mesh  string
19759                         Scale float32
19760                         //mt:const uint8(6)
19761                         Tiles        [6]TileDef
19762                         OverlayTiles [6]TileDef
19763                         //mt:const uint8(6)
19764                         SpecialTiles [6]TileDef
19765
19766                         Color   color.NRGBA
19767                         Palette Texture
19768
19769                         Waving       WaveType
19770                         ConnectSides uint8
19771                         ConnectTo    []Content
19772                         InsideTint   color.NRGBA
19773                         Level        uint8 // Must be < 128.
19774
19775                         Translucent bool // Sunlight is scattered and becomes normal light.
19776                         Transparent bool // Sunlight isn't scattered.
19777                         LightSrc    uint8
19778
19779                         GndContent   bool
19780                         Collides     bool
19781                         Pointable    bool
19782                         Diggable     bool
19783                         Climbable    bool
19784                         Replaceable  bool
19785                         OnRightClick bool
19786
19787                         DmgPerSec int32
19788
19789                         LiquidType   LiquidType
19790                         FlowingAlt   string
19791                         SrcAlt       string
19792                         Viscosity    uint8 // 0-7
19793                         LiqRenewable bool
19794                         FlowRange    uint8
19795                         DrownDmg     uint8
19796                         Floodable    bool
19797
19798                         DrawBox, ColBox, SelBox NodeBox
19799
19800                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19801
19802                         LegacyFaceDir bool
19803                         LegacyMounted bool
19804
19805                         DigPredict string
19806
19807                         MaxLvl uint8
19808
19809                         AlphaUse
19810                 }))(obj)).Groups) = make([]Group, local259)
19811                 for local260 := range (*(*(struct {
19812                         Param0 Content
19813
19814                         Name   string
19815                         Groups []Group
19816
19817                         P1Type   Param1Type
19818                         P2Type   Param2Type
19819                         DrawType DrawType
19820
19821                         Mesh  string
19822                         Scale float32
19823                         //mt:const uint8(6)
19824                         Tiles        [6]TileDef
19825                         OverlayTiles [6]TileDef
19826                         //mt:const uint8(6)
19827                         SpecialTiles [6]TileDef
19828
19829                         Color   color.NRGBA
19830                         Palette Texture
19831
19832                         Waving       WaveType
19833                         ConnectSides uint8
19834                         ConnectTo    []Content
19835                         InsideTint   color.NRGBA
19836                         Level        uint8 // Must be < 128.
19837
19838                         Translucent bool // Sunlight is scattered and becomes normal light.
19839                         Transparent bool // Sunlight isn't scattered.
19840                         LightSrc    uint8
19841
19842                         GndContent   bool
19843                         Collides     bool
19844                         Pointable    bool
19845                         Diggable     bool
19846                         Climbable    bool
19847                         Replaceable  bool
19848                         OnRightClick bool
19849
19850                         DmgPerSec int32
19851
19852                         LiquidType   LiquidType
19853                         FlowingAlt   string
19854                         SrcAlt       string
19855                         Viscosity    uint8 // 0-7
19856                         LiqRenewable bool
19857                         FlowRange    uint8
19858                         DrownDmg     uint8
19859                         Floodable    bool
19860
19861                         DrawBox, ColBox, SelBox NodeBox
19862
19863                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19864
19865                         LegacyFaceDir bool
19866                         LegacyMounted bool
19867
19868                         DigPredict string
19869
19870                         MaxLvl uint8
19871
19872                         AlphaUse
19873                 }))(obj)).Groups {
19874                         if err := pcall(func() {
19875                                 (((*(*(struct {
19876                                         Param0 Content
19877
19878                                         Name   string
19879                                         Groups []Group
19880
19881                                         P1Type   Param1Type
19882                                         P2Type   Param2Type
19883                                         DrawType DrawType
19884
19885                                         Mesh  string
19886                                         Scale float32
19887                                         //mt:const uint8(6)
19888                                         Tiles        [6]TileDef
19889                                         OverlayTiles [6]TileDef
19890                                         //mt:const uint8(6)
19891                                         SpecialTiles [6]TileDef
19892
19893                                         Color   color.NRGBA
19894                                         Palette Texture
19895
19896                                         Waving       WaveType
19897                                         ConnectSides uint8
19898                                         ConnectTo    []Content
19899                                         InsideTint   color.NRGBA
19900                                         Level        uint8 // Must be < 128.
19901
19902                                         Translucent bool // Sunlight is scattered and becomes normal light.
19903                                         Transparent bool // Sunlight isn't scattered.
19904                                         LightSrc    uint8
19905
19906                                         GndContent   bool
19907                                         Collides     bool
19908                                         Pointable    bool
19909                                         Diggable     bool
19910                                         Climbable    bool
19911                                         Replaceable  bool
19912                                         OnRightClick bool
19913
19914                                         DmgPerSec int32
19915
19916                                         LiquidType   LiquidType
19917                                         FlowingAlt   string
19918                                         SrcAlt       string
19919                                         Viscosity    uint8 // 0-7
19920                                         LiqRenewable bool
19921                                         FlowRange    uint8
19922                                         DrownDmg     uint8
19923                                         Floodable    bool
19924
19925                                         DrawBox, ColBox, SelBox NodeBox
19926
19927                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19928
19929                                         LegacyFaceDir bool
19930                                         LegacyMounted bool
19931
19932                                         DigPredict string
19933
19934                                         MaxLvl uint8
19935
19936                                         AlphaUse
19937                                 }))(obj)).Groups)[local260]).deserialize(r)
19938                         }); err != nil {
19939                                 if err == io.EOF {
19940                                         chk(io.EOF)
19941                                 }
19942                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
19943                         }
19944                 }
19945                 if err := pcall(func() {
19946                         ((*(*(struct {
19947                                 Param0 Content
19948
19949                                 Name   string
19950                                 Groups []Group
19951
19952                                 P1Type   Param1Type
19953                                 P2Type   Param2Type
19954                                 DrawType DrawType
19955
19956                                 Mesh  string
19957                                 Scale float32
19958                                 //mt:const uint8(6)
19959                                 Tiles        [6]TileDef
19960                                 OverlayTiles [6]TileDef
19961                                 //mt:const uint8(6)
19962                                 SpecialTiles [6]TileDef
19963
19964                                 Color   color.NRGBA
19965                                 Palette Texture
19966
19967                                 Waving       WaveType
19968                                 ConnectSides uint8
19969                                 ConnectTo    []Content
19970                                 InsideTint   color.NRGBA
19971                                 Level        uint8 // Must be < 128.
19972
19973                                 Translucent bool // Sunlight is scattered and becomes normal light.
19974                                 Transparent bool // Sunlight isn't scattered.
19975                                 LightSrc    uint8
19976
19977                                 GndContent   bool
19978                                 Collides     bool
19979                                 Pointable    bool
19980                                 Diggable     bool
19981                                 Climbable    bool
19982                                 Replaceable  bool
19983                                 OnRightClick bool
19984
19985                                 DmgPerSec int32
19986
19987                                 LiquidType   LiquidType
19988                                 FlowingAlt   string
19989                                 SrcAlt       string
19990                                 Viscosity    uint8 // 0-7
19991                                 LiqRenewable bool
19992                                 FlowRange    uint8
19993                                 DrownDmg     uint8
19994                                 Floodable    bool
19995
19996                                 DrawBox, ColBox, SelBox NodeBox
19997
19998                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19999
20000                                 LegacyFaceDir bool
20001                                 LegacyMounted bool
20002
20003                                 DigPredict string
20004
20005                                 MaxLvl uint8
20006
20007                                 AlphaUse
20008                         }))(obj)).P1Type).deserialize(r)
20009                 }); err != nil {
20010                         if err == io.EOF {
20011                                 chk(io.EOF)
20012                         }
20013                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param1Type", err))
20014                 }
20015                 if err := pcall(func() {
20016                         ((*(*(struct {
20017                                 Param0 Content
20018
20019                                 Name   string
20020                                 Groups []Group
20021
20022                                 P1Type   Param1Type
20023                                 P2Type   Param2Type
20024                                 DrawType DrawType
20025
20026                                 Mesh  string
20027                                 Scale float32
20028                                 //mt:const uint8(6)
20029                                 Tiles        [6]TileDef
20030                                 OverlayTiles [6]TileDef
20031                                 //mt:const uint8(6)
20032                                 SpecialTiles [6]TileDef
20033
20034                                 Color   color.NRGBA
20035                                 Palette Texture
20036
20037                                 Waving       WaveType
20038                                 ConnectSides uint8
20039                                 ConnectTo    []Content
20040                                 InsideTint   color.NRGBA
20041                                 Level        uint8 // Must be < 128.
20042
20043                                 Translucent bool // Sunlight is scattered and becomes normal light.
20044                                 Transparent bool // Sunlight isn't scattered.
20045                                 LightSrc    uint8
20046
20047                                 GndContent   bool
20048                                 Collides     bool
20049                                 Pointable    bool
20050                                 Diggable     bool
20051                                 Climbable    bool
20052                                 Replaceable  bool
20053                                 OnRightClick bool
20054
20055                                 DmgPerSec int32
20056
20057                                 LiquidType   LiquidType
20058                                 FlowingAlt   string
20059                                 SrcAlt       string
20060                                 Viscosity    uint8 // 0-7
20061                                 LiqRenewable bool
20062                                 FlowRange    uint8
20063                                 DrownDmg     uint8
20064                                 Floodable    bool
20065
20066                                 DrawBox, ColBox, SelBox NodeBox
20067
20068                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20069
20070                                 LegacyFaceDir bool
20071                                 LegacyMounted bool
20072
20073                                 DigPredict string
20074
20075                                 MaxLvl uint8
20076
20077                                 AlphaUse
20078                         }))(obj)).P2Type).deserialize(r)
20079                 }); err != nil {
20080                         if err == io.EOF {
20081                                 chk(io.EOF)
20082                         }
20083                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param2Type", err))
20084                 }
20085                 if err := pcall(func() {
20086                         ((*(*(struct {
20087                                 Param0 Content
20088
20089                                 Name   string
20090                                 Groups []Group
20091
20092                                 P1Type   Param1Type
20093                                 P2Type   Param2Type
20094                                 DrawType DrawType
20095
20096                                 Mesh  string
20097                                 Scale float32
20098                                 //mt:const uint8(6)
20099                                 Tiles        [6]TileDef
20100                                 OverlayTiles [6]TileDef
20101                                 //mt:const uint8(6)
20102                                 SpecialTiles [6]TileDef
20103
20104                                 Color   color.NRGBA
20105                                 Palette Texture
20106
20107                                 Waving       WaveType
20108                                 ConnectSides uint8
20109                                 ConnectTo    []Content
20110                                 InsideTint   color.NRGBA
20111                                 Level        uint8 // Must be < 128.
20112
20113                                 Translucent bool // Sunlight is scattered and becomes normal light.
20114                                 Transparent bool // Sunlight isn't scattered.
20115                                 LightSrc    uint8
20116
20117                                 GndContent   bool
20118                                 Collides     bool
20119                                 Pointable    bool
20120                                 Diggable     bool
20121                                 Climbable    bool
20122                                 Replaceable  bool
20123                                 OnRightClick bool
20124
20125                                 DmgPerSec int32
20126
20127                                 LiquidType   LiquidType
20128                                 FlowingAlt   string
20129                                 SrcAlt       string
20130                                 Viscosity    uint8 // 0-7
20131                                 LiqRenewable bool
20132                                 FlowRange    uint8
20133                                 DrownDmg     uint8
20134                                 Floodable    bool
20135
20136                                 DrawBox, ColBox, SelBox NodeBox
20137
20138                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20139
20140                                 LegacyFaceDir bool
20141                                 LegacyMounted bool
20142
20143                                 DigPredict string
20144
20145                                 MaxLvl uint8
20146
20147                                 AlphaUse
20148                         }))(obj)).DrawType).deserialize(r)
20149                 }); err != nil {
20150                         if err == io.EOF {
20151                                 chk(io.EOF)
20152                         }
20153                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
20154                 }
20155                 var local261 []uint8
20156                 var local262 uint16
20157                 {
20158                         p := &local262
20159                         *p = read16(r)
20160                 }
20161                 (local261) = make([]uint8, local262)
20162                 {
20163                         _, err := io.ReadFull(r, (local261)[:])
20164                         chk(err)
20165                 }
20166                 ((*(*(struct {
20167                         Param0 Content
20168
20169                         Name   string
20170                         Groups []Group
20171
20172                         P1Type   Param1Type
20173                         P2Type   Param2Type
20174                         DrawType DrawType
20175
20176                         Mesh  string
20177                         Scale float32
20178                         //mt:const uint8(6)
20179                         Tiles        [6]TileDef
20180                         OverlayTiles [6]TileDef
20181                         //mt:const uint8(6)
20182                         SpecialTiles [6]TileDef
20183
20184                         Color   color.NRGBA
20185                         Palette Texture
20186
20187                         Waving       WaveType
20188                         ConnectSides uint8
20189                         ConnectTo    []Content
20190                         InsideTint   color.NRGBA
20191                         Level        uint8 // Must be < 128.
20192
20193                         Translucent bool // Sunlight is scattered and becomes normal light.
20194                         Transparent bool // Sunlight isn't scattered.
20195                         LightSrc    uint8
20196
20197                         GndContent   bool
20198                         Collides     bool
20199                         Pointable    bool
20200                         Diggable     bool
20201                         Climbable    bool
20202                         Replaceable  bool
20203                         OnRightClick bool
20204
20205                         DmgPerSec int32
20206
20207                         LiquidType   LiquidType
20208                         FlowingAlt   string
20209                         SrcAlt       string
20210                         Viscosity    uint8 // 0-7
20211                         LiqRenewable bool
20212                         FlowRange    uint8
20213                         DrownDmg     uint8
20214                         Floodable    bool
20215
20216                         DrawBox, ColBox, SelBox NodeBox
20217
20218                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20219
20220                         LegacyFaceDir bool
20221                         LegacyMounted bool
20222
20223                         DigPredict string
20224
20225                         MaxLvl uint8
20226
20227                         AlphaUse
20228                 }))(obj)).Mesh) = string(local261)
20229                 {
20230                         p := &(*(*(struct {
20231                                 Param0 Content
20232
20233                                 Name   string
20234                                 Groups []Group
20235
20236                                 P1Type   Param1Type
20237                                 P2Type   Param2Type
20238                                 DrawType DrawType
20239
20240                                 Mesh  string
20241                                 Scale float32
20242                                 //mt:const uint8(6)
20243                                 Tiles        [6]TileDef
20244                                 OverlayTiles [6]TileDef
20245                                 //mt:const uint8(6)
20246                                 SpecialTiles [6]TileDef
20247
20248                                 Color   color.NRGBA
20249                                 Palette Texture
20250
20251                                 Waving       WaveType
20252                                 ConnectSides uint8
20253                                 ConnectTo    []Content
20254                                 InsideTint   color.NRGBA
20255                                 Level        uint8 // Must be < 128.
20256
20257                                 Translucent bool // Sunlight is scattered and becomes normal light.
20258                                 Transparent bool // Sunlight isn't scattered.
20259                                 LightSrc    uint8
20260
20261                                 GndContent   bool
20262                                 Collides     bool
20263                                 Pointable    bool
20264                                 Diggable     bool
20265                                 Climbable    bool
20266                                 Replaceable  bool
20267                                 OnRightClick bool
20268
20269                                 DmgPerSec int32
20270
20271                                 LiquidType   LiquidType
20272                                 FlowingAlt   string
20273                                 SrcAlt       string
20274                                 Viscosity    uint8 // 0-7
20275                                 LiqRenewable bool
20276                                 FlowRange    uint8
20277                                 DrownDmg     uint8
20278                                 Floodable    bool
20279
20280                                 DrawBox, ColBox, SelBox NodeBox
20281
20282                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20283
20284                                 LegacyFaceDir bool
20285                                 LegacyMounted bool
20286
20287                                 DigPredict string
20288
20289                                 MaxLvl uint8
20290
20291                                 AlphaUse
20292                         }))(obj)).Scale
20293                         *p = math.Float32frombits(read32(r))
20294                 }
20295                 {
20296                         var local263 uint8
20297                         {
20298                                 p := &local263
20299                                 *p = read8(r)
20300                         }
20301                         if local263 != (6) {
20302                                 chk(fmt.Errorf("const %v: %v", 6, local263))
20303                         }
20304                 }
20305                 for local264 := range (*(*(struct {
20306                         Param0 Content
20307
20308                         Name   string
20309                         Groups []Group
20310
20311                         P1Type   Param1Type
20312                         P2Type   Param2Type
20313                         DrawType DrawType
20314
20315                         Mesh  string
20316                         Scale float32
20317                         //mt:const uint8(6)
20318                         Tiles        [6]TileDef
20319                         OverlayTiles [6]TileDef
20320                         //mt:const uint8(6)
20321                         SpecialTiles [6]TileDef
20322
20323                         Color   color.NRGBA
20324                         Palette Texture
20325
20326                         Waving       WaveType
20327                         ConnectSides uint8
20328                         ConnectTo    []Content
20329                         InsideTint   color.NRGBA
20330                         Level        uint8 // Must be < 128.
20331
20332                         Translucent bool // Sunlight is scattered and becomes normal light.
20333                         Transparent bool // Sunlight isn't scattered.
20334                         LightSrc    uint8
20335
20336                         GndContent   bool
20337                         Collides     bool
20338                         Pointable    bool
20339                         Diggable     bool
20340                         Climbable    bool
20341                         Replaceable  bool
20342                         OnRightClick bool
20343
20344                         DmgPerSec int32
20345
20346                         LiquidType   LiquidType
20347                         FlowingAlt   string
20348                         SrcAlt       string
20349                         Viscosity    uint8 // 0-7
20350                         LiqRenewable bool
20351                         FlowRange    uint8
20352                         DrownDmg     uint8
20353                         Floodable    bool
20354
20355                         DrawBox, ColBox, SelBox NodeBox
20356
20357                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20358
20359                         LegacyFaceDir bool
20360                         LegacyMounted bool
20361
20362                         DigPredict string
20363
20364                         MaxLvl uint8
20365
20366                         AlphaUse
20367                 }))(obj)).Tiles {
20368                         if err := pcall(func() {
20369                                 (((*(*(struct {
20370                                         Param0 Content
20371
20372                                         Name   string
20373                                         Groups []Group
20374
20375                                         P1Type   Param1Type
20376                                         P2Type   Param2Type
20377                                         DrawType DrawType
20378
20379                                         Mesh  string
20380                                         Scale float32
20381                                         //mt:const uint8(6)
20382                                         Tiles        [6]TileDef
20383                                         OverlayTiles [6]TileDef
20384                                         //mt:const uint8(6)
20385                                         SpecialTiles [6]TileDef
20386
20387                                         Color   color.NRGBA
20388                                         Palette Texture
20389
20390                                         Waving       WaveType
20391                                         ConnectSides uint8
20392                                         ConnectTo    []Content
20393                                         InsideTint   color.NRGBA
20394                                         Level        uint8 // Must be < 128.
20395
20396                                         Translucent bool // Sunlight is scattered and becomes normal light.
20397                                         Transparent bool // Sunlight isn't scattered.
20398                                         LightSrc    uint8
20399
20400                                         GndContent   bool
20401                                         Collides     bool
20402                                         Pointable    bool
20403                                         Diggable     bool
20404                                         Climbable    bool
20405                                         Replaceable  bool
20406                                         OnRightClick bool
20407
20408                                         DmgPerSec int32
20409
20410                                         LiquidType   LiquidType
20411                                         FlowingAlt   string
20412                                         SrcAlt       string
20413                                         Viscosity    uint8 // 0-7
20414                                         LiqRenewable bool
20415                                         FlowRange    uint8
20416                                         DrownDmg     uint8
20417                                         Floodable    bool
20418
20419                                         DrawBox, ColBox, SelBox NodeBox
20420
20421                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20422
20423                                         LegacyFaceDir bool
20424                                         LegacyMounted bool
20425
20426                                         DigPredict string
20427
20428                                         MaxLvl uint8
20429
20430                                         AlphaUse
20431                                 }))(obj)).Tiles)[local264]).deserialize(r)
20432                         }); err != nil {
20433                                 if err == io.EOF {
20434                                         chk(io.EOF)
20435                                 }
20436                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
20437                         }
20438                 }
20439                 for local265 := range (*(*(struct {
20440                         Param0 Content
20441
20442                         Name   string
20443                         Groups []Group
20444
20445                         P1Type   Param1Type
20446                         P2Type   Param2Type
20447                         DrawType DrawType
20448
20449                         Mesh  string
20450                         Scale float32
20451                         //mt:const uint8(6)
20452                         Tiles        [6]TileDef
20453                         OverlayTiles [6]TileDef
20454                         //mt:const uint8(6)
20455                         SpecialTiles [6]TileDef
20456
20457                         Color   color.NRGBA
20458                         Palette Texture
20459
20460                         Waving       WaveType
20461                         ConnectSides uint8
20462                         ConnectTo    []Content
20463                         InsideTint   color.NRGBA
20464                         Level        uint8 // Must be < 128.
20465
20466                         Translucent bool // Sunlight is scattered and becomes normal light.
20467                         Transparent bool // Sunlight isn't scattered.
20468                         LightSrc    uint8
20469
20470                         GndContent   bool
20471                         Collides     bool
20472                         Pointable    bool
20473                         Diggable     bool
20474                         Climbable    bool
20475                         Replaceable  bool
20476                         OnRightClick bool
20477
20478                         DmgPerSec int32
20479
20480                         LiquidType   LiquidType
20481                         FlowingAlt   string
20482                         SrcAlt       string
20483                         Viscosity    uint8 // 0-7
20484                         LiqRenewable bool
20485                         FlowRange    uint8
20486                         DrownDmg     uint8
20487                         Floodable    bool
20488
20489                         DrawBox, ColBox, SelBox NodeBox
20490
20491                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20492
20493                         LegacyFaceDir bool
20494                         LegacyMounted bool
20495
20496                         DigPredict string
20497
20498                         MaxLvl uint8
20499
20500                         AlphaUse
20501                 }))(obj)).OverlayTiles {
20502                         if err := pcall(func() {
20503                                 (((*(*(struct {
20504                                         Param0 Content
20505
20506                                         Name   string
20507                                         Groups []Group
20508
20509                                         P1Type   Param1Type
20510                                         P2Type   Param2Type
20511                                         DrawType DrawType
20512
20513                                         Mesh  string
20514                                         Scale float32
20515                                         //mt:const uint8(6)
20516                                         Tiles        [6]TileDef
20517                                         OverlayTiles [6]TileDef
20518                                         //mt:const uint8(6)
20519                                         SpecialTiles [6]TileDef
20520
20521                                         Color   color.NRGBA
20522                                         Palette Texture
20523
20524                                         Waving       WaveType
20525                                         ConnectSides uint8
20526                                         ConnectTo    []Content
20527                                         InsideTint   color.NRGBA
20528                                         Level        uint8 // Must be < 128.
20529
20530                                         Translucent bool // Sunlight is scattered and becomes normal light.
20531                                         Transparent bool // Sunlight isn't scattered.
20532                                         LightSrc    uint8
20533
20534                                         GndContent   bool
20535                                         Collides     bool
20536                                         Pointable    bool
20537                                         Diggable     bool
20538                                         Climbable    bool
20539                                         Replaceable  bool
20540                                         OnRightClick bool
20541
20542                                         DmgPerSec int32
20543
20544                                         LiquidType   LiquidType
20545                                         FlowingAlt   string
20546                                         SrcAlt       string
20547                                         Viscosity    uint8 // 0-7
20548                                         LiqRenewable bool
20549                                         FlowRange    uint8
20550                                         DrownDmg     uint8
20551                                         Floodable    bool
20552
20553                                         DrawBox, ColBox, SelBox NodeBox
20554
20555                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20556
20557                                         LegacyFaceDir bool
20558                                         LegacyMounted bool
20559
20560                                         DigPredict string
20561
20562                                         MaxLvl uint8
20563
20564                                         AlphaUse
20565                                 }))(obj)).OverlayTiles)[local265]).deserialize(r)
20566                         }); err != nil {
20567                                 if err == io.EOF {
20568                                         chk(io.EOF)
20569                                 }
20570                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
20571                         }
20572                 }
20573                 {
20574                         var local266 uint8
20575                         {
20576                                 p := &local266
20577                                 *p = read8(r)
20578                         }
20579                         if local266 != (6) {
20580                                 chk(fmt.Errorf("const %v: %v", 6, local266))
20581                         }
20582                 }
20583                 for local267 := range (*(*(struct {
20584                         Param0 Content
20585
20586                         Name   string
20587                         Groups []Group
20588
20589                         P1Type   Param1Type
20590                         P2Type   Param2Type
20591                         DrawType DrawType
20592
20593                         Mesh  string
20594                         Scale float32
20595                         //mt:const uint8(6)
20596                         Tiles        [6]TileDef
20597                         OverlayTiles [6]TileDef
20598                         //mt:const uint8(6)
20599                         SpecialTiles [6]TileDef
20600
20601                         Color   color.NRGBA
20602                         Palette Texture
20603
20604                         Waving       WaveType
20605                         ConnectSides uint8
20606                         ConnectTo    []Content
20607                         InsideTint   color.NRGBA
20608                         Level        uint8 // Must be < 128.
20609
20610                         Translucent bool // Sunlight is scattered and becomes normal light.
20611                         Transparent bool // Sunlight isn't scattered.
20612                         LightSrc    uint8
20613
20614                         GndContent   bool
20615                         Collides     bool
20616                         Pointable    bool
20617                         Diggable     bool
20618                         Climbable    bool
20619                         Replaceable  bool
20620                         OnRightClick bool
20621
20622                         DmgPerSec int32
20623
20624                         LiquidType   LiquidType
20625                         FlowingAlt   string
20626                         SrcAlt       string
20627                         Viscosity    uint8 // 0-7
20628                         LiqRenewable bool
20629                         FlowRange    uint8
20630                         DrownDmg     uint8
20631                         Floodable    bool
20632
20633                         DrawBox, ColBox, SelBox NodeBox
20634
20635                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20636
20637                         LegacyFaceDir bool
20638                         LegacyMounted bool
20639
20640                         DigPredict string
20641
20642                         MaxLvl uint8
20643
20644                         AlphaUse
20645                 }))(obj)).SpecialTiles {
20646                         if err := pcall(func() {
20647                                 (((*(*(struct {
20648                                         Param0 Content
20649
20650                                         Name   string
20651                                         Groups []Group
20652
20653                                         P1Type   Param1Type
20654                                         P2Type   Param2Type
20655                                         DrawType DrawType
20656
20657                                         Mesh  string
20658                                         Scale float32
20659                                         //mt:const uint8(6)
20660                                         Tiles        [6]TileDef
20661                                         OverlayTiles [6]TileDef
20662                                         //mt:const uint8(6)
20663                                         SpecialTiles [6]TileDef
20664
20665                                         Color   color.NRGBA
20666                                         Palette Texture
20667
20668                                         Waving       WaveType
20669                                         ConnectSides uint8
20670                                         ConnectTo    []Content
20671                                         InsideTint   color.NRGBA
20672                                         Level        uint8 // Must be < 128.
20673
20674                                         Translucent bool // Sunlight is scattered and becomes normal light.
20675                                         Transparent bool // Sunlight isn't scattered.
20676                                         LightSrc    uint8
20677
20678                                         GndContent   bool
20679                                         Collides     bool
20680                                         Pointable    bool
20681                                         Diggable     bool
20682                                         Climbable    bool
20683                                         Replaceable  bool
20684                                         OnRightClick bool
20685
20686                                         DmgPerSec int32
20687
20688                                         LiquidType   LiquidType
20689                                         FlowingAlt   string
20690                                         SrcAlt       string
20691                                         Viscosity    uint8 // 0-7
20692                                         LiqRenewable bool
20693                                         FlowRange    uint8
20694                                         DrownDmg     uint8
20695                                         Floodable    bool
20696
20697                                         DrawBox, ColBox, SelBox NodeBox
20698
20699                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20700
20701                                         LegacyFaceDir bool
20702                                         LegacyMounted bool
20703
20704                                         DigPredict string
20705
20706                                         MaxLvl uint8
20707
20708                                         AlphaUse
20709                                 }))(obj)).SpecialTiles)[local267]).deserialize(r)
20710                         }); err != nil {
20711                                 if err == io.EOF {
20712                                         chk(io.EOF)
20713                                 }
20714                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
20715                         }
20716                 }
20717                 {
20718                         p := &(*(*(struct {
20719                                 Param0 Content
20720
20721                                 Name   string
20722                                 Groups []Group
20723
20724                                 P1Type   Param1Type
20725                                 P2Type   Param2Type
20726                                 DrawType DrawType
20727
20728                                 Mesh  string
20729                                 Scale float32
20730                                 //mt:const uint8(6)
20731                                 Tiles        [6]TileDef
20732                                 OverlayTiles [6]TileDef
20733                                 //mt:const uint8(6)
20734                                 SpecialTiles [6]TileDef
20735
20736                                 Color   color.NRGBA
20737                                 Palette Texture
20738
20739                                 Waving       WaveType
20740                                 ConnectSides uint8
20741                                 ConnectTo    []Content
20742                                 InsideTint   color.NRGBA
20743                                 Level        uint8 // Must be < 128.
20744
20745                                 Translucent bool // Sunlight is scattered and becomes normal light.
20746                                 Transparent bool // Sunlight isn't scattered.
20747                                 LightSrc    uint8
20748
20749                                 GndContent   bool
20750                                 Collides     bool
20751                                 Pointable    bool
20752                                 Diggable     bool
20753                                 Climbable    bool
20754                                 Replaceable  bool
20755                                 OnRightClick bool
20756
20757                                 DmgPerSec int32
20758
20759                                 LiquidType   LiquidType
20760                                 FlowingAlt   string
20761                                 SrcAlt       string
20762                                 Viscosity    uint8 // 0-7
20763                                 LiqRenewable bool
20764                                 FlowRange    uint8
20765                                 DrownDmg     uint8
20766                                 Floodable    bool
20767
20768                                 DrawBox, ColBox, SelBox NodeBox
20769
20770                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20771
20772                                 LegacyFaceDir bool
20773                                 LegacyMounted bool
20774
20775                                 DigPredict string
20776
20777                                 MaxLvl uint8
20778
20779                                 AlphaUse
20780                         }))(obj)).Color
20781                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20782                 }
20783                 if err := pcall(func() {
20784                         ((*(*(struct {
20785                                 Param0 Content
20786
20787                                 Name   string
20788                                 Groups []Group
20789
20790                                 P1Type   Param1Type
20791                                 P2Type   Param2Type
20792                                 DrawType DrawType
20793
20794                                 Mesh  string
20795                                 Scale float32
20796                                 //mt:const uint8(6)
20797                                 Tiles        [6]TileDef
20798                                 OverlayTiles [6]TileDef
20799                                 //mt:const uint8(6)
20800                                 SpecialTiles [6]TileDef
20801
20802                                 Color   color.NRGBA
20803                                 Palette Texture
20804
20805                                 Waving       WaveType
20806                                 ConnectSides uint8
20807                                 ConnectTo    []Content
20808                                 InsideTint   color.NRGBA
20809                                 Level        uint8 // Must be < 128.
20810
20811                                 Translucent bool // Sunlight is scattered and becomes normal light.
20812                                 Transparent bool // Sunlight isn't scattered.
20813                                 LightSrc    uint8
20814
20815                                 GndContent   bool
20816                                 Collides     bool
20817                                 Pointable    bool
20818                                 Diggable     bool
20819                                 Climbable    bool
20820                                 Replaceable  bool
20821                                 OnRightClick bool
20822
20823                                 DmgPerSec int32
20824
20825                                 LiquidType   LiquidType
20826                                 FlowingAlt   string
20827                                 SrcAlt       string
20828                                 Viscosity    uint8 // 0-7
20829                                 LiqRenewable bool
20830                                 FlowRange    uint8
20831                                 DrownDmg     uint8
20832                                 Floodable    bool
20833
20834                                 DrawBox, ColBox, SelBox NodeBox
20835
20836                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20837
20838                                 LegacyFaceDir bool
20839                                 LegacyMounted bool
20840
20841                                 DigPredict string
20842
20843                                 MaxLvl uint8
20844
20845                                 AlphaUse
20846                         }))(obj)).Palette).deserialize(r)
20847                 }); err != nil {
20848                         if err == io.EOF {
20849                                 chk(io.EOF)
20850                         }
20851                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
20852                 }
20853                 if err := pcall(func() {
20854                         ((*(*(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)).Waving).deserialize(r)
20917                 }); err != nil {
20918                         if err == io.EOF {
20919                                 chk(io.EOF)
20920                         }
20921                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.WaveType", err))
20922                 }
20923                 {
20924                         p := &(*(*(struct {
20925                                 Param0 Content
20926
20927                                 Name   string
20928                                 Groups []Group
20929
20930                                 P1Type   Param1Type
20931                                 P2Type   Param2Type
20932                                 DrawType DrawType
20933
20934                                 Mesh  string
20935                                 Scale float32
20936                                 //mt:const uint8(6)
20937                                 Tiles        [6]TileDef
20938                                 OverlayTiles [6]TileDef
20939                                 //mt:const uint8(6)
20940                                 SpecialTiles [6]TileDef
20941
20942                                 Color   color.NRGBA
20943                                 Palette Texture
20944
20945                                 Waving       WaveType
20946                                 ConnectSides uint8
20947                                 ConnectTo    []Content
20948                                 InsideTint   color.NRGBA
20949                                 Level        uint8 // Must be < 128.
20950
20951                                 Translucent bool // Sunlight is scattered and becomes normal light.
20952                                 Transparent bool // Sunlight isn't scattered.
20953                                 LightSrc    uint8
20954
20955                                 GndContent   bool
20956                                 Collides     bool
20957                                 Pointable    bool
20958                                 Diggable     bool
20959                                 Climbable    bool
20960                                 Replaceable  bool
20961                                 OnRightClick bool
20962
20963                                 DmgPerSec int32
20964
20965                                 LiquidType   LiquidType
20966                                 FlowingAlt   string
20967                                 SrcAlt       string
20968                                 Viscosity    uint8 // 0-7
20969                                 LiqRenewable bool
20970                                 FlowRange    uint8
20971                                 DrownDmg     uint8
20972                                 Floodable    bool
20973
20974                                 DrawBox, ColBox, SelBox NodeBox
20975
20976                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20977
20978                                 LegacyFaceDir bool
20979                                 LegacyMounted bool
20980
20981                                 DigPredict string
20982
20983                                 MaxLvl uint8
20984
20985                                 AlphaUse
20986                         }))(obj)).ConnectSides
20987                         *p = read8(r)
20988                 }
20989                 var local268 uint16
20990                 {
20991                         p := &local268
20992                         *p = read16(r)
20993                 }
20994                 ((*(*(struct {
20995                         Param0 Content
20996
20997                         Name   string
20998                         Groups []Group
20999
21000                         P1Type   Param1Type
21001                         P2Type   Param2Type
21002                         DrawType DrawType
21003
21004                         Mesh  string
21005                         Scale float32
21006                         //mt:const uint8(6)
21007                         Tiles        [6]TileDef
21008                         OverlayTiles [6]TileDef
21009                         //mt:const uint8(6)
21010                         SpecialTiles [6]TileDef
21011
21012                         Color   color.NRGBA
21013                         Palette Texture
21014
21015                         Waving       WaveType
21016                         ConnectSides uint8
21017                         ConnectTo    []Content
21018                         InsideTint   color.NRGBA
21019                         Level        uint8 // Must be < 128.
21020
21021                         Translucent bool // Sunlight is scattered and becomes normal light.
21022                         Transparent bool // Sunlight isn't scattered.
21023                         LightSrc    uint8
21024
21025                         GndContent   bool
21026                         Collides     bool
21027                         Pointable    bool
21028                         Diggable     bool
21029                         Climbable    bool
21030                         Replaceable  bool
21031                         OnRightClick bool
21032
21033                         DmgPerSec int32
21034
21035                         LiquidType   LiquidType
21036                         FlowingAlt   string
21037                         SrcAlt       string
21038                         Viscosity    uint8 // 0-7
21039                         LiqRenewable bool
21040                         FlowRange    uint8
21041                         DrownDmg     uint8
21042                         Floodable    bool
21043
21044                         DrawBox, ColBox, SelBox NodeBox
21045
21046                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21047
21048                         LegacyFaceDir bool
21049                         LegacyMounted bool
21050
21051                         DigPredict string
21052
21053                         MaxLvl uint8
21054
21055                         AlphaUse
21056                 }))(obj)).ConnectTo) = make([]Content, local268)
21057                 for local269 := range (*(*(struct {
21058                         Param0 Content
21059
21060                         Name   string
21061                         Groups []Group
21062
21063                         P1Type   Param1Type
21064                         P2Type   Param2Type
21065                         DrawType DrawType
21066
21067                         Mesh  string
21068                         Scale float32
21069                         //mt:const uint8(6)
21070                         Tiles        [6]TileDef
21071                         OverlayTiles [6]TileDef
21072                         //mt:const uint8(6)
21073                         SpecialTiles [6]TileDef
21074
21075                         Color   color.NRGBA
21076                         Palette Texture
21077
21078                         Waving       WaveType
21079                         ConnectSides uint8
21080                         ConnectTo    []Content
21081                         InsideTint   color.NRGBA
21082                         Level        uint8 // Must be < 128.
21083
21084                         Translucent bool // Sunlight is scattered and becomes normal light.
21085                         Transparent bool // Sunlight isn't scattered.
21086                         LightSrc    uint8
21087
21088                         GndContent   bool
21089                         Collides     bool
21090                         Pointable    bool
21091                         Diggable     bool
21092                         Climbable    bool
21093                         Replaceable  bool
21094                         OnRightClick bool
21095
21096                         DmgPerSec int32
21097
21098                         LiquidType   LiquidType
21099                         FlowingAlt   string
21100                         SrcAlt       string
21101                         Viscosity    uint8 // 0-7
21102                         LiqRenewable bool
21103                         FlowRange    uint8
21104                         DrownDmg     uint8
21105                         Floodable    bool
21106
21107                         DrawBox, ColBox, SelBox NodeBox
21108
21109                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21110
21111                         LegacyFaceDir bool
21112                         LegacyMounted bool
21113
21114                         DigPredict string
21115
21116                         MaxLvl uint8
21117
21118                         AlphaUse
21119                 }))(obj)).ConnectTo {
21120                         if err := pcall(func() {
21121                                 (((*(*(struct {
21122                                         Param0 Content
21123
21124                                         Name   string
21125                                         Groups []Group
21126
21127                                         P1Type   Param1Type
21128                                         P2Type   Param2Type
21129                                         DrawType DrawType
21130
21131                                         Mesh  string
21132                                         Scale float32
21133                                         //mt:const uint8(6)
21134                                         Tiles        [6]TileDef
21135                                         OverlayTiles [6]TileDef
21136                                         //mt:const uint8(6)
21137                                         SpecialTiles [6]TileDef
21138
21139                                         Color   color.NRGBA
21140                                         Palette Texture
21141
21142                                         Waving       WaveType
21143                                         ConnectSides uint8
21144                                         ConnectTo    []Content
21145                                         InsideTint   color.NRGBA
21146                                         Level        uint8 // Must be < 128.
21147
21148                                         Translucent bool // Sunlight is scattered and becomes normal light.
21149                                         Transparent bool // Sunlight isn't scattered.
21150                                         LightSrc    uint8
21151
21152                                         GndContent   bool
21153                                         Collides     bool
21154                                         Pointable    bool
21155                                         Diggable     bool
21156                                         Climbable    bool
21157                                         Replaceable  bool
21158                                         OnRightClick bool
21159
21160                                         DmgPerSec int32
21161
21162                                         LiquidType   LiquidType
21163                                         FlowingAlt   string
21164                                         SrcAlt       string
21165                                         Viscosity    uint8 // 0-7
21166                                         LiqRenewable bool
21167                                         FlowRange    uint8
21168                                         DrownDmg     uint8
21169                                         Floodable    bool
21170
21171                                         DrawBox, ColBox, SelBox NodeBox
21172
21173                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21174
21175                                         LegacyFaceDir bool
21176                                         LegacyMounted bool
21177
21178                                         DigPredict string
21179
21180                                         MaxLvl uint8
21181
21182                                         AlphaUse
21183                                 }))(obj)).ConnectTo)[local269]).deserialize(r)
21184                         }); err != nil {
21185                                 if err == io.EOF {
21186                                         chk(io.EOF)
21187                                 }
21188                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
21189                         }
21190                 }
21191                 {
21192                         p := &(*(*(struct {
21193                                 Param0 Content
21194
21195                                 Name   string
21196                                 Groups []Group
21197
21198                                 P1Type   Param1Type
21199                                 P2Type   Param2Type
21200                                 DrawType DrawType
21201
21202                                 Mesh  string
21203                                 Scale float32
21204                                 //mt:const uint8(6)
21205                                 Tiles        [6]TileDef
21206                                 OverlayTiles [6]TileDef
21207                                 //mt:const uint8(6)
21208                                 SpecialTiles [6]TileDef
21209
21210                                 Color   color.NRGBA
21211                                 Palette Texture
21212
21213                                 Waving       WaveType
21214                                 ConnectSides uint8
21215                                 ConnectTo    []Content
21216                                 InsideTint   color.NRGBA
21217                                 Level        uint8 // Must be < 128.
21218
21219                                 Translucent bool // Sunlight is scattered and becomes normal light.
21220                                 Transparent bool // Sunlight isn't scattered.
21221                                 LightSrc    uint8
21222
21223                                 GndContent   bool
21224                                 Collides     bool
21225                                 Pointable    bool
21226                                 Diggable     bool
21227                                 Climbable    bool
21228                                 Replaceable  bool
21229                                 OnRightClick bool
21230
21231                                 DmgPerSec int32
21232
21233                                 LiquidType   LiquidType
21234                                 FlowingAlt   string
21235                                 SrcAlt       string
21236                                 Viscosity    uint8 // 0-7
21237                                 LiqRenewable bool
21238                                 FlowRange    uint8
21239                                 DrownDmg     uint8
21240                                 Floodable    bool
21241
21242                                 DrawBox, ColBox, SelBox NodeBox
21243
21244                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21245
21246                                 LegacyFaceDir bool
21247                                 LegacyMounted bool
21248
21249                                 DigPredict string
21250
21251                                 MaxLvl uint8
21252
21253                                 AlphaUse
21254                         }))(obj)).InsideTint
21255                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
21256                 }
21257                 {
21258                         p := &(*(*(struct {
21259                                 Param0 Content
21260
21261                                 Name   string
21262                                 Groups []Group
21263
21264                                 P1Type   Param1Type
21265                                 P2Type   Param2Type
21266                                 DrawType DrawType
21267
21268                                 Mesh  string
21269                                 Scale float32
21270                                 //mt:const uint8(6)
21271                                 Tiles        [6]TileDef
21272                                 OverlayTiles [6]TileDef
21273                                 //mt:const uint8(6)
21274                                 SpecialTiles [6]TileDef
21275
21276                                 Color   color.NRGBA
21277                                 Palette Texture
21278
21279                                 Waving       WaveType
21280                                 ConnectSides uint8
21281                                 ConnectTo    []Content
21282                                 InsideTint   color.NRGBA
21283                                 Level        uint8 // Must be < 128.
21284
21285                                 Translucent bool // Sunlight is scattered and becomes normal light.
21286                                 Transparent bool // Sunlight isn't scattered.
21287                                 LightSrc    uint8
21288
21289                                 GndContent   bool
21290                                 Collides     bool
21291                                 Pointable    bool
21292                                 Diggable     bool
21293                                 Climbable    bool
21294                                 Replaceable  bool
21295                                 OnRightClick bool
21296
21297                                 DmgPerSec int32
21298
21299                                 LiquidType   LiquidType
21300                                 FlowingAlt   string
21301                                 SrcAlt       string
21302                                 Viscosity    uint8 // 0-7
21303                                 LiqRenewable bool
21304                                 FlowRange    uint8
21305                                 DrownDmg     uint8
21306                                 Floodable    bool
21307
21308                                 DrawBox, ColBox, SelBox NodeBox
21309
21310                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21311
21312                                 LegacyFaceDir bool
21313                                 LegacyMounted bool
21314
21315                                 DigPredict string
21316
21317                                 MaxLvl uint8
21318
21319                                 AlphaUse
21320                         }))(obj)).Level
21321                         *p = read8(r)
21322                 }
21323                 {
21324                         p := &(*(*(struct {
21325                                 Param0 Content
21326
21327                                 Name   string
21328                                 Groups []Group
21329
21330                                 P1Type   Param1Type
21331                                 P2Type   Param2Type
21332                                 DrawType DrawType
21333
21334                                 Mesh  string
21335                                 Scale float32
21336                                 //mt:const uint8(6)
21337                                 Tiles        [6]TileDef
21338                                 OverlayTiles [6]TileDef
21339                                 //mt:const uint8(6)
21340                                 SpecialTiles [6]TileDef
21341
21342                                 Color   color.NRGBA
21343                                 Palette Texture
21344
21345                                 Waving       WaveType
21346                                 ConnectSides uint8
21347                                 ConnectTo    []Content
21348                                 InsideTint   color.NRGBA
21349                                 Level        uint8 // Must be < 128.
21350
21351                                 Translucent bool // Sunlight is scattered and becomes normal light.
21352                                 Transparent bool // Sunlight isn't scattered.
21353                                 LightSrc    uint8
21354
21355                                 GndContent   bool
21356                                 Collides     bool
21357                                 Pointable    bool
21358                                 Diggable     bool
21359                                 Climbable    bool
21360                                 Replaceable  bool
21361                                 OnRightClick bool
21362
21363                                 DmgPerSec int32
21364
21365                                 LiquidType   LiquidType
21366                                 FlowingAlt   string
21367                                 SrcAlt       string
21368                                 Viscosity    uint8 // 0-7
21369                                 LiqRenewable bool
21370                                 FlowRange    uint8
21371                                 DrownDmg     uint8
21372                                 Floodable    bool
21373
21374                                 DrawBox, ColBox, SelBox NodeBox
21375
21376                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21377
21378                                 LegacyFaceDir bool
21379                                 LegacyMounted bool
21380
21381                                 DigPredict string
21382
21383                                 MaxLvl uint8
21384
21385                                 AlphaUse
21386                         }))(obj)).Translucent
21387                         switch n := read8(r); n {
21388                         case 0:
21389                                 *p = false
21390                         case 1:
21391                                 *p = true
21392                         default:
21393                                 chk(fmt.Errorf("invalid bool: %d", n))
21394                         }
21395                 }
21396                 {
21397                         p := &(*(*(struct {
21398                                 Param0 Content
21399
21400                                 Name   string
21401                                 Groups []Group
21402
21403                                 P1Type   Param1Type
21404                                 P2Type   Param2Type
21405                                 DrawType DrawType
21406
21407                                 Mesh  string
21408                                 Scale float32
21409                                 //mt:const uint8(6)
21410                                 Tiles        [6]TileDef
21411                                 OverlayTiles [6]TileDef
21412                                 //mt:const uint8(6)
21413                                 SpecialTiles [6]TileDef
21414
21415                                 Color   color.NRGBA
21416                                 Palette Texture
21417
21418                                 Waving       WaveType
21419                                 ConnectSides uint8
21420                                 ConnectTo    []Content
21421                                 InsideTint   color.NRGBA
21422                                 Level        uint8 // Must be < 128.
21423
21424                                 Translucent bool // Sunlight is scattered and becomes normal light.
21425                                 Transparent bool // Sunlight isn't scattered.
21426                                 LightSrc    uint8
21427
21428                                 GndContent   bool
21429                                 Collides     bool
21430                                 Pointable    bool
21431                                 Diggable     bool
21432                                 Climbable    bool
21433                                 Replaceable  bool
21434                                 OnRightClick bool
21435
21436                                 DmgPerSec int32
21437
21438                                 LiquidType   LiquidType
21439                                 FlowingAlt   string
21440                                 SrcAlt       string
21441                                 Viscosity    uint8 // 0-7
21442                                 LiqRenewable bool
21443                                 FlowRange    uint8
21444                                 DrownDmg     uint8
21445                                 Floodable    bool
21446
21447                                 DrawBox, ColBox, SelBox NodeBox
21448
21449                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21450
21451                                 LegacyFaceDir bool
21452                                 LegacyMounted bool
21453
21454                                 DigPredict string
21455
21456                                 MaxLvl uint8
21457
21458                                 AlphaUse
21459                         }))(obj)).Transparent
21460                         switch n := read8(r); n {
21461                         case 0:
21462                                 *p = false
21463                         case 1:
21464                                 *p = true
21465                         default:
21466                                 chk(fmt.Errorf("invalid bool: %d", n))
21467                         }
21468                 }
21469                 {
21470                         p := &(*(*(struct {
21471                                 Param0 Content
21472
21473                                 Name   string
21474                                 Groups []Group
21475
21476                                 P1Type   Param1Type
21477                                 P2Type   Param2Type
21478                                 DrawType DrawType
21479
21480                                 Mesh  string
21481                                 Scale float32
21482                                 //mt:const uint8(6)
21483                                 Tiles        [6]TileDef
21484                                 OverlayTiles [6]TileDef
21485                                 //mt:const uint8(6)
21486                                 SpecialTiles [6]TileDef
21487
21488                                 Color   color.NRGBA
21489                                 Palette Texture
21490
21491                                 Waving       WaveType
21492                                 ConnectSides uint8
21493                                 ConnectTo    []Content
21494                                 InsideTint   color.NRGBA
21495                                 Level        uint8 // Must be < 128.
21496
21497                                 Translucent bool // Sunlight is scattered and becomes normal light.
21498                                 Transparent bool // Sunlight isn't scattered.
21499                                 LightSrc    uint8
21500
21501                                 GndContent   bool
21502                                 Collides     bool
21503                                 Pointable    bool
21504                                 Diggable     bool
21505                                 Climbable    bool
21506                                 Replaceable  bool
21507                                 OnRightClick bool
21508
21509                                 DmgPerSec int32
21510
21511                                 LiquidType   LiquidType
21512                                 FlowingAlt   string
21513                                 SrcAlt       string
21514                                 Viscosity    uint8 // 0-7
21515                                 LiqRenewable bool
21516                                 FlowRange    uint8
21517                                 DrownDmg     uint8
21518                                 Floodable    bool
21519
21520                                 DrawBox, ColBox, SelBox NodeBox
21521
21522                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21523
21524                                 LegacyFaceDir bool
21525                                 LegacyMounted bool
21526
21527                                 DigPredict string
21528
21529                                 MaxLvl uint8
21530
21531                                 AlphaUse
21532                         }))(obj)).LightSrc
21533                         *p = read8(r)
21534                 }
21535                 {
21536                         p := &(*(*(struct {
21537                                 Param0 Content
21538
21539                                 Name   string
21540                                 Groups []Group
21541
21542                                 P1Type   Param1Type
21543                                 P2Type   Param2Type
21544                                 DrawType DrawType
21545
21546                                 Mesh  string
21547                                 Scale float32
21548                                 //mt:const uint8(6)
21549                                 Tiles        [6]TileDef
21550                                 OverlayTiles [6]TileDef
21551                                 //mt:const uint8(6)
21552                                 SpecialTiles [6]TileDef
21553
21554                                 Color   color.NRGBA
21555                                 Palette Texture
21556
21557                                 Waving       WaveType
21558                                 ConnectSides uint8
21559                                 ConnectTo    []Content
21560                                 InsideTint   color.NRGBA
21561                                 Level        uint8 // Must be < 128.
21562
21563                                 Translucent bool // Sunlight is scattered and becomes normal light.
21564                                 Transparent bool // Sunlight isn't scattered.
21565                                 LightSrc    uint8
21566
21567                                 GndContent   bool
21568                                 Collides     bool
21569                                 Pointable    bool
21570                                 Diggable     bool
21571                                 Climbable    bool
21572                                 Replaceable  bool
21573                                 OnRightClick bool
21574
21575                                 DmgPerSec int32
21576
21577                                 LiquidType   LiquidType
21578                                 FlowingAlt   string
21579                                 SrcAlt       string
21580                                 Viscosity    uint8 // 0-7
21581                                 LiqRenewable bool
21582                                 FlowRange    uint8
21583                                 DrownDmg     uint8
21584                                 Floodable    bool
21585
21586                                 DrawBox, ColBox, SelBox NodeBox
21587
21588                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21589
21590                                 LegacyFaceDir bool
21591                                 LegacyMounted bool
21592
21593                                 DigPredict string
21594
21595                                 MaxLvl uint8
21596
21597                                 AlphaUse
21598                         }))(obj)).GndContent
21599                         switch n := read8(r); n {
21600                         case 0:
21601                                 *p = false
21602                         case 1:
21603                                 *p = true
21604                         default:
21605                                 chk(fmt.Errorf("invalid bool: %d", n))
21606                         }
21607                 }
21608                 {
21609                         p := &(*(*(struct {
21610                                 Param0 Content
21611
21612                                 Name   string
21613                                 Groups []Group
21614
21615                                 P1Type   Param1Type
21616                                 P2Type   Param2Type
21617                                 DrawType DrawType
21618
21619                                 Mesh  string
21620                                 Scale float32
21621                                 //mt:const uint8(6)
21622                                 Tiles        [6]TileDef
21623                                 OverlayTiles [6]TileDef
21624                                 //mt:const uint8(6)
21625                                 SpecialTiles [6]TileDef
21626
21627                                 Color   color.NRGBA
21628                                 Palette Texture
21629
21630                                 Waving       WaveType
21631                                 ConnectSides uint8
21632                                 ConnectTo    []Content
21633                                 InsideTint   color.NRGBA
21634                                 Level        uint8 // Must be < 128.
21635
21636                                 Translucent bool // Sunlight is scattered and becomes normal light.
21637                                 Transparent bool // Sunlight isn't scattered.
21638                                 LightSrc    uint8
21639
21640                                 GndContent   bool
21641                                 Collides     bool
21642                                 Pointable    bool
21643                                 Diggable     bool
21644                                 Climbable    bool
21645                                 Replaceable  bool
21646                                 OnRightClick bool
21647
21648                                 DmgPerSec int32
21649
21650                                 LiquidType   LiquidType
21651                                 FlowingAlt   string
21652                                 SrcAlt       string
21653                                 Viscosity    uint8 // 0-7
21654                                 LiqRenewable bool
21655                                 FlowRange    uint8
21656                                 DrownDmg     uint8
21657                                 Floodable    bool
21658
21659                                 DrawBox, ColBox, SelBox NodeBox
21660
21661                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21662
21663                                 LegacyFaceDir bool
21664                                 LegacyMounted bool
21665
21666                                 DigPredict string
21667
21668                                 MaxLvl uint8
21669
21670                                 AlphaUse
21671                         }))(obj)).Collides
21672                         switch n := read8(r); n {
21673                         case 0:
21674                                 *p = false
21675                         case 1:
21676                                 *p = true
21677                         default:
21678                                 chk(fmt.Errorf("invalid bool: %d", n))
21679                         }
21680                 }
21681                 {
21682                         p := &(*(*(struct {
21683                                 Param0 Content
21684
21685                                 Name   string
21686                                 Groups []Group
21687
21688                                 P1Type   Param1Type
21689                                 P2Type   Param2Type
21690                                 DrawType DrawType
21691
21692                                 Mesh  string
21693                                 Scale float32
21694                                 //mt:const uint8(6)
21695                                 Tiles        [6]TileDef
21696                                 OverlayTiles [6]TileDef
21697                                 //mt:const uint8(6)
21698                                 SpecialTiles [6]TileDef
21699
21700                                 Color   color.NRGBA
21701                                 Palette Texture
21702
21703                                 Waving       WaveType
21704                                 ConnectSides uint8
21705                                 ConnectTo    []Content
21706                                 InsideTint   color.NRGBA
21707                                 Level        uint8 // Must be < 128.
21708
21709                                 Translucent bool // Sunlight is scattered and becomes normal light.
21710                                 Transparent bool // Sunlight isn't scattered.
21711                                 LightSrc    uint8
21712
21713                                 GndContent   bool
21714                                 Collides     bool
21715                                 Pointable    bool
21716                                 Diggable     bool
21717                                 Climbable    bool
21718                                 Replaceable  bool
21719                                 OnRightClick bool
21720
21721                                 DmgPerSec int32
21722
21723                                 LiquidType   LiquidType
21724                                 FlowingAlt   string
21725                                 SrcAlt       string
21726                                 Viscosity    uint8 // 0-7
21727                                 LiqRenewable bool
21728                                 FlowRange    uint8
21729                                 DrownDmg     uint8
21730                                 Floodable    bool
21731
21732                                 DrawBox, ColBox, SelBox NodeBox
21733
21734                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21735
21736                                 LegacyFaceDir bool
21737                                 LegacyMounted bool
21738
21739                                 DigPredict string
21740
21741                                 MaxLvl uint8
21742
21743                                 AlphaUse
21744                         }))(obj)).Pointable
21745                         switch n := read8(r); n {
21746                         case 0:
21747                                 *p = false
21748                         case 1:
21749                                 *p = true
21750                         default:
21751                                 chk(fmt.Errorf("invalid bool: %d", n))
21752                         }
21753                 }
21754                 {
21755                         p := &(*(*(struct {
21756                                 Param0 Content
21757
21758                                 Name   string
21759                                 Groups []Group
21760
21761                                 P1Type   Param1Type
21762                                 P2Type   Param2Type
21763                                 DrawType DrawType
21764
21765                                 Mesh  string
21766                                 Scale float32
21767                                 //mt:const uint8(6)
21768                                 Tiles        [6]TileDef
21769                                 OverlayTiles [6]TileDef
21770                                 //mt:const uint8(6)
21771                                 SpecialTiles [6]TileDef
21772
21773                                 Color   color.NRGBA
21774                                 Palette Texture
21775
21776                                 Waving       WaveType
21777                                 ConnectSides uint8
21778                                 ConnectTo    []Content
21779                                 InsideTint   color.NRGBA
21780                                 Level        uint8 // Must be < 128.
21781
21782                                 Translucent bool // Sunlight is scattered and becomes normal light.
21783                                 Transparent bool // Sunlight isn't scattered.
21784                                 LightSrc    uint8
21785
21786                                 GndContent   bool
21787                                 Collides     bool
21788                                 Pointable    bool
21789                                 Diggable     bool
21790                                 Climbable    bool
21791                                 Replaceable  bool
21792                                 OnRightClick bool
21793
21794                                 DmgPerSec int32
21795
21796                                 LiquidType   LiquidType
21797                                 FlowingAlt   string
21798                                 SrcAlt       string
21799                                 Viscosity    uint8 // 0-7
21800                                 LiqRenewable bool
21801                                 FlowRange    uint8
21802                                 DrownDmg     uint8
21803                                 Floodable    bool
21804
21805                                 DrawBox, ColBox, SelBox NodeBox
21806
21807                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21808
21809                                 LegacyFaceDir bool
21810                                 LegacyMounted bool
21811
21812                                 DigPredict string
21813
21814                                 MaxLvl uint8
21815
21816                                 AlphaUse
21817                         }))(obj)).Diggable
21818                         switch n := read8(r); n {
21819                         case 0:
21820                                 *p = false
21821                         case 1:
21822                                 *p = true
21823                         default:
21824                                 chk(fmt.Errorf("invalid bool: %d", n))
21825                         }
21826                 }
21827                 {
21828                         p := &(*(*(struct {
21829                                 Param0 Content
21830
21831                                 Name   string
21832                                 Groups []Group
21833
21834                                 P1Type   Param1Type
21835                                 P2Type   Param2Type
21836                                 DrawType DrawType
21837
21838                                 Mesh  string
21839                                 Scale float32
21840                                 //mt:const uint8(6)
21841                                 Tiles        [6]TileDef
21842                                 OverlayTiles [6]TileDef
21843                                 //mt:const uint8(6)
21844                                 SpecialTiles [6]TileDef
21845
21846                                 Color   color.NRGBA
21847                                 Palette Texture
21848
21849                                 Waving       WaveType
21850                                 ConnectSides uint8
21851                                 ConnectTo    []Content
21852                                 InsideTint   color.NRGBA
21853                                 Level        uint8 // Must be < 128.
21854
21855                                 Translucent bool // Sunlight is scattered and becomes normal light.
21856                                 Transparent bool // Sunlight isn't scattered.
21857                                 LightSrc    uint8
21858
21859                                 GndContent   bool
21860                                 Collides     bool
21861                                 Pointable    bool
21862                                 Diggable     bool
21863                                 Climbable    bool
21864                                 Replaceable  bool
21865                                 OnRightClick bool
21866
21867                                 DmgPerSec int32
21868
21869                                 LiquidType   LiquidType
21870                                 FlowingAlt   string
21871                                 SrcAlt       string
21872                                 Viscosity    uint8 // 0-7
21873                                 LiqRenewable bool
21874                                 FlowRange    uint8
21875                                 DrownDmg     uint8
21876                                 Floodable    bool
21877
21878                                 DrawBox, ColBox, SelBox NodeBox
21879
21880                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21881
21882                                 LegacyFaceDir bool
21883                                 LegacyMounted bool
21884
21885                                 DigPredict string
21886
21887                                 MaxLvl uint8
21888
21889                                 AlphaUse
21890                         }))(obj)).Climbable
21891                         switch n := read8(r); n {
21892                         case 0:
21893                                 *p = false
21894                         case 1:
21895                                 *p = true
21896                         default:
21897                                 chk(fmt.Errorf("invalid bool: %d", n))
21898                         }
21899                 }
21900                 {
21901                         p := &(*(*(struct {
21902                                 Param0 Content
21903
21904                                 Name   string
21905                                 Groups []Group
21906
21907                                 P1Type   Param1Type
21908                                 P2Type   Param2Type
21909                                 DrawType DrawType
21910
21911                                 Mesh  string
21912                                 Scale float32
21913                                 //mt:const uint8(6)
21914                                 Tiles        [6]TileDef
21915                                 OverlayTiles [6]TileDef
21916                                 //mt:const uint8(6)
21917                                 SpecialTiles [6]TileDef
21918
21919                                 Color   color.NRGBA
21920                                 Palette Texture
21921
21922                                 Waving       WaveType
21923                                 ConnectSides uint8
21924                                 ConnectTo    []Content
21925                                 InsideTint   color.NRGBA
21926                                 Level        uint8 // Must be < 128.
21927
21928                                 Translucent bool // Sunlight is scattered and becomes normal light.
21929                                 Transparent bool // Sunlight isn't scattered.
21930                                 LightSrc    uint8
21931
21932                                 GndContent   bool
21933                                 Collides     bool
21934                                 Pointable    bool
21935                                 Diggable     bool
21936                                 Climbable    bool
21937                                 Replaceable  bool
21938                                 OnRightClick bool
21939
21940                                 DmgPerSec int32
21941
21942                                 LiquidType   LiquidType
21943                                 FlowingAlt   string
21944                                 SrcAlt       string
21945                                 Viscosity    uint8 // 0-7
21946                                 LiqRenewable bool
21947                                 FlowRange    uint8
21948                                 DrownDmg     uint8
21949                                 Floodable    bool
21950
21951                                 DrawBox, ColBox, SelBox NodeBox
21952
21953                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21954
21955                                 LegacyFaceDir bool
21956                                 LegacyMounted bool
21957
21958                                 DigPredict string
21959
21960                                 MaxLvl uint8
21961
21962                                 AlphaUse
21963                         }))(obj)).Replaceable
21964                         switch n := read8(r); n {
21965                         case 0:
21966                                 *p = false
21967                         case 1:
21968                                 *p = true
21969                         default:
21970                                 chk(fmt.Errorf("invalid bool: %d", n))
21971                         }
21972                 }
21973                 {
21974                         p := &(*(*(struct {
21975                                 Param0 Content
21976
21977                                 Name   string
21978                                 Groups []Group
21979
21980                                 P1Type   Param1Type
21981                                 P2Type   Param2Type
21982                                 DrawType DrawType
21983
21984                                 Mesh  string
21985                                 Scale float32
21986                                 //mt:const uint8(6)
21987                                 Tiles        [6]TileDef
21988                                 OverlayTiles [6]TileDef
21989                                 //mt:const uint8(6)
21990                                 SpecialTiles [6]TileDef
21991
21992                                 Color   color.NRGBA
21993                                 Palette Texture
21994
21995                                 Waving       WaveType
21996                                 ConnectSides uint8
21997                                 ConnectTo    []Content
21998                                 InsideTint   color.NRGBA
21999                                 Level        uint8 // Must be < 128.
22000
22001                                 Translucent bool // Sunlight is scattered and becomes normal light.
22002                                 Transparent bool // Sunlight isn't scattered.
22003                                 LightSrc    uint8
22004
22005                                 GndContent   bool
22006                                 Collides     bool
22007                                 Pointable    bool
22008                                 Diggable     bool
22009                                 Climbable    bool
22010                                 Replaceable  bool
22011                                 OnRightClick bool
22012
22013                                 DmgPerSec int32
22014
22015                                 LiquidType   LiquidType
22016                                 FlowingAlt   string
22017                                 SrcAlt       string
22018                                 Viscosity    uint8 // 0-7
22019                                 LiqRenewable bool
22020                                 FlowRange    uint8
22021                                 DrownDmg     uint8
22022                                 Floodable    bool
22023
22024                                 DrawBox, ColBox, SelBox NodeBox
22025
22026                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22027
22028                                 LegacyFaceDir bool
22029                                 LegacyMounted bool
22030
22031                                 DigPredict string
22032
22033                                 MaxLvl uint8
22034
22035                                 AlphaUse
22036                         }))(obj)).OnRightClick
22037                         switch n := read8(r); n {
22038                         case 0:
22039                                 *p = false
22040                         case 1:
22041                                 *p = true
22042                         default:
22043                                 chk(fmt.Errorf("invalid bool: %d", n))
22044                         }
22045                 }
22046                 {
22047                         p := &(*(*(struct {
22048                                 Param0 Content
22049
22050                                 Name   string
22051                                 Groups []Group
22052
22053                                 P1Type   Param1Type
22054                                 P2Type   Param2Type
22055                                 DrawType DrawType
22056
22057                                 Mesh  string
22058                                 Scale float32
22059                                 //mt:const uint8(6)
22060                                 Tiles        [6]TileDef
22061                                 OverlayTiles [6]TileDef
22062                                 //mt:const uint8(6)
22063                                 SpecialTiles [6]TileDef
22064
22065                                 Color   color.NRGBA
22066                                 Palette Texture
22067
22068                                 Waving       WaveType
22069                                 ConnectSides uint8
22070                                 ConnectTo    []Content
22071                                 InsideTint   color.NRGBA
22072                                 Level        uint8 // Must be < 128.
22073
22074                                 Translucent bool // Sunlight is scattered and becomes normal light.
22075                                 Transparent bool // Sunlight isn't scattered.
22076                                 LightSrc    uint8
22077
22078                                 GndContent   bool
22079                                 Collides     bool
22080                                 Pointable    bool
22081                                 Diggable     bool
22082                                 Climbable    bool
22083                                 Replaceable  bool
22084                                 OnRightClick bool
22085
22086                                 DmgPerSec int32
22087
22088                                 LiquidType   LiquidType
22089                                 FlowingAlt   string
22090                                 SrcAlt       string
22091                                 Viscosity    uint8 // 0-7
22092                                 LiqRenewable bool
22093                                 FlowRange    uint8
22094                                 DrownDmg     uint8
22095                                 Floodable    bool
22096
22097                                 DrawBox, ColBox, SelBox NodeBox
22098
22099                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22100
22101                                 LegacyFaceDir bool
22102                                 LegacyMounted bool
22103
22104                                 DigPredict string
22105
22106                                 MaxLvl uint8
22107
22108                                 AlphaUse
22109                         }))(obj)).DmgPerSec
22110                         *p = int32(read32(r))
22111                 }
22112                 if err := pcall(func() {
22113                         ((*(*(struct {
22114                                 Param0 Content
22115
22116                                 Name   string
22117                                 Groups []Group
22118
22119                                 P1Type   Param1Type
22120                                 P2Type   Param2Type
22121                                 DrawType DrawType
22122
22123                                 Mesh  string
22124                                 Scale float32
22125                                 //mt:const uint8(6)
22126                                 Tiles        [6]TileDef
22127                                 OverlayTiles [6]TileDef
22128                                 //mt:const uint8(6)
22129                                 SpecialTiles [6]TileDef
22130
22131                                 Color   color.NRGBA
22132                                 Palette Texture
22133
22134                                 Waving       WaveType
22135                                 ConnectSides uint8
22136                                 ConnectTo    []Content
22137                                 InsideTint   color.NRGBA
22138                                 Level        uint8 // Must be < 128.
22139
22140                                 Translucent bool // Sunlight is scattered and becomes normal light.
22141                                 Transparent bool // Sunlight isn't scattered.
22142                                 LightSrc    uint8
22143
22144                                 GndContent   bool
22145                                 Collides     bool
22146                                 Pointable    bool
22147                                 Diggable     bool
22148                                 Climbable    bool
22149                                 Replaceable  bool
22150                                 OnRightClick bool
22151
22152                                 DmgPerSec int32
22153
22154                                 LiquidType   LiquidType
22155                                 FlowingAlt   string
22156                                 SrcAlt       string
22157                                 Viscosity    uint8 // 0-7
22158                                 LiqRenewable bool
22159                                 FlowRange    uint8
22160                                 DrownDmg     uint8
22161                                 Floodable    bool
22162
22163                                 DrawBox, ColBox, SelBox NodeBox
22164
22165                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22166
22167                                 LegacyFaceDir bool
22168                                 LegacyMounted bool
22169
22170                                 DigPredict string
22171
22172                                 MaxLvl uint8
22173
22174                                 AlphaUse
22175                         }))(obj)).LiquidType).deserialize(r)
22176                 }); err != nil {
22177                         if err == io.EOF {
22178                                 chk(io.EOF)
22179                         }
22180                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
22181                 }
22182                 var local270 []uint8
22183                 var local271 uint16
22184                 {
22185                         p := &local271
22186                         *p = read16(r)
22187                 }
22188                 (local270) = make([]uint8, local271)
22189                 {
22190                         _, err := io.ReadFull(r, (local270)[:])
22191                         chk(err)
22192                 }
22193                 ((*(*(struct {
22194                         Param0 Content
22195
22196                         Name   string
22197                         Groups []Group
22198
22199                         P1Type   Param1Type
22200                         P2Type   Param2Type
22201                         DrawType DrawType
22202
22203                         Mesh  string
22204                         Scale float32
22205                         //mt:const uint8(6)
22206                         Tiles        [6]TileDef
22207                         OverlayTiles [6]TileDef
22208                         //mt:const uint8(6)
22209                         SpecialTiles [6]TileDef
22210
22211                         Color   color.NRGBA
22212                         Palette Texture
22213
22214                         Waving       WaveType
22215                         ConnectSides uint8
22216                         ConnectTo    []Content
22217                         InsideTint   color.NRGBA
22218                         Level        uint8 // Must be < 128.
22219
22220                         Translucent bool // Sunlight is scattered and becomes normal light.
22221                         Transparent bool // Sunlight isn't scattered.
22222                         LightSrc    uint8
22223
22224                         GndContent   bool
22225                         Collides     bool
22226                         Pointable    bool
22227                         Diggable     bool
22228                         Climbable    bool
22229                         Replaceable  bool
22230                         OnRightClick bool
22231
22232                         DmgPerSec int32
22233
22234                         LiquidType   LiquidType
22235                         FlowingAlt   string
22236                         SrcAlt       string
22237                         Viscosity    uint8 // 0-7
22238                         LiqRenewable bool
22239                         FlowRange    uint8
22240                         DrownDmg     uint8
22241                         Floodable    bool
22242
22243                         DrawBox, ColBox, SelBox NodeBox
22244
22245                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22246
22247                         LegacyFaceDir bool
22248                         LegacyMounted bool
22249
22250                         DigPredict string
22251
22252                         MaxLvl uint8
22253
22254                         AlphaUse
22255                 }))(obj)).FlowingAlt) = string(local270)
22256                 var local272 []uint8
22257                 var local273 uint16
22258                 {
22259                         p := &local273
22260                         *p = read16(r)
22261                 }
22262                 (local272) = make([]uint8, local273)
22263                 {
22264                         _, err := io.ReadFull(r, (local272)[:])
22265                         chk(err)
22266                 }
22267                 ((*(*(struct {
22268                         Param0 Content
22269
22270                         Name   string
22271                         Groups []Group
22272
22273                         P1Type   Param1Type
22274                         P2Type   Param2Type
22275                         DrawType DrawType
22276
22277                         Mesh  string
22278                         Scale float32
22279                         //mt:const uint8(6)
22280                         Tiles        [6]TileDef
22281                         OverlayTiles [6]TileDef
22282                         //mt:const uint8(6)
22283                         SpecialTiles [6]TileDef
22284
22285                         Color   color.NRGBA
22286                         Palette Texture
22287
22288                         Waving       WaveType
22289                         ConnectSides uint8
22290                         ConnectTo    []Content
22291                         InsideTint   color.NRGBA
22292                         Level        uint8 // Must be < 128.
22293
22294                         Translucent bool // Sunlight is scattered and becomes normal light.
22295                         Transparent bool // Sunlight isn't scattered.
22296                         LightSrc    uint8
22297
22298                         GndContent   bool
22299                         Collides     bool
22300                         Pointable    bool
22301                         Diggable     bool
22302                         Climbable    bool
22303                         Replaceable  bool
22304                         OnRightClick bool
22305
22306                         DmgPerSec int32
22307
22308                         LiquidType   LiquidType
22309                         FlowingAlt   string
22310                         SrcAlt       string
22311                         Viscosity    uint8 // 0-7
22312                         LiqRenewable bool
22313                         FlowRange    uint8
22314                         DrownDmg     uint8
22315                         Floodable    bool
22316
22317                         DrawBox, ColBox, SelBox NodeBox
22318
22319                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22320
22321                         LegacyFaceDir bool
22322                         LegacyMounted bool
22323
22324                         DigPredict string
22325
22326                         MaxLvl uint8
22327
22328                         AlphaUse
22329                 }))(obj)).SrcAlt) = string(local272)
22330                 {
22331                         p := &(*(*(struct {
22332                                 Param0 Content
22333
22334                                 Name   string
22335                                 Groups []Group
22336
22337                                 P1Type   Param1Type
22338                                 P2Type   Param2Type
22339                                 DrawType DrawType
22340
22341                                 Mesh  string
22342                                 Scale float32
22343                                 //mt:const uint8(6)
22344                                 Tiles        [6]TileDef
22345                                 OverlayTiles [6]TileDef
22346                                 //mt:const uint8(6)
22347                                 SpecialTiles [6]TileDef
22348
22349                                 Color   color.NRGBA
22350                                 Palette Texture
22351
22352                                 Waving       WaveType
22353                                 ConnectSides uint8
22354                                 ConnectTo    []Content
22355                                 InsideTint   color.NRGBA
22356                                 Level        uint8 // Must be < 128.
22357
22358                                 Translucent bool // Sunlight is scattered and becomes normal light.
22359                                 Transparent bool // Sunlight isn't scattered.
22360                                 LightSrc    uint8
22361
22362                                 GndContent   bool
22363                                 Collides     bool
22364                                 Pointable    bool
22365                                 Diggable     bool
22366                                 Climbable    bool
22367                                 Replaceable  bool
22368                                 OnRightClick bool
22369
22370                                 DmgPerSec int32
22371
22372                                 LiquidType   LiquidType
22373                                 FlowingAlt   string
22374                                 SrcAlt       string
22375                                 Viscosity    uint8 // 0-7
22376                                 LiqRenewable bool
22377                                 FlowRange    uint8
22378                                 DrownDmg     uint8
22379                                 Floodable    bool
22380
22381                                 DrawBox, ColBox, SelBox NodeBox
22382
22383                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22384
22385                                 LegacyFaceDir bool
22386                                 LegacyMounted bool
22387
22388                                 DigPredict string
22389
22390                                 MaxLvl uint8
22391
22392                                 AlphaUse
22393                         }))(obj)).Viscosity
22394                         *p = read8(r)
22395                 }
22396                 {
22397                         p := &(*(*(struct {
22398                                 Param0 Content
22399
22400                                 Name   string
22401                                 Groups []Group
22402
22403                                 P1Type   Param1Type
22404                                 P2Type   Param2Type
22405                                 DrawType DrawType
22406
22407                                 Mesh  string
22408                                 Scale float32
22409                                 //mt:const uint8(6)
22410                                 Tiles        [6]TileDef
22411                                 OverlayTiles [6]TileDef
22412                                 //mt:const uint8(6)
22413                                 SpecialTiles [6]TileDef
22414
22415                                 Color   color.NRGBA
22416                                 Palette Texture
22417
22418                                 Waving       WaveType
22419                                 ConnectSides uint8
22420                                 ConnectTo    []Content
22421                                 InsideTint   color.NRGBA
22422                                 Level        uint8 // Must be < 128.
22423
22424                                 Translucent bool // Sunlight is scattered and becomes normal light.
22425                                 Transparent bool // Sunlight isn't scattered.
22426                                 LightSrc    uint8
22427
22428                                 GndContent   bool
22429                                 Collides     bool
22430                                 Pointable    bool
22431                                 Diggable     bool
22432                                 Climbable    bool
22433                                 Replaceable  bool
22434                                 OnRightClick bool
22435
22436                                 DmgPerSec int32
22437
22438                                 LiquidType   LiquidType
22439                                 FlowingAlt   string
22440                                 SrcAlt       string
22441                                 Viscosity    uint8 // 0-7
22442                                 LiqRenewable bool
22443                                 FlowRange    uint8
22444                                 DrownDmg     uint8
22445                                 Floodable    bool
22446
22447                                 DrawBox, ColBox, SelBox NodeBox
22448
22449                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22450
22451                                 LegacyFaceDir bool
22452                                 LegacyMounted bool
22453
22454                                 DigPredict string
22455
22456                                 MaxLvl uint8
22457
22458                                 AlphaUse
22459                         }))(obj)).LiqRenewable
22460                         switch n := read8(r); n {
22461                         case 0:
22462                                 *p = false
22463                         case 1:
22464                                 *p = true
22465                         default:
22466                                 chk(fmt.Errorf("invalid bool: %d", n))
22467                         }
22468                 }
22469                 {
22470                         p := &(*(*(struct {
22471                                 Param0 Content
22472
22473                                 Name   string
22474                                 Groups []Group
22475
22476                                 P1Type   Param1Type
22477                                 P2Type   Param2Type
22478                                 DrawType DrawType
22479
22480                                 Mesh  string
22481                                 Scale float32
22482                                 //mt:const uint8(6)
22483                                 Tiles        [6]TileDef
22484                                 OverlayTiles [6]TileDef
22485                                 //mt:const uint8(6)
22486                                 SpecialTiles [6]TileDef
22487
22488                                 Color   color.NRGBA
22489                                 Palette Texture
22490
22491                                 Waving       WaveType
22492                                 ConnectSides uint8
22493                                 ConnectTo    []Content
22494                                 InsideTint   color.NRGBA
22495                                 Level        uint8 // Must be < 128.
22496
22497                                 Translucent bool // Sunlight is scattered and becomes normal light.
22498                                 Transparent bool // Sunlight isn't scattered.
22499                                 LightSrc    uint8
22500
22501                                 GndContent   bool
22502                                 Collides     bool
22503                                 Pointable    bool
22504                                 Diggable     bool
22505                                 Climbable    bool
22506                                 Replaceable  bool
22507                                 OnRightClick bool
22508
22509                                 DmgPerSec int32
22510
22511                                 LiquidType   LiquidType
22512                                 FlowingAlt   string
22513                                 SrcAlt       string
22514                                 Viscosity    uint8 // 0-7
22515                                 LiqRenewable bool
22516                                 FlowRange    uint8
22517                                 DrownDmg     uint8
22518                                 Floodable    bool
22519
22520                                 DrawBox, ColBox, SelBox NodeBox
22521
22522                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22523
22524                                 LegacyFaceDir bool
22525                                 LegacyMounted bool
22526
22527                                 DigPredict string
22528
22529                                 MaxLvl uint8
22530
22531                                 AlphaUse
22532                         }))(obj)).FlowRange
22533                         *p = read8(r)
22534                 }
22535                 {
22536                         p := &(*(*(struct {
22537                                 Param0 Content
22538
22539                                 Name   string
22540                                 Groups []Group
22541
22542                                 P1Type   Param1Type
22543                                 P2Type   Param2Type
22544                                 DrawType DrawType
22545
22546                                 Mesh  string
22547                                 Scale float32
22548                                 //mt:const uint8(6)
22549                                 Tiles        [6]TileDef
22550                                 OverlayTiles [6]TileDef
22551                                 //mt:const uint8(6)
22552                                 SpecialTiles [6]TileDef
22553
22554                                 Color   color.NRGBA
22555                                 Palette Texture
22556
22557                                 Waving       WaveType
22558                                 ConnectSides uint8
22559                                 ConnectTo    []Content
22560                                 InsideTint   color.NRGBA
22561                                 Level        uint8 // Must be < 128.
22562
22563                                 Translucent bool // Sunlight is scattered and becomes normal light.
22564                                 Transparent bool // Sunlight isn't scattered.
22565                                 LightSrc    uint8
22566
22567                                 GndContent   bool
22568                                 Collides     bool
22569                                 Pointable    bool
22570                                 Diggable     bool
22571                                 Climbable    bool
22572                                 Replaceable  bool
22573                                 OnRightClick bool
22574
22575                                 DmgPerSec int32
22576
22577                                 LiquidType   LiquidType
22578                                 FlowingAlt   string
22579                                 SrcAlt       string
22580                                 Viscosity    uint8 // 0-7
22581                                 LiqRenewable bool
22582                                 FlowRange    uint8
22583                                 DrownDmg     uint8
22584                                 Floodable    bool
22585
22586                                 DrawBox, ColBox, SelBox NodeBox
22587
22588                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22589
22590                                 LegacyFaceDir bool
22591                                 LegacyMounted bool
22592
22593                                 DigPredict string
22594
22595                                 MaxLvl uint8
22596
22597                                 AlphaUse
22598                         }))(obj)).DrownDmg
22599                         *p = read8(r)
22600                 }
22601                 {
22602                         p := &(*(*(struct {
22603                                 Param0 Content
22604
22605                                 Name   string
22606                                 Groups []Group
22607
22608                                 P1Type   Param1Type
22609                                 P2Type   Param2Type
22610                                 DrawType DrawType
22611
22612                                 Mesh  string
22613                                 Scale float32
22614                                 //mt:const uint8(6)
22615                                 Tiles        [6]TileDef
22616                                 OverlayTiles [6]TileDef
22617                                 //mt:const uint8(6)
22618                                 SpecialTiles [6]TileDef
22619
22620                                 Color   color.NRGBA
22621                                 Palette Texture
22622
22623                                 Waving       WaveType
22624                                 ConnectSides uint8
22625                                 ConnectTo    []Content
22626                                 InsideTint   color.NRGBA
22627                                 Level        uint8 // Must be < 128.
22628
22629                                 Translucent bool // Sunlight is scattered and becomes normal light.
22630                                 Transparent bool // Sunlight isn't scattered.
22631                                 LightSrc    uint8
22632
22633                                 GndContent   bool
22634                                 Collides     bool
22635                                 Pointable    bool
22636                                 Diggable     bool
22637                                 Climbable    bool
22638                                 Replaceable  bool
22639                                 OnRightClick bool
22640
22641                                 DmgPerSec int32
22642
22643                                 LiquidType   LiquidType
22644                                 FlowingAlt   string
22645                                 SrcAlt       string
22646                                 Viscosity    uint8 // 0-7
22647                                 LiqRenewable bool
22648                                 FlowRange    uint8
22649                                 DrownDmg     uint8
22650                                 Floodable    bool
22651
22652                                 DrawBox, ColBox, SelBox NodeBox
22653
22654                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22655
22656                                 LegacyFaceDir bool
22657                                 LegacyMounted bool
22658
22659                                 DigPredict string
22660
22661                                 MaxLvl uint8
22662
22663                                 AlphaUse
22664                         }))(obj)).Floodable
22665                         switch n := read8(r); n {
22666                         case 0:
22667                                 *p = false
22668                         case 1:
22669                                 *p = true
22670                         default:
22671                                 chk(fmt.Errorf("invalid bool: %d", n))
22672                         }
22673                 }
22674                 if err := pcall(func() {
22675                         ((*(*(struct {
22676                                 Param0 Content
22677
22678                                 Name   string
22679                                 Groups []Group
22680
22681                                 P1Type   Param1Type
22682                                 P2Type   Param2Type
22683                                 DrawType DrawType
22684
22685                                 Mesh  string
22686                                 Scale float32
22687                                 //mt:const uint8(6)
22688                                 Tiles        [6]TileDef
22689                                 OverlayTiles [6]TileDef
22690                                 //mt:const uint8(6)
22691                                 SpecialTiles [6]TileDef
22692
22693                                 Color   color.NRGBA
22694                                 Palette Texture
22695
22696                                 Waving       WaveType
22697                                 ConnectSides uint8
22698                                 ConnectTo    []Content
22699                                 InsideTint   color.NRGBA
22700                                 Level        uint8 // Must be < 128.
22701
22702                                 Translucent bool // Sunlight is scattered and becomes normal light.
22703                                 Transparent bool // Sunlight isn't scattered.
22704                                 LightSrc    uint8
22705
22706                                 GndContent   bool
22707                                 Collides     bool
22708                                 Pointable    bool
22709                                 Diggable     bool
22710                                 Climbable    bool
22711                                 Replaceable  bool
22712                                 OnRightClick bool
22713
22714                                 DmgPerSec int32
22715
22716                                 LiquidType   LiquidType
22717                                 FlowingAlt   string
22718                                 SrcAlt       string
22719                                 Viscosity    uint8 // 0-7
22720                                 LiqRenewable bool
22721                                 FlowRange    uint8
22722                                 DrownDmg     uint8
22723                                 Floodable    bool
22724
22725                                 DrawBox, ColBox, SelBox NodeBox
22726
22727                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22728
22729                                 LegacyFaceDir bool
22730                                 LegacyMounted bool
22731
22732                                 DigPredict string
22733
22734                                 MaxLvl uint8
22735
22736                                 AlphaUse
22737                         }))(obj)).DrawBox).deserialize(r)
22738                 }); err != nil {
22739                         if err == io.EOF {
22740                                 chk(io.EOF)
22741                         }
22742                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
22743                 }
22744                 if err := pcall(func() {
22745                         ((*(*(struct {
22746                                 Param0 Content
22747
22748                                 Name   string
22749                                 Groups []Group
22750
22751                                 P1Type   Param1Type
22752                                 P2Type   Param2Type
22753                                 DrawType DrawType
22754
22755                                 Mesh  string
22756                                 Scale float32
22757                                 //mt:const uint8(6)
22758                                 Tiles        [6]TileDef
22759                                 OverlayTiles [6]TileDef
22760                                 //mt:const uint8(6)
22761                                 SpecialTiles [6]TileDef
22762
22763                                 Color   color.NRGBA
22764                                 Palette Texture
22765
22766                                 Waving       WaveType
22767                                 ConnectSides uint8
22768                                 ConnectTo    []Content
22769                                 InsideTint   color.NRGBA
22770                                 Level        uint8 // Must be < 128.
22771
22772                                 Translucent bool // Sunlight is scattered and becomes normal light.
22773                                 Transparent bool // Sunlight isn't scattered.
22774                                 LightSrc    uint8
22775
22776                                 GndContent   bool
22777                                 Collides     bool
22778                                 Pointable    bool
22779                                 Diggable     bool
22780                                 Climbable    bool
22781                                 Replaceable  bool
22782                                 OnRightClick bool
22783
22784                                 DmgPerSec int32
22785
22786                                 LiquidType   LiquidType
22787                                 FlowingAlt   string
22788                                 SrcAlt       string
22789                                 Viscosity    uint8 // 0-7
22790                                 LiqRenewable bool
22791                                 FlowRange    uint8
22792                                 DrownDmg     uint8
22793                                 Floodable    bool
22794
22795                                 DrawBox, ColBox, SelBox NodeBox
22796
22797                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22798
22799                                 LegacyFaceDir bool
22800                                 LegacyMounted bool
22801
22802                                 DigPredict string
22803
22804                                 MaxLvl uint8
22805
22806                                 AlphaUse
22807                         }))(obj)).ColBox).deserialize(r)
22808                 }); err != nil {
22809                         if err == io.EOF {
22810                                 chk(io.EOF)
22811                         }
22812                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
22813                 }
22814                 if err := pcall(func() {
22815                         ((*(*(struct {
22816                                 Param0 Content
22817
22818                                 Name   string
22819                                 Groups []Group
22820
22821                                 P1Type   Param1Type
22822                                 P2Type   Param2Type
22823                                 DrawType DrawType
22824
22825                                 Mesh  string
22826                                 Scale float32
22827                                 //mt:const uint8(6)
22828                                 Tiles        [6]TileDef
22829                                 OverlayTiles [6]TileDef
22830                                 //mt:const uint8(6)
22831                                 SpecialTiles [6]TileDef
22832
22833                                 Color   color.NRGBA
22834                                 Palette Texture
22835
22836                                 Waving       WaveType
22837                                 ConnectSides uint8
22838                                 ConnectTo    []Content
22839                                 InsideTint   color.NRGBA
22840                                 Level        uint8 // Must be < 128.
22841
22842                                 Translucent bool // Sunlight is scattered and becomes normal light.
22843                                 Transparent bool // Sunlight isn't scattered.
22844                                 LightSrc    uint8
22845
22846                                 GndContent   bool
22847                                 Collides     bool
22848                                 Pointable    bool
22849                                 Diggable     bool
22850                                 Climbable    bool
22851                                 Replaceable  bool
22852                                 OnRightClick bool
22853
22854                                 DmgPerSec int32
22855
22856                                 LiquidType   LiquidType
22857                                 FlowingAlt   string
22858                                 SrcAlt       string
22859                                 Viscosity    uint8 // 0-7
22860                                 LiqRenewable bool
22861                                 FlowRange    uint8
22862                                 DrownDmg     uint8
22863                                 Floodable    bool
22864
22865                                 DrawBox, ColBox, SelBox NodeBox
22866
22867                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22868
22869                                 LegacyFaceDir bool
22870                                 LegacyMounted bool
22871
22872                                 DigPredict string
22873
22874                                 MaxLvl uint8
22875
22876                                 AlphaUse
22877                         }))(obj)).SelBox).deserialize(r)
22878                 }); err != nil {
22879                         if err == io.EOF {
22880                                 chk(io.EOF)
22881                         }
22882                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
22883                 }
22884                 if err := pcall(func() {
22885                         ((*(*(struct {
22886                                 Param0 Content
22887
22888                                 Name   string
22889                                 Groups []Group
22890
22891                                 P1Type   Param1Type
22892                                 P2Type   Param2Type
22893                                 DrawType DrawType
22894
22895                                 Mesh  string
22896                                 Scale float32
22897                                 //mt:const uint8(6)
22898                                 Tiles        [6]TileDef
22899                                 OverlayTiles [6]TileDef
22900                                 //mt:const uint8(6)
22901                                 SpecialTiles [6]TileDef
22902
22903                                 Color   color.NRGBA
22904                                 Palette Texture
22905
22906                                 Waving       WaveType
22907                                 ConnectSides uint8
22908                                 ConnectTo    []Content
22909                                 InsideTint   color.NRGBA
22910                                 Level        uint8 // Must be < 128.
22911
22912                                 Translucent bool // Sunlight is scattered and becomes normal light.
22913                                 Transparent bool // Sunlight isn't scattered.
22914                                 LightSrc    uint8
22915
22916                                 GndContent   bool
22917                                 Collides     bool
22918                                 Pointable    bool
22919                                 Diggable     bool
22920                                 Climbable    bool
22921                                 Replaceable  bool
22922                                 OnRightClick bool
22923
22924                                 DmgPerSec int32
22925
22926                                 LiquidType   LiquidType
22927                                 FlowingAlt   string
22928                                 SrcAlt       string
22929                                 Viscosity    uint8 // 0-7
22930                                 LiqRenewable bool
22931                                 FlowRange    uint8
22932                                 DrownDmg     uint8
22933                                 Floodable    bool
22934
22935                                 DrawBox, ColBox, SelBox NodeBox
22936
22937                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22938
22939                                 LegacyFaceDir bool
22940                                 LegacyMounted bool
22941
22942                                 DigPredict string
22943
22944                                 MaxLvl uint8
22945
22946                                 AlphaUse
22947                         }))(obj)).FootstepSnd).deserialize(r)
22948                 }); err != nil {
22949                         if err == io.EOF {
22950                                 chk(io.EOF)
22951                         }
22952                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
22953                 }
22954                 if err := pcall(func() {
22955                         ((*(*(struct {
22956                                 Param0 Content
22957
22958                                 Name   string
22959                                 Groups []Group
22960
22961                                 P1Type   Param1Type
22962                                 P2Type   Param2Type
22963                                 DrawType DrawType
22964
22965                                 Mesh  string
22966                                 Scale float32
22967                                 //mt:const uint8(6)
22968                                 Tiles        [6]TileDef
22969                                 OverlayTiles [6]TileDef
22970                                 //mt:const uint8(6)
22971                                 SpecialTiles [6]TileDef
22972
22973                                 Color   color.NRGBA
22974                                 Palette Texture
22975
22976                                 Waving       WaveType
22977                                 ConnectSides uint8
22978                                 ConnectTo    []Content
22979                                 InsideTint   color.NRGBA
22980                                 Level        uint8 // Must be < 128.
22981
22982                                 Translucent bool // Sunlight is scattered and becomes normal light.
22983                                 Transparent bool // Sunlight isn't scattered.
22984                                 LightSrc    uint8
22985
22986                                 GndContent   bool
22987                                 Collides     bool
22988                                 Pointable    bool
22989                                 Diggable     bool
22990                                 Climbable    bool
22991                                 Replaceable  bool
22992                                 OnRightClick bool
22993
22994                                 DmgPerSec int32
22995
22996                                 LiquidType   LiquidType
22997                                 FlowingAlt   string
22998                                 SrcAlt       string
22999                                 Viscosity    uint8 // 0-7
23000                                 LiqRenewable bool
23001                                 FlowRange    uint8
23002                                 DrownDmg     uint8
23003                                 Floodable    bool
23004
23005                                 DrawBox, ColBox, SelBox NodeBox
23006
23007                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23008
23009                                 LegacyFaceDir bool
23010                                 LegacyMounted bool
23011
23012                                 DigPredict string
23013
23014                                 MaxLvl uint8
23015
23016                                 AlphaUse
23017                         }))(obj)).DiggingSnd).deserialize(r)
23018                 }); err != nil {
23019                         if err == io.EOF {
23020                                 chk(io.EOF)
23021                         }
23022                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
23023                 }
23024                 if err := pcall(func() {
23025                         ((*(*(struct {
23026                                 Param0 Content
23027
23028                                 Name   string
23029                                 Groups []Group
23030
23031                                 P1Type   Param1Type
23032                                 P2Type   Param2Type
23033                                 DrawType DrawType
23034
23035                                 Mesh  string
23036                                 Scale float32
23037                                 //mt:const uint8(6)
23038                                 Tiles        [6]TileDef
23039                                 OverlayTiles [6]TileDef
23040                                 //mt:const uint8(6)
23041                                 SpecialTiles [6]TileDef
23042
23043                                 Color   color.NRGBA
23044                                 Palette Texture
23045
23046                                 Waving       WaveType
23047                                 ConnectSides uint8
23048                                 ConnectTo    []Content
23049                                 InsideTint   color.NRGBA
23050                                 Level        uint8 // Must be < 128.
23051
23052                                 Translucent bool // Sunlight is scattered and becomes normal light.
23053                                 Transparent bool // Sunlight isn't scattered.
23054                                 LightSrc    uint8
23055
23056                                 GndContent   bool
23057                                 Collides     bool
23058                                 Pointable    bool
23059                                 Diggable     bool
23060                                 Climbable    bool
23061                                 Replaceable  bool
23062                                 OnRightClick bool
23063
23064                                 DmgPerSec int32
23065
23066                                 LiquidType   LiquidType
23067                                 FlowingAlt   string
23068                                 SrcAlt       string
23069                                 Viscosity    uint8 // 0-7
23070                                 LiqRenewable bool
23071                                 FlowRange    uint8
23072                                 DrownDmg     uint8
23073                                 Floodable    bool
23074
23075                                 DrawBox, ColBox, SelBox NodeBox
23076
23077                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23078
23079                                 LegacyFaceDir bool
23080                                 LegacyMounted bool
23081
23082                                 DigPredict string
23083
23084                                 MaxLvl uint8
23085
23086                                 AlphaUse
23087                         }))(obj)).DugSnd).deserialize(r)
23088                 }); err != nil {
23089                         if err == io.EOF {
23090                                 chk(io.EOF)
23091                         }
23092                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
23093                 }
23094                 {
23095                         p := &(*(*(struct {
23096                                 Param0 Content
23097
23098                                 Name   string
23099                                 Groups []Group
23100
23101                                 P1Type   Param1Type
23102                                 P2Type   Param2Type
23103                                 DrawType DrawType
23104
23105                                 Mesh  string
23106                                 Scale float32
23107                                 //mt:const uint8(6)
23108                                 Tiles        [6]TileDef
23109                                 OverlayTiles [6]TileDef
23110                                 //mt:const uint8(6)
23111                                 SpecialTiles [6]TileDef
23112
23113                                 Color   color.NRGBA
23114                                 Palette Texture
23115
23116                                 Waving       WaveType
23117                                 ConnectSides uint8
23118                                 ConnectTo    []Content
23119                                 InsideTint   color.NRGBA
23120                                 Level        uint8 // Must be < 128.
23121
23122                                 Translucent bool // Sunlight is scattered and becomes normal light.
23123                                 Transparent bool // Sunlight isn't scattered.
23124                                 LightSrc    uint8
23125
23126                                 GndContent   bool
23127                                 Collides     bool
23128                                 Pointable    bool
23129                                 Diggable     bool
23130                                 Climbable    bool
23131                                 Replaceable  bool
23132                                 OnRightClick bool
23133
23134                                 DmgPerSec int32
23135
23136                                 LiquidType   LiquidType
23137                                 FlowingAlt   string
23138                                 SrcAlt       string
23139                                 Viscosity    uint8 // 0-7
23140                                 LiqRenewable bool
23141                                 FlowRange    uint8
23142                                 DrownDmg     uint8
23143                                 Floodable    bool
23144
23145                                 DrawBox, ColBox, SelBox NodeBox
23146
23147                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23148
23149                                 LegacyFaceDir bool
23150                                 LegacyMounted bool
23151
23152                                 DigPredict string
23153
23154                                 MaxLvl uint8
23155
23156                                 AlphaUse
23157                         }))(obj)).LegacyFaceDir
23158                         switch n := read8(r); n {
23159                         case 0:
23160                                 *p = false
23161                         case 1:
23162                                 *p = true
23163                         default:
23164                                 chk(fmt.Errorf("invalid bool: %d", n))
23165                         }
23166                 }
23167                 {
23168                         p := &(*(*(struct {
23169                                 Param0 Content
23170
23171                                 Name   string
23172                                 Groups []Group
23173
23174                                 P1Type   Param1Type
23175                                 P2Type   Param2Type
23176                                 DrawType DrawType
23177
23178                                 Mesh  string
23179                                 Scale float32
23180                                 //mt:const uint8(6)
23181                                 Tiles        [6]TileDef
23182                                 OverlayTiles [6]TileDef
23183                                 //mt:const uint8(6)
23184                                 SpecialTiles [6]TileDef
23185
23186                                 Color   color.NRGBA
23187                                 Palette Texture
23188
23189                                 Waving       WaveType
23190                                 ConnectSides uint8
23191                                 ConnectTo    []Content
23192                                 InsideTint   color.NRGBA
23193                                 Level        uint8 // Must be < 128.
23194
23195                                 Translucent bool // Sunlight is scattered and becomes normal light.
23196                                 Transparent bool // Sunlight isn't scattered.
23197                                 LightSrc    uint8
23198
23199                                 GndContent   bool
23200                                 Collides     bool
23201                                 Pointable    bool
23202                                 Diggable     bool
23203                                 Climbable    bool
23204                                 Replaceable  bool
23205                                 OnRightClick bool
23206
23207                                 DmgPerSec int32
23208
23209                                 LiquidType   LiquidType
23210                                 FlowingAlt   string
23211                                 SrcAlt       string
23212                                 Viscosity    uint8 // 0-7
23213                                 LiqRenewable bool
23214                                 FlowRange    uint8
23215                                 DrownDmg     uint8
23216                                 Floodable    bool
23217
23218                                 DrawBox, ColBox, SelBox NodeBox
23219
23220                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23221
23222                                 LegacyFaceDir bool
23223                                 LegacyMounted bool
23224
23225                                 DigPredict string
23226
23227                                 MaxLvl uint8
23228
23229                                 AlphaUse
23230                         }))(obj)).LegacyMounted
23231                         switch n := read8(r); n {
23232                         case 0:
23233                                 *p = false
23234                         case 1:
23235                                 *p = true
23236                         default:
23237                                 chk(fmt.Errorf("invalid bool: %d", n))
23238                         }
23239                 }
23240                 var local274 []uint8
23241                 var local275 uint16
23242                 {
23243                         p := &local275
23244                         *p = read16(r)
23245                 }
23246                 (local274) = make([]uint8, local275)
23247                 {
23248                         _, err := io.ReadFull(r, (local274)[:])
23249                         chk(err)
23250                 }
23251                 ((*(*(struct {
23252                         Param0 Content
23253
23254                         Name   string
23255                         Groups []Group
23256
23257                         P1Type   Param1Type
23258                         P2Type   Param2Type
23259                         DrawType DrawType
23260
23261                         Mesh  string
23262                         Scale float32
23263                         //mt:const uint8(6)
23264                         Tiles        [6]TileDef
23265                         OverlayTiles [6]TileDef
23266                         //mt:const uint8(6)
23267                         SpecialTiles [6]TileDef
23268
23269                         Color   color.NRGBA
23270                         Palette Texture
23271
23272                         Waving       WaveType
23273                         ConnectSides uint8
23274                         ConnectTo    []Content
23275                         InsideTint   color.NRGBA
23276                         Level        uint8 // Must be < 128.
23277
23278                         Translucent bool // Sunlight is scattered and becomes normal light.
23279                         Transparent bool // Sunlight isn't scattered.
23280                         LightSrc    uint8
23281
23282                         GndContent   bool
23283                         Collides     bool
23284                         Pointable    bool
23285                         Diggable     bool
23286                         Climbable    bool
23287                         Replaceable  bool
23288                         OnRightClick bool
23289
23290                         DmgPerSec int32
23291
23292                         LiquidType   LiquidType
23293                         FlowingAlt   string
23294                         SrcAlt       string
23295                         Viscosity    uint8 // 0-7
23296                         LiqRenewable bool
23297                         FlowRange    uint8
23298                         DrownDmg     uint8
23299                         Floodable    bool
23300
23301                         DrawBox, ColBox, SelBox NodeBox
23302
23303                         FootstepSnd, DiggingSnd, DugSnd SoundDef
23304
23305                         LegacyFaceDir bool
23306                         LegacyMounted bool
23307
23308                         DigPredict string
23309
23310                         MaxLvl uint8
23311
23312                         AlphaUse
23313                 }))(obj)).DigPredict) = string(local274)
23314                 {
23315                         p := &(*(*(struct {
23316                                 Param0 Content
23317
23318                                 Name   string
23319                                 Groups []Group
23320
23321                                 P1Type   Param1Type
23322                                 P2Type   Param2Type
23323                                 DrawType DrawType
23324
23325                                 Mesh  string
23326                                 Scale float32
23327                                 //mt:const uint8(6)
23328                                 Tiles        [6]TileDef
23329                                 OverlayTiles [6]TileDef
23330                                 //mt:const uint8(6)
23331                                 SpecialTiles [6]TileDef
23332
23333                                 Color   color.NRGBA
23334                                 Palette Texture
23335
23336                                 Waving       WaveType
23337                                 ConnectSides uint8
23338                                 ConnectTo    []Content
23339                                 InsideTint   color.NRGBA
23340                                 Level        uint8 // Must be < 128.
23341
23342                                 Translucent bool // Sunlight is scattered and becomes normal light.
23343                                 Transparent bool // Sunlight isn't scattered.
23344                                 LightSrc    uint8
23345
23346                                 GndContent   bool
23347                                 Collides     bool
23348                                 Pointable    bool
23349                                 Diggable     bool
23350                                 Climbable    bool
23351                                 Replaceable  bool
23352                                 OnRightClick bool
23353
23354                                 DmgPerSec int32
23355
23356                                 LiquidType   LiquidType
23357                                 FlowingAlt   string
23358                                 SrcAlt       string
23359                                 Viscosity    uint8 // 0-7
23360                                 LiqRenewable bool
23361                                 FlowRange    uint8
23362                                 DrownDmg     uint8
23363                                 Floodable    bool
23364
23365                                 DrawBox, ColBox, SelBox NodeBox
23366
23367                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23368
23369                                 LegacyFaceDir bool
23370                                 LegacyMounted bool
23371
23372                                 DigPredict string
23373
23374                                 MaxLvl uint8
23375
23376                                 AlphaUse
23377                         }))(obj)).MaxLvl
23378                         *p = read8(r)
23379                 }
23380                 if err := pcall(func() {
23381                         ((*(*(struct {
23382                                 Param0 Content
23383
23384                                 Name   string
23385                                 Groups []Group
23386
23387                                 P1Type   Param1Type
23388                                 P2Type   Param2Type
23389                                 DrawType DrawType
23390
23391                                 Mesh  string
23392                                 Scale float32
23393                                 //mt:const uint8(6)
23394                                 Tiles        [6]TileDef
23395                                 OverlayTiles [6]TileDef
23396                                 //mt:const uint8(6)
23397                                 SpecialTiles [6]TileDef
23398
23399                                 Color   color.NRGBA
23400                                 Palette Texture
23401
23402                                 Waving       WaveType
23403                                 ConnectSides uint8
23404                                 ConnectTo    []Content
23405                                 InsideTint   color.NRGBA
23406                                 Level        uint8 // Must be < 128.
23407
23408                                 Translucent bool // Sunlight is scattered and becomes normal light.
23409                                 Transparent bool // Sunlight isn't scattered.
23410                                 LightSrc    uint8
23411
23412                                 GndContent   bool
23413                                 Collides     bool
23414                                 Pointable    bool
23415                                 Diggable     bool
23416                                 Climbable    bool
23417                                 Replaceable  bool
23418                                 OnRightClick bool
23419
23420                                 DmgPerSec int32
23421
23422                                 LiquidType   LiquidType
23423                                 FlowingAlt   string
23424                                 SrcAlt       string
23425                                 Viscosity    uint8 // 0-7
23426                                 LiqRenewable bool
23427                                 FlowRange    uint8
23428                                 DrownDmg     uint8
23429                                 Floodable    bool
23430
23431                                 DrawBox, ColBox, SelBox NodeBox
23432
23433                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23434
23435                                 LegacyFaceDir bool
23436                                 LegacyMounted bool
23437
23438                                 DigPredict string
23439
23440                                 MaxLvl uint8
23441
23442                                 AlphaUse
23443                         }))(obj)).AlphaUse).deserialize(r)
23444                 }); err != nil {
23445                         if err == io.EOF {
23446                                 chk(io.EOF)
23447                         }
23448                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlphaUse", err))
23449                 }
23450                 if r.N > 0 {
23451                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23452                 }
23453         }
23454 }
23455
23456 func (obj *PointedNode) serialize(w io.Writer) {
23457         for local276 := range (*(*(struct {
23458                 Under, Above [3]int16
23459         }))(obj)).Under {
23460                 {
23461                         x := ((*(*(struct {
23462                                 Under, Above [3]int16
23463                         }))(obj)).Under)[local276]
23464                         write16(w, uint16(x))
23465                 }
23466         }
23467         for local277 := range (*(*(struct {
23468                 Under, Above [3]int16
23469         }))(obj)).Above {
23470                 {
23471                         x := ((*(*(struct {
23472                                 Under, Above [3]int16
23473                         }))(obj)).Above)[local277]
23474                         write16(w, uint16(x))
23475                 }
23476         }
23477 }
23478
23479 func (obj *PointedNode) deserialize(r io.Reader) {
23480         for local278 := range (*(*(struct {
23481                 Under, Above [3]int16
23482         }))(obj)).Under {
23483                 {
23484                         p := &((*(*(struct {
23485                                 Under, Above [3]int16
23486                         }))(obj)).Under)[local278]
23487                         *p = int16(read16(r))
23488                 }
23489         }
23490         for local279 := range (*(*(struct {
23491                 Under, Above [3]int16
23492         }))(obj)).Above {
23493                 {
23494                         p := &((*(*(struct {
23495                                 Under, Above [3]int16
23496                         }))(obj)).Above)[local279]
23497                         *p = int16(read16(r))
23498                 }
23499         }
23500 }
23501
23502 func (obj *PointedAO) serialize(w io.Writer) {
23503         if err := pcall(func() {
23504                 ((*(*(struct {
23505                         ID AOID
23506                 }))(obj)).ID).serialize(w)
23507         }); err != nil {
23508                 if err == io.EOF {
23509                         chk(io.EOF)
23510                 }
23511                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23512         }
23513 }
23514
23515 func (obj *PointedAO) deserialize(r io.Reader) {
23516         if err := pcall(func() {
23517                 ((*(*(struct {
23518                         ID AOID
23519                 }))(obj)).ID).deserialize(r)
23520         }); err != nil {
23521                 if err == io.EOF {
23522                         chk(io.EOF)
23523                 }
23524                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23525         }
23526 }
23527
23528 func (obj *CompressionModes) serialize(w io.Writer) {
23529         {
23530                 x := *(*(uint16))(obj)
23531                 write16(w, uint16(x))
23532         }
23533 }
23534
23535 func (obj *CompressionModes) deserialize(r io.Reader) {
23536         {
23537                 p := &*(*(uint16))(obj)
23538                 *p = read16(r)
23539         }
23540 }
23541
23542 func (obj *PlayerPos) serialize(w io.Writer) {
23543         for local280 := range (*(*(struct {
23544                 Pos100, Vel100   [3]int32
23545                 Pitch100, Yaw100 int32
23546                 Keys             Keys
23547                 FOV80            uint8
23548                 WantedRange      uint8 // in MapBlks.
23549         }))(obj)).Pos100 {
23550                 {
23551                         x := ((*(*(struct {
23552                                 Pos100, Vel100   [3]int32
23553                                 Pitch100, Yaw100 int32
23554                                 Keys             Keys
23555                                 FOV80            uint8
23556                                 WantedRange      uint8 // in MapBlks.
23557                         }))(obj)).Pos100)[local280]
23558                         write32(w, uint32(x))
23559                 }
23560         }
23561         for local281 := range (*(*(struct {
23562                 Pos100, Vel100   [3]int32
23563                 Pitch100, Yaw100 int32
23564                 Keys             Keys
23565                 FOV80            uint8
23566                 WantedRange      uint8 // in MapBlks.
23567         }))(obj)).Vel100 {
23568                 {
23569                         x := ((*(*(struct {
23570                                 Pos100, Vel100   [3]int32
23571                                 Pitch100, Yaw100 int32
23572                                 Keys             Keys
23573                                 FOV80            uint8
23574                                 WantedRange      uint8 // in MapBlks.
23575                         }))(obj)).Vel100)[local281]
23576                         write32(w, uint32(x))
23577                 }
23578         }
23579         {
23580                 x := (*(*(struct {
23581                         Pos100, Vel100   [3]int32
23582                         Pitch100, Yaw100 int32
23583                         Keys             Keys
23584                         FOV80            uint8
23585                         WantedRange      uint8 // in MapBlks.
23586                 }))(obj)).Pitch100
23587                 write32(w, uint32(x))
23588         }
23589         {
23590                 x := (*(*(struct {
23591                         Pos100, Vel100   [3]int32
23592                         Pitch100, Yaw100 int32
23593                         Keys             Keys
23594                         FOV80            uint8
23595                         WantedRange      uint8 // in MapBlks.
23596                 }))(obj)).Yaw100
23597                 write32(w, uint32(x))
23598         }
23599         if err := pcall(func() {
23600                 ((*(*(struct {
23601                         Pos100, Vel100   [3]int32
23602                         Pitch100, Yaw100 int32
23603                         Keys             Keys
23604                         FOV80            uint8
23605                         WantedRange      uint8 // in MapBlks.
23606                 }))(obj)).Keys).serialize(w)
23607         }); err != nil {
23608                 if err == io.EOF {
23609                         chk(io.EOF)
23610                 }
23611                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Keys", err))
23612         }
23613         {
23614                 x := (*(*(struct {
23615                         Pos100, Vel100   [3]int32
23616                         Pitch100, Yaw100 int32
23617                         Keys             Keys
23618                         FOV80            uint8
23619                         WantedRange      uint8 // in MapBlks.
23620                 }))(obj)).FOV80
23621                 write8(w, uint8(x))
23622         }
23623         {
23624                 x := (*(*(struct {
23625                         Pos100, Vel100   [3]int32
23626                         Pitch100, Yaw100 int32
23627                         Keys             Keys
23628                         FOV80            uint8
23629                         WantedRange      uint8 // in MapBlks.
23630                 }))(obj)).WantedRange
23631                 write8(w, uint8(x))
23632         }
23633 }
23634
23635 func (obj *PlayerPos) deserialize(r io.Reader) {
23636         for local282 := range (*(*(struct {
23637                 Pos100, Vel100   [3]int32
23638                 Pitch100, Yaw100 int32
23639                 Keys             Keys
23640                 FOV80            uint8
23641                 WantedRange      uint8 // in MapBlks.
23642         }))(obj)).Pos100 {
23643                 {
23644                         p := &((*(*(struct {
23645                                 Pos100, Vel100   [3]int32
23646                                 Pitch100, Yaw100 int32
23647                                 Keys             Keys
23648                                 FOV80            uint8
23649                                 WantedRange      uint8 // in MapBlks.
23650                         }))(obj)).Pos100)[local282]
23651                         *p = int32(read32(r))
23652                 }
23653         }
23654         for local283 := range (*(*(struct {
23655                 Pos100, Vel100   [3]int32
23656                 Pitch100, Yaw100 int32
23657                 Keys             Keys
23658                 FOV80            uint8
23659                 WantedRange      uint8 // in MapBlks.
23660         }))(obj)).Vel100 {
23661                 {
23662                         p := &((*(*(struct {
23663                                 Pos100, Vel100   [3]int32
23664                                 Pitch100, Yaw100 int32
23665                                 Keys             Keys
23666                                 FOV80            uint8
23667                                 WantedRange      uint8 // in MapBlks.
23668                         }))(obj)).Vel100)[local283]
23669                         *p = int32(read32(r))
23670                 }
23671         }
23672         {
23673                 p := &(*(*(struct {
23674                         Pos100, Vel100   [3]int32
23675                         Pitch100, Yaw100 int32
23676                         Keys             Keys
23677                         FOV80            uint8
23678                         WantedRange      uint8 // in MapBlks.
23679                 }))(obj)).Pitch100
23680                 *p = int32(read32(r))
23681         }
23682         {
23683                 p := &(*(*(struct {
23684                         Pos100, Vel100   [3]int32
23685                         Pitch100, Yaw100 int32
23686                         Keys             Keys
23687                         FOV80            uint8
23688                         WantedRange      uint8 // in MapBlks.
23689                 }))(obj)).Yaw100
23690                 *p = int32(read32(r))
23691         }
23692         if err := pcall(func() {
23693                 ((*(*(struct {
23694                         Pos100, Vel100   [3]int32
23695                         Pitch100, Yaw100 int32
23696                         Keys             Keys
23697                         FOV80            uint8
23698                         WantedRange      uint8 // in MapBlks.
23699                 }))(obj)).Keys).deserialize(r)
23700         }); err != nil {
23701                 if err == io.EOF {
23702                         chk(io.EOF)
23703                 }
23704                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Keys", err))
23705         }
23706         {
23707                 p := &(*(*(struct {
23708                         Pos100, Vel100   [3]int32
23709                         Pitch100, Yaw100 int32
23710                         Keys             Keys
23711                         FOV80            uint8
23712                         WantedRange      uint8 // in MapBlks.
23713                 }))(obj)).FOV80
23714                 *p = read8(r)
23715         }
23716         {
23717                 p := &(*(*(struct {
23718                         Pos100, Vel100   [3]int32
23719                         Pitch100, Yaw100 int32
23720                         Keys             Keys
23721                         FOV80            uint8
23722                         WantedRange      uint8 // in MapBlks.
23723                 }))(obj)).WantedRange
23724                 *p = read8(r)
23725         }
23726 }
23727
23728 func (obj *Interaction) serialize(w io.Writer) {
23729         {
23730                 x := *(*(uint8))(obj)
23731                 write8(w, uint8(x))
23732         }
23733 }
23734
23735 func (obj *Interaction) deserialize(r io.Reader) {
23736         {
23737                 p := &*(*(uint8))(obj)
23738                 *p = read8(r)
23739         }
23740 }
23741
23742 func (obj *SoundID) serialize(w io.Writer) {
23743         {
23744                 x := *(*(int32))(obj)
23745                 write32(w, uint32(x))
23746         }
23747 }
23748
23749 func (obj *SoundID) deserialize(r io.Reader) {
23750         {
23751                 p := &*(*(int32))(obj)
23752                 *p = int32(read32(r))
23753         }
23754 }
23755
23756 func (obj *Field) serialize(w io.Writer) {
23757         if len(([]byte((*(*(struct {
23758                 Name string
23759
23760                 //mt:len32
23761                 Value string
23762         }))(obj)).Name))) > math.MaxUint16 {
23763                 chk(ErrTooLong)
23764         }
23765         {
23766                 x := uint16(len(([]byte((*(*(struct {
23767                         Name string
23768
23769                         //mt:len32
23770                         Value string
23771                 }))(obj)).Name))))
23772                 write16(w, uint16(x))
23773         }
23774         {
23775                 _, err := w.Write(([]byte((*(*(struct {
23776                         Name string
23777
23778                         //mt:len32
23779                         Value string
23780                 }))(obj)).Name))[:])
23781                 chk(err)
23782         }
23783         if len(([]byte((*(*(struct {
23784                 Name string
23785
23786                 //mt:len32
23787                 Value string
23788         }))(obj)).Value))) > math.MaxUint32 {
23789                 chk(ErrTooLong)
23790         }
23791         {
23792                 x := uint32(len(([]byte((*(*(struct {
23793                         Name string
23794
23795                         //mt:len32
23796                         Value string
23797                 }))(obj)).Value))))
23798                 write32(w, uint32(x))
23799         }
23800         {
23801                 _, err := w.Write(([]byte((*(*(struct {
23802                         Name string
23803
23804                         //mt:len32
23805                         Value string
23806                 }))(obj)).Value))[:])
23807                 chk(err)
23808         }
23809 }
23810
23811 func (obj *Field) deserialize(r io.Reader) {
23812         var local284 []uint8
23813         var local285 uint16
23814         {
23815                 p := &local285
23816                 *p = read16(r)
23817         }
23818         (local284) = make([]uint8, local285)
23819         {
23820                 _, err := io.ReadFull(r, (local284)[:])
23821                 chk(err)
23822         }
23823         ((*(*(struct {
23824                 Name string
23825
23826                 //mt:len32
23827                 Value string
23828         }))(obj)).Name) = string(local284)
23829         var local286 []uint8
23830         var local287 uint32
23831         {
23832                 p := &local287
23833                 *p = read32(r)
23834         }
23835         (local286) = make([]uint8, local287)
23836         {
23837                 _, err := io.ReadFull(r, (local286)[:])
23838                 chk(err)
23839         }
23840         ((*(*(struct {
23841                 Name string
23842
23843                 //mt:len32
23844                 Value string
23845         }))(obj)).Value) = string(local286)
23846 }
23847
23848 func (obj *AuthMethods) serialize(w io.Writer) {
23849         {
23850                 x := *(*(uint32))(obj)
23851                 write32(w, uint32(x))
23852         }
23853 }
23854
23855 func (obj *AuthMethods) deserialize(r io.Reader) {
23856         {
23857                 p := &*(*(uint32))(obj)
23858                 *p = read32(r)
23859         }
23860 }
23861
23862 func (obj *Pos) serialize(w io.Writer) {
23863         if err := pcall(func() {
23864                 (*(*(Vec))(obj)).serialize(w)
23865         }); err != nil {
23866                 if err == io.EOF {
23867                         chk(io.EOF)
23868                 }
23869                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
23870         }
23871 }
23872
23873 func (obj *Pos) deserialize(r io.Reader) {
23874         if err := pcall(func() {
23875                 (*(*(Vec))(obj)).deserialize(r)
23876         }); err != nil {
23877                 if err == io.EOF {
23878                         chk(io.EOF)
23879                 }
23880                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
23881         }
23882 }
23883
23884 func (obj *DiscoReason) serialize(w io.Writer) {
23885         {
23886                 x := *(*(uint8))(obj)
23887                 write8(w, uint8(x))
23888         }
23889 }
23890
23891 func (obj *DiscoReason) deserialize(r io.Reader) {
23892         {
23893                 p := &*(*(uint8))(obj)
23894                 *p = read8(r)
23895         }
23896 }
23897
23898 func (obj *MapBlk) serialize(w io.Writer) {
23899         if err := pcall(func() {
23900                 ((*(*(struct {
23901                         Flags   MapBlkFlags
23902                         LitFrom LitFromBlks
23903
23904                         //mt:zlib
23905                         Param0 [4096]Content
23906                         Param1 [4096]uint8
23907                         Param2 [4096]uint8
23908
23909                         NodeMetas map[uint16]*NodeMeta
23910                 }))(obj)).Flags).serialize(w)
23911         }); err != nil {
23912                 if err == io.EOF {
23913                         chk(io.EOF)
23914                 }
23915                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlkFlags", err))
23916         }
23917         if err := pcall(func() {
23918                 ((*(*(struct {
23919                         Flags   MapBlkFlags
23920                         LitFrom LitFromBlks
23921
23922                         //mt:zlib
23923                         Param0 [4096]Content
23924                         Param1 [4096]uint8
23925                         Param2 [4096]uint8
23926
23927                         NodeMetas map[uint16]*NodeMeta
23928                 }))(obj)).LitFrom).serialize(w)
23929         }); err != nil {
23930                 if err == io.EOF {
23931                         chk(io.EOF)
23932                 }
23933                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
23934         }
23935         {
23936                 local288 := uint8(2) // Size of param0 in bytes.
23937                 {
23938                         x := local288
23939                         write8(w, uint8(x))
23940                 }
23941         }
23942         {
23943                 local289 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23944                 {
23945                         x := local289
23946                         write8(w, uint8(x))
23947                 }
23948         }
23949         {
23950                 w := zlib.NewWriter(w)
23951                 for local290 := range (*(*(struct {
23952                         Flags   MapBlkFlags
23953                         LitFrom LitFromBlks
23954
23955                         //mt:zlib
23956                         Param0 [4096]Content
23957                         Param1 [4096]uint8
23958                         Param2 [4096]uint8
23959
23960                         NodeMetas map[uint16]*NodeMeta
23961                 }))(obj)).Param0 {
23962                         if err := pcall(func() {
23963                                 (((*(*(struct {
23964                                         Flags   MapBlkFlags
23965                                         LitFrom LitFromBlks
23966
23967                                         //mt:zlib
23968                                         Param0 [4096]Content
23969                                         Param1 [4096]uint8
23970                                         Param2 [4096]uint8
23971
23972                                         NodeMetas map[uint16]*NodeMeta
23973                                 }))(obj)).Param0)[local290]).serialize(w)
23974                         }); err != nil {
23975                                 if err == io.EOF {
23976                                         chk(io.EOF)
23977                                 }
23978                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23979                         }
23980                 }
23981                 {
23982                         _, err := w.Write(((*(*(struct {
23983                                 Flags   MapBlkFlags
23984                                 LitFrom LitFromBlks
23985
23986                                 //mt:zlib
23987                                 Param0 [4096]Content
23988                                 Param1 [4096]uint8
23989                                 Param2 [4096]uint8
23990
23991                                 NodeMetas map[uint16]*NodeMeta
23992                         }))(obj)).Param1)[:])
23993                         chk(err)
23994                 }
23995                 {
23996                         _, err := w.Write(((*(*(struct {
23997                                 Flags   MapBlkFlags
23998                                 LitFrom LitFromBlks
23999
24000                                 //mt:zlib
24001                                 Param0 [4096]Content
24002                                 Param1 [4096]uint8
24003                                 Param2 [4096]uint8
24004
24005                                 NodeMetas map[uint16]*NodeMeta
24006                         }))(obj)).Param2)[:])
24007                         chk(err)
24008                 }
24009                 chk(w.Close())
24010         }
24011         {
24012                 x := (*(*(struct {
24013                         Flags   MapBlkFlags
24014                         LitFrom LitFromBlks
24015
24016                         //mt:zlib
24017                         Param0 [4096]Content
24018                         Param1 [4096]uint8
24019                         Param2 [4096]uint8
24020
24021                         NodeMetas map[uint16]*NodeMeta
24022                 }))(obj)).NodeMetas
24023                 {
24024                         w := zlib.NewWriter(w)
24025                         if x == nil {
24026                                 write8(w, 0)
24027                         } else {
24028                                 write8(w, 2)
24029                                 if len(x) > math.MaxUint16 {
24030                                         chk(ErrTooLong)
24031                                 }
24032                                 write16(w, uint16(len(x)))
24033                                 keys := make([]uint16, 0, len(x))
24034                                 for key := range x {
24035                                         keys = append(keys, key)
24036                                 }
24037                                 sort.Slice(keys, func(i, j int) bool {
24038                                         i2pos := func(i int) [3]int16 {
24039                                                 return Blkpos2Pos([3]int16{}, keys[i])
24040                                         }
24041                                         p, q := i2pos(i), i2pos(j)
24042                                         for i := range p {
24043                                                 switch {
24044                                                 case p[i] < q[i]:
24045                                                         return true
24046                                                 case p[i] > q[i]:
24047                                                         return false
24048                                                 }
24049                                         }
24050                                         return false
24051                                 })
24052                                 for _, key := range keys {
24053                                         write16(w, key)
24054                                         chk(serialize(w, x[key]))
24055                                 }
24056                         }
24057                         chk(w.Close())
24058                 }
24059         }
24060         {
24061                 local291 := uint8(2) // version
24062                 {
24063                         x := local291
24064                         write8(w, uint8(x))
24065                 }
24066         }
24067 }
24068
24069 func (obj *MapBlk) deserialize(r io.Reader) {
24070         if err := pcall(func() {
24071                 ((*(*(struct {
24072                         Flags   MapBlkFlags
24073                         LitFrom LitFromBlks
24074
24075                         //mt:zlib
24076                         Param0 [4096]Content
24077                         Param1 [4096]uint8
24078                         Param2 [4096]uint8
24079
24080                         NodeMetas map[uint16]*NodeMeta
24081                 }))(obj)).Flags).deserialize(r)
24082         }); err != nil {
24083                 if err == io.EOF {
24084                         chk(io.EOF)
24085                 }
24086                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlkFlags", err))
24087         }
24088         if err := pcall(func() {
24089                 ((*(*(struct {
24090                         Flags   MapBlkFlags
24091                         LitFrom LitFromBlks
24092
24093                         //mt:zlib
24094                         Param0 [4096]Content
24095                         Param1 [4096]uint8
24096                         Param2 [4096]uint8
24097
24098                         NodeMetas map[uint16]*NodeMeta
24099                 }))(obj)).LitFrom).deserialize(r)
24100         }); err != nil {
24101                 if err == io.EOF {
24102                         chk(io.EOF)
24103                 }
24104                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
24105         }
24106         {
24107                 var local292 uint8
24108                 {
24109                         p := &local292
24110                         *p = read8(r)
24111                 }
24112                 if local292 != (2) {
24113                         chk(fmt.Errorf("const %v: %v", 2, local292))
24114                 }
24115         }
24116         {
24117                 var local293 uint8
24118                 {
24119                         p := &local293
24120                         *p = read8(r)
24121                 }
24122                 if local293 != (2) {
24123                         chk(fmt.Errorf("const %v: %v", 2, local293))
24124                 }
24125         }
24126         {
24127                 r, err := zlib.NewReader(byteReader{r})
24128                 chk(err)
24129                 for local294 := range (*(*(struct {
24130                         Flags   MapBlkFlags
24131                         LitFrom LitFromBlks
24132
24133                         //mt:zlib
24134                         Param0 [4096]Content
24135                         Param1 [4096]uint8
24136                         Param2 [4096]uint8
24137
24138                         NodeMetas map[uint16]*NodeMeta
24139                 }))(obj)).Param0 {
24140                         if err := pcall(func() {
24141                                 (((*(*(struct {
24142                                         Flags   MapBlkFlags
24143                                         LitFrom LitFromBlks
24144
24145                                         //mt:zlib
24146                                         Param0 [4096]Content
24147                                         Param1 [4096]uint8
24148                                         Param2 [4096]uint8
24149
24150                                         NodeMetas map[uint16]*NodeMeta
24151                                 }))(obj)).Param0)[local294]).deserialize(r)
24152                         }); err != nil {
24153                                 if err == io.EOF {
24154                                         chk(io.EOF)
24155                                 }
24156                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
24157                         }
24158                 }
24159                 {
24160                         _, err := io.ReadFull(r, ((*(*(struct {
24161                                 Flags   MapBlkFlags
24162                                 LitFrom LitFromBlks
24163
24164                                 //mt:zlib
24165                                 Param0 [4096]Content
24166                                 Param1 [4096]uint8
24167                                 Param2 [4096]uint8
24168
24169                                 NodeMetas map[uint16]*NodeMeta
24170                         }))(obj)).Param1)[:])
24171                         chk(err)
24172                 }
24173                 {
24174                         _, err := io.ReadFull(r, ((*(*(struct {
24175                                 Flags   MapBlkFlags
24176                                 LitFrom LitFromBlks
24177
24178                                 //mt:zlib
24179                                 Param0 [4096]Content
24180                                 Param1 [4096]uint8
24181                                 Param2 [4096]uint8
24182
24183                                 NodeMetas map[uint16]*NodeMeta
24184                         }))(obj)).Param2)[:])
24185                         chk(err)
24186                 }
24187                 chk(r.Close())
24188         }
24189         {
24190                 p := &(*(*(struct {
24191                         Flags   MapBlkFlags
24192                         LitFrom LitFromBlks
24193
24194                         //mt:zlib
24195                         Param0 [4096]Content
24196                         Param1 [4096]uint8
24197                         Param2 [4096]uint8
24198
24199                         NodeMetas map[uint16]*NodeMeta
24200                 }))(obj)).NodeMetas
24201                 {
24202                         r, err := zlib.NewReader(byteReader{r})
24203                         chk(err)
24204                         switch ver := read8(r); ver {
24205                         case 0:
24206                                 *p = nil
24207                         case 2:
24208                                 n := read16(r)
24209                                 *p = make(map[uint16]*NodeMeta, n)
24210                                 for ; n > 0; n-- {
24211                                         pos := read16(r)
24212                                         nm := new(NodeMeta)
24213                                         chk(deserialize(r, nm))
24214                                         (*p)[pos] = nm
24215                                 }
24216                         default:
24217                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
24218                         }
24219                         chk(r.Close())
24220                 }
24221         }
24222         {
24223                 var local295 uint8
24224                 {
24225                         p := &local295
24226                         *p = read8(r)
24227                 }
24228                 if local295 != (2) {
24229                         chk(fmt.Errorf("const %v: %v", 2, local295))
24230                 }
24231         }
24232 }
24233
24234 func (obj *Node) serialize(w io.Writer) {
24235         if err := pcall(func() {
24236                 ((*(*(struct {
24237                         Param0         Content
24238                         Param1, Param2 uint8
24239                 }))(obj)).Param0).serialize(w)
24240         }); err != nil {
24241                 if err == io.EOF {
24242                         chk(io.EOF)
24243                 }
24244                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
24245         }
24246         {
24247                 x := (*(*(struct {
24248                         Param0         Content
24249                         Param1, Param2 uint8
24250                 }))(obj)).Param1
24251                 write8(w, uint8(x))
24252         }
24253         {
24254                 x := (*(*(struct {
24255                         Param0         Content
24256                         Param1, Param2 uint8
24257                 }))(obj)).Param2
24258                 write8(w, uint8(x))
24259         }
24260 }
24261
24262 func (obj *Node) deserialize(r io.Reader) {
24263         if err := pcall(func() {
24264                 ((*(*(struct {
24265                         Param0         Content
24266                         Param1, Param2 uint8
24267                 }))(obj)).Param0).deserialize(r)
24268         }); err != nil {
24269                 if err == io.EOF {
24270                         chk(io.EOF)
24271                 }
24272                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
24273         }
24274         {
24275                 p := &(*(*(struct {
24276                         Param0         Content
24277                         Param1, Param2 uint8
24278                 }))(obj)).Param1
24279                 *p = read8(r)
24280         }
24281         {
24282                 p := &(*(*(struct {
24283                         Param0         Content
24284                         Param1, Param2 uint8
24285                 }))(obj)).Param2
24286                 *p = read8(r)
24287         }
24288 }
24289
24290 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
24291         {
24292                 x := *(*(uint64))(obj)
24293                 write64(w, uint64(x))
24294         }
24295 }
24296
24297 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
24298         {
24299                 p := &*(*(uint64))(obj)
24300                 *p = read64(r)
24301         }
24302 }
24303
24304 func (obj *Vec) serialize(w io.Writer) {
24305         for local296 := range *(*([3]float32))(obj) {
24306                 {
24307                         x := (*(*([3]float32))(obj))[local296]
24308                         write32(w, math.Float32bits(x))
24309                 }
24310         }
24311 }
24312
24313 func (obj *Vec) deserialize(r io.Reader) {
24314         for local297 := range *(*([3]float32))(obj) {
24315                 {
24316                         p := &(*(*([3]float32))(obj))[local297]
24317                         *p = math.Float32frombits(read32(r))
24318                 }
24319         }
24320 }
24321
24322 func (obj *ChatMsgType) serialize(w io.Writer) {
24323         {
24324                 x := *(*(uint8))(obj)
24325                 write8(w, uint8(x))
24326         }
24327 }
24328
24329 func (obj *ChatMsgType) deserialize(r io.Reader) {
24330         {
24331                 p := &*(*(uint8))(obj)
24332                 *p = read8(r)
24333         }
24334 }
24335
24336 func (obj *AOID) serialize(w io.Writer) {
24337         {
24338                 x := *(*(uint16))(obj)
24339                 write16(w, uint16(x))
24340         }
24341 }
24342
24343 func (obj *AOID) deserialize(r io.Reader) {
24344         {
24345                 p := &*(*(uint16))(obj)
24346                 *p = read16(r)
24347         }
24348 }
24349
24350 func (obj *aoType) serialize(w io.Writer) {
24351         {
24352                 x := *(*(uint8))(obj)
24353                 write8(w, uint8(x))
24354         }
24355 }
24356
24357 func (obj *aoType) deserialize(r io.Reader) {
24358         {
24359                 p := &*(*(uint8))(obj)
24360                 *p = read8(r)
24361         }
24362 }
24363
24364 func (obj *AOInitData) serialize(w io.Writer) {
24365         {
24366                 local298 := uint8(1)
24367                 {
24368                         x := local298
24369                         write8(w, uint8(x))
24370                 }
24371         }
24372         if len(([]byte((*(*(struct {
24373
24374                 // For players.
24375                 Name     string
24376                 IsPlayer bool
24377
24378                 ID AOID
24379
24380                 Pos
24381                 Rot [3]float32
24382
24383                 HP uint16
24384
24385                 // See (de)serialize.fmt.
24386                 Msgs []AOMsg
24387         }))(obj)).Name))) > math.MaxUint16 {
24388                 chk(ErrTooLong)
24389         }
24390         {
24391                 x := uint16(len(([]byte((*(*(struct {
24392
24393                         // For players.
24394                         Name     string
24395                         IsPlayer bool
24396
24397                         ID AOID
24398
24399                         Pos
24400                         Rot [3]float32
24401
24402                         HP uint16
24403
24404                         // See (de)serialize.fmt.
24405                         Msgs []AOMsg
24406                 }))(obj)).Name))))
24407                 write16(w, uint16(x))
24408         }
24409         {
24410                 _, err := w.Write(([]byte((*(*(struct {
24411
24412                         // For players.
24413                         Name     string
24414                         IsPlayer bool
24415
24416                         ID AOID
24417
24418                         Pos
24419                         Rot [3]float32
24420
24421                         HP uint16
24422
24423                         // See (de)serialize.fmt.
24424                         Msgs []AOMsg
24425                 }))(obj)).Name))[:])
24426                 chk(err)
24427         }
24428         {
24429                 x := (*(*(struct {
24430
24431                         // For players.
24432                         Name     string
24433                         IsPlayer bool
24434
24435                         ID AOID
24436
24437                         Pos
24438                         Rot [3]float32
24439
24440                         HP uint16
24441
24442                         // See (de)serialize.fmt.
24443                         Msgs []AOMsg
24444                 }))(obj)).IsPlayer
24445                 if x {
24446                         write8(w, 1)
24447                 } else {
24448                         write8(w, 0)
24449                 }
24450         }
24451         if err := pcall(func() {
24452                 ((*(*(struct {
24453
24454                         // For players.
24455                         Name     string
24456                         IsPlayer bool
24457
24458                         ID AOID
24459
24460                         Pos
24461                         Rot [3]float32
24462
24463                         HP uint16
24464
24465                         // See (de)serialize.fmt.
24466                         Msgs []AOMsg
24467                 }))(obj)).ID).serialize(w)
24468         }); err != nil {
24469                 if err == io.EOF {
24470                         chk(io.EOF)
24471                 }
24472                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
24473         }
24474         if err := pcall(func() {
24475                 ((*(*(struct {
24476
24477                         // For players.
24478                         Name     string
24479                         IsPlayer bool
24480
24481                         ID AOID
24482
24483                         Pos
24484                         Rot [3]float32
24485
24486                         HP uint16
24487
24488                         // See (de)serialize.fmt.
24489                         Msgs []AOMsg
24490                 }))(obj)).Pos).serialize(w)
24491         }); err != nil {
24492                 if err == io.EOF {
24493                         chk(io.EOF)
24494                 }
24495                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
24496         }
24497         for local299 := range (*(*(struct {
24498
24499                 // For players.
24500                 Name     string
24501                 IsPlayer bool
24502
24503                 ID AOID
24504
24505                 Pos
24506                 Rot [3]float32
24507
24508                 HP uint16
24509
24510                 // See (de)serialize.fmt.
24511                 Msgs []AOMsg
24512         }))(obj)).Rot {
24513                 {
24514                         x := ((*(*(struct {
24515
24516                                 // For players.
24517                                 Name     string
24518                                 IsPlayer bool
24519
24520                                 ID AOID
24521
24522                                 Pos
24523                                 Rot [3]float32
24524
24525                                 HP uint16
24526
24527                                 // See (de)serialize.fmt.
24528                                 Msgs []AOMsg
24529                         }))(obj)).Rot)[local299]
24530                         write32(w, math.Float32bits(x))
24531                 }
24532         }
24533         {
24534                 x := (*(*(struct {
24535
24536                         // For players.
24537                         Name     string
24538                         IsPlayer bool
24539
24540                         ID AOID
24541
24542                         Pos
24543                         Rot [3]float32
24544
24545                         HP uint16
24546
24547                         // See (de)serialize.fmt.
24548                         Msgs []AOMsg
24549                 }))(obj)).HP
24550                 write16(w, uint16(x))
24551         }
24552         {
24553                 x := (*(*(struct {
24554
24555                         // For players.
24556                         Name     string
24557                         IsPlayer bool
24558
24559                         ID AOID
24560
24561                         Pos
24562                         Rot [3]float32
24563
24564                         HP uint16
24565
24566                         // See (de)serialize.fmt.
24567                         Msgs []AOMsg
24568                 }))(obj)).Msgs
24569                 { // For AOInitData.Msgs.
24570                         if len(x) > math.MaxUint8 {
24571                                 chk(ErrTooLong)
24572                         }
24573                         write8(w, uint8(len(x)))
24574                         for _, msg := range x {
24575                                 var b bytes.Buffer
24576                                 chk(writeAOMsg(&b, msg))
24577                                 if b.Len() > math.MaxUint32 {
24578                                         chk(ErrTooLong)
24579                                 }
24580                                 write32(w, uint32(b.Len()))
24581                                 _, err := b.WriteTo(w)
24582                                 chk(err)
24583                         }
24584                 }
24585         }
24586 }
24587
24588 func (obj *AOInitData) deserialize(r io.Reader) {
24589         {
24590                 var local300 uint8
24591                 {
24592                         p := &local300
24593                         *p = read8(r)
24594                 }
24595                 if local300 != (1) {
24596                         chk(fmt.Errorf("const %v: %v", 1, local300))
24597                 }
24598         }
24599         var local301 []uint8
24600         var local302 uint16
24601         {
24602                 p := &local302
24603                 *p = read16(r)
24604         }
24605         (local301) = make([]uint8, local302)
24606         {
24607                 _, err := io.ReadFull(r, (local301)[:])
24608                 chk(err)
24609         }
24610         ((*(*(struct {
24611
24612                 // For players.
24613                 Name     string
24614                 IsPlayer bool
24615
24616                 ID AOID
24617
24618                 Pos
24619                 Rot [3]float32
24620
24621                 HP uint16
24622
24623                 // See (de)serialize.fmt.
24624                 Msgs []AOMsg
24625         }))(obj)).Name) = string(local301)
24626         {
24627                 p := &(*(*(struct {
24628
24629                         // For players.
24630                         Name     string
24631                         IsPlayer bool
24632
24633                         ID AOID
24634
24635                         Pos
24636                         Rot [3]float32
24637
24638                         HP uint16
24639
24640                         // See (de)serialize.fmt.
24641                         Msgs []AOMsg
24642                 }))(obj)).IsPlayer
24643                 switch n := read8(r); n {
24644                 case 0:
24645                         *p = false
24646                 case 1:
24647                         *p = true
24648                 default:
24649                         chk(fmt.Errorf("invalid bool: %d", n))
24650                 }
24651         }
24652         if err := pcall(func() {
24653                 ((*(*(struct {
24654
24655                         // For players.
24656                         Name     string
24657                         IsPlayer bool
24658
24659                         ID AOID
24660
24661                         Pos
24662                         Rot [3]float32
24663
24664                         HP uint16
24665
24666                         // See (de)serialize.fmt.
24667                         Msgs []AOMsg
24668                 }))(obj)).ID).deserialize(r)
24669         }); err != nil {
24670                 if err == io.EOF {
24671                         chk(io.EOF)
24672                 }
24673                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
24674         }
24675         if err := pcall(func() {
24676                 ((*(*(struct {
24677
24678                         // For players.
24679                         Name     string
24680                         IsPlayer bool
24681
24682                         ID AOID
24683
24684                         Pos
24685                         Rot [3]float32
24686
24687                         HP uint16
24688
24689                         // See (de)serialize.fmt.
24690                         Msgs []AOMsg
24691                 }))(obj)).Pos).deserialize(r)
24692         }); err != nil {
24693                 if err == io.EOF {
24694                         chk(io.EOF)
24695                 }
24696                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
24697         }
24698         for local303 := range (*(*(struct {
24699
24700                 // For players.
24701                 Name     string
24702                 IsPlayer bool
24703
24704                 ID AOID
24705
24706                 Pos
24707                 Rot [3]float32
24708
24709                 HP uint16
24710
24711                 // See (de)serialize.fmt.
24712                 Msgs []AOMsg
24713         }))(obj)).Rot {
24714                 {
24715                         p := &((*(*(struct {
24716
24717                                 // For players.
24718                                 Name     string
24719                                 IsPlayer bool
24720
24721                                 ID AOID
24722
24723                                 Pos
24724                                 Rot [3]float32
24725
24726                                 HP uint16
24727
24728                                 // See (de)serialize.fmt.
24729                                 Msgs []AOMsg
24730                         }))(obj)).Rot)[local303]
24731                         *p = math.Float32frombits(read32(r))
24732                 }
24733         }
24734         {
24735                 p := &(*(*(struct {
24736
24737                         // For players.
24738                         Name     string
24739                         IsPlayer bool
24740
24741                         ID AOID
24742
24743                         Pos
24744                         Rot [3]float32
24745
24746                         HP uint16
24747
24748                         // See (de)serialize.fmt.
24749                         Msgs []AOMsg
24750                 }))(obj)).HP
24751                 *p = read16(r)
24752         }
24753         {
24754                 p := &(*(*(struct {
24755
24756                         // For players.
24757                         Name     string
24758                         IsPlayer bool
24759
24760                         ID AOID
24761
24762                         Pos
24763                         Rot [3]float32
24764
24765                         HP uint16
24766
24767                         // See (de)serialize.fmt.
24768                         Msgs []AOMsg
24769                 }))(obj)).Msgs
24770                 { // For AOInitData.Msgs.
24771                         *p = make([]AOMsg, read8(r))
24772                         for i := range *p {
24773                                 r := &io.LimitedReader{r, int64(read32(r))}
24774                                 msg, err := readAOMsg(r)
24775                                 chk(err)
24776                                 (*p)[i] = msg
24777                                 if r.N > 0 {
24778                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
24779                                 }
24780                         }
24781                 }
24782         }
24783 }
24784
24785 func (obj *IDAOMsg) serialize(w io.Writer) {
24786         if err := pcall(func() {
24787                 ((*(*(struct {
24788                         ID AOID
24789                         //mt:lenhdr 16
24790                         Msg AOMsg
24791                 }))(obj)).ID).serialize(w)
24792         }); err != nil {
24793                 if err == io.EOF {
24794                         chk(io.EOF)
24795                 }
24796                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
24797         }
24798         {
24799                 ow := w
24800                 w := new(bytes.Buffer)
24801                 {
24802                         x := (*(*(struct {
24803                                 ID AOID
24804                                 //mt:lenhdr 16
24805                                 Msg AOMsg
24806                         }))(obj)).Msg
24807                         writeAOMsg(w, x)
24808                 }
24809                 {
24810                         buf := w
24811                         w := ow
24812                         if len((buf.Bytes())) > math.MaxUint16 {
24813                                 chk(ErrTooLong)
24814                         }
24815                         {
24816                                 x := uint16(len((buf.Bytes())))
24817                                 write16(w, uint16(x))
24818                         }
24819                         {
24820                                 _, err := w.Write((buf.Bytes())[:])
24821                                 chk(err)
24822                         }
24823                 }
24824         }
24825 }
24826
24827 func (obj *IDAOMsg) deserialize(r io.Reader) {
24828         if err := pcall(func() {
24829                 ((*(*(struct {
24830                         ID AOID
24831                         //mt:lenhdr 16
24832                         Msg AOMsg
24833                 }))(obj)).ID).deserialize(r)
24834         }); err != nil {
24835                 if err == io.EOF {
24836                         chk(io.EOF)
24837                 }
24838                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
24839         }
24840         {
24841                 var n uint16
24842                 {
24843                         p := &n
24844                         *p = read16(r)
24845                 }
24846                 r := &io.LimitedReader{r, int64(n)}
24847                 {
24848                         p := &(*(*(struct {
24849                                 ID AOID
24850                                 //mt:lenhdr 16
24851                                 Msg AOMsg
24852                         }))(obj)).Msg
24853                         {
24854                                 var err error
24855                                 *p, err = readAOMsg(r)
24856                                 chk(err)
24857                         }
24858                 }
24859                 if r.N > 0 {
24860                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
24861                 }
24862         }
24863 }
24864
24865 func (obj *ItemDef) serialize(w io.Writer) {
24866         {
24867                 ow := w
24868                 w := new(bytes.Buffer)
24869                 {
24870                         local304 := uint8(6)
24871                         {
24872                                 x := local304
24873                                 write8(w, uint8(x))
24874                         }
24875                 }
24876                 if err := pcall(func() {
24877                         ((*(*(struct {
24878                                 Type ItemType
24879
24880                                 Name, Desc string
24881
24882                                 InvImg, WieldImg Texture
24883                                 WieldScale       [3]float32
24884
24885                                 StackMax uint16
24886
24887                                 Usable          bool
24888                                 CanPointLiquids bool
24889
24890                                 ToolCaps ToolCaps
24891
24892                                 Groups []Group
24893
24894                                 PlacePredict string
24895
24896                                 PlaceSnd, PlaceFailSnd SoundDef
24897
24898                                 PointRange float32
24899
24900                                 // Set index in Palette with "palette_index" item meta field,
24901                                 // this overrides Color.
24902                                 Palette Texture
24903                                 Color   color.NRGBA
24904
24905                                 // Texture overlays.
24906                                 InvOverlay, WieldOverlay Texture
24907
24908                                 ShortDesc string
24909
24910                                 PlaceParam2 byte
24911                         }))(obj)).Type).serialize(w)
24912                 }); err != nil {
24913                         if err == io.EOF {
24914                                 chk(io.EOF)
24915                         }
24916                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
24917                 }
24918                 if len(([]byte((*(*(struct {
24919                         Type ItemType
24920
24921                         Name, Desc string
24922
24923                         InvImg, WieldImg Texture
24924                         WieldScale       [3]float32
24925
24926                         StackMax uint16
24927
24928                         Usable          bool
24929                         CanPointLiquids bool
24930
24931                         ToolCaps ToolCaps
24932
24933                         Groups []Group
24934
24935                         PlacePredict string
24936
24937                         PlaceSnd, PlaceFailSnd SoundDef
24938
24939                         PointRange float32
24940
24941                         // Set index in Palette with "palette_index" item meta field,
24942                         // this overrides Color.
24943                         Palette Texture
24944                         Color   color.NRGBA
24945
24946                         // Texture overlays.
24947                         InvOverlay, WieldOverlay Texture
24948
24949                         ShortDesc string
24950
24951                         PlaceParam2 byte
24952                 }))(obj)).Name))) > math.MaxUint16 {
24953                         chk(ErrTooLong)
24954                 }
24955                 {
24956                         x := uint16(len(([]byte((*(*(struct {
24957                                 Type ItemType
24958
24959                                 Name, Desc string
24960
24961                                 InvImg, WieldImg Texture
24962                                 WieldScale       [3]float32
24963
24964                                 StackMax uint16
24965
24966                                 Usable          bool
24967                                 CanPointLiquids bool
24968
24969                                 ToolCaps ToolCaps
24970
24971                                 Groups []Group
24972
24973                                 PlacePredict string
24974
24975                                 PlaceSnd, PlaceFailSnd SoundDef
24976
24977                                 PointRange float32
24978
24979                                 // Set index in Palette with "palette_index" item meta field,
24980                                 // this overrides Color.
24981                                 Palette Texture
24982                                 Color   color.NRGBA
24983
24984                                 // Texture overlays.
24985                                 InvOverlay, WieldOverlay Texture
24986
24987                                 ShortDesc string
24988
24989                                 PlaceParam2 byte
24990                         }))(obj)).Name))))
24991                         write16(w, uint16(x))
24992                 }
24993                 {
24994                         _, err := w.Write(([]byte((*(*(struct {
24995                                 Type ItemType
24996
24997                                 Name, Desc string
24998
24999                                 InvImg, WieldImg Texture
25000                                 WieldScale       [3]float32
25001
25002                                 StackMax uint16
25003
25004                                 Usable          bool
25005                                 CanPointLiquids bool
25006
25007                                 ToolCaps ToolCaps
25008
25009                                 Groups []Group
25010
25011                                 PlacePredict string
25012
25013                                 PlaceSnd, PlaceFailSnd SoundDef
25014
25015                                 PointRange float32
25016
25017                                 // Set index in Palette with "palette_index" item meta field,
25018                                 // this overrides Color.
25019                                 Palette Texture
25020                                 Color   color.NRGBA
25021
25022                                 // Texture overlays.
25023                                 InvOverlay, WieldOverlay Texture
25024
25025                                 ShortDesc string
25026
25027                                 PlaceParam2 byte
25028                         }))(obj)).Name))[:])
25029                         chk(err)
25030                 }
25031                 if len(([]byte((*(*(struct {
25032                         Type ItemType
25033
25034                         Name, Desc string
25035
25036                         InvImg, WieldImg Texture
25037                         WieldScale       [3]float32
25038
25039                         StackMax uint16
25040
25041                         Usable          bool
25042                         CanPointLiquids bool
25043
25044                         ToolCaps ToolCaps
25045
25046                         Groups []Group
25047
25048                         PlacePredict string
25049
25050                         PlaceSnd, PlaceFailSnd SoundDef
25051
25052                         PointRange float32
25053
25054                         // Set index in Palette with "palette_index" item meta field,
25055                         // this overrides Color.
25056                         Palette Texture
25057                         Color   color.NRGBA
25058
25059                         // Texture overlays.
25060                         InvOverlay, WieldOverlay Texture
25061
25062                         ShortDesc string
25063
25064                         PlaceParam2 byte
25065                 }))(obj)).Desc))) > math.MaxUint16 {
25066                         chk(ErrTooLong)
25067                 }
25068                 {
25069                         x := uint16(len(([]byte((*(*(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
25102                                 PlaceParam2 byte
25103                         }))(obj)).Desc))))
25104                         write16(w, uint16(x))
25105                 }
25106                 {
25107                         _, err := w.Write(([]byte((*(*(struct {
25108                                 Type ItemType
25109
25110                                 Name, Desc string
25111
25112                                 InvImg, WieldImg Texture
25113                                 WieldScale       [3]float32
25114
25115                                 StackMax uint16
25116
25117                                 Usable          bool
25118                                 CanPointLiquids bool
25119
25120                                 ToolCaps ToolCaps
25121
25122                                 Groups []Group
25123
25124                                 PlacePredict string
25125
25126                                 PlaceSnd, PlaceFailSnd SoundDef
25127
25128                                 PointRange float32
25129
25130                                 // Set index in Palette with "palette_index" item meta field,
25131                                 // this overrides Color.
25132                                 Palette Texture
25133                                 Color   color.NRGBA
25134
25135                                 // Texture overlays.
25136                                 InvOverlay, WieldOverlay Texture
25137
25138                                 ShortDesc string
25139
25140                                 PlaceParam2 byte
25141                         }))(obj)).Desc))[:])
25142                         chk(err)
25143                 }
25144                 if err := pcall(func() {
25145                         ((*(*(struct {
25146                                 Type ItemType
25147
25148                                 Name, Desc string
25149
25150                                 InvImg, WieldImg Texture
25151                                 WieldScale       [3]float32
25152
25153                                 StackMax uint16
25154
25155                                 Usable          bool
25156                                 CanPointLiquids bool
25157
25158                                 ToolCaps ToolCaps
25159
25160                                 Groups []Group
25161
25162                                 PlacePredict string
25163
25164                                 PlaceSnd, PlaceFailSnd SoundDef
25165
25166                                 PointRange float32
25167
25168                                 // Set index in Palette with "palette_index" item meta field,
25169                                 // this overrides Color.
25170                                 Palette Texture
25171                                 Color   color.NRGBA
25172
25173                                 // Texture overlays.
25174                                 InvOverlay, WieldOverlay Texture
25175
25176                                 ShortDesc string
25177
25178                                 PlaceParam2 byte
25179                         }))(obj)).InvImg).serialize(w)
25180                 }); err != nil {
25181                         if err == io.EOF {
25182                                 chk(io.EOF)
25183                         }
25184                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25185                 }
25186                 if err := pcall(func() {
25187                         ((*(*(struct {
25188                                 Type ItemType
25189
25190                                 Name, Desc string
25191
25192                                 InvImg, WieldImg Texture
25193                                 WieldScale       [3]float32
25194
25195                                 StackMax uint16
25196
25197                                 Usable          bool
25198                                 CanPointLiquids bool
25199
25200                                 ToolCaps ToolCaps
25201
25202                                 Groups []Group
25203
25204                                 PlacePredict string
25205
25206                                 PlaceSnd, PlaceFailSnd SoundDef
25207
25208                                 PointRange float32
25209
25210                                 // Set index in Palette with "palette_index" item meta field,
25211                                 // this overrides Color.
25212                                 Palette Texture
25213                                 Color   color.NRGBA
25214
25215                                 // Texture overlays.
25216                                 InvOverlay, WieldOverlay Texture
25217
25218                                 ShortDesc string
25219
25220                                 PlaceParam2 byte
25221                         }))(obj)).WieldImg).serialize(w)
25222                 }); err != nil {
25223                         if err == io.EOF {
25224                                 chk(io.EOF)
25225                         }
25226                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25227                 }
25228                 for local305 := range (*(*(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
25261                         PlaceParam2 byte
25262                 }))(obj)).WieldScale {
25263                         {
25264                                 x := ((*(*(struct {
25265                                         Type ItemType
25266
25267                                         Name, Desc string
25268
25269                                         InvImg, WieldImg Texture
25270                                         WieldScale       [3]float32
25271
25272                                         StackMax uint16
25273
25274                                         Usable          bool
25275                                         CanPointLiquids bool
25276
25277                                         ToolCaps ToolCaps
25278
25279                                         Groups []Group
25280
25281                                         PlacePredict string
25282
25283                                         PlaceSnd, PlaceFailSnd SoundDef
25284
25285                                         PointRange float32
25286
25287                                         // Set index in Palette with "palette_index" item meta field,
25288                                         // this overrides Color.
25289                                         Palette Texture
25290                                         Color   color.NRGBA
25291
25292                                         // Texture overlays.
25293                                         InvOverlay, WieldOverlay Texture
25294
25295                                         ShortDesc string
25296
25297                                         PlaceParam2 byte
25298                                 }))(obj)).WieldScale)[local305]
25299                                 write32(w, math.Float32bits(x))
25300                         }
25301                 }
25302                 {
25303                         x := (*(*(struct {
25304                                 Type ItemType
25305
25306                                 Name, Desc string
25307
25308                                 InvImg, WieldImg Texture
25309                                 WieldScale       [3]float32
25310
25311                                 StackMax uint16
25312
25313                                 Usable          bool
25314                                 CanPointLiquids bool
25315
25316                                 ToolCaps ToolCaps
25317
25318                                 Groups []Group
25319
25320                                 PlacePredict string
25321
25322                                 PlaceSnd, PlaceFailSnd SoundDef
25323
25324                                 PointRange float32
25325
25326                                 // Set index in Palette with "palette_index" item meta field,
25327                                 // this overrides Color.
25328                                 Palette Texture
25329                                 Color   color.NRGBA
25330
25331                                 // Texture overlays.
25332                                 InvOverlay, WieldOverlay Texture
25333
25334                                 ShortDesc string
25335
25336                                 PlaceParam2 byte
25337                         }))(obj)).StackMax
25338                         write16(w, uint16(x))
25339                 }
25340                 {
25341                         x := (*(*(struct {
25342                                 Type ItemType
25343
25344                                 Name, Desc string
25345
25346                                 InvImg, WieldImg Texture
25347                                 WieldScale       [3]float32
25348
25349                                 StackMax uint16
25350
25351                                 Usable          bool
25352                                 CanPointLiquids bool
25353
25354                                 ToolCaps ToolCaps
25355
25356                                 Groups []Group
25357
25358                                 PlacePredict string
25359
25360                                 PlaceSnd, PlaceFailSnd SoundDef
25361
25362                                 PointRange float32
25363
25364                                 // Set index in Palette with "palette_index" item meta field,
25365                                 // this overrides Color.
25366                                 Palette Texture
25367                                 Color   color.NRGBA
25368
25369                                 // Texture overlays.
25370                                 InvOverlay, WieldOverlay Texture
25371
25372                                 ShortDesc string
25373
25374                                 PlaceParam2 byte
25375                         }))(obj)).Usable
25376                         if x {
25377                                 write8(w, 1)
25378                         } else {
25379                                 write8(w, 0)
25380                         }
25381                 }
25382                 {
25383                         x := (*(*(struct {
25384                                 Type ItemType
25385
25386                                 Name, Desc string
25387
25388                                 InvImg, WieldImg Texture
25389                                 WieldScale       [3]float32
25390
25391                                 StackMax uint16
25392
25393                                 Usable          bool
25394                                 CanPointLiquids bool
25395
25396                                 ToolCaps ToolCaps
25397
25398                                 Groups []Group
25399
25400                                 PlacePredict string
25401
25402                                 PlaceSnd, PlaceFailSnd SoundDef
25403
25404                                 PointRange float32
25405
25406                                 // Set index in Palette with "palette_index" item meta field,
25407                                 // this overrides Color.
25408                                 Palette Texture
25409                                 Color   color.NRGBA
25410
25411                                 // Texture overlays.
25412                                 InvOverlay, WieldOverlay Texture
25413
25414                                 ShortDesc string
25415
25416                                 PlaceParam2 byte
25417                         }))(obj)).CanPointLiquids
25418                         if x {
25419                                 write8(w, 1)
25420                         } else {
25421                                 write8(w, 0)
25422                         }
25423                 }
25424                 if err := pcall(func() {
25425                         ((*(*(struct {
25426                                 Type ItemType
25427
25428                                 Name, Desc string
25429
25430                                 InvImg, WieldImg Texture
25431                                 WieldScale       [3]float32
25432
25433                                 StackMax uint16
25434
25435                                 Usable          bool
25436                                 CanPointLiquids bool
25437
25438                                 ToolCaps ToolCaps
25439
25440                                 Groups []Group
25441
25442                                 PlacePredict string
25443
25444                                 PlaceSnd, PlaceFailSnd SoundDef
25445
25446                                 PointRange float32
25447
25448                                 // Set index in Palette with "palette_index" item meta field,
25449                                 // this overrides Color.
25450                                 Palette Texture
25451                                 Color   color.NRGBA
25452
25453                                 // Texture overlays.
25454                                 InvOverlay, WieldOverlay Texture
25455
25456                                 ShortDesc string
25457
25458                                 PlaceParam2 byte
25459                         }))(obj)).ToolCaps).serialize(w)
25460                 }); err != nil {
25461                         if err == io.EOF {
25462                                 chk(io.EOF)
25463                         }
25464                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
25465                 }
25466                 if len(((*(*(struct {
25467                         Type ItemType
25468
25469                         Name, Desc string
25470
25471                         InvImg, WieldImg Texture
25472                         WieldScale       [3]float32
25473
25474                         StackMax uint16
25475
25476                         Usable          bool
25477                         CanPointLiquids bool
25478
25479                         ToolCaps ToolCaps
25480
25481                         Groups []Group
25482
25483                         PlacePredict string
25484
25485                         PlaceSnd, PlaceFailSnd SoundDef
25486
25487                         PointRange float32
25488
25489                         // Set index in Palette with "palette_index" item meta field,
25490                         // this overrides Color.
25491                         Palette Texture
25492                         Color   color.NRGBA
25493
25494                         // Texture overlays.
25495                         InvOverlay, WieldOverlay Texture
25496
25497                         ShortDesc string
25498
25499                         PlaceParam2 byte
25500                 }))(obj)).Groups)) > math.MaxUint16 {
25501                         chk(ErrTooLong)
25502                 }
25503                 {
25504                         x := uint16(len(((*(*(struct {
25505                                 Type ItemType
25506
25507                                 Name, Desc string
25508
25509                                 InvImg, WieldImg Texture
25510                                 WieldScale       [3]float32
25511
25512                                 StackMax uint16
25513
25514                                 Usable          bool
25515                                 CanPointLiquids bool
25516
25517                                 ToolCaps ToolCaps
25518
25519                                 Groups []Group
25520
25521                                 PlacePredict string
25522
25523                                 PlaceSnd, PlaceFailSnd SoundDef
25524
25525                                 PointRange float32
25526
25527                                 // Set index in Palette with "palette_index" item meta field,
25528                                 // this overrides Color.
25529                                 Palette Texture
25530                                 Color   color.NRGBA
25531
25532                                 // Texture overlays.
25533                                 InvOverlay, WieldOverlay Texture
25534
25535                                 ShortDesc string
25536
25537                                 PlaceParam2 byte
25538                         }))(obj)).Groups)))
25539                         write16(w, uint16(x))
25540                 }
25541                 for local306 := range (*(*(struct {
25542                         Type ItemType
25543
25544                         Name, Desc string
25545
25546                         InvImg, WieldImg Texture
25547                         WieldScale       [3]float32
25548
25549                         StackMax uint16
25550
25551                         Usable          bool
25552                         CanPointLiquids bool
25553
25554                         ToolCaps ToolCaps
25555
25556                         Groups []Group
25557
25558                         PlacePredict string
25559
25560                         PlaceSnd, PlaceFailSnd SoundDef
25561
25562                         PointRange float32
25563
25564                         // Set index in Palette with "palette_index" item meta field,
25565                         // this overrides Color.
25566                         Palette Texture
25567                         Color   color.NRGBA
25568
25569                         // Texture overlays.
25570                         InvOverlay, WieldOverlay Texture
25571
25572                         ShortDesc string
25573
25574                         PlaceParam2 byte
25575                 }))(obj)).Groups {
25576                         if err := pcall(func() {
25577                                 (((*(*(struct {
25578                                         Type ItemType
25579
25580                                         Name, Desc string
25581
25582                                         InvImg, WieldImg Texture
25583                                         WieldScale       [3]float32
25584
25585                                         StackMax uint16
25586
25587                                         Usable          bool
25588                                         CanPointLiquids bool
25589
25590                                         ToolCaps ToolCaps
25591
25592                                         Groups []Group
25593
25594                                         PlacePredict string
25595
25596                                         PlaceSnd, PlaceFailSnd SoundDef
25597
25598                                         PointRange float32
25599
25600                                         // Set index in Palette with "palette_index" item meta field,
25601                                         // this overrides Color.
25602                                         Palette Texture
25603                                         Color   color.NRGBA
25604
25605                                         // Texture overlays.
25606                                         InvOverlay, WieldOverlay Texture
25607
25608                                         ShortDesc string
25609
25610                                         PlaceParam2 byte
25611                                 }))(obj)).Groups)[local306]).serialize(w)
25612                         }); err != nil {
25613                                 if err == io.EOF {
25614                                         chk(io.EOF)
25615                                 }
25616                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
25617                         }
25618                 }
25619                 if len(([]byte((*(*(struct {
25620                         Type ItemType
25621
25622                         Name, Desc string
25623
25624                         InvImg, WieldImg Texture
25625                         WieldScale       [3]float32
25626
25627                         StackMax uint16
25628
25629                         Usable          bool
25630                         CanPointLiquids bool
25631
25632                         ToolCaps ToolCaps
25633
25634                         Groups []Group
25635
25636                         PlacePredict string
25637
25638                         PlaceSnd, PlaceFailSnd SoundDef
25639
25640                         PointRange float32
25641
25642                         // Set index in Palette with "palette_index" item meta field,
25643                         // this overrides Color.
25644                         Palette Texture
25645                         Color   color.NRGBA
25646
25647                         // Texture overlays.
25648                         InvOverlay, WieldOverlay Texture
25649
25650                         ShortDesc string
25651
25652                         PlaceParam2 byte
25653                 }))(obj)).PlacePredict))) > math.MaxUint16 {
25654                         chk(ErrTooLong)
25655                 }
25656                 {
25657                         x := uint16(len(([]byte((*(*(struct {
25658                                 Type ItemType
25659
25660                                 Name, Desc string
25661
25662                                 InvImg, WieldImg Texture
25663                                 WieldScale       [3]float32
25664
25665                                 StackMax uint16
25666
25667                                 Usable          bool
25668                                 CanPointLiquids bool
25669
25670                                 ToolCaps ToolCaps
25671
25672                                 Groups []Group
25673
25674                                 PlacePredict string
25675
25676                                 PlaceSnd, PlaceFailSnd SoundDef
25677
25678                                 PointRange float32
25679
25680                                 // Set index in Palette with "palette_index" item meta field,
25681                                 // this overrides Color.
25682                                 Palette Texture
25683                                 Color   color.NRGBA
25684
25685                                 // Texture overlays.
25686                                 InvOverlay, WieldOverlay Texture
25687
25688                                 ShortDesc string
25689
25690                                 PlaceParam2 byte
25691                         }))(obj)).PlacePredict))))
25692                         write16(w, uint16(x))
25693                 }
25694                 {
25695                         _, err := w.Write(([]byte((*(*(struct {
25696                                 Type ItemType
25697
25698                                 Name, Desc string
25699
25700                                 InvImg, WieldImg Texture
25701                                 WieldScale       [3]float32
25702
25703                                 StackMax uint16
25704
25705                                 Usable          bool
25706                                 CanPointLiquids bool
25707
25708                                 ToolCaps ToolCaps
25709
25710                                 Groups []Group
25711
25712                                 PlacePredict string
25713
25714                                 PlaceSnd, PlaceFailSnd SoundDef
25715
25716                                 PointRange float32
25717
25718                                 // Set index in Palette with "palette_index" item meta field,
25719                                 // this overrides Color.
25720                                 Palette Texture
25721                                 Color   color.NRGBA
25722
25723                                 // Texture overlays.
25724                                 InvOverlay, WieldOverlay Texture
25725
25726                                 ShortDesc string
25727
25728                                 PlaceParam2 byte
25729                         }))(obj)).PlacePredict))[:])
25730                         chk(err)
25731                 }
25732                 if err := pcall(func() {
25733                         ((*(*(struct {
25734                                 Type ItemType
25735
25736                                 Name, Desc string
25737
25738                                 InvImg, WieldImg Texture
25739                                 WieldScale       [3]float32
25740
25741                                 StackMax uint16
25742
25743                                 Usable          bool
25744                                 CanPointLiquids bool
25745
25746                                 ToolCaps ToolCaps
25747
25748                                 Groups []Group
25749
25750                                 PlacePredict string
25751
25752                                 PlaceSnd, PlaceFailSnd SoundDef
25753
25754                                 PointRange float32
25755
25756                                 // Set index in Palette with "palette_index" item meta field,
25757                                 // this overrides Color.
25758                                 Palette Texture
25759                                 Color   color.NRGBA
25760
25761                                 // Texture overlays.
25762                                 InvOverlay, WieldOverlay Texture
25763
25764                                 ShortDesc string
25765
25766                                 PlaceParam2 byte
25767                         }))(obj)).PlaceSnd).serialize(w)
25768                 }); err != nil {
25769                         if err == io.EOF {
25770                                 chk(io.EOF)
25771                         }
25772                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25773                 }
25774                 if err := pcall(func() {
25775                         ((*(*(struct {
25776                                 Type ItemType
25777
25778                                 Name, Desc string
25779
25780                                 InvImg, WieldImg Texture
25781                                 WieldScale       [3]float32
25782
25783                                 StackMax uint16
25784
25785                                 Usable          bool
25786                                 CanPointLiquids bool
25787
25788                                 ToolCaps ToolCaps
25789
25790                                 Groups []Group
25791
25792                                 PlacePredict string
25793
25794                                 PlaceSnd, PlaceFailSnd SoundDef
25795
25796                                 PointRange float32
25797
25798                                 // Set index in Palette with "palette_index" item meta field,
25799                                 // this overrides Color.
25800                                 Palette Texture
25801                                 Color   color.NRGBA
25802
25803                                 // Texture overlays.
25804                                 InvOverlay, WieldOverlay Texture
25805
25806                                 ShortDesc string
25807
25808                                 PlaceParam2 byte
25809                         }))(obj)).PlaceFailSnd).serialize(w)
25810                 }); err != nil {
25811                         if err == io.EOF {
25812                                 chk(io.EOF)
25813                         }
25814                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25815                 }
25816                 {
25817                         x := (*(*(struct {
25818                                 Type ItemType
25819
25820                                 Name, Desc string
25821
25822                                 InvImg, WieldImg Texture
25823                                 WieldScale       [3]float32
25824
25825                                 StackMax uint16
25826
25827                                 Usable          bool
25828                                 CanPointLiquids bool
25829
25830                                 ToolCaps ToolCaps
25831
25832                                 Groups []Group
25833
25834                                 PlacePredict string
25835
25836                                 PlaceSnd, PlaceFailSnd SoundDef
25837
25838                                 PointRange float32
25839
25840                                 // Set index in Palette with "palette_index" item meta field,
25841                                 // this overrides Color.
25842                                 Palette Texture
25843                                 Color   color.NRGBA
25844
25845                                 // Texture overlays.
25846                                 InvOverlay, WieldOverlay Texture
25847
25848                                 ShortDesc string
25849
25850                                 PlaceParam2 byte
25851                         }))(obj)).PointRange
25852                         write32(w, math.Float32bits(x))
25853                 }
25854                 if err := pcall(func() {
25855                         ((*(*(struct {
25856                                 Type ItemType
25857
25858                                 Name, Desc string
25859
25860                                 InvImg, WieldImg Texture
25861                                 WieldScale       [3]float32
25862
25863                                 StackMax uint16
25864
25865                                 Usable          bool
25866                                 CanPointLiquids bool
25867
25868                                 ToolCaps ToolCaps
25869
25870                                 Groups []Group
25871
25872                                 PlacePredict string
25873
25874                                 PlaceSnd, PlaceFailSnd SoundDef
25875
25876                                 PointRange float32
25877
25878                                 // Set index in Palette with "palette_index" item meta field,
25879                                 // this overrides Color.
25880                                 Palette Texture
25881                                 Color   color.NRGBA
25882
25883                                 // Texture overlays.
25884                                 InvOverlay, WieldOverlay Texture
25885
25886                                 ShortDesc string
25887
25888                                 PlaceParam2 byte
25889                         }))(obj)).Palette).serialize(w)
25890                 }); err != nil {
25891                         if err == io.EOF {
25892                                 chk(io.EOF)
25893                         }
25894                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25895                 }
25896                 {
25897                         x := (*(*(struct {
25898                                 Type ItemType
25899
25900                                 Name, Desc string
25901
25902                                 InvImg, WieldImg Texture
25903                                 WieldScale       [3]float32
25904
25905                                 StackMax uint16
25906
25907                                 Usable          bool
25908                                 CanPointLiquids bool
25909
25910                                 ToolCaps ToolCaps
25911
25912                                 Groups []Group
25913
25914                                 PlacePredict string
25915
25916                                 PlaceSnd, PlaceFailSnd SoundDef
25917
25918                                 PointRange float32
25919
25920                                 // Set index in Palette with "palette_index" item meta field,
25921                                 // this overrides Color.
25922                                 Palette Texture
25923                                 Color   color.NRGBA
25924
25925                                 // Texture overlays.
25926                                 InvOverlay, WieldOverlay Texture
25927
25928                                 ShortDesc string
25929
25930                                 PlaceParam2 byte
25931                         }))(obj)).Color
25932                         w.Write([]byte{x.A, x.R, x.G, x.B})
25933                 }
25934                 if err := pcall(func() {
25935                         ((*(*(struct {
25936                                 Type ItemType
25937
25938                                 Name, Desc string
25939
25940                                 InvImg, WieldImg Texture
25941                                 WieldScale       [3]float32
25942
25943                                 StackMax uint16
25944
25945                                 Usable          bool
25946                                 CanPointLiquids bool
25947
25948                                 ToolCaps ToolCaps
25949
25950                                 Groups []Group
25951
25952                                 PlacePredict string
25953
25954                                 PlaceSnd, PlaceFailSnd SoundDef
25955
25956                                 PointRange float32
25957
25958                                 // Set index in Palette with "palette_index" item meta field,
25959                                 // this overrides Color.
25960                                 Palette Texture
25961                                 Color   color.NRGBA
25962
25963                                 // Texture overlays.
25964                                 InvOverlay, WieldOverlay Texture
25965
25966                                 ShortDesc string
25967
25968                                 PlaceParam2 byte
25969                         }))(obj)).InvOverlay).serialize(w)
25970                 }); err != nil {
25971                         if err == io.EOF {
25972                                 chk(io.EOF)
25973                         }
25974                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25975                 }
25976                 if err := pcall(func() {
25977                         ((*(*(struct {
25978                                 Type ItemType
25979
25980                                 Name, Desc string
25981
25982                                 InvImg, WieldImg Texture
25983                                 WieldScale       [3]float32
25984
25985                                 StackMax uint16
25986
25987                                 Usable          bool
25988                                 CanPointLiquids bool
25989
25990                                 ToolCaps ToolCaps
25991
25992                                 Groups []Group
25993
25994                                 PlacePredict string
25995
25996                                 PlaceSnd, PlaceFailSnd SoundDef
25997
25998                                 PointRange float32
25999
26000                                 // Set index in Palette with "palette_index" item meta field,
26001                                 // this overrides Color.
26002                                 Palette Texture
26003                                 Color   color.NRGBA
26004
26005                                 // Texture overlays.
26006                                 InvOverlay, WieldOverlay Texture
26007
26008                                 ShortDesc string
26009
26010                                 PlaceParam2 byte
26011                         }))(obj)).WieldOverlay).serialize(w)
26012                 }); err != nil {
26013                         if err == io.EOF {
26014                                 chk(io.EOF)
26015                         }
26016                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
26017                 }
26018                 if len(([]byte((*(*(struct {
26019                         Type ItemType
26020
26021                         Name, Desc string
26022
26023                         InvImg, WieldImg Texture
26024                         WieldScale       [3]float32
26025
26026                         StackMax uint16
26027
26028                         Usable          bool
26029                         CanPointLiquids bool
26030
26031                         ToolCaps ToolCaps
26032
26033                         Groups []Group
26034
26035                         PlacePredict string
26036
26037                         PlaceSnd, PlaceFailSnd SoundDef
26038
26039                         PointRange float32
26040
26041                         // Set index in Palette with "palette_index" item meta field,
26042                         // this overrides Color.
26043                         Palette Texture
26044                         Color   color.NRGBA
26045
26046                         // Texture overlays.
26047                         InvOverlay, WieldOverlay Texture
26048
26049                         ShortDesc string
26050
26051                         PlaceParam2 byte
26052                 }))(obj)).ShortDesc))) > math.MaxUint16 {
26053                         chk(ErrTooLong)
26054                 }
26055                 {
26056                         x := uint16(len(([]byte((*(*(struct {
26057                                 Type ItemType
26058
26059                                 Name, Desc string
26060
26061                                 InvImg, WieldImg Texture
26062                                 WieldScale       [3]float32
26063
26064                                 StackMax uint16
26065
26066                                 Usable          bool
26067                                 CanPointLiquids bool
26068
26069                                 ToolCaps ToolCaps
26070
26071                                 Groups []Group
26072
26073                                 PlacePredict string
26074
26075                                 PlaceSnd, PlaceFailSnd SoundDef
26076
26077                                 PointRange float32
26078
26079                                 // Set index in Palette with "palette_index" item meta field,
26080                                 // this overrides Color.
26081                                 Palette Texture
26082                                 Color   color.NRGBA
26083
26084                                 // Texture overlays.
26085                                 InvOverlay, WieldOverlay Texture
26086
26087                                 ShortDesc string
26088
26089                                 PlaceParam2 byte
26090                         }))(obj)).ShortDesc))))
26091                         write16(w, uint16(x))
26092                 }
26093                 {
26094                         _, err := w.Write(([]byte((*(*(struct {
26095                                 Type ItemType
26096
26097                                 Name, Desc string
26098
26099                                 InvImg, WieldImg Texture
26100                                 WieldScale       [3]float32
26101
26102                                 StackMax uint16
26103
26104                                 Usable          bool
26105                                 CanPointLiquids bool
26106
26107                                 ToolCaps ToolCaps
26108
26109                                 Groups []Group
26110
26111                                 PlacePredict string
26112
26113                                 PlaceSnd, PlaceFailSnd SoundDef
26114
26115                                 PointRange float32
26116
26117                                 // Set index in Palette with "palette_index" item meta field,
26118                                 // this overrides Color.
26119                                 Palette Texture
26120                                 Color   color.NRGBA
26121
26122                                 // Texture overlays.
26123                                 InvOverlay, WieldOverlay Texture
26124
26125                                 ShortDesc string
26126
26127                                 PlaceParam2 byte
26128                         }))(obj)).ShortDesc))[:])
26129                         chk(err)
26130                 }
26131                 {
26132                         x := (*(*(struct {
26133                                 Type ItemType
26134
26135                                 Name, Desc string
26136
26137                                 InvImg, WieldImg Texture
26138                                 WieldScale       [3]float32
26139
26140                                 StackMax uint16
26141
26142                                 Usable          bool
26143                                 CanPointLiquids bool
26144
26145                                 ToolCaps ToolCaps
26146
26147                                 Groups []Group
26148
26149                                 PlacePredict string
26150
26151                                 PlaceSnd, PlaceFailSnd SoundDef
26152
26153                                 PointRange float32
26154
26155                                 // Set index in Palette with "palette_index" item meta field,
26156                                 // this overrides Color.
26157                                 Palette Texture
26158                                 Color   color.NRGBA
26159
26160                                 // Texture overlays.
26161                                 InvOverlay, WieldOverlay Texture
26162
26163                                 ShortDesc string
26164
26165                                 PlaceParam2 byte
26166                         }))(obj)).PlaceParam2
26167                         write8(w, uint8(x))
26168                 }
26169                 {
26170                         buf := w
26171                         w := ow
26172                         if len((buf.Bytes())) > math.MaxUint16 {
26173                                 chk(ErrTooLong)
26174                         }
26175                         {
26176                                 x := uint16(len((buf.Bytes())))
26177                                 write16(w, uint16(x))
26178                         }
26179                         {
26180                                 _, err := w.Write((buf.Bytes())[:])
26181                                 chk(err)
26182                         }
26183                 }
26184         }
26185 }
26186
26187 func (obj *ItemDef) deserialize(r io.Reader) {
26188         {
26189                 var n uint16
26190                 {
26191                         p := &n
26192                         *p = read16(r)
26193                 }
26194                 r := &io.LimitedReader{r, int64(n)}
26195                 {
26196                         var local307 uint8
26197                         {
26198                                 p := &local307
26199                                 *p = read8(r)
26200                         }
26201                         if local307 != (6) {
26202                                 chk(fmt.Errorf("const %v: %v", 6, local307))
26203                         }
26204                 }
26205                 if err := pcall(func() {
26206                         ((*(*(struct {
26207                                 Type ItemType
26208
26209                                 Name, Desc string
26210
26211                                 InvImg, WieldImg Texture
26212                                 WieldScale       [3]float32
26213
26214                                 StackMax uint16
26215
26216                                 Usable          bool
26217                                 CanPointLiquids bool
26218
26219                                 ToolCaps ToolCaps
26220
26221                                 Groups []Group
26222
26223                                 PlacePredict string
26224
26225                                 PlaceSnd, PlaceFailSnd SoundDef
26226
26227                                 PointRange float32
26228
26229                                 // Set index in Palette with "palette_index" item meta field,
26230                                 // this overrides Color.
26231                                 Palette Texture
26232                                 Color   color.NRGBA
26233
26234                                 // Texture overlays.
26235                                 InvOverlay, WieldOverlay Texture
26236
26237                                 ShortDesc string
26238
26239                                 PlaceParam2 byte
26240                         }))(obj)).Type).deserialize(r)
26241                 }); err != nil {
26242                         if err == io.EOF {
26243                                 chk(io.EOF)
26244                         }
26245                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
26246                 }
26247                 var local308 []uint8
26248                 var local309 uint16
26249                 {
26250                         p := &local309
26251                         *p = read16(r)
26252                 }
26253                 (local308) = make([]uint8, local309)
26254                 {
26255                         _, err := io.ReadFull(r, (local308)[:])
26256                         chk(err)
26257                 }
26258                 ((*(*(struct {
26259                         Type ItemType
26260
26261                         Name, Desc string
26262
26263                         InvImg, WieldImg Texture
26264                         WieldScale       [3]float32
26265
26266                         StackMax uint16
26267
26268                         Usable          bool
26269                         CanPointLiquids bool
26270
26271                         ToolCaps ToolCaps
26272
26273                         Groups []Group
26274
26275                         PlacePredict string
26276
26277                         PlaceSnd, PlaceFailSnd SoundDef
26278
26279                         PointRange float32
26280
26281                         // Set index in Palette with "palette_index" item meta field,
26282                         // this overrides Color.
26283                         Palette Texture
26284                         Color   color.NRGBA
26285
26286                         // Texture overlays.
26287                         InvOverlay, WieldOverlay Texture
26288
26289                         ShortDesc string
26290
26291                         PlaceParam2 byte
26292                 }))(obj)).Name) = string(local308)
26293                 var local310 []uint8
26294                 var local311 uint16
26295                 {
26296                         p := &local311
26297                         *p = read16(r)
26298                 }
26299                 (local310) = make([]uint8, local311)
26300                 {
26301                         _, err := io.ReadFull(r, (local310)[:])
26302                         chk(err)
26303                 }
26304                 ((*(*(struct {
26305                         Type ItemType
26306
26307                         Name, Desc string
26308
26309                         InvImg, WieldImg Texture
26310                         WieldScale       [3]float32
26311
26312                         StackMax uint16
26313
26314                         Usable          bool
26315                         CanPointLiquids bool
26316
26317                         ToolCaps ToolCaps
26318
26319                         Groups []Group
26320
26321                         PlacePredict string
26322
26323                         PlaceSnd, PlaceFailSnd SoundDef
26324
26325                         PointRange float32
26326
26327                         // Set index in Palette with "palette_index" item meta field,
26328                         // this overrides Color.
26329                         Palette Texture
26330                         Color   color.NRGBA
26331
26332                         // Texture overlays.
26333                         InvOverlay, WieldOverlay Texture
26334
26335                         ShortDesc string
26336
26337                         PlaceParam2 byte
26338                 }))(obj)).Desc) = string(local310)
26339                 if err := pcall(func() {
26340                         ((*(*(struct {
26341                                 Type ItemType
26342
26343                                 Name, Desc string
26344
26345                                 InvImg, WieldImg Texture
26346                                 WieldScale       [3]float32
26347
26348                                 StackMax uint16
26349
26350                                 Usable          bool
26351                                 CanPointLiquids bool
26352
26353                                 ToolCaps ToolCaps
26354
26355                                 Groups []Group
26356
26357                                 PlacePredict string
26358
26359                                 PlaceSnd, PlaceFailSnd SoundDef
26360
26361                                 PointRange float32
26362
26363                                 // Set index in Palette with "palette_index" item meta field,
26364                                 // this overrides Color.
26365                                 Palette Texture
26366                                 Color   color.NRGBA
26367
26368                                 // Texture overlays.
26369                                 InvOverlay, WieldOverlay Texture
26370
26371                                 ShortDesc string
26372
26373                                 PlaceParam2 byte
26374                         }))(obj)).InvImg).deserialize(r)
26375                 }); err != nil {
26376                         if err == io.EOF {
26377                                 chk(io.EOF)
26378                         }
26379                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
26380                 }
26381                 if err := pcall(func() {
26382                         ((*(*(struct {
26383                                 Type ItemType
26384
26385                                 Name, Desc string
26386
26387                                 InvImg, WieldImg Texture
26388                                 WieldScale       [3]float32
26389
26390                                 StackMax uint16
26391
26392                                 Usable          bool
26393                                 CanPointLiquids bool
26394
26395                                 ToolCaps ToolCaps
26396
26397                                 Groups []Group
26398
26399                                 PlacePredict string
26400
26401                                 PlaceSnd, PlaceFailSnd SoundDef
26402
26403                                 PointRange float32
26404
26405                                 // Set index in Palette with "palette_index" item meta field,
26406                                 // this overrides Color.
26407                                 Palette Texture
26408                                 Color   color.NRGBA
26409
26410                                 // Texture overlays.
26411                                 InvOverlay, WieldOverlay Texture
26412
26413                                 ShortDesc string
26414
26415                                 PlaceParam2 byte
26416                         }))(obj)).WieldImg).deserialize(r)
26417                 }); err != nil {
26418                         if err == io.EOF {
26419                                 chk(io.EOF)
26420                         }
26421                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
26422                 }
26423                 for local312 := range (*(*(struct {
26424                         Type ItemType
26425
26426                         Name, Desc string
26427
26428                         InvImg, WieldImg Texture
26429                         WieldScale       [3]float32
26430
26431                         StackMax uint16
26432
26433                         Usable          bool
26434                         CanPointLiquids bool
26435
26436                         ToolCaps ToolCaps
26437
26438                         Groups []Group
26439
26440                         PlacePredict string
26441
26442                         PlaceSnd, PlaceFailSnd SoundDef
26443
26444                         PointRange float32
26445
26446                         // Set index in Palette with "palette_index" item meta field,
26447                         // this overrides Color.
26448                         Palette Texture
26449                         Color   color.NRGBA
26450
26451                         // Texture overlays.
26452                         InvOverlay, WieldOverlay Texture
26453
26454                         ShortDesc string
26455
26456                         PlaceParam2 byte
26457                 }))(obj)).WieldScale {
26458                         {
26459                                 p := &((*(*(struct {
26460                                         Type ItemType
26461
26462                                         Name, Desc string
26463
26464                                         InvImg, WieldImg Texture
26465                                         WieldScale       [3]float32
26466
26467                                         StackMax uint16
26468
26469                                         Usable          bool
26470                                         CanPointLiquids bool
26471
26472                                         ToolCaps ToolCaps
26473
26474                                         Groups []Group
26475
26476                                         PlacePredict string
26477
26478                                         PlaceSnd, PlaceFailSnd SoundDef
26479
26480                                         PointRange float32
26481
26482                                         // Set index in Palette with "palette_index" item meta field,
26483                                         // this overrides Color.
26484                                         Palette Texture
26485                                         Color   color.NRGBA
26486
26487                                         // Texture overlays.
26488                                         InvOverlay, WieldOverlay Texture
26489
26490                                         ShortDesc string
26491
26492                                         PlaceParam2 byte
26493                                 }))(obj)).WieldScale)[local312]
26494                                 *p = math.Float32frombits(read32(r))
26495                         }
26496                 }
26497                 {
26498                         p := &(*(*(struct {
26499                                 Type ItemType
26500
26501                                 Name, Desc string
26502
26503                                 InvImg, WieldImg Texture
26504                                 WieldScale       [3]float32
26505
26506                                 StackMax uint16
26507
26508                                 Usable          bool
26509                                 CanPointLiquids bool
26510
26511                                 ToolCaps ToolCaps
26512
26513                                 Groups []Group
26514
26515                                 PlacePredict string
26516
26517                                 PlaceSnd, PlaceFailSnd SoundDef
26518
26519                                 PointRange float32
26520
26521                                 // Set index in Palette with "palette_index" item meta field,
26522                                 // this overrides Color.
26523                                 Palette Texture
26524                                 Color   color.NRGBA
26525
26526                                 // Texture overlays.
26527                                 InvOverlay, WieldOverlay Texture
26528
26529                                 ShortDesc string
26530
26531                                 PlaceParam2 byte
26532                         }))(obj)).StackMax
26533                         *p = read16(r)
26534                 }
26535                 {
26536                         p := &(*(*(struct {
26537                                 Type ItemType
26538
26539                                 Name, Desc string
26540
26541                                 InvImg, WieldImg Texture
26542                                 WieldScale       [3]float32
26543
26544                                 StackMax uint16
26545
26546                                 Usable          bool
26547                                 CanPointLiquids bool
26548
26549                                 ToolCaps ToolCaps
26550
26551                                 Groups []Group
26552
26553                                 PlacePredict string
26554
26555                                 PlaceSnd, PlaceFailSnd SoundDef
26556
26557                                 PointRange float32
26558
26559                                 // Set index in Palette with "palette_index" item meta field,
26560                                 // this overrides Color.
26561                                 Palette Texture
26562                                 Color   color.NRGBA
26563
26564                                 // Texture overlays.
26565                                 InvOverlay, WieldOverlay Texture
26566
26567                                 ShortDesc string
26568
26569                                 PlaceParam2 byte
26570                         }))(obj)).Usable
26571                         switch n := read8(r); n {
26572                         case 0:
26573                                 *p = false
26574                         case 1:
26575                                 *p = true
26576                         default:
26577                                 chk(fmt.Errorf("invalid bool: %d", n))
26578                         }
26579                 }
26580                 {
26581                         p := &(*(*(struct {
26582                                 Type ItemType
26583
26584                                 Name, Desc string
26585
26586                                 InvImg, WieldImg Texture
26587                                 WieldScale       [3]float32
26588
26589                                 StackMax uint16
26590
26591                                 Usable          bool
26592                                 CanPointLiquids bool
26593
26594                                 ToolCaps ToolCaps
26595
26596                                 Groups []Group
26597
26598                                 PlacePredict string
26599
26600                                 PlaceSnd, PlaceFailSnd SoundDef
26601
26602                                 PointRange float32
26603
26604                                 // Set index in Palette with "palette_index" item meta field,
26605                                 // this overrides Color.
26606                                 Palette Texture
26607                                 Color   color.NRGBA
26608
26609                                 // Texture overlays.
26610                                 InvOverlay, WieldOverlay Texture
26611
26612                                 ShortDesc string
26613
26614                                 PlaceParam2 byte
26615                         }))(obj)).CanPointLiquids
26616                         switch n := read8(r); n {
26617                         case 0:
26618                                 *p = false
26619                         case 1:
26620                                 *p = true
26621                         default:
26622                                 chk(fmt.Errorf("invalid bool: %d", n))
26623                         }
26624                 }
26625                 if err := pcall(func() {
26626                         ((*(*(struct {
26627                                 Type ItemType
26628
26629                                 Name, Desc string
26630
26631                                 InvImg, WieldImg Texture
26632                                 WieldScale       [3]float32
26633
26634                                 StackMax uint16
26635
26636                                 Usable          bool
26637                                 CanPointLiquids bool
26638
26639                                 ToolCaps ToolCaps
26640
26641                                 Groups []Group
26642
26643                                 PlacePredict string
26644
26645                                 PlaceSnd, PlaceFailSnd SoundDef
26646
26647                                 PointRange float32
26648
26649                                 // Set index in Palette with "palette_index" item meta field,
26650                                 // this overrides Color.
26651                                 Palette Texture
26652                                 Color   color.NRGBA
26653
26654                                 // Texture overlays.
26655                                 InvOverlay, WieldOverlay Texture
26656
26657                                 ShortDesc string
26658
26659                                 PlaceParam2 byte
26660                         }))(obj)).ToolCaps).deserialize(r)
26661                 }); err != nil {
26662                         if err == io.EOF {
26663                                 chk(io.EOF)
26664                         }
26665                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
26666                 }
26667                 var local313 uint16
26668                 {
26669                         p := &local313
26670                         *p = read16(r)
26671                 }
26672                 ((*(*(struct {
26673                         Type ItemType
26674
26675                         Name, Desc string
26676
26677                         InvImg, WieldImg Texture
26678                         WieldScale       [3]float32
26679
26680                         StackMax uint16
26681
26682                         Usable          bool
26683                         CanPointLiquids bool
26684
26685                         ToolCaps ToolCaps
26686
26687                         Groups []Group
26688
26689                         PlacePredict string
26690
26691                         PlaceSnd, PlaceFailSnd SoundDef
26692
26693                         PointRange float32
26694
26695                         // Set index in Palette with "palette_index" item meta field,
26696                         // this overrides Color.
26697                         Palette Texture
26698                         Color   color.NRGBA
26699
26700                         // Texture overlays.
26701                         InvOverlay, WieldOverlay Texture
26702
26703                         ShortDesc string
26704
26705                         PlaceParam2 byte
26706                 }))(obj)).Groups) = make([]Group, local313)
26707                 for local314 := range (*(*(struct {
26708                         Type ItemType
26709
26710                         Name, Desc string
26711
26712                         InvImg, WieldImg Texture
26713                         WieldScale       [3]float32
26714
26715                         StackMax uint16
26716
26717                         Usable          bool
26718                         CanPointLiquids bool
26719
26720                         ToolCaps ToolCaps
26721
26722                         Groups []Group
26723
26724                         PlacePredict string
26725
26726                         PlaceSnd, PlaceFailSnd SoundDef
26727
26728                         PointRange float32
26729
26730                         // Set index in Palette with "palette_index" item meta field,
26731                         // this overrides Color.
26732                         Palette Texture
26733                         Color   color.NRGBA
26734
26735                         // Texture overlays.
26736                         InvOverlay, WieldOverlay Texture
26737
26738                         ShortDesc string
26739
26740                         PlaceParam2 byte
26741                 }))(obj)).Groups {
26742                         if err := pcall(func() {
26743                                 (((*(*(struct {
26744                                         Type ItemType
26745
26746                                         Name, Desc string
26747
26748                                         InvImg, WieldImg Texture
26749                                         WieldScale       [3]float32
26750
26751                                         StackMax uint16
26752
26753                                         Usable          bool
26754                                         CanPointLiquids bool
26755
26756                                         ToolCaps ToolCaps
26757
26758                                         Groups []Group
26759
26760                                         PlacePredict string
26761
26762                                         PlaceSnd, PlaceFailSnd SoundDef
26763
26764                                         PointRange float32
26765
26766                                         // Set index in Palette with "palette_index" item meta field,
26767                                         // this overrides Color.
26768                                         Palette Texture
26769                                         Color   color.NRGBA
26770
26771                                         // Texture overlays.
26772                                         InvOverlay, WieldOverlay Texture
26773
26774                                         ShortDesc string
26775
26776                                         PlaceParam2 byte
26777                                 }))(obj)).Groups)[local314]).deserialize(r)
26778                         }); err != nil {
26779                                 if err == io.EOF {
26780                                         chk(io.EOF)
26781                                 }
26782                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
26783                         }
26784                 }
26785                 var local315 []uint8
26786                 var local316 uint16
26787                 {
26788                         p := &local316
26789                         *p = read16(r)
26790                 }
26791                 (local315) = make([]uint8, local316)
26792                 {
26793                         _, err := io.ReadFull(r, (local315)[:])
26794                         chk(err)
26795                 }
26796                 ((*(*(struct {
26797                         Type ItemType
26798
26799                         Name, Desc string
26800
26801                         InvImg, WieldImg Texture
26802                         WieldScale       [3]float32
26803
26804                         StackMax uint16
26805
26806                         Usable          bool
26807                         CanPointLiquids bool
26808
26809                         ToolCaps ToolCaps
26810
26811                         Groups []Group
26812
26813                         PlacePredict string
26814
26815                         PlaceSnd, PlaceFailSnd SoundDef
26816
26817                         PointRange float32
26818
26819                         // Set index in Palette with "palette_index" item meta field,
26820                         // this overrides Color.
26821                         Palette Texture
26822                         Color   color.NRGBA
26823
26824                         // Texture overlays.
26825                         InvOverlay, WieldOverlay Texture
26826
26827                         ShortDesc string
26828
26829                         PlaceParam2 byte
26830                 }))(obj)).PlacePredict) = string(local315)
26831                 if err := pcall(func() {
26832                         ((*(*(struct {
26833                                 Type ItemType
26834
26835                                 Name, Desc string
26836
26837                                 InvImg, WieldImg Texture
26838                                 WieldScale       [3]float32
26839
26840                                 StackMax uint16
26841
26842                                 Usable          bool
26843                                 CanPointLiquids bool
26844
26845                                 ToolCaps ToolCaps
26846
26847                                 Groups []Group
26848
26849                                 PlacePredict string
26850
26851                                 PlaceSnd, PlaceFailSnd SoundDef
26852
26853                                 PointRange float32
26854
26855                                 // Set index in Palette with "palette_index" item meta field,
26856                                 // this overrides Color.
26857                                 Palette Texture
26858                                 Color   color.NRGBA
26859
26860                                 // Texture overlays.
26861                                 InvOverlay, WieldOverlay Texture
26862
26863                                 ShortDesc string
26864
26865                                 PlaceParam2 byte
26866                         }))(obj)).PlaceSnd).deserialize(r)
26867                 }); err != nil {
26868                         if err == io.EOF {
26869                                 chk(io.EOF)
26870                         }
26871                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
26872                 }
26873                 if err := pcall(func() {
26874                         ((*(*(struct {
26875                                 Type ItemType
26876
26877                                 Name, Desc string
26878
26879                                 InvImg, WieldImg Texture
26880                                 WieldScale       [3]float32
26881
26882                                 StackMax uint16
26883
26884                                 Usable          bool
26885                                 CanPointLiquids bool
26886
26887                                 ToolCaps ToolCaps
26888
26889                                 Groups []Group
26890
26891                                 PlacePredict string
26892
26893                                 PlaceSnd, PlaceFailSnd SoundDef
26894
26895                                 PointRange float32
26896
26897                                 // Set index in Palette with "palette_index" item meta field,
26898                                 // this overrides Color.
26899                                 Palette Texture
26900                                 Color   color.NRGBA
26901
26902                                 // Texture overlays.
26903                                 InvOverlay, WieldOverlay Texture
26904
26905                                 ShortDesc string
26906
26907                                 PlaceParam2 byte
26908                         }))(obj)).PlaceFailSnd).deserialize(r)
26909                 }); err != nil {
26910                         if err == io.EOF {
26911                                 chk(io.EOF)
26912                         }
26913                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
26914                 }
26915                 {
26916                         p := &(*(*(struct {
26917                                 Type ItemType
26918
26919                                 Name, Desc string
26920
26921                                 InvImg, WieldImg Texture
26922                                 WieldScale       [3]float32
26923
26924                                 StackMax uint16
26925
26926                                 Usable          bool
26927                                 CanPointLiquids bool
26928
26929                                 ToolCaps ToolCaps
26930
26931                                 Groups []Group
26932
26933                                 PlacePredict string
26934
26935                                 PlaceSnd, PlaceFailSnd SoundDef
26936
26937                                 PointRange float32
26938
26939                                 // Set index in Palette with "palette_index" item meta field,
26940                                 // this overrides Color.
26941                                 Palette Texture
26942                                 Color   color.NRGBA
26943
26944                                 // Texture overlays.
26945                                 InvOverlay, WieldOverlay Texture
26946
26947                                 ShortDesc string
26948
26949                                 PlaceParam2 byte
26950                         }))(obj)).PointRange
26951                         *p = math.Float32frombits(read32(r))
26952                 }
26953                 if err := pcall(func() {
26954                         ((*(*(struct {
26955                                 Type ItemType
26956
26957                                 Name, Desc string
26958
26959                                 InvImg, WieldImg Texture
26960                                 WieldScale       [3]float32
26961
26962                                 StackMax uint16
26963
26964                                 Usable          bool
26965                                 CanPointLiquids bool
26966
26967                                 ToolCaps ToolCaps
26968
26969                                 Groups []Group
26970
26971                                 PlacePredict string
26972
26973                                 PlaceSnd, PlaceFailSnd SoundDef
26974
26975                                 PointRange float32
26976
26977                                 // Set index in Palette with "palette_index" item meta field,
26978                                 // this overrides Color.
26979                                 Palette Texture
26980                                 Color   color.NRGBA
26981
26982                                 // Texture overlays.
26983                                 InvOverlay, WieldOverlay Texture
26984
26985                                 ShortDesc string
26986
26987                                 PlaceParam2 byte
26988                         }))(obj)).Palette).deserialize(r)
26989                 }); err != nil {
26990                         if err == io.EOF {
26991                                 chk(io.EOF)
26992                         }
26993                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
26994                 }
26995                 {
26996                         p := &(*(*(struct {
26997                                 Type ItemType
26998
26999                                 Name, Desc string
27000
27001                                 InvImg, WieldImg Texture
27002                                 WieldScale       [3]float32
27003
27004                                 StackMax uint16
27005
27006                                 Usable          bool
27007                                 CanPointLiquids bool
27008
27009                                 ToolCaps ToolCaps
27010
27011                                 Groups []Group
27012
27013                                 PlacePredict string
27014
27015                                 PlaceSnd, PlaceFailSnd SoundDef
27016
27017                                 PointRange float32
27018
27019                                 // Set index in Palette with "palette_index" item meta field,
27020                                 // this overrides Color.
27021                                 Palette Texture
27022                                 Color   color.NRGBA
27023
27024                                 // Texture overlays.
27025                                 InvOverlay, WieldOverlay Texture
27026
27027                                 ShortDesc string
27028
27029                                 PlaceParam2 byte
27030                         }))(obj)).Color
27031                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
27032                 }
27033                 if err := pcall(func() {
27034                         ((*(*(struct {
27035                                 Type ItemType
27036
27037                                 Name, Desc string
27038
27039                                 InvImg, WieldImg Texture
27040                                 WieldScale       [3]float32
27041
27042                                 StackMax uint16
27043
27044                                 Usable          bool
27045                                 CanPointLiquids bool
27046
27047                                 ToolCaps ToolCaps
27048
27049                                 Groups []Group
27050
27051                                 PlacePredict string
27052
27053                                 PlaceSnd, PlaceFailSnd SoundDef
27054
27055                                 PointRange float32
27056
27057                                 // Set index in Palette with "palette_index" item meta field,
27058                                 // this overrides Color.
27059                                 Palette Texture
27060                                 Color   color.NRGBA
27061
27062                                 // Texture overlays.
27063                                 InvOverlay, WieldOverlay Texture
27064
27065                                 ShortDesc string
27066
27067                                 PlaceParam2 byte
27068                         }))(obj)).InvOverlay).deserialize(r)
27069                 }); err != nil {
27070                         if err == io.EOF {
27071                                 chk(io.EOF)
27072                         }
27073                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
27074                 }
27075                 if err := pcall(func() {
27076                         ((*(*(struct {
27077                                 Type ItemType
27078
27079                                 Name, Desc string
27080
27081                                 InvImg, WieldImg Texture
27082                                 WieldScale       [3]float32
27083
27084                                 StackMax uint16
27085
27086                                 Usable          bool
27087                                 CanPointLiquids bool
27088
27089                                 ToolCaps ToolCaps
27090
27091                                 Groups []Group
27092
27093                                 PlacePredict string
27094
27095                                 PlaceSnd, PlaceFailSnd SoundDef
27096
27097                                 PointRange float32
27098
27099                                 // Set index in Palette with "palette_index" item meta field,
27100                                 // this overrides Color.
27101                                 Palette Texture
27102                                 Color   color.NRGBA
27103
27104                                 // Texture overlays.
27105                                 InvOverlay, WieldOverlay Texture
27106
27107                                 ShortDesc string
27108
27109                                 PlaceParam2 byte
27110                         }))(obj)).WieldOverlay).deserialize(r)
27111                 }); err != nil {
27112                         if err == io.EOF {
27113                                 chk(io.EOF)
27114                         }
27115                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
27116                 }
27117                 var local317 []uint8
27118                 var local318 uint16
27119                 {
27120                         p := &local318
27121                         *p = read16(r)
27122                 }
27123                 (local317) = make([]uint8, local318)
27124                 {
27125                         _, err := io.ReadFull(r, (local317)[:])
27126                         chk(err)
27127                 }
27128                 ((*(*(struct {
27129                         Type ItemType
27130
27131                         Name, Desc string
27132
27133                         InvImg, WieldImg Texture
27134                         WieldScale       [3]float32
27135
27136                         StackMax uint16
27137
27138                         Usable          bool
27139                         CanPointLiquids bool
27140
27141                         ToolCaps ToolCaps
27142
27143                         Groups []Group
27144
27145                         PlacePredict string
27146
27147                         PlaceSnd, PlaceFailSnd SoundDef
27148
27149                         PointRange float32
27150
27151                         // Set index in Palette with "palette_index" item meta field,
27152                         // this overrides Color.
27153                         Palette Texture
27154                         Color   color.NRGBA
27155
27156                         // Texture overlays.
27157                         InvOverlay, WieldOverlay Texture
27158
27159                         ShortDesc string
27160
27161                         PlaceParam2 byte
27162                 }))(obj)).ShortDesc) = string(local317)
27163                 {
27164                         p := &(*(*(struct {
27165                                 Type ItemType
27166
27167                                 Name, Desc string
27168
27169                                 InvImg, WieldImg Texture
27170                                 WieldScale       [3]float32
27171
27172                                 StackMax uint16
27173
27174                                 Usable          bool
27175                                 CanPointLiquids bool
27176
27177                                 ToolCaps ToolCaps
27178
27179                                 Groups []Group
27180
27181                                 PlacePredict string
27182
27183                                 PlaceSnd, PlaceFailSnd SoundDef
27184
27185                                 PointRange float32
27186
27187                                 // Set index in Palette with "palette_index" item meta field,
27188                                 // this overrides Color.
27189                                 Palette Texture
27190                                 Color   color.NRGBA
27191
27192                                 // Texture overlays.
27193                                 InvOverlay, WieldOverlay Texture
27194
27195                                 ShortDesc string
27196
27197                                 PlaceParam2 byte
27198                         }))(obj)).PlaceParam2
27199                         *p = read8(r)
27200                 }
27201                 if r.N > 0 {
27202                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
27203                 }
27204         }
27205 }
27206
27207 func (obj *SoundSrcType) serialize(w io.Writer) {
27208         {
27209                 x := *(*(uint8))(obj)
27210                 write8(w, uint8(x))
27211         }
27212 }
27213
27214 func (obj *SoundSrcType) deserialize(r io.Reader) {
27215         {
27216                 p := &*(*(uint8))(obj)
27217                 *p = read8(r)
27218         }
27219 }
27220
27221 func (obj *TileAnim) serialize(w io.Writer) {
27222         if err := pcall(func() {
27223                 ((*(*(struct {
27224                         Type AnimType
27225
27226                         //mt:if %s.Type == SpriteSheetAnim
27227                         AspectRatio [2]uint8
27228
27229                         //mt:if %s.Type == VerticalFrameAnim
27230                         NFrames [2]uint16
27231
27232                         //mt:if %s.Type != NoAnim
27233                         Duration float32 // in seconds
27234
27235                 }))(obj)).Type).serialize(w)
27236         }); err != nil {
27237                 if err == io.EOF {
27238                         chk(io.EOF)
27239                 }
27240                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
27241         }
27242         if !((*(*(struct {
27243                 Type AnimType
27244
27245                 //mt:if %s.Type == SpriteSheetAnim
27246                 AspectRatio [2]uint8
27247
27248                 //mt:if %s.Type == VerticalFrameAnim
27249                 NFrames [2]uint16
27250
27251                 //mt:if %s.Type != NoAnim
27252                 Duration float32 // in seconds
27253
27254         }))(obj)).Type < maxAnim) {
27255                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
27256         }
27257         if (*(*(struct {
27258                 Type AnimType
27259
27260                 //mt:if %s.Type == SpriteSheetAnim
27261                 AspectRatio [2]uint8
27262
27263                 //mt:if %s.Type == VerticalFrameAnim
27264                 NFrames [2]uint16
27265
27266                 //mt:if %s.Type != NoAnim
27267                 Duration float32 // in seconds
27268
27269         }))(obj)).Type == SpriteSheetAnim {
27270                 {
27271                         _, err := w.Write(((*(*(struct {
27272                                 Type AnimType
27273
27274                                 //mt:if %s.Type == SpriteSheetAnim
27275                                 AspectRatio [2]uint8
27276
27277                                 //mt:if %s.Type == VerticalFrameAnim
27278                                 NFrames [2]uint16
27279
27280                                 //mt:if %s.Type != NoAnim
27281                                 Duration float32 // in seconds
27282
27283                         }))(obj)).AspectRatio)[:])
27284                         chk(err)
27285                 }
27286         }
27287         if (*(*(struct {
27288                 Type AnimType
27289
27290                 //mt:if %s.Type == SpriteSheetAnim
27291                 AspectRatio [2]uint8
27292
27293                 //mt:if %s.Type == VerticalFrameAnim
27294                 NFrames [2]uint16
27295
27296                 //mt:if %s.Type != NoAnim
27297                 Duration float32 // in seconds
27298
27299         }))(obj)).Type == VerticalFrameAnim {
27300                 for local319 := range (*(*(struct {
27301                         Type AnimType
27302
27303                         //mt:if %s.Type == SpriteSheetAnim
27304                         AspectRatio [2]uint8
27305
27306                         //mt:if %s.Type == VerticalFrameAnim
27307                         NFrames [2]uint16
27308
27309                         //mt:if %s.Type != NoAnim
27310                         Duration float32 // in seconds
27311
27312                 }))(obj)).NFrames {
27313                         {
27314                                 x := ((*(*(struct {
27315                                         Type AnimType
27316
27317                                         //mt:if %s.Type == SpriteSheetAnim
27318                                         AspectRatio [2]uint8
27319
27320                                         //mt:if %s.Type == VerticalFrameAnim
27321                                         NFrames [2]uint16
27322
27323                                         //mt:if %s.Type != NoAnim
27324                                         Duration float32 // in seconds
27325
27326                                 }))(obj)).NFrames)[local319]
27327                                 write16(w, uint16(x))
27328                         }
27329                 }
27330         }
27331         if (*(*(struct {
27332                 Type AnimType
27333
27334                 //mt:if %s.Type == SpriteSheetAnim
27335                 AspectRatio [2]uint8
27336
27337                 //mt:if %s.Type == VerticalFrameAnim
27338                 NFrames [2]uint16
27339
27340                 //mt:if %s.Type != NoAnim
27341                 Duration float32 // in seconds
27342
27343         }))(obj)).Type != NoAnim {
27344                 {
27345                         x := (*(*(struct {
27346                                 Type AnimType
27347
27348                                 //mt:if %s.Type == SpriteSheetAnim
27349                                 AspectRatio [2]uint8
27350
27351                                 //mt:if %s.Type == VerticalFrameAnim
27352                                 NFrames [2]uint16
27353
27354                                 //mt:if %s.Type != NoAnim
27355                                 Duration float32 // in seconds
27356
27357                         }))(obj)).Duration
27358                         write32(w, math.Float32bits(x))
27359                 }
27360         }
27361 }
27362
27363 func (obj *TileAnim) deserialize(r io.Reader) {
27364         if err := pcall(func() {
27365                 ((*(*(struct {
27366                         Type AnimType
27367
27368                         //mt:if %s.Type == SpriteSheetAnim
27369                         AspectRatio [2]uint8
27370
27371                         //mt:if %s.Type == VerticalFrameAnim
27372                         NFrames [2]uint16
27373
27374                         //mt:if %s.Type != NoAnim
27375                         Duration float32 // in seconds
27376
27377                 }))(obj)).Type).deserialize(r)
27378         }); err != nil {
27379                 if err == io.EOF {
27380                         chk(io.EOF)
27381                 }
27382                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
27383         }
27384         if !((*(*(struct {
27385                 Type AnimType
27386
27387                 //mt:if %s.Type == SpriteSheetAnim
27388                 AspectRatio [2]uint8
27389
27390                 //mt:if %s.Type == VerticalFrameAnim
27391                 NFrames [2]uint16
27392
27393                 //mt:if %s.Type != NoAnim
27394                 Duration float32 // in seconds
27395
27396         }))(obj)).Type < maxAnim) {
27397                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
27398         }
27399         if (*(*(struct {
27400                 Type AnimType
27401
27402                 //mt:if %s.Type == SpriteSheetAnim
27403                 AspectRatio [2]uint8
27404
27405                 //mt:if %s.Type == VerticalFrameAnim
27406                 NFrames [2]uint16
27407
27408                 //mt:if %s.Type != NoAnim
27409                 Duration float32 // in seconds
27410
27411         }))(obj)).Type == SpriteSheetAnim {
27412                 {
27413                         _, err := io.ReadFull(r, ((*(*(struct {
27414                                 Type AnimType
27415
27416                                 //mt:if %s.Type == SpriteSheetAnim
27417                                 AspectRatio [2]uint8
27418
27419                                 //mt:if %s.Type == VerticalFrameAnim
27420                                 NFrames [2]uint16
27421
27422                                 //mt:if %s.Type != NoAnim
27423                                 Duration float32 // in seconds
27424
27425                         }))(obj)).AspectRatio)[:])
27426                         chk(err)
27427                 }
27428         }
27429         if (*(*(struct {
27430                 Type AnimType
27431
27432                 //mt:if %s.Type == SpriteSheetAnim
27433                 AspectRatio [2]uint8
27434
27435                 //mt:if %s.Type == VerticalFrameAnim
27436                 NFrames [2]uint16
27437
27438                 //mt:if %s.Type != NoAnim
27439                 Duration float32 // in seconds
27440
27441         }))(obj)).Type == VerticalFrameAnim {
27442                 for local320 := range (*(*(struct {
27443                         Type AnimType
27444
27445                         //mt:if %s.Type == SpriteSheetAnim
27446                         AspectRatio [2]uint8
27447
27448                         //mt:if %s.Type == VerticalFrameAnim
27449                         NFrames [2]uint16
27450
27451                         //mt:if %s.Type != NoAnim
27452                         Duration float32 // in seconds
27453
27454                 }))(obj)).NFrames {
27455                         {
27456                                 p := &((*(*(struct {
27457                                         Type AnimType
27458
27459                                         //mt:if %s.Type == SpriteSheetAnim
27460                                         AspectRatio [2]uint8
27461
27462                                         //mt:if %s.Type == VerticalFrameAnim
27463                                         NFrames [2]uint16
27464
27465                                         //mt:if %s.Type != NoAnim
27466                                         Duration float32 // in seconds
27467
27468                                 }))(obj)).NFrames)[local320]
27469                                 *p = read16(r)
27470                         }
27471                 }
27472         }
27473         if (*(*(struct {
27474                 Type AnimType
27475
27476                 //mt:if %s.Type == SpriteSheetAnim
27477                 AspectRatio [2]uint8
27478
27479                 //mt:if %s.Type == VerticalFrameAnim
27480                 NFrames [2]uint16
27481
27482                 //mt:if %s.Type != NoAnim
27483                 Duration float32 // in seconds
27484
27485         }))(obj)).Type != NoAnim {
27486                 {
27487                         p := &(*(*(struct {
27488                                 Type AnimType
27489
27490                                 //mt:if %s.Type == SpriteSheetAnim
27491                                 AspectRatio [2]uint8
27492
27493                                 //mt:if %s.Type == VerticalFrameAnim
27494                                 NFrames [2]uint16
27495
27496                                 //mt:if %s.Type != NoAnim
27497                                 Duration float32 // in seconds
27498
27499                         }))(obj)).Duration
27500                         *p = math.Float32frombits(read32(r))
27501                 }
27502         }
27503 }
27504
27505 func (obj *Content) serialize(w io.Writer) {
27506         {
27507                 x := *(*(uint16))(obj)
27508                 write16(w, uint16(x))
27509         }
27510 }
27511
27512 func (obj *Content) deserialize(r io.Reader) {
27513         {
27514                 p := &*(*(uint16))(obj)
27515                 *p = read16(r)
27516         }
27517 }
27518
27519 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
27520         {
27521                 x := *(*(uint32))(obj)
27522                 write32(w, uint32(x))
27523         }
27524 }
27525
27526 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
27527         {
27528                 p := &*(*(uint32))(obj)
27529                 *p = read32(r)
27530         }
27531 }
27532
27533 func (obj *HUDID) serialize(w io.Writer) {
27534         {
27535                 x := *(*(uint32))(obj)
27536                 write32(w, uint32(x))
27537         }
27538 }
27539
27540 func (obj *HUDID) deserialize(r io.Reader) {
27541         {
27542                 p := &*(*(uint32))(obj)
27543                 *p = read32(r)
27544         }
27545 }
27546
27547 func (obj *HUDType) serialize(w io.Writer) {
27548         {
27549                 x := *(*(uint8))(obj)
27550                 write8(w, uint8(x))
27551         }
27552 }
27553
27554 func (obj *HUDType) deserialize(r io.Reader) {
27555         {
27556                 p := &*(*(uint8))(obj)
27557                 *p = read8(r)
27558         }
27559 }
27560
27561 func (obj *HUDField) serialize(w io.Writer) {
27562         {
27563                 x := *(*(uint8))(obj)
27564                 write8(w, uint8(x))
27565         }
27566 }
27567
27568 func (obj *HUDField) deserialize(r io.Reader) {
27569         {
27570                 p := &*(*(uint8))(obj)
27571                 *p = read8(r)
27572         }
27573 }
27574
27575 func (obj *HUDFlags) serialize(w io.Writer) {
27576         {
27577                 x := *(*(uint32))(obj)
27578                 write32(w, uint32(x))
27579         }
27580 }
27581
27582 func (obj *HUDFlags) deserialize(r io.Reader) {
27583         {
27584                 p := &*(*(uint32))(obj)
27585                 *p = read32(r)
27586         }
27587 }
27588
27589 func (obj *HotbarParam) serialize(w io.Writer) {
27590         {
27591                 x := *(*(uint16))(obj)
27592                 write16(w, uint16(x))
27593         }
27594 }
27595
27596 func (obj *HotbarParam) deserialize(r io.Reader) {
27597         {
27598                 p := &*(*(uint16))(obj)
27599                 *p = read16(r)
27600         }
27601 }
27602
27603 func (obj *Texture) serialize(w io.Writer) {
27604         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
27605                 chk(ErrTooLong)
27606         }
27607         {
27608                 x := uint16(len(([]byte(*(*(string))(obj)))))
27609                 write16(w, uint16(x))
27610         }
27611         {
27612                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
27613                 chk(err)
27614         }
27615 }
27616
27617 func (obj *Texture) deserialize(r io.Reader) {
27618         var local321 []uint8
27619         var local322 uint16
27620         {
27621                 p := &local322
27622                 *p = read16(r)
27623         }
27624         (local321) = make([]uint8, local322)
27625         {
27626                 _, err := io.ReadFull(r, (local321)[:])
27627                 chk(err)
27628         }
27629         (*(*(string))(obj)) = string(local321)
27630 }
27631
27632 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
27633         {
27634                 x := *(*(uint8))(obj)
27635                 write8(w, uint8(x))
27636         }
27637 }
27638
27639 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
27640         {
27641                 p := &*(*(uint8))(obj)
27642                 *p = read8(r)
27643         }
27644 }
27645
27646 func (obj *ModChanSig) serialize(w io.Writer) {
27647         {
27648                 x := *(*(uint8))(obj)
27649                 write8(w, uint8(x))
27650         }
27651 }
27652
27653 func (obj *ModChanSig) deserialize(r io.Reader) {
27654         {
27655                 p := &*(*(uint8))(obj)
27656                 *p = read8(r)
27657         }
27658 }
27659
27660 func (obj *AOProps) serialize(w io.Writer) {
27661         {
27662                 local323 := uint8(4)
27663                 {
27664                         x := local323
27665                         write8(w, uint8(x))
27666                 }
27667         }
27668         {
27669                 x := (*(*(struct {
27670                         MaxHP            uint16 // Player only.
27671                         CollideWithNodes bool
27672                         Weight           float32 // deprecated
27673                         ColBox, SelBox   Box
27674                         Pointable        bool
27675                         Visual           string
27676                         VisualSize       [3]float32
27677                         Textures         []Texture
27678                         SpriteSheetSize  [2]int16 // in sprites.
27679                         SpritePos        [2]int16 // in sprite sheet.
27680                         Visible          bool
27681                         MakeFootstepSnds bool
27682                         RotateSpeed      float32 // in radians per second.
27683                         Mesh             string
27684                         Colors           []color.NRGBA
27685                         CollideWithAOs   bool
27686                         StepHeight       float32
27687                         FaceRotateDir    bool
27688                         FaceRotateDirOff float32 // in degrees.
27689                         BackfaceCull     bool
27690                         Nametag          string
27691                         NametagColor     color.NRGBA
27692                         FaceRotateSpeed  float32 // in degrees per second.
27693                         Infotext         string
27694                         Itemstring       string
27695                         Glow             int8
27696                         MaxBreath        uint16  // Player only.
27697                         EyeHeight        float32 // Player only.
27698                         ZoomFOV          float32 // in degrees. Player only.
27699                         UseTextureAlpha  bool
27700                         DmgTextureMod    Texture // suffix
27701                         Shaded           bool
27702                         ShowOnMinimap    bool
27703                         NametagBG        color.NRGBA
27704                 }))(obj)).MaxHP
27705                 write16(w, uint16(x))
27706         }
27707         {
27708                 x := (*(*(struct {
27709                         MaxHP            uint16 // Player only.
27710                         CollideWithNodes bool
27711                         Weight           float32 // deprecated
27712                         ColBox, SelBox   Box
27713                         Pointable        bool
27714                         Visual           string
27715                         VisualSize       [3]float32
27716                         Textures         []Texture
27717                         SpriteSheetSize  [2]int16 // in sprites.
27718                         SpritePos        [2]int16 // in sprite sheet.
27719                         Visible          bool
27720                         MakeFootstepSnds bool
27721                         RotateSpeed      float32 // in radians per second.
27722                         Mesh             string
27723                         Colors           []color.NRGBA
27724                         CollideWithAOs   bool
27725                         StepHeight       float32
27726                         FaceRotateDir    bool
27727                         FaceRotateDirOff float32 // in degrees.
27728                         BackfaceCull     bool
27729                         Nametag          string
27730                         NametagColor     color.NRGBA
27731                         FaceRotateSpeed  float32 // in degrees per second.
27732                         Infotext         string
27733                         Itemstring       string
27734                         Glow             int8
27735                         MaxBreath        uint16  // Player only.
27736                         EyeHeight        float32 // Player only.
27737                         ZoomFOV          float32 // in degrees. Player only.
27738                         UseTextureAlpha  bool
27739                         DmgTextureMod    Texture // suffix
27740                         Shaded           bool
27741                         ShowOnMinimap    bool
27742                         NametagBG        color.NRGBA
27743                 }))(obj)).CollideWithNodes
27744                 if x {
27745                         write8(w, 1)
27746                 } else {
27747                         write8(w, 0)
27748                 }
27749         }
27750         {
27751                 x := (*(*(struct {
27752                         MaxHP            uint16 // Player only.
27753                         CollideWithNodes bool
27754                         Weight           float32 // deprecated
27755                         ColBox, SelBox   Box
27756                         Pointable        bool
27757                         Visual           string
27758                         VisualSize       [3]float32
27759                         Textures         []Texture
27760                         SpriteSheetSize  [2]int16 // in sprites.
27761                         SpritePos        [2]int16 // in sprite sheet.
27762                         Visible          bool
27763                         MakeFootstepSnds bool
27764                         RotateSpeed      float32 // in radians per second.
27765                         Mesh             string
27766                         Colors           []color.NRGBA
27767                         CollideWithAOs   bool
27768                         StepHeight       float32
27769                         FaceRotateDir    bool
27770                         FaceRotateDirOff float32 // in degrees.
27771                         BackfaceCull     bool
27772                         Nametag          string
27773                         NametagColor     color.NRGBA
27774                         FaceRotateSpeed  float32 // in degrees per second.
27775                         Infotext         string
27776                         Itemstring       string
27777                         Glow             int8
27778                         MaxBreath        uint16  // Player only.
27779                         EyeHeight        float32 // Player only.
27780                         ZoomFOV          float32 // in degrees. Player only.
27781                         UseTextureAlpha  bool
27782                         DmgTextureMod    Texture // suffix
27783                         Shaded           bool
27784                         ShowOnMinimap    bool
27785                         NametagBG        color.NRGBA
27786                 }))(obj)).Weight
27787                 write32(w, math.Float32bits(x))
27788         }
27789         if err := pcall(func() {
27790                 ((*(*(struct {
27791                         MaxHP            uint16 // Player only.
27792                         CollideWithNodes bool
27793                         Weight           float32 // deprecated
27794                         ColBox, SelBox   Box
27795                         Pointable        bool
27796                         Visual           string
27797                         VisualSize       [3]float32
27798                         Textures         []Texture
27799                         SpriteSheetSize  [2]int16 // in sprites.
27800                         SpritePos        [2]int16 // in sprite sheet.
27801                         Visible          bool
27802                         MakeFootstepSnds bool
27803                         RotateSpeed      float32 // in radians per second.
27804                         Mesh             string
27805                         Colors           []color.NRGBA
27806                         CollideWithAOs   bool
27807                         StepHeight       float32
27808                         FaceRotateDir    bool
27809                         FaceRotateDirOff float32 // in degrees.
27810                         BackfaceCull     bool
27811                         Nametag          string
27812                         NametagColor     color.NRGBA
27813                         FaceRotateSpeed  float32 // in degrees per second.
27814                         Infotext         string
27815                         Itemstring       string
27816                         Glow             int8
27817                         MaxBreath        uint16  // Player only.
27818                         EyeHeight        float32 // Player only.
27819                         ZoomFOV          float32 // in degrees. Player only.
27820                         UseTextureAlpha  bool
27821                         DmgTextureMod    Texture // suffix
27822                         Shaded           bool
27823                         ShowOnMinimap    bool
27824                         NametagBG        color.NRGBA
27825                 }))(obj)).ColBox).serialize(w)
27826         }); err != nil {
27827                 if err == io.EOF {
27828                         chk(io.EOF)
27829                 }
27830                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27831         }
27832         if err := pcall(func() {
27833                 ((*(*(struct {
27834                         MaxHP            uint16 // Player only.
27835                         CollideWithNodes bool
27836                         Weight           float32 // deprecated
27837                         ColBox, SelBox   Box
27838                         Pointable        bool
27839                         Visual           string
27840                         VisualSize       [3]float32
27841                         Textures         []Texture
27842                         SpriteSheetSize  [2]int16 // in sprites.
27843                         SpritePos        [2]int16 // in sprite sheet.
27844                         Visible          bool
27845                         MakeFootstepSnds bool
27846                         RotateSpeed      float32 // in radians per second.
27847                         Mesh             string
27848                         Colors           []color.NRGBA
27849                         CollideWithAOs   bool
27850                         StepHeight       float32
27851                         FaceRotateDir    bool
27852                         FaceRotateDirOff float32 // in degrees.
27853                         BackfaceCull     bool
27854                         Nametag          string
27855                         NametagColor     color.NRGBA
27856                         FaceRotateSpeed  float32 // in degrees per second.
27857                         Infotext         string
27858                         Itemstring       string
27859                         Glow             int8
27860                         MaxBreath        uint16  // Player only.
27861                         EyeHeight        float32 // Player only.
27862                         ZoomFOV          float32 // in degrees. Player only.
27863                         UseTextureAlpha  bool
27864                         DmgTextureMod    Texture // suffix
27865                         Shaded           bool
27866                         ShowOnMinimap    bool
27867                         NametagBG        color.NRGBA
27868                 }))(obj)).SelBox).serialize(w)
27869         }); err != nil {
27870                 if err == io.EOF {
27871                         chk(io.EOF)
27872                 }
27873                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27874         }
27875         {
27876                 x := (*(*(struct {
27877                         MaxHP            uint16 // Player only.
27878                         CollideWithNodes bool
27879                         Weight           float32 // deprecated
27880                         ColBox, SelBox   Box
27881                         Pointable        bool
27882                         Visual           string
27883                         VisualSize       [3]float32
27884                         Textures         []Texture
27885                         SpriteSheetSize  [2]int16 // in sprites.
27886                         SpritePos        [2]int16 // in sprite sheet.
27887                         Visible          bool
27888                         MakeFootstepSnds bool
27889                         RotateSpeed      float32 // in radians per second.
27890                         Mesh             string
27891                         Colors           []color.NRGBA
27892                         CollideWithAOs   bool
27893                         StepHeight       float32
27894                         FaceRotateDir    bool
27895                         FaceRotateDirOff float32 // in degrees.
27896                         BackfaceCull     bool
27897                         Nametag          string
27898                         NametagColor     color.NRGBA
27899                         FaceRotateSpeed  float32 // in degrees per second.
27900                         Infotext         string
27901                         Itemstring       string
27902                         Glow             int8
27903                         MaxBreath        uint16  // Player only.
27904                         EyeHeight        float32 // Player only.
27905                         ZoomFOV          float32 // in degrees. Player only.
27906                         UseTextureAlpha  bool
27907                         DmgTextureMod    Texture // suffix
27908                         Shaded           bool
27909                         ShowOnMinimap    bool
27910                         NametagBG        color.NRGBA
27911                 }))(obj)).Pointable
27912                 if x {
27913                         write8(w, 1)
27914                 } else {
27915                         write8(w, 0)
27916                 }
27917         }
27918         if len(([]byte((*(*(struct {
27919                 MaxHP            uint16 // Player only.
27920                 CollideWithNodes bool
27921                 Weight           float32 // deprecated
27922                 ColBox, SelBox   Box
27923                 Pointable        bool
27924                 Visual           string
27925                 VisualSize       [3]float32
27926                 Textures         []Texture
27927                 SpriteSheetSize  [2]int16 // in sprites.
27928                 SpritePos        [2]int16 // in sprite sheet.
27929                 Visible          bool
27930                 MakeFootstepSnds bool
27931                 RotateSpeed      float32 // in radians per second.
27932                 Mesh             string
27933                 Colors           []color.NRGBA
27934                 CollideWithAOs   bool
27935                 StepHeight       float32
27936                 FaceRotateDir    bool
27937                 FaceRotateDirOff float32 // in degrees.
27938                 BackfaceCull     bool
27939                 Nametag          string
27940                 NametagColor     color.NRGBA
27941                 FaceRotateSpeed  float32 // in degrees per second.
27942                 Infotext         string
27943                 Itemstring       string
27944                 Glow             int8
27945                 MaxBreath        uint16  // Player only.
27946                 EyeHeight        float32 // Player only.
27947                 ZoomFOV          float32 // in degrees. Player only.
27948                 UseTextureAlpha  bool
27949                 DmgTextureMod    Texture // suffix
27950                 Shaded           bool
27951                 ShowOnMinimap    bool
27952                 NametagBG        color.NRGBA
27953         }))(obj)).Visual))) > math.MaxUint16 {
27954                 chk(ErrTooLong)
27955         }
27956         {
27957                 x := uint16(len(([]byte((*(*(struct {
27958                         MaxHP            uint16 // Player only.
27959                         CollideWithNodes bool
27960                         Weight           float32 // deprecated
27961                         ColBox, SelBox   Box
27962                         Pointable        bool
27963                         Visual           string
27964                         VisualSize       [3]float32
27965                         Textures         []Texture
27966                         SpriteSheetSize  [2]int16 // in sprites.
27967                         SpritePos        [2]int16 // in sprite sheet.
27968                         Visible          bool
27969                         MakeFootstepSnds bool
27970                         RotateSpeed      float32 // in radians per second.
27971                         Mesh             string
27972                         Colors           []color.NRGBA
27973                         CollideWithAOs   bool
27974                         StepHeight       float32
27975                         FaceRotateDir    bool
27976                         FaceRotateDirOff float32 // in degrees.
27977                         BackfaceCull     bool
27978                         Nametag          string
27979                         NametagColor     color.NRGBA
27980                         FaceRotateSpeed  float32 // in degrees per second.
27981                         Infotext         string
27982                         Itemstring       string
27983                         Glow             int8
27984                         MaxBreath        uint16  // Player only.
27985                         EyeHeight        float32 // Player only.
27986                         ZoomFOV          float32 // in degrees. Player only.
27987                         UseTextureAlpha  bool
27988                         DmgTextureMod    Texture // suffix
27989                         Shaded           bool
27990                         ShowOnMinimap    bool
27991                         NametagBG        color.NRGBA
27992                 }))(obj)).Visual))))
27993                 write16(w, uint16(x))
27994         }
27995         {
27996                 _, err := w.Write(([]byte((*(*(struct {
27997                         MaxHP            uint16 // Player only.
27998                         CollideWithNodes bool
27999                         Weight           float32 // deprecated
28000                         ColBox, SelBox   Box
28001                         Pointable        bool
28002                         Visual           string
28003                         VisualSize       [3]float32
28004                         Textures         []Texture
28005                         SpriteSheetSize  [2]int16 // in sprites.
28006                         SpritePos        [2]int16 // in sprite sheet.
28007                         Visible          bool
28008                         MakeFootstepSnds bool
28009                         RotateSpeed      float32 // in radians per second.
28010                         Mesh             string
28011                         Colors           []color.NRGBA
28012                         CollideWithAOs   bool
28013                         StepHeight       float32
28014                         FaceRotateDir    bool
28015                         FaceRotateDirOff float32 // in degrees.
28016                         BackfaceCull     bool
28017                         Nametag          string
28018                         NametagColor     color.NRGBA
28019                         FaceRotateSpeed  float32 // in degrees per second.
28020                         Infotext         string
28021                         Itemstring       string
28022                         Glow             int8
28023                         MaxBreath        uint16  // Player only.
28024                         EyeHeight        float32 // Player only.
28025                         ZoomFOV          float32 // in degrees. Player only.
28026                         UseTextureAlpha  bool
28027                         DmgTextureMod    Texture // suffix
28028                         Shaded           bool
28029                         ShowOnMinimap    bool
28030                         NametagBG        color.NRGBA
28031                 }))(obj)).Visual))[:])
28032                 chk(err)
28033         }
28034         for local324 := range (*(*(struct {
28035                 MaxHP            uint16 // Player only.
28036                 CollideWithNodes bool
28037                 Weight           float32 // deprecated
28038                 ColBox, SelBox   Box
28039                 Pointable        bool
28040                 Visual           string
28041                 VisualSize       [3]float32
28042                 Textures         []Texture
28043                 SpriteSheetSize  [2]int16 // in sprites.
28044                 SpritePos        [2]int16 // in sprite sheet.
28045                 Visible          bool
28046                 MakeFootstepSnds bool
28047                 RotateSpeed      float32 // in radians per second.
28048                 Mesh             string
28049                 Colors           []color.NRGBA
28050                 CollideWithAOs   bool
28051                 StepHeight       float32
28052                 FaceRotateDir    bool
28053                 FaceRotateDirOff float32 // in degrees.
28054                 BackfaceCull     bool
28055                 Nametag          string
28056                 NametagColor     color.NRGBA
28057                 FaceRotateSpeed  float32 // in degrees per second.
28058                 Infotext         string
28059                 Itemstring       string
28060                 Glow             int8
28061                 MaxBreath        uint16  // Player only.
28062                 EyeHeight        float32 // Player only.
28063                 ZoomFOV          float32 // in degrees. Player only.
28064                 UseTextureAlpha  bool
28065                 DmgTextureMod    Texture // suffix
28066                 Shaded           bool
28067                 ShowOnMinimap    bool
28068                 NametagBG        color.NRGBA
28069         }))(obj)).VisualSize {
28070                 {
28071                         x := ((*(*(struct {
28072                                 MaxHP            uint16 // Player only.
28073                                 CollideWithNodes bool
28074                                 Weight           float32 // deprecated
28075                                 ColBox, SelBox   Box
28076                                 Pointable        bool
28077                                 Visual           string
28078                                 VisualSize       [3]float32
28079                                 Textures         []Texture
28080                                 SpriteSheetSize  [2]int16 // in sprites.
28081                                 SpritePos        [2]int16 // in sprite sheet.
28082                                 Visible          bool
28083                                 MakeFootstepSnds bool
28084                                 RotateSpeed      float32 // in radians per second.
28085                                 Mesh             string
28086                                 Colors           []color.NRGBA
28087                                 CollideWithAOs   bool
28088                                 StepHeight       float32
28089                                 FaceRotateDir    bool
28090                                 FaceRotateDirOff float32 // in degrees.
28091                                 BackfaceCull     bool
28092                                 Nametag          string
28093                                 NametagColor     color.NRGBA
28094                                 FaceRotateSpeed  float32 // in degrees per second.
28095                                 Infotext         string
28096                                 Itemstring       string
28097                                 Glow             int8
28098                                 MaxBreath        uint16  // Player only.
28099                                 EyeHeight        float32 // Player only.
28100                                 ZoomFOV          float32 // in degrees. Player only.
28101                                 UseTextureAlpha  bool
28102                                 DmgTextureMod    Texture // suffix
28103                                 Shaded           bool
28104                                 ShowOnMinimap    bool
28105                                 NametagBG        color.NRGBA
28106                         }))(obj)).VisualSize)[local324]
28107                         write32(w, math.Float32bits(x))
28108                 }
28109         }
28110         if len(((*(*(struct {
28111                 MaxHP            uint16 // Player only.
28112                 CollideWithNodes bool
28113                 Weight           float32 // deprecated
28114                 ColBox, SelBox   Box
28115                 Pointable        bool
28116                 Visual           string
28117                 VisualSize       [3]float32
28118                 Textures         []Texture
28119                 SpriteSheetSize  [2]int16 // in sprites.
28120                 SpritePos        [2]int16 // in sprite sheet.
28121                 Visible          bool
28122                 MakeFootstepSnds bool
28123                 RotateSpeed      float32 // in radians per second.
28124                 Mesh             string
28125                 Colors           []color.NRGBA
28126                 CollideWithAOs   bool
28127                 StepHeight       float32
28128                 FaceRotateDir    bool
28129                 FaceRotateDirOff float32 // in degrees.
28130                 BackfaceCull     bool
28131                 Nametag          string
28132                 NametagColor     color.NRGBA
28133                 FaceRotateSpeed  float32 // in degrees per second.
28134                 Infotext         string
28135                 Itemstring       string
28136                 Glow             int8
28137                 MaxBreath        uint16  // Player only.
28138                 EyeHeight        float32 // Player only.
28139                 ZoomFOV          float32 // in degrees. Player only.
28140                 UseTextureAlpha  bool
28141                 DmgTextureMod    Texture // suffix
28142                 Shaded           bool
28143                 ShowOnMinimap    bool
28144                 NametagBG        color.NRGBA
28145         }))(obj)).Textures)) > math.MaxUint16 {
28146                 chk(ErrTooLong)
28147         }
28148         {
28149                 x := uint16(len(((*(*(struct {
28150                         MaxHP            uint16 // Player only.
28151                         CollideWithNodes bool
28152                         Weight           float32 // deprecated
28153                         ColBox, SelBox   Box
28154                         Pointable        bool
28155                         Visual           string
28156                         VisualSize       [3]float32
28157                         Textures         []Texture
28158                         SpriteSheetSize  [2]int16 // in sprites.
28159                         SpritePos        [2]int16 // in sprite sheet.
28160                         Visible          bool
28161                         MakeFootstepSnds bool
28162                         RotateSpeed      float32 // in radians per second.
28163                         Mesh             string
28164                         Colors           []color.NRGBA
28165                         CollideWithAOs   bool
28166                         StepHeight       float32
28167                         FaceRotateDir    bool
28168                         FaceRotateDirOff float32 // in degrees.
28169                         BackfaceCull     bool
28170                         Nametag          string
28171                         NametagColor     color.NRGBA
28172                         FaceRotateSpeed  float32 // in degrees per second.
28173                         Infotext         string
28174                         Itemstring       string
28175                         Glow             int8
28176                         MaxBreath        uint16  // Player only.
28177                         EyeHeight        float32 // Player only.
28178                         ZoomFOV          float32 // in degrees. Player only.
28179                         UseTextureAlpha  bool
28180                         DmgTextureMod    Texture // suffix
28181                         Shaded           bool
28182                         ShowOnMinimap    bool
28183                         NametagBG        color.NRGBA
28184                 }))(obj)).Textures)))
28185                 write16(w, uint16(x))
28186         }
28187         for local325 := range (*(*(struct {
28188                 MaxHP            uint16 // Player only.
28189                 CollideWithNodes bool
28190                 Weight           float32 // deprecated
28191                 ColBox, SelBox   Box
28192                 Pointable        bool
28193                 Visual           string
28194                 VisualSize       [3]float32
28195                 Textures         []Texture
28196                 SpriteSheetSize  [2]int16 // in sprites.
28197                 SpritePos        [2]int16 // in sprite sheet.
28198                 Visible          bool
28199                 MakeFootstepSnds bool
28200                 RotateSpeed      float32 // in radians per second.
28201                 Mesh             string
28202                 Colors           []color.NRGBA
28203                 CollideWithAOs   bool
28204                 StepHeight       float32
28205                 FaceRotateDir    bool
28206                 FaceRotateDirOff float32 // in degrees.
28207                 BackfaceCull     bool
28208                 Nametag          string
28209                 NametagColor     color.NRGBA
28210                 FaceRotateSpeed  float32 // in degrees per second.
28211                 Infotext         string
28212                 Itemstring       string
28213                 Glow             int8
28214                 MaxBreath        uint16  // Player only.
28215                 EyeHeight        float32 // Player only.
28216                 ZoomFOV          float32 // in degrees. Player only.
28217                 UseTextureAlpha  bool
28218                 DmgTextureMod    Texture // suffix
28219                 Shaded           bool
28220                 ShowOnMinimap    bool
28221                 NametagBG        color.NRGBA
28222         }))(obj)).Textures {
28223                 if err := pcall(func() {
28224                         (((*(*(struct {
28225                                 MaxHP            uint16 // Player only.
28226                                 CollideWithNodes bool
28227                                 Weight           float32 // deprecated
28228                                 ColBox, SelBox   Box
28229                                 Pointable        bool
28230                                 Visual           string
28231                                 VisualSize       [3]float32
28232                                 Textures         []Texture
28233                                 SpriteSheetSize  [2]int16 // in sprites.
28234                                 SpritePos        [2]int16 // in sprite sheet.
28235                                 Visible          bool
28236                                 MakeFootstepSnds bool
28237                                 RotateSpeed      float32 // in radians per second.
28238                                 Mesh             string
28239                                 Colors           []color.NRGBA
28240                                 CollideWithAOs   bool
28241                                 StepHeight       float32
28242                                 FaceRotateDir    bool
28243                                 FaceRotateDirOff float32 // in degrees.
28244                                 BackfaceCull     bool
28245                                 Nametag          string
28246                                 NametagColor     color.NRGBA
28247                                 FaceRotateSpeed  float32 // in degrees per second.
28248                                 Infotext         string
28249                                 Itemstring       string
28250                                 Glow             int8
28251                                 MaxBreath        uint16  // Player only.
28252                                 EyeHeight        float32 // Player only.
28253                                 ZoomFOV          float32 // in degrees. Player only.
28254                                 UseTextureAlpha  bool
28255                                 DmgTextureMod    Texture // suffix
28256                                 Shaded           bool
28257                                 ShowOnMinimap    bool
28258                                 NametagBG        color.NRGBA
28259                         }))(obj)).Textures)[local325]).serialize(w)
28260                 }); err != nil {
28261                         if err == io.EOF {
28262                                 chk(io.EOF)
28263                         }
28264                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
28265                 }
28266         }
28267         for local326 := range (*(*(struct {
28268                 MaxHP            uint16 // Player only.
28269                 CollideWithNodes bool
28270                 Weight           float32 // deprecated
28271                 ColBox, SelBox   Box
28272                 Pointable        bool
28273                 Visual           string
28274                 VisualSize       [3]float32
28275                 Textures         []Texture
28276                 SpriteSheetSize  [2]int16 // in sprites.
28277                 SpritePos        [2]int16 // in sprite sheet.
28278                 Visible          bool
28279                 MakeFootstepSnds bool
28280                 RotateSpeed      float32 // in radians per second.
28281                 Mesh             string
28282                 Colors           []color.NRGBA
28283                 CollideWithAOs   bool
28284                 StepHeight       float32
28285                 FaceRotateDir    bool
28286                 FaceRotateDirOff float32 // in degrees.
28287                 BackfaceCull     bool
28288                 Nametag          string
28289                 NametagColor     color.NRGBA
28290                 FaceRotateSpeed  float32 // in degrees per second.
28291                 Infotext         string
28292                 Itemstring       string
28293                 Glow             int8
28294                 MaxBreath        uint16  // Player only.
28295                 EyeHeight        float32 // Player only.
28296                 ZoomFOV          float32 // in degrees. Player only.
28297                 UseTextureAlpha  bool
28298                 DmgTextureMod    Texture // suffix
28299                 Shaded           bool
28300                 ShowOnMinimap    bool
28301                 NametagBG        color.NRGBA
28302         }))(obj)).SpriteSheetSize {
28303                 {
28304                         x := ((*(*(struct {
28305                                 MaxHP            uint16 // Player only.
28306                                 CollideWithNodes bool
28307                                 Weight           float32 // deprecated
28308                                 ColBox, SelBox   Box
28309                                 Pointable        bool
28310                                 Visual           string
28311                                 VisualSize       [3]float32
28312                                 Textures         []Texture
28313                                 SpriteSheetSize  [2]int16 // in sprites.
28314                                 SpritePos        [2]int16 // in sprite sheet.
28315                                 Visible          bool
28316                                 MakeFootstepSnds bool
28317                                 RotateSpeed      float32 // in radians per second.
28318                                 Mesh             string
28319                                 Colors           []color.NRGBA
28320                                 CollideWithAOs   bool
28321                                 StepHeight       float32
28322                                 FaceRotateDir    bool
28323                                 FaceRotateDirOff float32 // in degrees.
28324                                 BackfaceCull     bool
28325                                 Nametag          string
28326                                 NametagColor     color.NRGBA
28327                                 FaceRotateSpeed  float32 // in degrees per second.
28328                                 Infotext         string
28329                                 Itemstring       string
28330                                 Glow             int8
28331                                 MaxBreath        uint16  // Player only.
28332                                 EyeHeight        float32 // Player only.
28333                                 ZoomFOV          float32 // in degrees. Player only.
28334                                 UseTextureAlpha  bool
28335                                 DmgTextureMod    Texture // suffix
28336                                 Shaded           bool
28337                                 ShowOnMinimap    bool
28338                                 NametagBG        color.NRGBA
28339                         }))(obj)).SpriteSheetSize)[local326]
28340                         write16(w, uint16(x))
28341                 }
28342         }
28343         for local327 := range (*(*(struct {
28344                 MaxHP            uint16 // Player only.
28345                 CollideWithNodes bool
28346                 Weight           float32 // deprecated
28347                 ColBox, SelBox   Box
28348                 Pointable        bool
28349                 Visual           string
28350                 VisualSize       [3]float32
28351                 Textures         []Texture
28352                 SpriteSheetSize  [2]int16 // in sprites.
28353                 SpritePos        [2]int16 // in sprite sheet.
28354                 Visible          bool
28355                 MakeFootstepSnds bool
28356                 RotateSpeed      float32 // in radians per second.
28357                 Mesh             string
28358                 Colors           []color.NRGBA
28359                 CollideWithAOs   bool
28360                 StepHeight       float32
28361                 FaceRotateDir    bool
28362                 FaceRotateDirOff float32 // in degrees.
28363                 BackfaceCull     bool
28364                 Nametag          string
28365                 NametagColor     color.NRGBA
28366                 FaceRotateSpeed  float32 // in degrees per second.
28367                 Infotext         string
28368                 Itemstring       string
28369                 Glow             int8
28370                 MaxBreath        uint16  // Player only.
28371                 EyeHeight        float32 // Player only.
28372                 ZoomFOV          float32 // in degrees. Player only.
28373                 UseTextureAlpha  bool
28374                 DmgTextureMod    Texture // suffix
28375                 Shaded           bool
28376                 ShowOnMinimap    bool
28377                 NametagBG        color.NRGBA
28378         }))(obj)).SpritePos {
28379                 {
28380                         x := ((*(*(struct {
28381                                 MaxHP            uint16 // Player only.
28382                                 CollideWithNodes bool
28383                                 Weight           float32 // deprecated
28384                                 ColBox, SelBox   Box
28385                                 Pointable        bool
28386                                 Visual           string
28387                                 VisualSize       [3]float32
28388                                 Textures         []Texture
28389                                 SpriteSheetSize  [2]int16 // in sprites.
28390                                 SpritePos        [2]int16 // in sprite sheet.
28391                                 Visible          bool
28392                                 MakeFootstepSnds bool
28393                                 RotateSpeed      float32 // in radians per second.
28394                                 Mesh             string
28395                                 Colors           []color.NRGBA
28396                                 CollideWithAOs   bool
28397                                 StepHeight       float32
28398                                 FaceRotateDir    bool
28399                                 FaceRotateDirOff float32 // in degrees.
28400                                 BackfaceCull     bool
28401                                 Nametag          string
28402                                 NametagColor     color.NRGBA
28403                                 FaceRotateSpeed  float32 // in degrees per second.
28404                                 Infotext         string
28405                                 Itemstring       string
28406                                 Glow             int8
28407                                 MaxBreath        uint16  // Player only.
28408                                 EyeHeight        float32 // Player only.
28409                                 ZoomFOV          float32 // in degrees. Player only.
28410                                 UseTextureAlpha  bool
28411                                 DmgTextureMod    Texture // suffix
28412                                 Shaded           bool
28413                                 ShowOnMinimap    bool
28414                                 NametagBG        color.NRGBA
28415                         }))(obj)).SpritePos)[local327]
28416                         write16(w, uint16(x))
28417                 }
28418         }
28419         {
28420                 x := (*(*(struct {
28421                         MaxHP            uint16 // Player only.
28422                         CollideWithNodes bool
28423                         Weight           float32 // deprecated
28424                         ColBox, SelBox   Box
28425                         Pointable        bool
28426                         Visual           string
28427                         VisualSize       [3]float32
28428                         Textures         []Texture
28429                         SpriteSheetSize  [2]int16 // in sprites.
28430                         SpritePos        [2]int16 // in sprite sheet.
28431                         Visible          bool
28432                         MakeFootstepSnds bool
28433                         RotateSpeed      float32 // in radians per second.
28434                         Mesh             string
28435                         Colors           []color.NRGBA
28436                         CollideWithAOs   bool
28437                         StepHeight       float32
28438                         FaceRotateDir    bool
28439                         FaceRotateDirOff float32 // in degrees.
28440                         BackfaceCull     bool
28441                         Nametag          string
28442                         NametagColor     color.NRGBA
28443                         FaceRotateSpeed  float32 // in degrees per second.
28444                         Infotext         string
28445                         Itemstring       string
28446                         Glow             int8
28447                         MaxBreath        uint16  // Player only.
28448                         EyeHeight        float32 // Player only.
28449                         ZoomFOV          float32 // in degrees. Player only.
28450                         UseTextureAlpha  bool
28451                         DmgTextureMod    Texture // suffix
28452                         Shaded           bool
28453                         ShowOnMinimap    bool
28454                         NametagBG        color.NRGBA
28455                 }))(obj)).Visible
28456                 if x {
28457                         write8(w, 1)
28458                 } else {
28459                         write8(w, 0)
28460                 }
28461         }
28462         {
28463                 x := (*(*(struct {
28464                         MaxHP            uint16 // Player only.
28465                         CollideWithNodes bool
28466                         Weight           float32 // deprecated
28467                         ColBox, SelBox   Box
28468                         Pointable        bool
28469                         Visual           string
28470                         VisualSize       [3]float32
28471                         Textures         []Texture
28472                         SpriteSheetSize  [2]int16 // in sprites.
28473                         SpritePos        [2]int16 // in sprite sheet.
28474                         Visible          bool
28475                         MakeFootstepSnds bool
28476                         RotateSpeed      float32 // in radians per second.
28477                         Mesh             string
28478                         Colors           []color.NRGBA
28479                         CollideWithAOs   bool
28480                         StepHeight       float32
28481                         FaceRotateDir    bool
28482                         FaceRotateDirOff float32 // in degrees.
28483                         BackfaceCull     bool
28484                         Nametag          string
28485                         NametagColor     color.NRGBA
28486                         FaceRotateSpeed  float32 // in degrees per second.
28487                         Infotext         string
28488                         Itemstring       string
28489                         Glow             int8
28490                         MaxBreath        uint16  // Player only.
28491                         EyeHeight        float32 // Player only.
28492                         ZoomFOV          float32 // in degrees. Player only.
28493                         UseTextureAlpha  bool
28494                         DmgTextureMod    Texture // suffix
28495                         Shaded           bool
28496                         ShowOnMinimap    bool
28497                         NametagBG        color.NRGBA
28498                 }))(obj)).MakeFootstepSnds
28499                 if x {
28500                         write8(w, 1)
28501                 } else {
28502                         write8(w, 0)
28503                 }
28504         }
28505         {
28506                 x := (*(*(struct {
28507                         MaxHP            uint16 // Player only.
28508                         CollideWithNodes bool
28509                         Weight           float32 // deprecated
28510                         ColBox, SelBox   Box
28511                         Pointable        bool
28512                         Visual           string
28513                         VisualSize       [3]float32
28514                         Textures         []Texture
28515                         SpriteSheetSize  [2]int16 // in sprites.
28516                         SpritePos        [2]int16 // in sprite sheet.
28517                         Visible          bool
28518                         MakeFootstepSnds bool
28519                         RotateSpeed      float32 // in radians per second.
28520                         Mesh             string
28521                         Colors           []color.NRGBA
28522                         CollideWithAOs   bool
28523                         StepHeight       float32
28524                         FaceRotateDir    bool
28525                         FaceRotateDirOff float32 // in degrees.
28526                         BackfaceCull     bool
28527                         Nametag          string
28528                         NametagColor     color.NRGBA
28529                         FaceRotateSpeed  float32 // in degrees per second.
28530                         Infotext         string
28531                         Itemstring       string
28532                         Glow             int8
28533                         MaxBreath        uint16  // Player only.
28534                         EyeHeight        float32 // Player only.
28535                         ZoomFOV          float32 // in degrees. Player only.
28536                         UseTextureAlpha  bool
28537                         DmgTextureMod    Texture // suffix
28538                         Shaded           bool
28539                         ShowOnMinimap    bool
28540                         NametagBG        color.NRGBA
28541                 }))(obj)).RotateSpeed
28542                 write32(w, math.Float32bits(x))
28543         }
28544         if len(([]byte((*(*(struct {
28545                 MaxHP            uint16 // Player only.
28546                 CollideWithNodes bool
28547                 Weight           float32 // deprecated
28548                 ColBox, SelBox   Box
28549                 Pointable        bool
28550                 Visual           string
28551                 VisualSize       [3]float32
28552                 Textures         []Texture
28553                 SpriteSheetSize  [2]int16 // in sprites.
28554                 SpritePos        [2]int16 // in sprite sheet.
28555                 Visible          bool
28556                 MakeFootstepSnds bool
28557                 RotateSpeed      float32 // in radians per second.
28558                 Mesh             string
28559                 Colors           []color.NRGBA
28560                 CollideWithAOs   bool
28561                 StepHeight       float32
28562                 FaceRotateDir    bool
28563                 FaceRotateDirOff float32 // in degrees.
28564                 BackfaceCull     bool
28565                 Nametag          string
28566                 NametagColor     color.NRGBA
28567                 FaceRotateSpeed  float32 // in degrees per second.
28568                 Infotext         string
28569                 Itemstring       string
28570                 Glow             int8
28571                 MaxBreath        uint16  // Player only.
28572                 EyeHeight        float32 // Player only.
28573                 ZoomFOV          float32 // in degrees. Player only.
28574                 UseTextureAlpha  bool
28575                 DmgTextureMod    Texture // suffix
28576                 Shaded           bool
28577                 ShowOnMinimap    bool
28578                 NametagBG        color.NRGBA
28579         }))(obj)).Mesh))) > math.MaxUint16 {
28580                 chk(ErrTooLong)
28581         }
28582         {
28583                 x := uint16(len(([]byte((*(*(struct {
28584                         MaxHP            uint16 // Player only.
28585                         CollideWithNodes bool
28586                         Weight           float32 // deprecated
28587                         ColBox, SelBox   Box
28588                         Pointable        bool
28589                         Visual           string
28590                         VisualSize       [3]float32
28591                         Textures         []Texture
28592                         SpriteSheetSize  [2]int16 // in sprites.
28593                         SpritePos        [2]int16 // in sprite sheet.
28594                         Visible          bool
28595                         MakeFootstepSnds bool
28596                         RotateSpeed      float32 // in radians per second.
28597                         Mesh             string
28598                         Colors           []color.NRGBA
28599                         CollideWithAOs   bool
28600                         StepHeight       float32
28601                         FaceRotateDir    bool
28602                         FaceRotateDirOff float32 // in degrees.
28603                         BackfaceCull     bool
28604                         Nametag          string
28605                         NametagColor     color.NRGBA
28606                         FaceRotateSpeed  float32 // in degrees per second.
28607                         Infotext         string
28608                         Itemstring       string
28609                         Glow             int8
28610                         MaxBreath        uint16  // Player only.
28611                         EyeHeight        float32 // Player only.
28612                         ZoomFOV          float32 // in degrees. Player only.
28613                         UseTextureAlpha  bool
28614                         DmgTextureMod    Texture // suffix
28615                         Shaded           bool
28616                         ShowOnMinimap    bool
28617                         NametagBG        color.NRGBA
28618                 }))(obj)).Mesh))))
28619                 write16(w, uint16(x))
28620         }
28621         {
28622                 _, err := w.Write(([]byte((*(*(struct {
28623                         MaxHP            uint16 // Player only.
28624                         CollideWithNodes bool
28625                         Weight           float32 // deprecated
28626                         ColBox, SelBox   Box
28627                         Pointable        bool
28628                         Visual           string
28629                         VisualSize       [3]float32
28630                         Textures         []Texture
28631                         SpriteSheetSize  [2]int16 // in sprites.
28632                         SpritePos        [2]int16 // in sprite sheet.
28633                         Visible          bool
28634                         MakeFootstepSnds bool
28635                         RotateSpeed      float32 // in radians per second.
28636                         Mesh             string
28637                         Colors           []color.NRGBA
28638                         CollideWithAOs   bool
28639                         StepHeight       float32
28640                         FaceRotateDir    bool
28641                         FaceRotateDirOff float32 // in degrees.
28642                         BackfaceCull     bool
28643                         Nametag          string
28644                         NametagColor     color.NRGBA
28645                         FaceRotateSpeed  float32 // in degrees per second.
28646                         Infotext         string
28647                         Itemstring       string
28648                         Glow             int8
28649                         MaxBreath        uint16  // Player only.
28650                         EyeHeight        float32 // Player only.
28651                         ZoomFOV          float32 // in degrees. Player only.
28652                         UseTextureAlpha  bool
28653                         DmgTextureMod    Texture // suffix
28654                         Shaded           bool
28655                         ShowOnMinimap    bool
28656                         NametagBG        color.NRGBA
28657                 }))(obj)).Mesh))[:])
28658                 chk(err)
28659         }
28660         if len(((*(*(struct {
28661                 MaxHP            uint16 // Player only.
28662                 CollideWithNodes bool
28663                 Weight           float32 // deprecated
28664                 ColBox, SelBox   Box
28665                 Pointable        bool
28666                 Visual           string
28667                 VisualSize       [3]float32
28668                 Textures         []Texture
28669                 SpriteSheetSize  [2]int16 // in sprites.
28670                 SpritePos        [2]int16 // in sprite sheet.
28671                 Visible          bool
28672                 MakeFootstepSnds bool
28673                 RotateSpeed      float32 // in radians per second.
28674                 Mesh             string
28675                 Colors           []color.NRGBA
28676                 CollideWithAOs   bool
28677                 StepHeight       float32
28678                 FaceRotateDir    bool
28679                 FaceRotateDirOff float32 // in degrees.
28680                 BackfaceCull     bool
28681                 Nametag          string
28682                 NametagColor     color.NRGBA
28683                 FaceRotateSpeed  float32 // in degrees per second.
28684                 Infotext         string
28685                 Itemstring       string
28686                 Glow             int8
28687                 MaxBreath        uint16  // Player only.
28688                 EyeHeight        float32 // Player only.
28689                 ZoomFOV          float32 // in degrees. Player only.
28690                 UseTextureAlpha  bool
28691                 DmgTextureMod    Texture // suffix
28692                 Shaded           bool
28693                 ShowOnMinimap    bool
28694                 NametagBG        color.NRGBA
28695         }))(obj)).Colors)) > math.MaxUint16 {
28696                 chk(ErrTooLong)
28697         }
28698         {
28699                 x := uint16(len(((*(*(struct {
28700                         MaxHP            uint16 // Player only.
28701                         CollideWithNodes bool
28702                         Weight           float32 // deprecated
28703                         ColBox, SelBox   Box
28704                         Pointable        bool
28705                         Visual           string
28706                         VisualSize       [3]float32
28707                         Textures         []Texture
28708                         SpriteSheetSize  [2]int16 // in sprites.
28709                         SpritePos        [2]int16 // in sprite sheet.
28710                         Visible          bool
28711                         MakeFootstepSnds bool
28712                         RotateSpeed      float32 // in radians per second.
28713                         Mesh             string
28714                         Colors           []color.NRGBA
28715                         CollideWithAOs   bool
28716                         StepHeight       float32
28717                         FaceRotateDir    bool
28718                         FaceRotateDirOff float32 // in degrees.
28719                         BackfaceCull     bool
28720                         Nametag          string
28721                         NametagColor     color.NRGBA
28722                         FaceRotateSpeed  float32 // in degrees per second.
28723                         Infotext         string
28724                         Itemstring       string
28725                         Glow             int8
28726                         MaxBreath        uint16  // Player only.
28727                         EyeHeight        float32 // Player only.
28728                         ZoomFOV          float32 // in degrees. Player only.
28729                         UseTextureAlpha  bool
28730                         DmgTextureMod    Texture // suffix
28731                         Shaded           bool
28732                         ShowOnMinimap    bool
28733                         NametagBG        color.NRGBA
28734                 }))(obj)).Colors)))
28735                 write16(w, uint16(x))
28736         }
28737         for local328 := range (*(*(struct {
28738                 MaxHP            uint16 // Player only.
28739                 CollideWithNodes bool
28740                 Weight           float32 // deprecated
28741                 ColBox, SelBox   Box
28742                 Pointable        bool
28743                 Visual           string
28744                 VisualSize       [3]float32
28745                 Textures         []Texture
28746                 SpriteSheetSize  [2]int16 // in sprites.
28747                 SpritePos        [2]int16 // in sprite sheet.
28748                 Visible          bool
28749                 MakeFootstepSnds bool
28750                 RotateSpeed      float32 // in radians per second.
28751                 Mesh             string
28752                 Colors           []color.NRGBA
28753                 CollideWithAOs   bool
28754                 StepHeight       float32
28755                 FaceRotateDir    bool
28756                 FaceRotateDirOff float32 // in degrees.
28757                 BackfaceCull     bool
28758                 Nametag          string
28759                 NametagColor     color.NRGBA
28760                 FaceRotateSpeed  float32 // in degrees per second.
28761                 Infotext         string
28762                 Itemstring       string
28763                 Glow             int8
28764                 MaxBreath        uint16  // Player only.
28765                 EyeHeight        float32 // Player only.
28766                 ZoomFOV          float32 // in degrees. Player only.
28767                 UseTextureAlpha  bool
28768                 DmgTextureMod    Texture // suffix
28769                 Shaded           bool
28770                 ShowOnMinimap    bool
28771                 NametagBG        color.NRGBA
28772         }))(obj)).Colors {
28773                 {
28774                         x := ((*(*(struct {
28775                                 MaxHP            uint16 // Player only.
28776                                 CollideWithNodes bool
28777                                 Weight           float32 // deprecated
28778                                 ColBox, SelBox   Box
28779                                 Pointable        bool
28780                                 Visual           string
28781                                 VisualSize       [3]float32
28782                                 Textures         []Texture
28783                                 SpriteSheetSize  [2]int16 // in sprites.
28784                                 SpritePos        [2]int16 // in sprite sheet.
28785                                 Visible          bool
28786                                 MakeFootstepSnds bool
28787                                 RotateSpeed      float32 // in radians per second.
28788                                 Mesh             string
28789                                 Colors           []color.NRGBA
28790                                 CollideWithAOs   bool
28791                                 StepHeight       float32
28792                                 FaceRotateDir    bool
28793                                 FaceRotateDirOff float32 // in degrees.
28794                                 BackfaceCull     bool
28795                                 Nametag          string
28796                                 NametagColor     color.NRGBA
28797                                 FaceRotateSpeed  float32 // in degrees per second.
28798                                 Infotext         string
28799                                 Itemstring       string
28800                                 Glow             int8
28801                                 MaxBreath        uint16  // Player only.
28802                                 EyeHeight        float32 // Player only.
28803                                 ZoomFOV          float32 // in degrees. Player only.
28804                                 UseTextureAlpha  bool
28805                                 DmgTextureMod    Texture // suffix
28806                                 Shaded           bool
28807                                 ShowOnMinimap    bool
28808                                 NametagBG        color.NRGBA
28809                         }))(obj)).Colors)[local328]
28810                         w.Write([]byte{x.A, x.R, x.G, x.B})
28811                 }
28812         }
28813         {
28814                 x := (*(*(struct {
28815                         MaxHP            uint16 // Player only.
28816                         CollideWithNodes bool
28817                         Weight           float32 // deprecated
28818                         ColBox, SelBox   Box
28819                         Pointable        bool
28820                         Visual           string
28821                         VisualSize       [3]float32
28822                         Textures         []Texture
28823                         SpriteSheetSize  [2]int16 // in sprites.
28824                         SpritePos        [2]int16 // in sprite sheet.
28825                         Visible          bool
28826                         MakeFootstepSnds bool
28827                         RotateSpeed      float32 // in radians per second.
28828                         Mesh             string
28829                         Colors           []color.NRGBA
28830                         CollideWithAOs   bool
28831                         StepHeight       float32
28832                         FaceRotateDir    bool
28833                         FaceRotateDirOff float32 // in degrees.
28834                         BackfaceCull     bool
28835                         Nametag          string
28836                         NametagColor     color.NRGBA
28837                         FaceRotateSpeed  float32 // in degrees per second.
28838                         Infotext         string
28839                         Itemstring       string
28840                         Glow             int8
28841                         MaxBreath        uint16  // Player only.
28842                         EyeHeight        float32 // Player only.
28843                         ZoomFOV          float32 // in degrees. Player only.
28844                         UseTextureAlpha  bool
28845                         DmgTextureMod    Texture // suffix
28846                         Shaded           bool
28847                         ShowOnMinimap    bool
28848                         NametagBG        color.NRGBA
28849                 }))(obj)).CollideWithAOs
28850                 if x {
28851                         write8(w, 1)
28852                 } else {
28853                         write8(w, 0)
28854                 }
28855         }
28856         {
28857                 x := (*(*(struct {
28858                         MaxHP            uint16 // Player only.
28859                         CollideWithNodes bool
28860                         Weight           float32 // deprecated
28861                         ColBox, SelBox   Box
28862                         Pointable        bool
28863                         Visual           string
28864                         VisualSize       [3]float32
28865                         Textures         []Texture
28866                         SpriteSheetSize  [2]int16 // in sprites.
28867                         SpritePos        [2]int16 // in sprite sheet.
28868                         Visible          bool
28869                         MakeFootstepSnds bool
28870                         RotateSpeed      float32 // in radians per second.
28871                         Mesh             string
28872                         Colors           []color.NRGBA
28873                         CollideWithAOs   bool
28874                         StepHeight       float32
28875                         FaceRotateDir    bool
28876                         FaceRotateDirOff float32 // in degrees.
28877                         BackfaceCull     bool
28878                         Nametag          string
28879                         NametagColor     color.NRGBA
28880                         FaceRotateSpeed  float32 // in degrees per second.
28881                         Infotext         string
28882                         Itemstring       string
28883                         Glow             int8
28884                         MaxBreath        uint16  // Player only.
28885                         EyeHeight        float32 // Player only.
28886                         ZoomFOV          float32 // in degrees. Player only.
28887                         UseTextureAlpha  bool
28888                         DmgTextureMod    Texture // suffix
28889                         Shaded           bool
28890                         ShowOnMinimap    bool
28891                         NametagBG        color.NRGBA
28892                 }))(obj)).StepHeight
28893                 write32(w, math.Float32bits(x))
28894         }
28895         {
28896                 x := (*(*(struct {
28897                         MaxHP            uint16 // Player only.
28898                         CollideWithNodes bool
28899                         Weight           float32 // deprecated
28900                         ColBox, SelBox   Box
28901                         Pointable        bool
28902                         Visual           string
28903                         VisualSize       [3]float32
28904                         Textures         []Texture
28905                         SpriteSheetSize  [2]int16 // in sprites.
28906                         SpritePos        [2]int16 // in sprite sheet.
28907                         Visible          bool
28908                         MakeFootstepSnds bool
28909                         RotateSpeed      float32 // in radians per second.
28910                         Mesh             string
28911                         Colors           []color.NRGBA
28912                         CollideWithAOs   bool
28913                         StepHeight       float32
28914                         FaceRotateDir    bool
28915                         FaceRotateDirOff float32 // in degrees.
28916                         BackfaceCull     bool
28917                         Nametag          string
28918                         NametagColor     color.NRGBA
28919                         FaceRotateSpeed  float32 // in degrees per second.
28920                         Infotext         string
28921                         Itemstring       string
28922                         Glow             int8
28923                         MaxBreath        uint16  // Player only.
28924                         EyeHeight        float32 // Player only.
28925                         ZoomFOV          float32 // in degrees. Player only.
28926                         UseTextureAlpha  bool
28927                         DmgTextureMod    Texture // suffix
28928                         Shaded           bool
28929                         ShowOnMinimap    bool
28930                         NametagBG        color.NRGBA
28931                 }))(obj)).FaceRotateDir
28932                 if x {
28933                         write8(w, 1)
28934                 } else {
28935                         write8(w, 0)
28936                 }
28937         }
28938         {
28939                 x := (*(*(struct {
28940                         MaxHP            uint16 // Player only.
28941                         CollideWithNodes bool
28942                         Weight           float32 // deprecated
28943                         ColBox, SelBox   Box
28944                         Pointable        bool
28945                         Visual           string
28946                         VisualSize       [3]float32
28947                         Textures         []Texture
28948                         SpriteSheetSize  [2]int16 // in sprites.
28949                         SpritePos        [2]int16 // in sprite sheet.
28950                         Visible          bool
28951                         MakeFootstepSnds bool
28952                         RotateSpeed      float32 // in radians per second.
28953                         Mesh             string
28954                         Colors           []color.NRGBA
28955                         CollideWithAOs   bool
28956                         StepHeight       float32
28957                         FaceRotateDir    bool
28958                         FaceRotateDirOff float32 // in degrees.
28959                         BackfaceCull     bool
28960                         Nametag          string
28961                         NametagColor     color.NRGBA
28962                         FaceRotateSpeed  float32 // in degrees per second.
28963                         Infotext         string
28964                         Itemstring       string
28965                         Glow             int8
28966                         MaxBreath        uint16  // Player only.
28967                         EyeHeight        float32 // Player only.
28968                         ZoomFOV          float32 // in degrees. Player only.
28969                         UseTextureAlpha  bool
28970                         DmgTextureMod    Texture // suffix
28971                         Shaded           bool
28972                         ShowOnMinimap    bool
28973                         NametagBG        color.NRGBA
28974                 }))(obj)).FaceRotateDirOff
28975                 write32(w, math.Float32bits(x))
28976         }
28977         {
28978                 x := (*(*(struct {
28979                         MaxHP            uint16 // Player only.
28980                         CollideWithNodes bool
28981                         Weight           float32 // deprecated
28982                         ColBox, SelBox   Box
28983                         Pointable        bool
28984                         Visual           string
28985                         VisualSize       [3]float32
28986                         Textures         []Texture
28987                         SpriteSheetSize  [2]int16 // in sprites.
28988                         SpritePos        [2]int16 // in sprite sheet.
28989                         Visible          bool
28990                         MakeFootstepSnds bool
28991                         RotateSpeed      float32 // in radians per second.
28992                         Mesh             string
28993                         Colors           []color.NRGBA
28994                         CollideWithAOs   bool
28995                         StepHeight       float32
28996                         FaceRotateDir    bool
28997                         FaceRotateDirOff float32 // in degrees.
28998                         BackfaceCull     bool
28999                         Nametag          string
29000                         NametagColor     color.NRGBA
29001                         FaceRotateSpeed  float32 // in degrees per second.
29002                         Infotext         string
29003                         Itemstring       string
29004                         Glow             int8
29005                         MaxBreath        uint16  // Player only.
29006                         EyeHeight        float32 // Player only.
29007                         ZoomFOV          float32 // in degrees. Player only.
29008                         UseTextureAlpha  bool
29009                         DmgTextureMod    Texture // suffix
29010                         Shaded           bool
29011                         ShowOnMinimap    bool
29012                         NametagBG        color.NRGBA
29013                 }))(obj)).BackfaceCull
29014                 if x {
29015                         write8(w, 1)
29016                 } else {
29017                         write8(w, 0)
29018                 }
29019         }
29020         if len(([]byte((*(*(struct {
29021                 MaxHP            uint16 // Player only.
29022                 CollideWithNodes bool
29023                 Weight           float32 // deprecated
29024                 ColBox, SelBox   Box
29025                 Pointable        bool
29026                 Visual           string
29027                 VisualSize       [3]float32
29028                 Textures         []Texture
29029                 SpriteSheetSize  [2]int16 // in sprites.
29030                 SpritePos        [2]int16 // in sprite sheet.
29031                 Visible          bool
29032                 MakeFootstepSnds bool
29033                 RotateSpeed      float32 // in radians per second.
29034                 Mesh             string
29035                 Colors           []color.NRGBA
29036                 CollideWithAOs   bool
29037                 StepHeight       float32
29038                 FaceRotateDir    bool
29039                 FaceRotateDirOff float32 // in degrees.
29040                 BackfaceCull     bool
29041                 Nametag          string
29042                 NametagColor     color.NRGBA
29043                 FaceRotateSpeed  float32 // in degrees per second.
29044                 Infotext         string
29045                 Itemstring       string
29046                 Glow             int8
29047                 MaxBreath        uint16  // Player only.
29048                 EyeHeight        float32 // Player only.
29049                 ZoomFOV          float32 // in degrees. Player only.
29050                 UseTextureAlpha  bool
29051                 DmgTextureMod    Texture // suffix
29052                 Shaded           bool
29053                 ShowOnMinimap    bool
29054                 NametagBG        color.NRGBA
29055         }))(obj)).Nametag))) > math.MaxUint16 {
29056                 chk(ErrTooLong)
29057         }
29058         {
29059                 x := uint16(len(([]byte((*(*(struct {
29060                         MaxHP            uint16 // Player only.
29061                         CollideWithNodes bool
29062                         Weight           float32 // deprecated
29063                         ColBox, SelBox   Box
29064                         Pointable        bool
29065                         Visual           string
29066                         VisualSize       [3]float32
29067                         Textures         []Texture
29068                         SpriteSheetSize  [2]int16 // in sprites.
29069                         SpritePos        [2]int16 // in sprite sheet.
29070                         Visible          bool
29071                         MakeFootstepSnds bool
29072                         RotateSpeed      float32 // in radians per second.
29073                         Mesh             string
29074                         Colors           []color.NRGBA
29075                         CollideWithAOs   bool
29076                         StepHeight       float32
29077                         FaceRotateDir    bool
29078                         FaceRotateDirOff float32 // in degrees.
29079                         BackfaceCull     bool
29080                         Nametag          string
29081                         NametagColor     color.NRGBA
29082                         FaceRotateSpeed  float32 // in degrees per second.
29083                         Infotext         string
29084                         Itemstring       string
29085                         Glow             int8
29086                         MaxBreath        uint16  // Player only.
29087                         EyeHeight        float32 // Player only.
29088                         ZoomFOV          float32 // in degrees. Player only.
29089                         UseTextureAlpha  bool
29090                         DmgTextureMod    Texture // suffix
29091                         Shaded           bool
29092                         ShowOnMinimap    bool
29093                         NametagBG        color.NRGBA
29094                 }))(obj)).Nametag))))
29095                 write16(w, uint16(x))
29096         }
29097         {
29098                 _, err := w.Write(([]byte((*(*(struct {
29099                         MaxHP            uint16 // Player only.
29100                         CollideWithNodes bool
29101                         Weight           float32 // deprecated
29102                         ColBox, SelBox   Box
29103                         Pointable        bool
29104                         Visual           string
29105                         VisualSize       [3]float32
29106                         Textures         []Texture
29107                         SpriteSheetSize  [2]int16 // in sprites.
29108                         SpritePos        [2]int16 // in sprite sheet.
29109                         Visible          bool
29110                         MakeFootstepSnds bool
29111                         RotateSpeed      float32 // in radians per second.
29112                         Mesh             string
29113                         Colors           []color.NRGBA
29114                         CollideWithAOs   bool
29115                         StepHeight       float32
29116                         FaceRotateDir    bool
29117                         FaceRotateDirOff float32 // in degrees.
29118                         BackfaceCull     bool
29119                         Nametag          string
29120                         NametagColor     color.NRGBA
29121                         FaceRotateSpeed  float32 // in degrees per second.
29122                         Infotext         string
29123                         Itemstring       string
29124                         Glow             int8
29125                         MaxBreath        uint16  // Player only.
29126                         EyeHeight        float32 // Player only.
29127                         ZoomFOV          float32 // in degrees. Player only.
29128                         UseTextureAlpha  bool
29129                         DmgTextureMod    Texture // suffix
29130                         Shaded           bool
29131                         ShowOnMinimap    bool
29132                         NametagBG        color.NRGBA
29133                 }))(obj)).Nametag))[:])
29134                 chk(err)
29135         }
29136         {
29137                 x := (*(*(struct {
29138                         MaxHP            uint16 // Player only.
29139                         CollideWithNodes bool
29140                         Weight           float32 // deprecated
29141                         ColBox, SelBox   Box
29142                         Pointable        bool
29143                         Visual           string
29144                         VisualSize       [3]float32
29145                         Textures         []Texture
29146                         SpriteSheetSize  [2]int16 // in sprites.
29147                         SpritePos        [2]int16 // in sprite sheet.
29148                         Visible          bool
29149                         MakeFootstepSnds bool
29150                         RotateSpeed      float32 // in radians per second.
29151                         Mesh             string
29152                         Colors           []color.NRGBA
29153                         CollideWithAOs   bool
29154                         StepHeight       float32
29155                         FaceRotateDir    bool
29156                         FaceRotateDirOff float32 // in degrees.
29157                         BackfaceCull     bool
29158                         Nametag          string
29159                         NametagColor     color.NRGBA
29160                         FaceRotateSpeed  float32 // in degrees per second.
29161                         Infotext         string
29162                         Itemstring       string
29163                         Glow             int8
29164                         MaxBreath        uint16  // Player only.
29165                         EyeHeight        float32 // Player only.
29166                         ZoomFOV          float32 // in degrees. Player only.
29167                         UseTextureAlpha  bool
29168                         DmgTextureMod    Texture // suffix
29169                         Shaded           bool
29170                         ShowOnMinimap    bool
29171                         NametagBG        color.NRGBA
29172                 }))(obj)).NametagColor
29173                 w.Write([]byte{x.A, x.R, x.G, x.B})
29174         }
29175         {
29176                 x := (*(*(struct {
29177                         MaxHP            uint16 // Player only.
29178                         CollideWithNodes bool
29179                         Weight           float32 // deprecated
29180                         ColBox, SelBox   Box
29181                         Pointable        bool
29182                         Visual           string
29183                         VisualSize       [3]float32
29184                         Textures         []Texture
29185                         SpriteSheetSize  [2]int16 // in sprites.
29186                         SpritePos        [2]int16 // in sprite sheet.
29187                         Visible          bool
29188                         MakeFootstepSnds bool
29189                         RotateSpeed      float32 // in radians per second.
29190                         Mesh             string
29191                         Colors           []color.NRGBA
29192                         CollideWithAOs   bool
29193                         StepHeight       float32
29194                         FaceRotateDir    bool
29195                         FaceRotateDirOff float32 // in degrees.
29196                         BackfaceCull     bool
29197                         Nametag          string
29198                         NametagColor     color.NRGBA
29199                         FaceRotateSpeed  float32 // in degrees per second.
29200                         Infotext         string
29201                         Itemstring       string
29202                         Glow             int8
29203                         MaxBreath        uint16  // Player only.
29204                         EyeHeight        float32 // Player only.
29205                         ZoomFOV          float32 // in degrees. Player only.
29206                         UseTextureAlpha  bool
29207                         DmgTextureMod    Texture // suffix
29208                         Shaded           bool
29209                         ShowOnMinimap    bool
29210                         NametagBG        color.NRGBA
29211                 }))(obj)).FaceRotateSpeed
29212                 write32(w, math.Float32bits(x))
29213         }
29214         if len(([]byte((*(*(struct {
29215                 MaxHP            uint16 // Player only.
29216                 CollideWithNodes bool
29217                 Weight           float32 // deprecated
29218                 ColBox, SelBox   Box
29219                 Pointable        bool
29220                 Visual           string
29221                 VisualSize       [3]float32
29222                 Textures         []Texture
29223                 SpriteSheetSize  [2]int16 // in sprites.
29224                 SpritePos        [2]int16 // in sprite sheet.
29225                 Visible          bool
29226                 MakeFootstepSnds bool
29227                 RotateSpeed      float32 // in radians per second.
29228                 Mesh             string
29229                 Colors           []color.NRGBA
29230                 CollideWithAOs   bool
29231                 StepHeight       float32
29232                 FaceRotateDir    bool
29233                 FaceRotateDirOff float32 // in degrees.
29234                 BackfaceCull     bool
29235                 Nametag          string
29236                 NametagColor     color.NRGBA
29237                 FaceRotateSpeed  float32 // in degrees per second.
29238                 Infotext         string
29239                 Itemstring       string
29240                 Glow             int8
29241                 MaxBreath        uint16  // Player only.
29242                 EyeHeight        float32 // Player only.
29243                 ZoomFOV          float32 // in degrees. Player only.
29244                 UseTextureAlpha  bool
29245                 DmgTextureMod    Texture // suffix
29246                 Shaded           bool
29247                 ShowOnMinimap    bool
29248                 NametagBG        color.NRGBA
29249         }))(obj)).Infotext))) > math.MaxUint16 {
29250                 chk(ErrTooLong)
29251         }
29252         {
29253                 x := uint16(len(([]byte((*(*(struct {
29254                         MaxHP            uint16 // Player only.
29255                         CollideWithNodes bool
29256                         Weight           float32 // deprecated
29257                         ColBox, SelBox   Box
29258                         Pointable        bool
29259                         Visual           string
29260                         VisualSize       [3]float32
29261                         Textures         []Texture
29262                         SpriteSheetSize  [2]int16 // in sprites.
29263                         SpritePos        [2]int16 // in sprite sheet.
29264                         Visible          bool
29265                         MakeFootstepSnds bool
29266                         RotateSpeed      float32 // in radians per second.
29267                         Mesh             string
29268                         Colors           []color.NRGBA
29269                         CollideWithAOs   bool
29270                         StepHeight       float32
29271                         FaceRotateDir    bool
29272                         FaceRotateDirOff float32 // in degrees.
29273                         BackfaceCull     bool
29274                         Nametag          string
29275                         NametagColor     color.NRGBA
29276                         FaceRotateSpeed  float32 // in degrees per second.
29277                         Infotext         string
29278                         Itemstring       string
29279                         Glow             int8
29280                         MaxBreath        uint16  // Player only.
29281                         EyeHeight        float32 // Player only.
29282                         ZoomFOV          float32 // in degrees. Player only.
29283                         UseTextureAlpha  bool
29284                         DmgTextureMod    Texture // suffix
29285                         Shaded           bool
29286                         ShowOnMinimap    bool
29287                         NametagBG        color.NRGBA
29288                 }))(obj)).Infotext))))
29289                 write16(w, uint16(x))
29290         }
29291         {
29292                 _, err := w.Write(([]byte((*(*(struct {
29293                         MaxHP            uint16 // Player only.
29294                         CollideWithNodes bool
29295                         Weight           float32 // deprecated
29296                         ColBox, SelBox   Box
29297                         Pointable        bool
29298                         Visual           string
29299                         VisualSize       [3]float32
29300                         Textures         []Texture
29301                         SpriteSheetSize  [2]int16 // in sprites.
29302                         SpritePos        [2]int16 // in sprite sheet.
29303                         Visible          bool
29304                         MakeFootstepSnds bool
29305                         RotateSpeed      float32 // in radians per second.
29306                         Mesh             string
29307                         Colors           []color.NRGBA
29308                         CollideWithAOs   bool
29309                         StepHeight       float32
29310                         FaceRotateDir    bool
29311                         FaceRotateDirOff float32 // in degrees.
29312                         BackfaceCull     bool
29313                         Nametag          string
29314                         NametagColor     color.NRGBA
29315                         FaceRotateSpeed  float32 // in degrees per second.
29316                         Infotext         string
29317                         Itemstring       string
29318                         Glow             int8
29319                         MaxBreath        uint16  // Player only.
29320                         EyeHeight        float32 // Player only.
29321                         ZoomFOV          float32 // in degrees. Player only.
29322                         UseTextureAlpha  bool
29323                         DmgTextureMod    Texture // suffix
29324                         Shaded           bool
29325                         ShowOnMinimap    bool
29326                         NametagBG        color.NRGBA
29327                 }))(obj)).Infotext))[:])
29328                 chk(err)
29329         }
29330         if len(([]byte((*(*(struct {
29331                 MaxHP            uint16 // Player only.
29332                 CollideWithNodes bool
29333                 Weight           float32 // deprecated
29334                 ColBox, SelBox   Box
29335                 Pointable        bool
29336                 Visual           string
29337                 VisualSize       [3]float32
29338                 Textures         []Texture
29339                 SpriteSheetSize  [2]int16 // in sprites.
29340                 SpritePos        [2]int16 // in sprite sheet.
29341                 Visible          bool
29342                 MakeFootstepSnds bool
29343                 RotateSpeed      float32 // in radians per second.
29344                 Mesh             string
29345                 Colors           []color.NRGBA
29346                 CollideWithAOs   bool
29347                 StepHeight       float32
29348                 FaceRotateDir    bool
29349                 FaceRotateDirOff float32 // in degrees.
29350                 BackfaceCull     bool
29351                 Nametag          string
29352                 NametagColor     color.NRGBA
29353                 FaceRotateSpeed  float32 // in degrees per second.
29354                 Infotext         string
29355                 Itemstring       string
29356                 Glow             int8
29357                 MaxBreath        uint16  // Player only.
29358                 EyeHeight        float32 // Player only.
29359                 ZoomFOV          float32 // in degrees. Player only.
29360                 UseTextureAlpha  bool
29361                 DmgTextureMod    Texture // suffix
29362                 Shaded           bool
29363                 ShowOnMinimap    bool
29364                 NametagBG        color.NRGBA
29365         }))(obj)).Itemstring))) > math.MaxUint16 {
29366                 chk(ErrTooLong)
29367         }
29368         {
29369                 x := uint16(len(([]byte((*(*(struct {
29370                         MaxHP            uint16 // Player only.
29371                         CollideWithNodes bool
29372                         Weight           float32 // deprecated
29373                         ColBox, SelBox   Box
29374                         Pointable        bool
29375                         Visual           string
29376                         VisualSize       [3]float32
29377                         Textures         []Texture
29378                         SpriteSheetSize  [2]int16 // in sprites.
29379                         SpritePos        [2]int16 // in sprite sheet.
29380                         Visible          bool
29381                         MakeFootstepSnds bool
29382                         RotateSpeed      float32 // in radians per second.
29383                         Mesh             string
29384                         Colors           []color.NRGBA
29385                         CollideWithAOs   bool
29386                         StepHeight       float32
29387                         FaceRotateDir    bool
29388                         FaceRotateDirOff float32 // in degrees.
29389                         BackfaceCull     bool
29390                         Nametag          string
29391                         NametagColor     color.NRGBA
29392                         FaceRotateSpeed  float32 // in degrees per second.
29393                         Infotext         string
29394                         Itemstring       string
29395                         Glow             int8
29396                         MaxBreath        uint16  // Player only.
29397                         EyeHeight        float32 // Player only.
29398                         ZoomFOV          float32 // in degrees. Player only.
29399                         UseTextureAlpha  bool
29400                         DmgTextureMod    Texture // suffix
29401                         Shaded           bool
29402                         ShowOnMinimap    bool
29403                         NametagBG        color.NRGBA
29404                 }))(obj)).Itemstring))))
29405                 write16(w, uint16(x))
29406         }
29407         {
29408                 _, err := w.Write(([]byte((*(*(struct {
29409                         MaxHP            uint16 // Player only.
29410                         CollideWithNodes bool
29411                         Weight           float32 // deprecated
29412                         ColBox, SelBox   Box
29413                         Pointable        bool
29414                         Visual           string
29415                         VisualSize       [3]float32
29416                         Textures         []Texture
29417                         SpriteSheetSize  [2]int16 // in sprites.
29418                         SpritePos        [2]int16 // in sprite sheet.
29419                         Visible          bool
29420                         MakeFootstepSnds bool
29421                         RotateSpeed      float32 // in radians per second.
29422                         Mesh             string
29423                         Colors           []color.NRGBA
29424                         CollideWithAOs   bool
29425                         StepHeight       float32
29426                         FaceRotateDir    bool
29427                         FaceRotateDirOff float32 // in degrees.
29428                         BackfaceCull     bool
29429                         Nametag          string
29430                         NametagColor     color.NRGBA
29431                         FaceRotateSpeed  float32 // in degrees per second.
29432                         Infotext         string
29433                         Itemstring       string
29434                         Glow             int8
29435                         MaxBreath        uint16  // Player only.
29436                         EyeHeight        float32 // Player only.
29437                         ZoomFOV          float32 // in degrees. Player only.
29438                         UseTextureAlpha  bool
29439                         DmgTextureMod    Texture // suffix
29440                         Shaded           bool
29441                         ShowOnMinimap    bool
29442                         NametagBG        color.NRGBA
29443                 }))(obj)).Itemstring))[:])
29444                 chk(err)
29445         }
29446         {
29447                 x := (*(*(struct {
29448                         MaxHP            uint16 // Player only.
29449                         CollideWithNodes bool
29450                         Weight           float32 // deprecated
29451                         ColBox, SelBox   Box
29452                         Pointable        bool
29453                         Visual           string
29454                         VisualSize       [3]float32
29455                         Textures         []Texture
29456                         SpriteSheetSize  [2]int16 // in sprites.
29457                         SpritePos        [2]int16 // in sprite sheet.
29458                         Visible          bool
29459                         MakeFootstepSnds bool
29460                         RotateSpeed      float32 // in radians per second.
29461                         Mesh             string
29462                         Colors           []color.NRGBA
29463                         CollideWithAOs   bool
29464                         StepHeight       float32
29465                         FaceRotateDir    bool
29466                         FaceRotateDirOff float32 // in degrees.
29467                         BackfaceCull     bool
29468                         Nametag          string
29469                         NametagColor     color.NRGBA
29470                         FaceRotateSpeed  float32 // in degrees per second.
29471                         Infotext         string
29472                         Itemstring       string
29473                         Glow             int8
29474                         MaxBreath        uint16  // Player only.
29475                         EyeHeight        float32 // Player only.
29476                         ZoomFOV          float32 // in degrees. Player only.
29477                         UseTextureAlpha  bool
29478                         DmgTextureMod    Texture // suffix
29479                         Shaded           bool
29480                         ShowOnMinimap    bool
29481                         NametagBG        color.NRGBA
29482                 }))(obj)).Glow
29483                 write8(w, uint8(x))
29484         }
29485         {
29486                 x := (*(*(struct {
29487                         MaxHP            uint16 // Player only.
29488                         CollideWithNodes bool
29489                         Weight           float32 // deprecated
29490                         ColBox, SelBox   Box
29491                         Pointable        bool
29492                         Visual           string
29493                         VisualSize       [3]float32
29494                         Textures         []Texture
29495                         SpriteSheetSize  [2]int16 // in sprites.
29496                         SpritePos        [2]int16 // in sprite sheet.
29497                         Visible          bool
29498                         MakeFootstepSnds bool
29499                         RotateSpeed      float32 // in radians per second.
29500                         Mesh             string
29501                         Colors           []color.NRGBA
29502                         CollideWithAOs   bool
29503                         StepHeight       float32
29504                         FaceRotateDir    bool
29505                         FaceRotateDirOff float32 // in degrees.
29506                         BackfaceCull     bool
29507                         Nametag          string
29508                         NametagColor     color.NRGBA
29509                         FaceRotateSpeed  float32 // in degrees per second.
29510                         Infotext         string
29511                         Itemstring       string
29512                         Glow             int8
29513                         MaxBreath        uint16  // Player only.
29514                         EyeHeight        float32 // Player only.
29515                         ZoomFOV          float32 // in degrees. Player only.
29516                         UseTextureAlpha  bool
29517                         DmgTextureMod    Texture // suffix
29518                         Shaded           bool
29519                         ShowOnMinimap    bool
29520                         NametagBG        color.NRGBA
29521                 }))(obj)).MaxBreath
29522                 write16(w, uint16(x))
29523         }
29524         {
29525                 x := (*(*(struct {
29526                         MaxHP            uint16 // Player only.
29527                         CollideWithNodes bool
29528                         Weight           float32 // deprecated
29529                         ColBox, SelBox   Box
29530                         Pointable        bool
29531                         Visual           string
29532                         VisualSize       [3]float32
29533                         Textures         []Texture
29534                         SpriteSheetSize  [2]int16 // in sprites.
29535                         SpritePos        [2]int16 // in sprite sheet.
29536                         Visible          bool
29537                         MakeFootstepSnds bool
29538                         RotateSpeed      float32 // in radians per second.
29539                         Mesh             string
29540                         Colors           []color.NRGBA
29541                         CollideWithAOs   bool
29542                         StepHeight       float32
29543                         FaceRotateDir    bool
29544                         FaceRotateDirOff float32 // in degrees.
29545                         BackfaceCull     bool
29546                         Nametag          string
29547                         NametagColor     color.NRGBA
29548                         FaceRotateSpeed  float32 // in degrees per second.
29549                         Infotext         string
29550                         Itemstring       string
29551                         Glow             int8
29552                         MaxBreath        uint16  // Player only.
29553                         EyeHeight        float32 // Player only.
29554                         ZoomFOV          float32 // in degrees. Player only.
29555                         UseTextureAlpha  bool
29556                         DmgTextureMod    Texture // suffix
29557                         Shaded           bool
29558                         ShowOnMinimap    bool
29559                         NametagBG        color.NRGBA
29560                 }))(obj)).EyeHeight
29561                 write32(w, math.Float32bits(x))
29562         }
29563         {
29564                 x := (*(*(struct {
29565                         MaxHP            uint16 // Player only.
29566                         CollideWithNodes bool
29567                         Weight           float32 // deprecated
29568                         ColBox, SelBox   Box
29569                         Pointable        bool
29570                         Visual           string
29571                         VisualSize       [3]float32
29572                         Textures         []Texture
29573                         SpriteSheetSize  [2]int16 // in sprites.
29574                         SpritePos        [2]int16 // in sprite sheet.
29575                         Visible          bool
29576                         MakeFootstepSnds bool
29577                         RotateSpeed      float32 // in radians per second.
29578                         Mesh             string
29579                         Colors           []color.NRGBA
29580                         CollideWithAOs   bool
29581                         StepHeight       float32
29582                         FaceRotateDir    bool
29583                         FaceRotateDirOff float32 // in degrees.
29584                         BackfaceCull     bool
29585                         Nametag          string
29586                         NametagColor     color.NRGBA
29587                         FaceRotateSpeed  float32 // in degrees per second.
29588                         Infotext         string
29589                         Itemstring       string
29590                         Glow             int8
29591                         MaxBreath        uint16  // Player only.
29592                         EyeHeight        float32 // Player only.
29593                         ZoomFOV          float32 // in degrees. Player only.
29594                         UseTextureAlpha  bool
29595                         DmgTextureMod    Texture // suffix
29596                         Shaded           bool
29597                         ShowOnMinimap    bool
29598                         NametagBG        color.NRGBA
29599                 }))(obj)).ZoomFOV
29600                 write32(w, math.Float32bits(x))
29601         }
29602         {
29603                 x := (*(*(struct {
29604                         MaxHP            uint16 // Player only.
29605                         CollideWithNodes bool
29606                         Weight           float32 // deprecated
29607                         ColBox, SelBox   Box
29608                         Pointable        bool
29609                         Visual           string
29610                         VisualSize       [3]float32
29611                         Textures         []Texture
29612                         SpriteSheetSize  [2]int16 // in sprites.
29613                         SpritePos        [2]int16 // in sprite sheet.
29614                         Visible          bool
29615                         MakeFootstepSnds bool
29616                         RotateSpeed      float32 // in radians per second.
29617                         Mesh             string
29618                         Colors           []color.NRGBA
29619                         CollideWithAOs   bool
29620                         StepHeight       float32
29621                         FaceRotateDir    bool
29622                         FaceRotateDirOff float32 // in degrees.
29623                         BackfaceCull     bool
29624                         Nametag          string
29625                         NametagColor     color.NRGBA
29626                         FaceRotateSpeed  float32 // in degrees per second.
29627                         Infotext         string
29628                         Itemstring       string
29629                         Glow             int8
29630                         MaxBreath        uint16  // Player only.
29631                         EyeHeight        float32 // Player only.
29632                         ZoomFOV          float32 // in degrees. Player only.
29633                         UseTextureAlpha  bool
29634                         DmgTextureMod    Texture // suffix
29635                         Shaded           bool
29636                         ShowOnMinimap    bool
29637                         NametagBG        color.NRGBA
29638                 }))(obj)).UseTextureAlpha
29639                 if x {
29640                         write8(w, 1)
29641                 } else {
29642                         write8(w, 0)
29643                 }
29644         }
29645         if err := pcall(func() {
29646                 ((*(*(struct {
29647                         MaxHP            uint16 // Player only.
29648                         CollideWithNodes bool
29649                         Weight           float32 // deprecated
29650                         ColBox, SelBox   Box
29651                         Pointable        bool
29652                         Visual           string
29653                         VisualSize       [3]float32
29654                         Textures         []Texture
29655                         SpriteSheetSize  [2]int16 // in sprites.
29656                         SpritePos        [2]int16 // in sprite sheet.
29657                         Visible          bool
29658                         MakeFootstepSnds bool
29659                         RotateSpeed      float32 // in radians per second.
29660                         Mesh             string
29661                         Colors           []color.NRGBA
29662                         CollideWithAOs   bool
29663                         StepHeight       float32
29664                         FaceRotateDir    bool
29665                         FaceRotateDirOff float32 // in degrees.
29666                         BackfaceCull     bool
29667                         Nametag          string
29668                         NametagColor     color.NRGBA
29669                         FaceRotateSpeed  float32 // in degrees per second.
29670                         Infotext         string
29671                         Itemstring       string
29672                         Glow             int8
29673                         MaxBreath        uint16  // Player only.
29674                         EyeHeight        float32 // Player only.
29675                         ZoomFOV          float32 // in degrees. Player only.
29676                         UseTextureAlpha  bool
29677                         DmgTextureMod    Texture // suffix
29678                         Shaded           bool
29679                         ShowOnMinimap    bool
29680                         NametagBG        color.NRGBA
29681                 }))(obj)).DmgTextureMod).serialize(w)
29682         }); err != nil {
29683                 if err == io.EOF {
29684                         chk(io.EOF)
29685                 }
29686                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
29687         }
29688         {
29689                 x := (*(*(struct {
29690                         MaxHP            uint16 // Player only.
29691                         CollideWithNodes bool
29692                         Weight           float32 // deprecated
29693                         ColBox, SelBox   Box
29694                         Pointable        bool
29695                         Visual           string
29696                         VisualSize       [3]float32
29697                         Textures         []Texture
29698                         SpriteSheetSize  [2]int16 // in sprites.
29699                         SpritePos        [2]int16 // in sprite sheet.
29700                         Visible          bool
29701                         MakeFootstepSnds bool
29702                         RotateSpeed      float32 // in radians per second.
29703                         Mesh             string
29704                         Colors           []color.NRGBA
29705                         CollideWithAOs   bool
29706                         StepHeight       float32
29707                         FaceRotateDir    bool
29708                         FaceRotateDirOff float32 // in degrees.
29709                         BackfaceCull     bool
29710                         Nametag          string
29711                         NametagColor     color.NRGBA
29712                         FaceRotateSpeed  float32 // in degrees per second.
29713                         Infotext         string
29714                         Itemstring       string
29715                         Glow             int8
29716                         MaxBreath        uint16  // Player only.
29717                         EyeHeight        float32 // Player only.
29718                         ZoomFOV          float32 // in degrees. Player only.
29719                         UseTextureAlpha  bool
29720                         DmgTextureMod    Texture // suffix
29721                         Shaded           bool
29722                         ShowOnMinimap    bool
29723                         NametagBG        color.NRGBA
29724                 }))(obj)).Shaded
29725                 if x {
29726                         write8(w, 1)
29727                 } else {
29728                         write8(w, 0)
29729                 }
29730         }
29731         {
29732                 x := (*(*(struct {
29733                         MaxHP            uint16 // Player only.
29734                         CollideWithNodes bool
29735                         Weight           float32 // deprecated
29736                         ColBox, SelBox   Box
29737                         Pointable        bool
29738                         Visual           string
29739                         VisualSize       [3]float32
29740                         Textures         []Texture
29741                         SpriteSheetSize  [2]int16 // in sprites.
29742                         SpritePos        [2]int16 // in sprite sheet.
29743                         Visible          bool
29744                         MakeFootstepSnds bool
29745                         RotateSpeed      float32 // in radians per second.
29746                         Mesh             string
29747                         Colors           []color.NRGBA
29748                         CollideWithAOs   bool
29749                         StepHeight       float32
29750                         FaceRotateDir    bool
29751                         FaceRotateDirOff float32 // in degrees.
29752                         BackfaceCull     bool
29753                         Nametag          string
29754                         NametagColor     color.NRGBA
29755                         FaceRotateSpeed  float32 // in degrees per second.
29756                         Infotext         string
29757                         Itemstring       string
29758                         Glow             int8
29759                         MaxBreath        uint16  // Player only.
29760                         EyeHeight        float32 // Player only.
29761                         ZoomFOV          float32 // in degrees. Player only.
29762                         UseTextureAlpha  bool
29763                         DmgTextureMod    Texture // suffix
29764                         Shaded           bool
29765                         ShowOnMinimap    bool
29766                         NametagBG        color.NRGBA
29767                 }))(obj)).ShowOnMinimap
29768                 if x {
29769                         write8(w, 1)
29770                 } else {
29771                         write8(w, 0)
29772                 }
29773         }
29774         {
29775                 x := (*(*(struct {
29776                         MaxHP            uint16 // Player only.
29777                         CollideWithNodes bool
29778                         Weight           float32 // deprecated
29779                         ColBox, SelBox   Box
29780                         Pointable        bool
29781                         Visual           string
29782                         VisualSize       [3]float32
29783                         Textures         []Texture
29784                         SpriteSheetSize  [2]int16 // in sprites.
29785                         SpritePos        [2]int16 // in sprite sheet.
29786                         Visible          bool
29787                         MakeFootstepSnds bool
29788                         RotateSpeed      float32 // in radians per second.
29789                         Mesh             string
29790                         Colors           []color.NRGBA
29791                         CollideWithAOs   bool
29792                         StepHeight       float32
29793                         FaceRotateDir    bool
29794                         FaceRotateDirOff float32 // in degrees.
29795                         BackfaceCull     bool
29796                         Nametag          string
29797                         NametagColor     color.NRGBA
29798                         FaceRotateSpeed  float32 // in degrees per second.
29799                         Infotext         string
29800                         Itemstring       string
29801                         Glow             int8
29802                         MaxBreath        uint16  // Player only.
29803                         EyeHeight        float32 // Player only.
29804                         ZoomFOV          float32 // in degrees. Player only.
29805                         UseTextureAlpha  bool
29806                         DmgTextureMod    Texture // suffix
29807                         Shaded           bool
29808                         ShowOnMinimap    bool
29809                         NametagBG        color.NRGBA
29810                 }))(obj)).NametagBG
29811                 w.Write([]byte{x.A, x.R, x.G, x.B})
29812         }
29813 }
29814
29815 func (obj *AOProps) deserialize(r io.Reader) {
29816         {
29817                 var local329 uint8
29818                 {
29819                         p := &local329
29820                         *p = read8(r)
29821                 }
29822                 if local329 != (4) {
29823                         chk(fmt.Errorf("const %v: %v", 4, local329))
29824                 }
29825         }
29826         {
29827                 p := &(*(*(struct {
29828                         MaxHP            uint16 // Player only.
29829                         CollideWithNodes bool
29830                         Weight           float32 // deprecated
29831                         ColBox, SelBox   Box
29832                         Pointable        bool
29833                         Visual           string
29834                         VisualSize       [3]float32
29835                         Textures         []Texture
29836                         SpriteSheetSize  [2]int16 // in sprites.
29837                         SpritePos        [2]int16 // in sprite sheet.
29838                         Visible          bool
29839                         MakeFootstepSnds bool
29840                         RotateSpeed      float32 // in radians per second.
29841                         Mesh             string
29842                         Colors           []color.NRGBA
29843                         CollideWithAOs   bool
29844                         StepHeight       float32
29845                         FaceRotateDir    bool
29846                         FaceRotateDirOff float32 // in degrees.
29847                         BackfaceCull     bool
29848                         Nametag          string
29849                         NametagColor     color.NRGBA
29850                         FaceRotateSpeed  float32 // in degrees per second.
29851                         Infotext         string
29852                         Itemstring       string
29853                         Glow             int8
29854                         MaxBreath        uint16  // Player only.
29855                         EyeHeight        float32 // Player only.
29856                         ZoomFOV          float32 // in degrees. Player only.
29857                         UseTextureAlpha  bool
29858                         DmgTextureMod    Texture // suffix
29859                         Shaded           bool
29860                         ShowOnMinimap    bool
29861                         NametagBG        color.NRGBA
29862                 }))(obj)).MaxHP
29863                 *p = read16(r)
29864         }
29865         {
29866                 p := &(*(*(struct {
29867                         MaxHP            uint16 // Player only.
29868                         CollideWithNodes bool
29869                         Weight           float32 // deprecated
29870                         ColBox, SelBox   Box
29871                         Pointable        bool
29872                         Visual           string
29873                         VisualSize       [3]float32
29874                         Textures         []Texture
29875                         SpriteSheetSize  [2]int16 // in sprites.
29876                         SpritePos        [2]int16 // in sprite sheet.
29877                         Visible          bool
29878                         MakeFootstepSnds bool
29879                         RotateSpeed      float32 // in radians per second.
29880                         Mesh             string
29881                         Colors           []color.NRGBA
29882                         CollideWithAOs   bool
29883                         StepHeight       float32
29884                         FaceRotateDir    bool
29885                         FaceRotateDirOff float32 // in degrees.
29886                         BackfaceCull     bool
29887                         Nametag          string
29888                         NametagColor     color.NRGBA
29889                         FaceRotateSpeed  float32 // in degrees per second.
29890                         Infotext         string
29891                         Itemstring       string
29892                         Glow             int8
29893                         MaxBreath        uint16  // Player only.
29894                         EyeHeight        float32 // Player only.
29895                         ZoomFOV          float32 // in degrees. Player only.
29896                         UseTextureAlpha  bool
29897                         DmgTextureMod    Texture // suffix
29898                         Shaded           bool
29899                         ShowOnMinimap    bool
29900                         NametagBG        color.NRGBA
29901                 }))(obj)).CollideWithNodes
29902                 switch n := read8(r); n {
29903                 case 0:
29904                         *p = false
29905                 case 1:
29906                         *p = true
29907                 default:
29908                         chk(fmt.Errorf("invalid bool: %d", n))
29909                 }
29910         }
29911         {
29912                 p := &(*(*(struct {
29913                         MaxHP            uint16 // Player only.
29914                         CollideWithNodes bool
29915                         Weight           float32 // deprecated
29916                         ColBox, SelBox   Box
29917                         Pointable        bool
29918                         Visual           string
29919                         VisualSize       [3]float32
29920                         Textures         []Texture
29921                         SpriteSheetSize  [2]int16 // in sprites.
29922                         SpritePos        [2]int16 // in sprite sheet.
29923                         Visible          bool
29924                         MakeFootstepSnds bool
29925                         RotateSpeed      float32 // in radians per second.
29926                         Mesh             string
29927                         Colors           []color.NRGBA
29928                         CollideWithAOs   bool
29929                         StepHeight       float32
29930                         FaceRotateDir    bool
29931                         FaceRotateDirOff float32 // in degrees.
29932                         BackfaceCull     bool
29933                         Nametag          string
29934                         NametagColor     color.NRGBA
29935                         FaceRotateSpeed  float32 // in degrees per second.
29936                         Infotext         string
29937                         Itemstring       string
29938                         Glow             int8
29939                         MaxBreath        uint16  // Player only.
29940                         EyeHeight        float32 // Player only.
29941                         ZoomFOV          float32 // in degrees. Player only.
29942                         UseTextureAlpha  bool
29943                         DmgTextureMod    Texture // suffix
29944                         Shaded           bool
29945                         ShowOnMinimap    bool
29946                         NametagBG        color.NRGBA
29947                 }))(obj)).Weight
29948                 *p = math.Float32frombits(read32(r))
29949         }
29950         if err := pcall(func() {
29951                 ((*(*(struct {
29952                         MaxHP            uint16 // Player only.
29953                         CollideWithNodes bool
29954                         Weight           float32 // deprecated
29955                         ColBox, SelBox   Box
29956                         Pointable        bool
29957                         Visual           string
29958                         VisualSize       [3]float32
29959                         Textures         []Texture
29960                         SpriteSheetSize  [2]int16 // in sprites.
29961                         SpritePos        [2]int16 // in sprite sheet.
29962                         Visible          bool
29963                         MakeFootstepSnds bool
29964                         RotateSpeed      float32 // in radians per second.
29965                         Mesh             string
29966                         Colors           []color.NRGBA
29967                         CollideWithAOs   bool
29968                         StepHeight       float32
29969                         FaceRotateDir    bool
29970                         FaceRotateDirOff float32 // in degrees.
29971                         BackfaceCull     bool
29972                         Nametag          string
29973                         NametagColor     color.NRGBA
29974                         FaceRotateSpeed  float32 // in degrees per second.
29975                         Infotext         string
29976                         Itemstring       string
29977                         Glow             int8
29978                         MaxBreath        uint16  // Player only.
29979                         EyeHeight        float32 // Player only.
29980                         ZoomFOV          float32 // in degrees. Player only.
29981                         UseTextureAlpha  bool
29982                         DmgTextureMod    Texture // suffix
29983                         Shaded           bool
29984                         ShowOnMinimap    bool
29985                         NametagBG        color.NRGBA
29986                 }))(obj)).ColBox).deserialize(r)
29987         }); err != nil {
29988                 if err == io.EOF {
29989                         chk(io.EOF)
29990                 }
29991                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29992         }
29993         if err := pcall(func() {
29994                 ((*(*(struct {
29995                         MaxHP            uint16 // Player only.
29996                         CollideWithNodes bool
29997                         Weight           float32 // deprecated
29998                         ColBox, SelBox   Box
29999                         Pointable        bool
30000                         Visual           string
30001                         VisualSize       [3]float32
30002                         Textures         []Texture
30003                         SpriteSheetSize  [2]int16 // in sprites.
30004                         SpritePos        [2]int16 // in sprite sheet.
30005                         Visible          bool
30006                         MakeFootstepSnds bool
30007                         RotateSpeed      float32 // in radians per second.
30008                         Mesh             string
30009                         Colors           []color.NRGBA
30010                         CollideWithAOs   bool
30011                         StepHeight       float32
30012                         FaceRotateDir    bool
30013                         FaceRotateDirOff float32 // in degrees.
30014                         BackfaceCull     bool
30015                         Nametag          string
30016                         NametagColor     color.NRGBA
30017                         FaceRotateSpeed  float32 // in degrees per second.
30018                         Infotext         string
30019                         Itemstring       string
30020                         Glow             int8
30021                         MaxBreath        uint16  // Player only.
30022                         EyeHeight        float32 // Player only.
30023                         ZoomFOV          float32 // in degrees. Player only.
30024                         UseTextureAlpha  bool
30025                         DmgTextureMod    Texture // suffix
30026                         Shaded           bool
30027                         ShowOnMinimap    bool
30028                         NametagBG        color.NRGBA
30029                 }))(obj)).SelBox).deserialize(r)
30030         }); err != nil {
30031                 if err == io.EOF {
30032                         chk(io.EOF)
30033                 }
30034                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
30035         }
30036         {
30037                 p := &(*(*(struct {
30038                         MaxHP            uint16 // Player only.
30039                         CollideWithNodes bool
30040                         Weight           float32 // deprecated
30041                         ColBox, SelBox   Box
30042                         Pointable        bool
30043                         Visual           string
30044                         VisualSize       [3]float32
30045                         Textures         []Texture
30046                         SpriteSheetSize  [2]int16 // in sprites.
30047                         SpritePos        [2]int16 // in sprite sheet.
30048                         Visible          bool
30049                         MakeFootstepSnds bool
30050                         RotateSpeed      float32 // in radians per second.
30051                         Mesh             string
30052                         Colors           []color.NRGBA
30053                         CollideWithAOs   bool
30054                         StepHeight       float32
30055                         FaceRotateDir    bool
30056                         FaceRotateDirOff float32 // in degrees.
30057                         BackfaceCull     bool
30058                         Nametag          string
30059                         NametagColor     color.NRGBA
30060                         FaceRotateSpeed  float32 // in degrees per second.
30061                         Infotext         string
30062                         Itemstring       string
30063                         Glow             int8
30064                         MaxBreath        uint16  // Player only.
30065                         EyeHeight        float32 // Player only.
30066                         ZoomFOV          float32 // in degrees. Player only.
30067                         UseTextureAlpha  bool
30068                         DmgTextureMod    Texture // suffix
30069                         Shaded           bool
30070                         ShowOnMinimap    bool
30071                         NametagBG        color.NRGBA
30072                 }))(obj)).Pointable
30073                 switch n := read8(r); n {
30074                 case 0:
30075                         *p = false
30076                 case 1:
30077                         *p = true
30078                 default:
30079                         chk(fmt.Errorf("invalid bool: %d", n))
30080                 }
30081         }
30082         var local330 []uint8
30083         var local331 uint16
30084         {
30085                 p := &local331
30086                 *p = read16(r)
30087         }
30088         (local330) = make([]uint8, local331)
30089         {
30090                 _, err := io.ReadFull(r, (local330)[:])
30091                 chk(err)
30092         }
30093         ((*(*(struct {
30094                 MaxHP            uint16 // Player only.
30095                 CollideWithNodes bool
30096                 Weight           float32 // deprecated
30097                 ColBox, SelBox   Box
30098                 Pointable        bool
30099                 Visual           string
30100                 VisualSize       [3]float32
30101                 Textures         []Texture
30102                 SpriteSheetSize  [2]int16 // in sprites.
30103                 SpritePos        [2]int16 // in sprite sheet.
30104                 Visible          bool
30105                 MakeFootstepSnds bool
30106                 RotateSpeed      float32 // in radians per second.
30107                 Mesh             string
30108                 Colors           []color.NRGBA
30109                 CollideWithAOs   bool
30110                 StepHeight       float32
30111                 FaceRotateDir    bool
30112                 FaceRotateDirOff float32 // in degrees.
30113                 BackfaceCull     bool
30114                 Nametag          string
30115                 NametagColor     color.NRGBA
30116                 FaceRotateSpeed  float32 // in degrees per second.
30117                 Infotext         string
30118                 Itemstring       string
30119                 Glow             int8
30120                 MaxBreath        uint16  // Player only.
30121                 EyeHeight        float32 // Player only.
30122                 ZoomFOV          float32 // in degrees. Player only.
30123                 UseTextureAlpha  bool
30124                 DmgTextureMod    Texture // suffix
30125                 Shaded           bool
30126                 ShowOnMinimap    bool
30127                 NametagBG        color.NRGBA
30128         }))(obj)).Visual) = string(local330)
30129         for local332 := range (*(*(struct {
30130                 MaxHP            uint16 // Player only.
30131                 CollideWithNodes bool
30132                 Weight           float32 // deprecated
30133                 ColBox, SelBox   Box
30134                 Pointable        bool
30135                 Visual           string
30136                 VisualSize       [3]float32
30137                 Textures         []Texture
30138                 SpriteSheetSize  [2]int16 // in sprites.
30139                 SpritePos        [2]int16 // in sprite sheet.
30140                 Visible          bool
30141                 MakeFootstepSnds bool
30142                 RotateSpeed      float32 // in radians per second.
30143                 Mesh             string
30144                 Colors           []color.NRGBA
30145                 CollideWithAOs   bool
30146                 StepHeight       float32
30147                 FaceRotateDir    bool
30148                 FaceRotateDirOff float32 // in degrees.
30149                 BackfaceCull     bool
30150                 Nametag          string
30151                 NametagColor     color.NRGBA
30152                 FaceRotateSpeed  float32 // in degrees per second.
30153                 Infotext         string
30154                 Itemstring       string
30155                 Glow             int8
30156                 MaxBreath        uint16  // Player only.
30157                 EyeHeight        float32 // Player only.
30158                 ZoomFOV          float32 // in degrees. Player only.
30159                 UseTextureAlpha  bool
30160                 DmgTextureMod    Texture // suffix
30161                 Shaded           bool
30162                 ShowOnMinimap    bool
30163                 NametagBG        color.NRGBA
30164         }))(obj)).VisualSize {
30165                 {
30166                         p := &((*(*(struct {
30167                                 MaxHP            uint16 // Player only.
30168                                 CollideWithNodes bool
30169                                 Weight           float32 // deprecated
30170                                 ColBox, SelBox   Box
30171                                 Pointable        bool
30172                                 Visual           string
30173                                 VisualSize       [3]float32
30174                                 Textures         []Texture
30175                                 SpriteSheetSize  [2]int16 // in sprites.
30176                                 SpritePos        [2]int16 // in sprite sheet.
30177                                 Visible          bool
30178                                 MakeFootstepSnds bool
30179                                 RotateSpeed      float32 // in radians per second.
30180                                 Mesh             string
30181                                 Colors           []color.NRGBA
30182                                 CollideWithAOs   bool
30183                                 StepHeight       float32
30184                                 FaceRotateDir    bool
30185                                 FaceRotateDirOff float32 // in degrees.
30186                                 BackfaceCull     bool
30187                                 Nametag          string
30188                                 NametagColor     color.NRGBA
30189                                 FaceRotateSpeed  float32 // in degrees per second.
30190                                 Infotext         string
30191                                 Itemstring       string
30192                                 Glow             int8
30193                                 MaxBreath        uint16  // Player only.
30194                                 EyeHeight        float32 // Player only.
30195                                 ZoomFOV          float32 // in degrees. Player only.
30196                                 UseTextureAlpha  bool
30197                                 DmgTextureMod    Texture // suffix
30198                                 Shaded           bool
30199                                 ShowOnMinimap    bool
30200                                 NametagBG        color.NRGBA
30201                         }))(obj)).VisualSize)[local332]
30202                         *p = math.Float32frombits(read32(r))
30203                 }
30204         }
30205         var local333 uint16
30206         {
30207                 p := &local333
30208                 *p = read16(r)
30209         }
30210         ((*(*(struct {
30211                 MaxHP            uint16 // Player only.
30212                 CollideWithNodes bool
30213                 Weight           float32 // deprecated
30214                 ColBox, SelBox   Box
30215                 Pointable        bool
30216                 Visual           string
30217                 VisualSize       [3]float32
30218                 Textures         []Texture
30219                 SpriteSheetSize  [2]int16 // in sprites.
30220                 SpritePos        [2]int16 // in sprite sheet.
30221                 Visible          bool
30222                 MakeFootstepSnds bool
30223                 RotateSpeed      float32 // in radians per second.
30224                 Mesh             string
30225                 Colors           []color.NRGBA
30226                 CollideWithAOs   bool
30227                 StepHeight       float32
30228                 FaceRotateDir    bool
30229                 FaceRotateDirOff float32 // in degrees.
30230                 BackfaceCull     bool
30231                 Nametag          string
30232                 NametagColor     color.NRGBA
30233                 FaceRotateSpeed  float32 // in degrees per second.
30234                 Infotext         string
30235                 Itemstring       string
30236                 Glow             int8
30237                 MaxBreath        uint16  // Player only.
30238                 EyeHeight        float32 // Player only.
30239                 ZoomFOV          float32 // in degrees. Player only.
30240                 UseTextureAlpha  bool
30241                 DmgTextureMod    Texture // suffix
30242                 Shaded           bool
30243                 ShowOnMinimap    bool
30244                 NametagBG        color.NRGBA
30245         }))(obj)).Textures) = make([]Texture, local333)
30246         for local334 := range (*(*(struct {
30247                 MaxHP            uint16 // Player only.
30248                 CollideWithNodes bool
30249                 Weight           float32 // deprecated
30250                 ColBox, SelBox   Box
30251                 Pointable        bool
30252                 Visual           string
30253                 VisualSize       [3]float32
30254                 Textures         []Texture
30255                 SpriteSheetSize  [2]int16 // in sprites.
30256                 SpritePos        [2]int16 // in sprite sheet.
30257                 Visible          bool
30258                 MakeFootstepSnds bool
30259                 RotateSpeed      float32 // in radians per second.
30260                 Mesh             string
30261                 Colors           []color.NRGBA
30262                 CollideWithAOs   bool
30263                 StepHeight       float32
30264                 FaceRotateDir    bool
30265                 FaceRotateDirOff float32 // in degrees.
30266                 BackfaceCull     bool
30267                 Nametag          string
30268                 NametagColor     color.NRGBA
30269                 FaceRotateSpeed  float32 // in degrees per second.
30270                 Infotext         string
30271                 Itemstring       string
30272                 Glow             int8
30273                 MaxBreath        uint16  // Player only.
30274                 EyeHeight        float32 // Player only.
30275                 ZoomFOV          float32 // in degrees. Player only.
30276                 UseTextureAlpha  bool
30277                 DmgTextureMod    Texture // suffix
30278                 Shaded           bool
30279                 ShowOnMinimap    bool
30280                 NametagBG        color.NRGBA
30281         }))(obj)).Textures {
30282                 if err := pcall(func() {
30283                         (((*(*(struct {
30284                                 MaxHP            uint16 // Player only.
30285                                 CollideWithNodes bool
30286                                 Weight           float32 // deprecated
30287                                 ColBox, SelBox   Box
30288                                 Pointable        bool
30289                                 Visual           string
30290                                 VisualSize       [3]float32
30291                                 Textures         []Texture
30292                                 SpriteSheetSize  [2]int16 // in sprites.
30293                                 SpritePos        [2]int16 // in sprite sheet.
30294                                 Visible          bool
30295                                 MakeFootstepSnds bool
30296                                 RotateSpeed      float32 // in radians per second.
30297                                 Mesh             string
30298                                 Colors           []color.NRGBA
30299                                 CollideWithAOs   bool
30300                                 StepHeight       float32
30301                                 FaceRotateDir    bool
30302                                 FaceRotateDirOff float32 // in degrees.
30303                                 BackfaceCull     bool
30304                                 Nametag          string
30305                                 NametagColor     color.NRGBA
30306                                 FaceRotateSpeed  float32 // in degrees per second.
30307                                 Infotext         string
30308                                 Itemstring       string
30309                                 Glow             int8
30310                                 MaxBreath        uint16  // Player only.
30311                                 EyeHeight        float32 // Player only.
30312                                 ZoomFOV          float32 // in degrees. Player only.
30313                                 UseTextureAlpha  bool
30314                                 DmgTextureMod    Texture // suffix
30315                                 Shaded           bool
30316                                 ShowOnMinimap    bool
30317                                 NametagBG        color.NRGBA
30318                         }))(obj)).Textures)[local334]).deserialize(r)
30319                 }); err != nil {
30320                         if err == io.EOF {
30321                                 chk(io.EOF)
30322                         }
30323                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
30324                 }
30325         }
30326         for local335 := range (*(*(struct {
30327                 MaxHP            uint16 // Player only.
30328                 CollideWithNodes bool
30329                 Weight           float32 // deprecated
30330                 ColBox, SelBox   Box
30331                 Pointable        bool
30332                 Visual           string
30333                 VisualSize       [3]float32
30334                 Textures         []Texture
30335                 SpriteSheetSize  [2]int16 // in sprites.
30336                 SpritePos        [2]int16 // in sprite sheet.
30337                 Visible          bool
30338                 MakeFootstepSnds bool
30339                 RotateSpeed      float32 // in radians per second.
30340                 Mesh             string
30341                 Colors           []color.NRGBA
30342                 CollideWithAOs   bool
30343                 StepHeight       float32
30344                 FaceRotateDir    bool
30345                 FaceRotateDirOff float32 // in degrees.
30346                 BackfaceCull     bool
30347                 Nametag          string
30348                 NametagColor     color.NRGBA
30349                 FaceRotateSpeed  float32 // in degrees per second.
30350                 Infotext         string
30351                 Itemstring       string
30352                 Glow             int8
30353                 MaxBreath        uint16  // Player only.
30354                 EyeHeight        float32 // Player only.
30355                 ZoomFOV          float32 // in degrees. Player only.
30356                 UseTextureAlpha  bool
30357                 DmgTextureMod    Texture // suffix
30358                 Shaded           bool
30359                 ShowOnMinimap    bool
30360                 NametagBG        color.NRGBA
30361         }))(obj)).SpriteSheetSize {
30362                 {
30363                         p := &((*(*(struct {
30364                                 MaxHP            uint16 // Player only.
30365                                 CollideWithNodes bool
30366                                 Weight           float32 // deprecated
30367                                 ColBox, SelBox   Box
30368                                 Pointable        bool
30369                                 Visual           string
30370                                 VisualSize       [3]float32
30371                                 Textures         []Texture
30372                                 SpriteSheetSize  [2]int16 // in sprites.
30373                                 SpritePos        [2]int16 // in sprite sheet.
30374                                 Visible          bool
30375                                 MakeFootstepSnds bool
30376                                 RotateSpeed      float32 // in radians per second.
30377                                 Mesh             string
30378                                 Colors           []color.NRGBA
30379                                 CollideWithAOs   bool
30380                                 StepHeight       float32
30381                                 FaceRotateDir    bool
30382                                 FaceRotateDirOff float32 // in degrees.
30383                                 BackfaceCull     bool
30384                                 Nametag          string
30385                                 NametagColor     color.NRGBA
30386                                 FaceRotateSpeed  float32 // in degrees per second.
30387                                 Infotext         string
30388                                 Itemstring       string
30389                                 Glow             int8
30390                                 MaxBreath        uint16  // Player only.
30391                                 EyeHeight        float32 // Player only.
30392                                 ZoomFOV          float32 // in degrees. Player only.
30393                                 UseTextureAlpha  bool
30394                                 DmgTextureMod    Texture // suffix
30395                                 Shaded           bool
30396                                 ShowOnMinimap    bool
30397                                 NametagBG        color.NRGBA
30398                         }))(obj)).SpriteSheetSize)[local335]
30399                         *p = int16(read16(r))
30400                 }
30401         }
30402         for local336 := range (*(*(struct {
30403                 MaxHP            uint16 // Player only.
30404                 CollideWithNodes bool
30405                 Weight           float32 // deprecated
30406                 ColBox, SelBox   Box
30407                 Pointable        bool
30408                 Visual           string
30409                 VisualSize       [3]float32
30410                 Textures         []Texture
30411                 SpriteSheetSize  [2]int16 // in sprites.
30412                 SpritePos        [2]int16 // in sprite sheet.
30413                 Visible          bool
30414                 MakeFootstepSnds bool
30415                 RotateSpeed      float32 // in radians per second.
30416                 Mesh             string
30417                 Colors           []color.NRGBA
30418                 CollideWithAOs   bool
30419                 StepHeight       float32
30420                 FaceRotateDir    bool
30421                 FaceRotateDirOff float32 // in degrees.
30422                 BackfaceCull     bool
30423                 Nametag          string
30424                 NametagColor     color.NRGBA
30425                 FaceRotateSpeed  float32 // in degrees per second.
30426                 Infotext         string
30427                 Itemstring       string
30428                 Glow             int8
30429                 MaxBreath        uint16  // Player only.
30430                 EyeHeight        float32 // Player only.
30431                 ZoomFOV          float32 // in degrees. Player only.
30432                 UseTextureAlpha  bool
30433                 DmgTextureMod    Texture // suffix
30434                 Shaded           bool
30435                 ShowOnMinimap    bool
30436                 NametagBG        color.NRGBA
30437         }))(obj)).SpritePos {
30438                 {
30439                         p := &((*(*(struct {
30440                                 MaxHP            uint16 // Player only.
30441                                 CollideWithNodes bool
30442                                 Weight           float32 // deprecated
30443                                 ColBox, SelBox   Box
30444                                 Pointable        bool
30445                                 Visual           string
30446                                 VisualSize       [3]float32
30447                                 Textures         []Texture
30448                                 SpriteSheetSize  [2]int16 // in sprites.
30449                                 SpritePos        [2]int16 // in sprite sheet.
30450                                 Visible          bool
30451                                 MakeFootstepSnds bool
30452                                 RotateSpeed      float32 // in radians per second.
30453                                 Mesh             string
30454                                 Colors           []color.NRGBA
30455                                 CollideWithAOs   bool
30456                                 StepHeight       float32
30457                                 FaceRotateDir    bool
30458                                 FaceRotateDirOff float32 // in degrees.
30459                                 BackfaceCull     bool
30460                                 Nametag          string
30461                                 NametagColor     color.NRGBA
30462                                 FaceRotateSpeed  float32 // in degrees per second.
30463                                 Infotext         string
30464                                 Itemstring       string
30465                                 Glow             int8
30466                                 MaxBreath        uint16  // Player only.
30467                                 EyeHeight        float32 // Player only.
30468                                 ZoomFOV          float32 // in degrees. Player only.
30469                                 UseTextureAlpha  bool
30470                                 DmgTextureMod    Texture // suffix
30471                                 Shaded           bool
30472                                 ShowOnMinimap    bool
30473                                 NametagBG        color.NRGBA
30474                         }))(obj)).SpritePos)[local336]
30475                         *p = int16(read16(r))
30476                 }
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)).Visible
30515                 switch n := read8(r); n {
30516                 case 0:
30517                         *p = false
30518                 case 1:
30519                         *p = true
30520                 default:
30521                         chk(fmt.Errorf("invalid bool: %d", n))
30522                 }
30523         }
30524         {
30525                 p := &(*(*(struct {
30526                         MaxHP            uint16 // Player only.
30527                         CollideWithNodes bool
30528                         Weight           float32 // deprecated
30529                         ColBox, SelBox   Box
30530                         Pointable        bool
30531                         Visual           string
30532                         VisualSize       [3]float32
30533                         Textures         []Texture
30534                         SpriteSheetSize  [2]int16 // in sprites.
30535                         SpritePos        [2]int16 // in sprite sheet.
30536                         Visible          bool
30537                         MakeFootstepSnds bool
30538                         RotateSpeed      float32 // in radians per second.
30539                         Mesh             string
30540                         Colors           []color.NRGBA
30541                         CollideWithAOs   bool
30542                         StepHeight       float32
30543                         FaceRotateDir    bool
30544                         FaceRotateDirOff float32 // in degrees.
30545                         BackfaceCull     bool
30546                         Nametag          string
30547                         NametagColor     color.NRGBA
30548                         FaceRotateSpeed  float32 // in degrees per second.
30549                         Infotext         string
30550                         Itemstring       string
30551                         Glow             int8
30552                         MaxBreath        uint16  // Player only.
30553                         EyeHeight        float32 // Player only.
30554                         ZoomFOV          float32 // in degrees. Player only.
30555                         UseTextureAlpha  bool
30556                         DmgTextureMod    Texture // suffix
30557                         Shaded           bool
30558                         ShowOnMinimap    bool
30559                         NametagBG        color.NRGBA
30560                 }))(obj)).MakeFootstepSnds
30561                 switch n := read8(r); n {
30562                 case 0:
30563                         *p = false
30564                 case 1:
30565                         *p = true
30566                 default:
30567                         chk(fmt.Errorf("invalid bool: %d", n))
30568                 }
30569         }
30570         {
30571                 p := &(*(*(struct {
30572                         MaxHP            uint16 // Player only.
30573                         CollideWithNodes bool
30574                         Weight           float32 // deprecated
30575                         ColBox, SelBox   Box
30576                         Pointable        bool
30577                         Visual           string
30578                         VisualSize       [3]float32
30579                         Textures         []Texture
30580                         SpriteSheetSize  [2]int16 // in sprites.
30581                         SpritePos        [2]int16 // in sprite sheet.
30582                         Visible          bool
30583                         MakeFootstepSnds bool
30584                         RotateSpeed      float32 // in radians per second.
30585                         Mesh             string
30586                         Colors           []color.NRGBA
30587                         CollideWithAOs   bool
30588                         StepHeight       float32
30589                         FaceRotateDir    bool
30590                         FaceRotateDirOff float32 // in degrees.
30591                         BackfaceCull     bool
30592                         Nametag          string
30593                         NametagColor     color.NRGBA
30594                         FaceRotateSpeed  float32 // in degrees per second.
30595                         Infotext         string
30596                         Itemstring       string
30597                         Glow             int8
30598                         MaxBreath        uint16  // Player only.
30599                         EyeHeight        float32 // Player only.
30600                         ZoomFOV          float32 // in degrees. Player only.
30601                         UseTextureAlpha  bool
30602                         DmgTextureMod    Texture // suffix
30603                         Shaded           bool
30604                         ShowOnMinimap    bool
30605                         NametagBG        color.NRGBA
30606                 }))(obj)).RotateSpeed
30607                 *p = math.Float32frombits(read32(r))
30608         }
30609         var local337 []uint8
30610         var local338 uint16
30611         {
30612                 p := &local338
30613                 *p = read16(r)
30614         }
30615         (local337) = make([]uint8, local338)
30616         {
30617                 _, err := io.ReadFull(r, (local337)[:])
30618                 chk(err)
30619         }
30620         ((*(*(struct {
30621                 MaxHP            uint16 // Player only.
30622                 CollideWithNodes bool
30623                 Weight           float32 // deprecated
30624                 ColBox, SelBox   Box
30625                 Pointable        bool
30626                 Visual           string
30627                 VisualSize       [3]float32
30628                 Textures         []Texture
30629                 SpriteSheetSize  [2]int16 // in sprites.
30630                 SpritePos        [2]int16 // in sprite sheet.
30631                 Visible          bool
30632                 MakeFootstepSnds bool
30633                 RotateSpeed      float32 // in radians per second.
30634                 Mesh             string
30635                 Colors           []color.NRGBA
30636                 CollideWithAOs   bool
30637                 StepHeight       float32
30638                 FaceRotateDir    bool
30639                 FaceRotateDirOff float32 // in degrees.
30640                 BackfaceCull     bool
30641                 Nametag          string
30642                 NametagColor     color.NRGBA
30643                 FaceRotateSpeed  float32 // in degrees per second.
30644                 Infotext         string
30645                 Itemstring       string
30646                 Glow             int8
30647                 MaxBreath        uint16  // Player only.
30648                 EyeHeight        float32 // Player only.
30649                 ZoomFOV          float32 // in degrees. Player only.
30650                 UseTextureAlpha  bool
30651                 DmgTextureMod    Texture // suffix
30652                 Shaded           bool
30653                 ShowOnMinimap    bool
30654                 NametagBG        color.NRGBA
30655         }))(obj)).Mesh) = string(local337)
30656         var local339 uint16
30657         {
30658                 p := &local339
30659                 *p = read16(r)
30660         }
30661         ((*(*(struct {
30662                 MaxHP            uint16 // Player only.
30663                 CollideWithNodes bool
30664                 Weight           float32 // deprecated
30665                 ColBox, SelBox   Box
30666                 Pointable        bool
30667                 Visual           string
30668                 VisualSize       [3]float32
30669                 Textures         []Texture
30670                 SpriteSheetSize  [2]int16 // in sprites.
30671                 SpritePos        [2]int16 // in sprite sheet.
30672                 Visible          bool
30673                 MakeFootstepSnds bool
30674                 RotateSpeed      float32 // in radians per second.
30675                 Mesh             string
30676                 Colors           []color.NRGBA
30677                 CollideWithAOs   bool
30678                 StepHeight       float32
30679                 FaceRotateDir    bool
30680                 FaceRotateDirOff float32 // in degrees.
30681                 BackfaceCull     bool
30682                 Nametag          string
30683                 NametagColor     color.NRGBA
30684                 FaceRotateSpeed  float32 // in degrees per second.
30685                 Infotext         string
30686                 Itemstring       string
30687                 Glow             int8
30688                 MaxBreath        uint16  // Player only.
30689                 EyeHeight        float32 // Player only.
30690                 ZoomFOV          float32 // in degrees. Player only.
30691                 UseTextureAlpha  bool
30692                 DmgTextureMod    Texture // suffix
30693                 Shaded           bool
30694                 ShowOnMinimap    bool
30695                 NametagBG        color.NRGBA
30696         }))(obj)).Colors) = make([]color.NRGBA, local339)
30697         for local340 := range (*(*(struct {
30698                 MaxHP            uint16 // Player only.
30699                 CollideWithNodes bool
30700                 Weight           float32 // deprecated
30701                 ColBox, SelBox   Box
30702                 Pointable        bool
30703                 Visual           string
30704                 VisualSize       [3]float32
30705                 Textures         []Texture
30706                 SpriteSheetSize  [2]int16 // in sprites.
30707                 SpritePos        [2]int16 // in sprite sheet.
30708                 Visible          bool
30709                 MakeFootstepSnds bool
30710                 RotateSpeed      float32 // in radians per second.
30711                 Mesh             string
30712                 Colors           []color.NRGBA
30713                 CollideWithAOs   bool
30714                 StepHeight       float32
30715                 FaceRotateDir    bool
30716                 FaceRotateDirOff float32 // in degrees.
30717                 BackfaceCull     bool
30718                 Nametag          string
30719                 NametagColor     color.NRGBA
30720                 FaceRotateSpeed  float32 // in degrees per second.
30721                 Infotext         string
30722                 Itemstring       string
30723                 Glow             int8
30724                 MaxBreath        uint16  // Player only.
30725                 EyeHeight        float32 // Player only.
30726                 ZoomFOV          float32 // in degrees. Player only.
30727                 UseTextureAlpha  bool
30728                 DmgTextureMod    Texture // suffix
30729                 Shaded           bool
30730                 ShowOnMinimap    bool
30731                 NametagBG        color.NRGBA
30732         }))(obj)).Colors {
30733                 {
30734                         p := &((*(*(struct {
30735                                 MaxHP            uint16 // Player only.
30736                                 CollideWithNodes bool
30737                                 Weight           float32 // deprecated
30738                                 ColBox, SelBox   Box
30739                                 Pointable        bool
30740                                 Visual           string
30741                                 VisualSize       [3]float32
30742                                 Textures         []Texture
30743                                 SpriteSheetSize  [2]int16 // in sprites.
30744                                 SpritePos        [2]int16 // in sprite sheet.
30745                                 Visible          bool
30746                                 MakeFootstepSnds bool
30747                                 RotateSpeed      float32 // in radians per second.
30748                                 Mesh             string
30749                                 Colors           []color.NRGBA
30750                                 CollideWithAOs   bool
30751                                 StepHeight       float32
30752                                 FaceRotateDir    bool
30753                                 FaceRotateDirOff float32 // in degrees.
30754                                 BackfaceCull     bool
30755                                 Nametag          string
30756                                 NametagColor     color.NRGBA
30757                                 FaceRotateSpeed  float32 // in degrees per second.
30758                                 Infotext         string
30759                                 Itemstring       string
30760                                 Glow             int8
30761                                 MaxBreath        uint16  // Player only.
30762                                 EyeHeight        float32 // Player only.
30763                                 ZoomFOV          float32 // in degrees. Player only.
30764                                 UseTextureAlpha  bool
30765                                 DmgTextureMod    Texture // suffix
30766                                 Shaded           bool
30767                                 ShowOnMinimap    bool
30768                                 NametagBG        color.NRGBA
30769                         }))(obj)).Colors)[local340]
30770                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30771                 }
30772         }
30773         {
30774                 p := &(*(*(struct {
30775                         MaxHP            uint16 // Player only.
30776                         CollideWithNodes bool
30777                         Weight           float32 // deprecated
30778                         ColBox, SelBox   Box
30779                         Pointable        bool
30780                         Visual           string
30781                         VisualSize       [3]float32
30782                         Textures         []Texture
30783                         SpriteSheetSize  [2]int16 // in sprites.
30784                         SpritePos        [2]int16 // in sprite sheet.
30785                         Visible          bool
30786                         MakeFootstepSnds bool
30787                         RotateSpeed      float32 // in radians per second.
30788                         Mesh             string
30789                         Colors           []color.NRGBA
30790                         CollideWithAOs   bool
30791                         StepHeight       float32
30792                         FaceRotateDir    bool
30793                         FaceRotateDirOff float32 // in degrees.
30794                         BackfaceCull     bool
30795                         Nametag          string
30796                         NametagColor     color.NRGBA
30797                         FaceRotateSpeed  float32 // in degrees per second.
30798                         Infotext         string
30799                         Itemstring       string
30800                         Glow             int8
30801                         MaxBreath        uint16  // Player only.
30802                         EyeHeight        float32 // Player only.
30803                         ZoomFOV          float32 // in degrees. Player only.
30804                         UseTextureAlpha  bool
30805                         DmgTextureMod    Texture // suffix
30806                         Shaded           bool
30807                         ShowOnMinimap    bool
30808                         NametagBG        color.NRGBA
30809                 }))(obj)).CollideWithAOs
30810                 switch n := read8(r); n {
30811                 case 0:
30812                         *p = false
30813                 case 1:
30814                         *p = true
30815                 default:
30816                         chk(fmt.Errorf("invalid bool: %d", n))
30817                 }
30818         }
30819         {
30820                 p := &(*(*(struct {
30821                         MaxHP            uint16 // Player only.
30822                         CollideWithNodes bool
30823                         Weight           float32 // deprecated
30824                         ColBox, SelBox   Box
30825                         Pointable        bool
30826                         Visual           string
30827                         VisualSize       [3]float32
30828                         Textures         []Texture
30829                         SpriteSheetSize  [2]int16 // in sprites.
30830                         SpritePos        [2]int16 // in sprite sheet.
30831                         Visible          bool
30832                         MakeFootstepSnds bool
30833                         RotateSpeed      float32 // in radians per second.
30834                         Mesh             string
30835                         Colors           []color.NRGBA
30836                         CollideWithAOs   bool
30837                         StepHeight       float32
30838                         FaceRotateDir    bool
30839                         FaceRotateDirOff float32 // in degrees.
30840                         BackfaceCull     bool
30841                         Nametag          string
30842                         NametagColor     color.NRGBA
30843                         FaceRotateSpeed  float32 // in degrees per second.
30844                         Infotext         string
30845                         Itemstring       string
30846                         Glow             int8
30847                         MaxBreath        uint16  // Player only.
30848                         EyeHeight        float32 // Player only.
30849                         ZoomFOV          float32 // in degrees. Player only.
30850                         UseTextureAlpha  bool
30851                         DmgTextureMod    Texture // suffix
30852                         Shaded           bool
30853                         ShowOnMinimap    bool
30854                         NametagBG        color.NRGBA
30855                 }))(obj)).StepHeight
30856                 *p = math.Float32frombits(read32(r))
30857         }
30858         {
30859                 p := &(*(*(struct {
30860                         MaxHP            uint16 // Player only.
30861                         CollideWithNodes bool
30862                         Weight           float32 // deprecated
30863                         ColBox, SelBox   Box
30864                         Pointable        bool
30865                         Visual           string
30866                         VisualSize       [3]float32
30867                         Textures         []Texture
30868                         SpriteSheetSize  [2]int16 // in sprites.
30869                         SpritePos        [2]int16 // in sprite sheet.
30870                         Visible          bool
30871                         MakeFootstepSnds bool
30872                         RotateSpeed      float32 // in radians per second.
30873                         Mesh             string
30874                         Colors           []color.NRGBA
30875                         CollideWithAOs   bool
30876                         StepHeight       float32
30877                         FaceRotateDir    bool
30878                         FaceRotateDirOff float32 // in degrees.
30879                         BackfaceCull     bool
30880                         Nametag          string
30881                         NametagColor     color.NRGBA
30882                         FaceRotateSpeed  float32 // in degrees per second.
30883                         Infotext         string
30884                         Itemstring       string
30885                         Glow             int8
30886                         MaxBreath        uint16  // Player only.
30887                         EyeHeight        float32 // Player only.
30888                         ZoomFOV          float32 // in degrees. Player only.
30889                         UseTextureAlpha  bool
30890                         DmgTextureMod    Texture // suffix
30891                         Shaded           bool
30892                         ShowOnMinimap    bool
30893                         NametagBG        color.NRGBA
30894                 }))(obj)).FaceRotateDir
30895                 switch n := read8(r); n {
30896                 case 0:
30897                         *p = false
30898                 case 1:
30899                         *p = true
30900                 default:
30901                         chk(fmt.Errorf("invalid bool: %d", n))
30902                 }
30903         }
30904         {
30905                 p := &(*(*(struct {
30906                         MaxHP            uint16 // Player only.
30907                         CollideWithNodes bool
30908                         Weight           float32 // deprecated
30909                         ColBox, SelBox   Box
30910                         Pointable        bool
30911                         Visual           string
30912                         VisualSize       [3]float32
30913                         Textures         []Texture
30914                         SpriteSheetSize  [2]int16 // in sprites.
30915                         SpritePos        [2]int16 // in sprite sheet.
30916                         Visible          bool
30917                         MakeFootstepSnds bool
30918                         RotateSpeed      float32 // in radians per second.
30919                         Mesh             string
30920                         Colors           []color.NRGBA
30921                         CollideWithAOs   bool
30922                         StepHeight       float32
30923                         FaceRotateDir    bool
30924                         FaceRotateDirOff float32 // in degrees.
30925                         BackfaceCull     bool
30926                         Nametag          string
30927                         NametagColor     color.NRGBA
30928                         FaceRotateSpeed  float32 // in degrees per second.
30929                         Infotext         string
30930                         Itemstring       string
30931                         Glow             int8
30932                         MaxBreath        uint16  // Player only.
30933                         EyeHeight        float32 // Player only.
30934                         ZoomFOV          float32 // in degrees. Player only.
30935                         UseTextureAlpha  bool
30936                         DmgTextureMod    Texture // suffix
30937                         Shaded           bool
30938                         ShowOnMinimap    bool
30939                         NametagBG        color.NRGBA
30940                 }))(obj)).FaceRotateDirOff
30941                 *p = math.Float32frombits(read32(r))
30942         }
30943         {
30944                 p := &(*(*(struct {
30945                         MaxHP            uint16 // Player only.
30946                         CollideWithNodes bool
30947                         Weight           float32 // deprecated
30948                         ColBox, SelBox   Box
30949                         Pointable        bool
30950                         Visual           string
30951                         VisualSize       [3]float32
30952                         Textures         []Texture
30953                         SpriteSheetSize  [2]int16 // in sprites.
30954                         SpritePos        [2]int16 // in sprite sheet.
30955                         Visible          bool
30956                         MakeFootstepSnds bool
30957                         RotateSpeed      float32 // in radians per second.
30958                         Mesh             string
30959                         Colors           []color.NRGBA
30960                         CollideWithAOs   bool
30961                         StepHeight       float32
30962                         FaceRotateDir    bool
30963                         FaceRotateDirOff float32 // in degrees.
30964                         BackfaceCull     bool
30965                         Nametag          string
30966                         NametagColor     color.NRGBA
30967                         FaceRotateSpeed  float32 // in degrees per second.
30968                         Infotext         string
30969                         Itemstring       string
30970                         Glow             int8
30971                         MaxBreath        uint16  // Player only.
30972                         EyeHeight        float32 // Player only.
30973                         ZoomFOV          float32 // in degrees. Player only.
30974                         UseTextureAlpha  bool
30975                         DmgTextureMod    Texture // suffix
30976                         Shaded           bool
30977                         ShowOnMinimap    bool
30978                         NametagBG        color.NRGBA
30979                 }))(obj)).BackfaceCull
30980                 switch n := read8(r); n {
30981                 case 0:
30982                         *p = false
30983                 case 1:
30984                         *p = true
30985                 default:
30986                         chk(fmt.Errorf("invalid bool: %d", n))
30987                 }
30988         }
30989         var local341 []uint8
30990         var local342 uint16
30991         {
30992                 p := &local342
30993                 *p = read16(r)
30994         }
30995         (local341) = make([]uint8, local342)
30996         {
30997                 _, err := io.ReadFull(r, (local341)[:])
30998                 chk(err)
30999         }
31000         ((*(*(struct {
31001                 MaxHP            uint16 // Player only.
31002                 CollideWithNodes bool
31003                 Weight           float32 // deprecated
31004                 ColBox, SelBox   Box
31005                 Pointable        bool
31006                 Visual           string
31007                 VisualSize       [3]float32
31008                 Textures         []Texture
31009                 SpriteSheetSize  [2]int16 // in sprites.
31010                 SpritePos        [2]int16 // in sprite sheet.
31011                 Visible          bool
31012                 MakeFootstepSnds bool
31013                 RotateSpeed      float32 // in radians per second.
31014                 Mesh             string
31015                 Colors           []color.NRGBA
31016                 CollideWithAOs   bool
31017                 StepHeight       float32
31018                 FaceRotateDir    bool
31019                 FaceRotateDirOff float32 // in degrees.
31020                 BackfaceCull     bool
31021                 Nametag          string
31022                 NametagColor     color.NRGBA
31023                 FaceRotateSpeed  float32 // in degrees per second.
31024                 Infotext         string
31025                 Itemstring       string
31026                 Glow             int8
31027                 MaxBreath        uint16  // Player only.
31028                 EyeHeight        float32 // Player only.
31029                 ZoomFOV          float32 // in degrees. Player only.
31030                 UseTextureAlpha  bool
31031                 DmgTextureMod    Texture // suffix
31032                 Shaded           bool
31033                 ShowOnMinimap    bool
31034                 NametagBG        color.NRGBA
31035         }))(obj)).Nametag) = string(local341)
31036         {
31037                 p := &(*(*(struct {
31038                         MaxHP            uint16 // Player only.
31039                         CollideWithNodes bool
31040                         Weight           float32 // deprecated
31041                         ColBox, SelBox   Box
31042                         Pointable        bool
31043                         Visual           string
31044                         VisualSize       [3]float32
31045                         Textures         []Texture
31046                         SpriteSheetSize  [2]int16 // in sprites.
31047                         SpritePos        [2]int16 // in sprite sheet.
31048                         Visible          bool
31049                         MakeFootstepSnds bool
31050                         RotateSpeed      float32 // in radians per second.
31051                         Mesh             string
31052                         Colors           []color.NRGBA
31053                         CollideWithAOs   bool
31054                         StepHeight       float32
31055                         FaceRotateDir    bool
31056                         FaceRotateDirOff float32 // in degrees.
31057                         BackfaceCull     bool
31058                         Nametag          string
31059                         NametagColor     color.NRGBA
31060                         FaceRotateSpeed  float32 // in degrees per second.
31061                         Infotext         string
31062                         Itemstring       string
31063                         Glow             int8
31064                         MaxBreath        uint16  // Player only.
31065                         EyeHeight        float32 // Player only.
31066                         ZoomFOV          float32 // in degrees. Player only.
31067                         UseTextureAlpha  bool
31068                         DmgTextureMod    Texture // suffix
31069                         Shaded           bool
31070                         ShowOnMinimap    bool
31071                         NametagBG        color.NRGBA
31072                 }))(obj)).NametagColor
31073                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31074         }
31075         {
31076                 p := &(*(*(struct {
31077                         MaxHP            uint16 // Player only.
31078                         CollideWithNodes bool
31079                         Weight           float32 // deprecated
31080                         ColBox, SelBox   Box
31081                         Pointable        bool
31082                         Visual           string
31083                         VisualSize       [3]float32
31084                         Textures         []Texture
31085                         SpriteSheetSize  [2]int16 // in sprites.
31086                         SpritePos        [2]int16 // in sprite sheet.
31087                         Visible          bool
31088                         MakeFootstepSnds bool
31089                         RotateSpeed      float32 // in radians per second.
31090                         Mesh             string
31091                         Colors           []color.NRGBA
31092                         CollideWithAOs   bool
31093                         StepHeight       float32
31094                         FaceRotateDir    bool
31095                         FaceRotateDirOff float32 // in degrees.
31096                         BackfaceCull     bool
31097                         Nametag          string
31098                         NametagColor     color.NRGBA
31099                         FaceRotateSpeed  float32 // in degrees per second.
31100                         Infotext         string
31101                         Itemstring       string
31102                         Glow             int8
31103                         MaxBreath        uint16  // Player only.
31104                         EyeHeight        float32 // Player only.
31105                         ZoomFOV          float32 // in degrees. Player only.
31106                         UseTextureAlpha  bool
31107                         DmgTextureMod    Texture // suffix
31108                         Shaded           bool
31109                         ShowOnMinimap    bool
31110                         NametagBG        color.NRGBA
31111                 }))(obj)).FaceRotateSpeed
31112                 *p = math.Float32frombits(read32(r))
31113         }
31114         var local343 []uint8
31115         var local344 uint16
31116         {
31117                 p := &local344
31118                 *p = read16(r)
31119         }
31120         (local343) = make([]uint8, local344)
31121         {
31122                 _, err := io.ReadFull(r, (local343)[:])
31123                 chk(err)
31124         }
31125         ((*(*(struct {
31126                 MaxHP            uint16 // Player only.
31127                 CollideWithNodes bool
31128                 Weight           float32 // deprecated
31129                 ColBox, SelBox   Box
31130                 Pointable        bool
31131                 Visual           string
31132                 VisualSize       [3]float32
31133                 Textures         []Texture
31134                 SpriteSheetSize  [2]int16 // in sprites.
31135                 SpritePos        [2]int16 // in sprite sheet.
31136                 Visible          bool
31137                 MakeFootstepSnds bool
31138                 RotateSpeed      float32 // in radians per second.
31139                 Mesh             string
31140                 Colors           []color.NRGBA
31141                 CollideWithAOs   bool
31142                 StepHeight       float32
31143                 FaceRotateDir    bool
31144                 FaceRotateDirOff float32 // in degrees.
31145                 BackfaceCull     bool
31146                 Nametag          string
31147                 NametagColor     color.NRGBA
31148                 FaceRotateSpeed  float32 // in degrees per second.
31149                 Infotext         string
31150                 Itemstring       string
31151                 Glow             int8
31152                 MaxBreath        uint16  // Player only.
31153                 EyeHeight        float32 // Player only.
31154                 ZoomFOV          float32 // in degrees. Player only.
31155                 UseTextureAlpha  bool
31156                 DmgTextureMod    Texture // suffix
31157                 Shaded           bool
31158                 ShowOnMinimap    bool
31159                 NametagBG        color.NRGBA
31160         }))(obj)).Infotext) = string(local343)
31161         var local345 []uint8
31162         var local346 uint16
31163         {
31164                 p := &local346
31165                 *p = read16(r)
31166         }
31167         (local345) = make([]uint8, local346)
31168         {
31169                 _, err := io.ReadFull(r, (local345)[:])
31170                 chk(err)
31171         }
31172         ((*(*(struct {
31173                 MaxHP            uint16 // Player only.
31174                 CollideWithNodes bool
31175                 Weight           float32 // deprecated
31176                 ColBox, SelBox   Box
31177                 Pointable        bool
31178                 Visual           string
31179                 VisualSize       [3]float32
31180                 Textures         []Texture
31181                 SpriteSheetSize  [2]int16 // in sprites.
31182                 SpritePos        [2]int16 // in sprite sheet.
31183                 Visible          bool
31184                 MakeFootstepSnds bool
31185                 RotateSpeed      float32 // in radians per second.
31186                 Mesh             string
31187                 Colors           []color.NRGBA
31188                 CollideWithAOs   bool
31189                 StepHeight       float32
31190                 FaceRotateDir    bool
31191                 FaceRotateDirOff float32 // in degrees.
31192                 BackfaceCull     bool
31193                 Nametag          string
31194                 NametagColor     color.NRGBA
31195                 FaceRotateSpeed  float32 // in degrees per second.
31196                 Infotext         string
31197                 Itemstring       string
31198                 Glow             int8
31199                 MaxBreath        uint16  // Player only.
31200                 EyeHeight        float32 // Player only.
31201                 ZoomFOV          float32 // in degrees. Player only.
31202                 UseTextureAlpha  bool
31203                 DmgTextureMod    Texture // suffix
31204                 Shaded           bool
31205                 ShowOnMinimap    bool
31206                 NametagBG        color.NRGBA
31207         }))(obj)).Itemstring) = string(local345)
31208         {
31209                 p := &(*(*(struct {
31210                         MaxHP            uint16 // Player only.
31211                         CollideWithNodes bool
31212                         Weight           float32 // deprecated
31213                         ColBox, SelBox   Box
31214                         Pointable        bool
31215                         Visual           string
31216                         VisualSize       [3]float32
31217                         Textures         []Texture
31218                         SpriteSheetSize  [2]int16 // in sprites.
31219                         SpritePos        [2]int16 // in sprite sheet.
31220                         Visible          bool
31221                         MakeFootstepSnds bool
31222                         RotateSpeed      float32 // in radians per second.
31223                         Mesh             string
31224                         Colors           []color.NRGBA
31225                         CollideWithAOs   bool
31226                         StepHeight       float32
31227                         FaceRotateDir    bool
31228                         FaceRotateDirOff float32 // in degrees.
31229                         BackfaceCull     bool
31230                         Nametag          string
31231                         NametagColor     color.NRGBA
31232                         FaceRotateSpeed  float32 // in degrees per second.
31233                         Infotext         string
31234                         Itemstring       string
31235                         Glow             int8
31236                         MaxBreath        uint16  // Player only.
31237                         EyeHeight        float32 // Player only.
31238                         ZoomFOV          float32 // in degrees. Player only.
31239                         UseTextureAlpha  bool
31240                         DmgTextureMod    Texture // suffix
31241                         Shaded           bool
31242                         ShowOnMinimap    bool
31243                         NametagBG        color.NRGBA
31244                 }))(obj)).Glow
31245                 *p = int8(read8(r))
31246         }
31247         {
31248                 p := &(*(*(struct {
31249                         MaxHP            uint16 // Player only.
31250                         CollideWithNodes bool
31251                         Weight           float32 // deprecated
31252                         ColBox, SelBox   Box
31253                         Pointable        bool
31254                         Visual           string
31255                         VisualSize       [3]float32
31256                         Textures         []Texture
31257                         SpriteSheetSize  [2]int16 // in sprites.
31258                         SpritePos        [2]int16 // in sprite sheet.
31259                         Visible          bool
31260                         MakeFootstepSnds bool
31261                         RotateSpeed      float32 // in radians per second.
31262                         Mesh             string
31263                         Colors           []color.NRGBA
31264                         CollideWithAOs   bool
31265                         StepHeight       float32
31266                         FaceRotateDir    bool
31267                         FaceRotateDirOff float32 // in degrees.
31268                         BackfaceCull     bool
31269                         Nametag          string
31270                         NametagColor     color.NRGBA
31271                         FaceRotateSpeed  float32 // in degrees per second.
31272                         Infotext         string
31273                         Itemstring       string
31274                         Glow             int8
31275                         MaxBreath        uint16  // Player only.
31276                         EyeHeight        float32 // Player only.
31277                         ZoomFOV          float32 // in degrees. Player only.
31278                         UseTextureAlpha  bool
31279                         DmgTextureMod    Texture // suffix
31280                         Shaded           bool
31281                         ShowOnMinimap    bool
31282                         NametagBG        color.NRGBA
31283                 }))(obj)).MaxBreath
31284                 *p = read16(r)
31285         }
31286         {
31287                 p := &(*(*(struct {
31288                         MaxHP            uint16 // Player only.
31289                         CollideWithNodes bool
31290                         Weight           float32 // deprecated
31291                         ColBox, SelBox   Box
31292                         Pointable        bool
31293                         Visual           string
31294                         VisualSize       [3]float32
31295                         Textures         []Texture
31296                         SpriteSheetSize  [2]int16 // in sprites.
31297                         SpritePos        [2]int16 // in sprite sheet.
31298                         Visible          bool
31299                         MakeFootstepSnds bool
31300                         RotateSpeed      float32 // in radians per second.
31301                         Mesh             string
31302                         Colors           []color.NRGBA
31303                         CollideWithAOs   bool
31304                         StepHeight       float32
31305                         FaceRotateDir    bool
31306                         FaceRotateDirOff float32 // in degrees.
31307                         BackfaceCull     bool
31308                         Nametag          string
31309                         NametagColor     color.NRGBA
31310                         FaceRotateSpeed  float32 // in degrees per second.
31311                         Infotext         string
31312                         Itemstring       string
31313                         Glow             int8
31314                         MaxBreath        uint16  // Player only.
31315                         EyeHeight        float32 // Player only.
31316                         ZoomFOV          float32 // in degrees. Player only.
31317                         UseTextureAlpha  bool
31318                         DmgTextureMod    Texture // suffix
31319                         Shaded           bool
31320                         ShowOnMinimap    bool
31321                         NametagBG        color.NRGBA
31322                 }))(obj)).EyeHeight
31323                 *p = math.Float32frombits(read32(r))
31324         }
31325         {
31326                 p := &(*(*(struct {
31327                         MaxHP            uint16 // Player only.
31328                         CollideWithNodes bool
31329                         Weight           float32 // deprecated
31330                         ColBox, SelBox   Box
31331                         Pointable        bool
31332                         Visual           string
31333                         VisualSize       [3]float32
31334                         Textures         []Texture
31335                         SpriteSheetSize  [2]int16 // in sprites.
31336                         SpritePos        [2]int16 // in sprite sheet.
31337                         Visible          bool
31338                         MakeFootstepSnds bool
31339                         RotateSpeed      float32 // in radians per second.
31340                         Mesh             string
31341                         Colors           []color.NRGBA
31342                         CollideWithAOs   bool
31343                         StepHeight       float32
31344                         FaceRotateDir    bool
31345                         FaceRotateDirOff float32 // in degrees.
31346                         BackfaceCull     bool
31347                         Nametag          string
31348                         NametagColor     color.NRGBA
31349                         FaceRotateSpeed  float32 // in degrees per second.
31350                         Infotext         string
31351                         Itemstring       string
31352                         Glow             int8
31353                         MaxBreath        uint16  // Player only.
31354                         EyeHeight        float32 // Player only.
31355                         ZoomFOV          float32 // in degrees. Player only.
31356                         UseTextureAlpha  bool
31357                         DmgTextureMod    Texture // suffix
31358                         Shaded           bool
31359                         ShowOnMinimap    bool
31360                         NametagBG        color.NRGBA
31361                 }))(obj)).ZoomFOV
31362                 *p = math.Float32frombits(read32(r))
31363         }
31364         {
31365                 p := &(*(*(struct {
31366                         MaxHP            uint16 // Player only.
31367                         CollideWithNodes bool
31368                         Weight           float32 // deprecated
31369                         ColBox, SelBox   Box
31370                         Pointable        bool
31371                         Visual           string
31372                         VisualSize       [3]float32
31373                         Textures         []Texture
31374                         SpriteSheetSize  [2]int16 // in sprites.
31375                         SpritePos        [2]int16 // in sprite sheet.
31376                         Visible          bool
31377                         MakeFootstepSnds bool
31378                         RotateSpeed      float32 // in radians per second.
31379                         Mesh             string
31380                         Colors           []color.NRGBA
31381                         CollideWithAOs   bool
31382                         StepHeight       float32
31383                         FaceRotateDir    bool
31384                         FaceRotateDirOff float32 // in degrees.
31385                         BackfaceCull     bool
31386                         Nametag          string
31387                         NametagColor     color.NRGBA
31388                         FaceRotateSpeed  float32 // in degrees per second.
31389                         Infotext         string
31390                         Itemstring       string
31391                         Glow             int8
31392                         MaxBreath        uint16  // Player only.
31393                         EyeHeight        float32 // Player only.
31394                         ZoomFOV          float32 // in degrees. Player only.
31395                         UseTextureAlpha  bool
31396                         DmgTextureMod    Texture // suffix
31397                         Shaded           bool
31398                         ShowOnMinimap    bool
31399                         NametagBG        color.NRGBA
31400                 }))(obj)).UseTextureAlpha
31401                 switch n := read8(r); n {
31402                 case 0:
31403                         *p = false
31404                 case 1:
31405                         *p = true
31406                 default:
31407                         chk(fmt.Errorf("invalid bool: %d", n))
31408                 }
31409         }
31410         if err := pcall(func() {
31411                 ((*(*(struct {
31412                         MaxHP            uint16 // Player only.
31413                         CollideWithNodes bool
31414                         Weight           float32 // deprecated
31415                         ColBox, SelBox   Box
31416                         Pointable        bool
31417                         Visual           string
31418                         VisualSize       [3]float32
31419                         Textures         []Texture
31420                         SpriteSheetSize  [2]int16 // in sprites.
31421                         SpritePos        [2]int16 // in sprite sheet.
31422                         Visible          bool
31423                         MakeFootstepSnds bool
31424                         RotateSpeed      float32 // in radians per second.
31425                         Mesh             string
31426                         Colors           []color.NRGBA
31427                         CollideWithAOs   bool
31428                         StepHeight       float32
31429                         FaceRotateDir    bool
31430                         FaceRotateDirOff float32 // in degrees.
31431                         BackfaceCull     bool
31432                         Nametag          string
31433                         NametagColor     color.NRGBA
31434                         FaceRotateSpeed  float32 // in degrees per second.
31435                         Infotext         string
31436                         Itemstring       string
31437                         Glow             int8
31438                         MaxBreath        uint16  // Player only.
31439                         EyeHeight        float32 // Player only.
31440                         ZoomFOV          float32 // in degrees. Player only.
31441                         UseTextureAlpha  bool
31442                         DmgTextureMod    Texture // suffix
31443                         Shaded           bool
31444                         ShowOnMinimap    bool
31445                         NametagBG        color.NRGBA
31446                 }))(obj)).DmgTextureMod).deserialize(r)
31447         }); err != nil {
31448                 if err == io.EOF {
31449                         chk(io.EOF)
31450                 }
31451                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
31452         }
31453         {
31454                 p := &(*(*(struct {
31455                         MaxHP            uint16 // Player only.
31456                         CollideWithNodes bool
31457                         Weight           float32 // deprecated
31458                         ColBox, SelBox   Box
31459                         Pointable        bool
31460                         Visual           string
31461                         VisualSize       [3]float32
31462                         Textures         []Texture
31463                         SpriteSheetSize  [2]int16 // in sprites.
31464                         SpritePos        [2]int16 // in sprite sheet.
31465                         Visible          bool
31466                         MakeFootstepSnds bool
31467                         RotateSpeed      float32 // in radians per second.
31468                         Mesh             string
31469                         Colors           []color.NRGBA
31470                         CollideWithAOs   bool
31471                         StepHeight       float32
31472                         FaceRotateDir    bool
31473                         FaceRotateDirOff float32 // in degrees.
31474                         BackfaceCull     bool
31475                         Nametag          string
31476                         NametagColor     color.NRGBA
31477                         FaceRotateSpeed  float32 // in degrees per second.
31478                         Infotext         string
31479                         Itemstring       string
31480                         Glow             int8
31481                         MaxBreath        uint16  // Player only.
31482                         EyeHeight        float32 // Player only.
31483                         ZoomFOV          float32 // in degrees. Player only.
31484                         UseTextureAlpha  bool
31485                         DmgTextureMod    Texture // suffix
31486                         Shaded           bool
31487                         ShowOnMinimap    bool
31488                         NametagBG        color.NRGBA
31489                 }))(obj)).Shaded
31490                 switch n := read8(r); n {
31491                 case 0:
31492                         *p = false
31493                 case 1:
31494                         *p = true
31495                 default:
31496                         chk(fmt.Errorf("invalid bool: %d", n))
31497                 }
31498         }
31499         {
31500                 p := &(*(*(struct {
31501                         MaxHP            uint16 // Player only.
31502                         CollideWithNodes bool
31503                         Weight           float32 // deprecated
31504                         ColBox, SelBox   Box
31505                         Pointable        bool
31506                         Visual           string
31507                         VisualSize       [3]float32
31508                         Textures         []Texture
31509                         SpriteSheetSize  [2]int16 // in sprites.
31510                         SpritePos        [2]int16 // in sprite sheet.
31511                         Visible          bool
31512                         MakeFootstepSnds bool
31513                         RotateSpeed      float32 // in radians per second.
31514                         Mesh             string
31515                         Colors           []color.NRGBA
31516                         CollideWithAOs   bool
31517                         StepHeight       float32
31518                         FaceRotateDir    bool
31519                         FaceRotateDirOff float32 // in degrees.
31520                         BackfaceCull     bool
31521                         Nametag          string
31522                         NametagColor     color.NRGBA
31523                         FaceRotateSpeed  float32 // in degrees per second.
31524                         Infotext         string
31525                         Itemstring       string
31526                         Glow             int8
31527                         MaxBreath        uint16  // Player only.
31528                         EyeHeight        float32 // Player only.
31529                         ZoomFOV          float32 // in degrees. Player only.
31530                         UseTextureAlpha  bool
31531                         DmgTextureMod    Texture // suffix
31532                         Shaded           bool
31533                         ShowOnMinimap    bool
31534                         NametagBG        color.NRGBA
31535                 }))(obj)).ShowOnMinimap
31536                 switch n := read8(r); n {
31537                 case 0:
31538                         *p = false
31539                 case 1:
31540                         *p = true
31541                 default:
31542                         chk(fmt.Errorf("invalid bool: %d", n))
31543                 }
31544         }
31545         {
31546                 p := &(*(*(struct {
31547                         MaxHP            uint16 // Player only.
31548                         CollideWithNodes bool
31549                         Weight           float32 // deprecated
31550                         ColBox, SelBox   Box
31551                         Pointable        bool
31552                         Visual           string
31553                         VisualSize       [3]float32
31554                         Textures         []Texture
31555                         SpriteSheetSize  [2]int16 // in sprites.
31556                         SpritePos        [2]int16 // in sprite sheet.
31557                         Visible          bool
31558                         MakeFootstepSnds bool
31559                         RotateSpeed      float32 // in radians per second.
31560                         Mesh             string
31561                         Colors           []color.NRGBA
31562                         CollideWithAOs   bool
31563                         StepHeight       float32
31564                         FaceRotateDir    bool
31565                         FaceRotateDirOff float32 // in degrees.
31566                         BackfaceCull     bool
31567                         Nametag          string
31568                         NametagColor     color.NRGBA
31569                         FaceRotateSpeed  float32 // in degrees per second.
31570                         Infotext         string
31571                         Itemstring       string
31572                         Glow             int8
31573                         MaxBreath        uint16  // Player only.
31574                         EyeHeight        float32 // Player only.
31575                         ZoomFOV          float32 // in degrees. Player only.
31576                         UseTextureAlpha  bool
31577                         DmgTextureMod    Texture // suffix
31578                         Shaded           bool
31579                         ShowOnMinimap    bool
31580                         NametagBG        color.NRGBA
31581                 }))(obj)).NametagBG
31582                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31583         }
31584 }
31585
31586 func (obj *AOPos) serialize(w io.Writer) {
31587         if err := pcall(func() {
31588                 ((*(*(struct {
31589                         Pos
31590                         Vel, Acc Vec
31591                         Rot      [3]float32
31592
31593                         Interpolate    bool
31594                         End            bool
31595                         UpdateInterval float32
31596                 }))(obj)).Pos).serialize(w)
31597         }); err != nil {
31598                 if err == io.EOF {
31599                         chk(io.EOF)
31600                 }
31601                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
31602         }
31603         if err := pcall(func() {
31604                 ((*(*(struct {
31605                         Pos
31606                         Vel, Acc Vec
31607                         Rot      [3]float32
31608
31609                         Interpolate    bool
31610                         End            bool
31611                         UpdateInterval float32
31612                 }))(obj)).Vel).serialize(w)
31613         }); err != nil {
31614                 if err == io.EOF {
31615                         chk(io.EOF)
31616                 }
31617                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31618         }
31619         if err := pcall(func() {
31620                 ((*(*(struct {
31621                         Pos
31622                         Vel, Acc Vec
31623                         Rot      [3]float32
31624
31625                         Interpolate    bool
31626                         End            bool
31627                         UpdateInterval float32
31628                 }))(obj)).Acc).serialize(w)
31629         }); err != nil {
31630                 if err == io.EOF {
31631                         chk(io.EOF)
31632                 }
31633                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31634         }
31635         for local347 := range (*(*(struct {
31636                 Pos
31637                 Vel, Acc Vec
31638                 Rot      [3]float32
31639
31640                 Interpolate    bool
31641                 End            bool
31642                 UpdateInterval float32
31643         }))(obj)).Rot {
31644                 {
31645                         x := ((*(*(struct {
31646                                 Pos
31647                                 Vel, Acc Vec
31648                                 Rot      [3]float32
31649
31650                                 Interpolate    bool
31651                                 End            bool
31652                                 UpdateInterval float32
31653                         }))(obj)).Rot)[local347]
31654                         write32(w, math.Float32bits(x))
31655                 }
31656         }
31657         {
31658                 x := (*(*(struct {
31659                         Pos
31660                         Vel, Acc Vec
31661                         Rot      [3]float32
31662
31663                         Interpolate    bool
31664                         End            bool
31665                         UpdateInterval float32
31666                 }))(obj)).Interpolate
31667                 if x {
31668                         write8(w, 1)
31669                 } else {
31670                         write8(w, 0)
31671                 }
31672         }
31673         {
31674                 x := (*(*(struct {
31675                         Pos
31676                         Vel, Acc Vec
31677                         Rot      [3]float32
31678
31679                         Interpolate    bool
31680                         End            bool
31681                         UpdateInterval float32
31682                 }))(obj)).End
31683                 if x {
31684                         write8(w, 1)
31685                 } else {
31686                         write8(w, 0)
31687                 }
31688         }
31689         {
31690                 x := (*(*(struct {
31691                         Pos
31692                         Vel, Acc Vec
31693                         Rot      [3]float32
31694
31695                         Interpolate    bool
31696                         End            bool
31697                         UpdateInterval float32
31698                 }))(obj)).UpdateInterval
31699                 write32(w, math.Float32bits(x))
31700         }
31701 }
31702
31703 func (obj *AOPos) deserialize(r io.Reader) {
31704         if err := pcall(func() {
31705                 ((*(*(struct {
31706                         Pos
31707                         Vel, Acc Vec
31708                         Rot      [3]float32
31709
31710                         Interpolate    bool
31711                         End            bool
31712                         UpdateInterval float32
31713                 }))(obj)).Pos).deserialize(r)
31714         }); err != nil {
31715                 if err == io.EOF {
31716                         chk(io.EOF)
31717                 }
31718                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
31719         }
31720         if err := pcall(func() {
31721                 ((*(*(struct {
31722                         Pos
31723                         Vel, Acc Vec
31724                         Rot      [3]float32
31725
31726                         Interpolate    bool
31727                         End            bool
31728                         UpdateInterval float32
31729                 }))(obj)).Vel).deserialize(r)
31730         }); err != nil {
31731                 if err == io.EOF {
31732                         chk(io.EOF)
31733                 }
31734                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31735         }
31736         if err := pcall(func() {
31737                 ((*(*(struct {
31738                         Pos
31739                         Vel, Acc Vec
31740                         Rot      [3]float32
31741
31742                         Interpolate    bool
31743                         End            bool
31744                         UpdateInterval float32
31745                 }))(obj)).Acc).deserialize(r)
31746         }); err != nil {
31747                 if err == io.EOF {
31748                         chk(io.EOF)
31749                 }
31750                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31751         }
31752         for local348 := range (*(*(struct {
31753                 Pos
31754                 Vel, Acc Vec
31755                 Rot      [3]float32
31756
31757                 Interpolate    bool
31758                 End            bool
31759                 UpdateInterval float32
31760         }))(obj)).Rot {
31761                 {
31762                         p := &((*(*(struct {
31763                                 Pos
31764                                 Vel, Acc Vec
31765                                 Rot      [3]float32
31766
31767                                 Interpolate    bool
31768                                 End            bool
31769                                 UpdateInterval float32
31770                         }))(obj)).Rot)[local348]
31771                         *p = math.Float32frombits(read32(r))
31772                 }
31773         }
31774         {
31775                 p := &(*(*(struct {
31776                         Pos
31777                         Vel, Acc Vec
31778                         Rot      [3]float32
31779
31780                         Interpolate    bool
31781                         End            bool
31782                         UpdateInterval float32
31783                 }))(obj)).Interpolate
31784                 switch n := read8(r); n {
31785                 case 0:
31786                         *p = false
31787                 case 1:
31788                         *p = true
31789                 default:
31790                         chk(fmt.Errorf("invalid bool: %d", n))
31791                 }
31792         }
31793         {
31794                 p := &(*(*(struct {
31795                         Pos
31796                         Vel, Acc Vec
31797                         Rot      [3]float32
31798
31799                         Interpolate    bool
31800                         End            bool
31801                         UpdateInterval float32
31802                 }))(obj)).End
31803                 switch n := read8(r); n {
31804                 case 0:
31805                         *p = false
31806                 case 1:
31807                         *p = true
31808                 default:
31809                         chk(fmt.Errorf("invalid bool: %d", n))
31810                 }
31811         }
31812         {
31813                 p := &(*(*(struct {
31814                         Pos
31815                         Vel, Acc Vec
31816                         Rot      [3]float32
31817
31818                         Interpolate    bool
31819                         End            bool
31820                         UpdateInterval float32
31821                 }))(obj)).UpdateInterval
31822                 *p = math.Float32frombits(read32(r))
31823         }
31824 }
31825
31826 func (obj *AOSprite) serialize(w io.Writer) {
31827         for local349 := range (*(*(struct {
31828                 Frame0          [2]int16
31829                 Frames          uint16
31830                 FrameDuration   float32
31831                 ViewAngleFrames bool
31832         }))(obj)).Frame0 {
31833                 {
31834                         x := ((*(*(struct {
31835                                 Frame0          [2]int16
31836                                 Frames          uint16
31837                                 FrameDuration   float32
31838                                 ViewAngleFrames bool
31839                         }))(obj)).Frame0)[local349]
31840                         write16(w, uint16(x))
31841                 }
31842         }
31843         {
31844                 x := (*(*(struct {
31845                         Frame0          [2]int16
31846                         Frames          uint16
31847                         FrameDuration   float32
31848                         ViewAngleFrames bool
31849                 }))(obj)).Frames
31850                 write16(w, uint16(x))
31851         }
31852         {
31853                 x := (*(*(struct {
31854                         Frame0          [2]int16
31855                         Frames          uint16
31856                         FrameDuration   float32
31857                         ViewAngleFrames bool
31858                 }))(obj)).FrameDuration
31859                 write32(w, math.Float32bits(x))
31860         }
31861         {
31862                 x := (*(*(struct {
31863                         Frame0          [2]int16
31864                         Frames          uint16
31865                         FrameDuration   float32
31866                         ViewAngleFrames bool
31867                 }))(obj)).ViewAngleFrames
31868                 if x {
31869                         write8(w, 1)
31870                 } else {
31871                         write8(w, 0)
31872                 }
31873         }
31874 }
31875
31876 func (obj *AOSprite) deserialize(r io.Reader) {
31877         for local350 := range (*(*(struct {
31878                 Frame0          [2]int16
31879                 Frames          uint16
31880                 FrameDuration   float32
31881                 ViewAngleFrames bool
31882         }))(obj)).Frame0 {
31883                 {
31884                         p := &((*(*(struct {
31885                                 Frame0          [2]int16
31886                                 Frames          uint16
31887                                 FrameDuration   float32
31888                                 ViewAngleFrames bool
31889                         }))(obj)).Frame0)[local350]
31890                         *p = int16(read16(r))
31891                 }
31892         }
31893         {
31894                 p := &(*(*(struct {
31895                         Frame0          [2]int16
31896                         Frames          uint16
31897                         FrameDuration   float32
31898                         ViewAngleFrames bool
31899                 }))(obj)).Frames
31900                 *p = read16(r)
31901         }
31902         {
31903                 p := &(*(*(struct {
31904                         Frame0          [2]int16
31905                         Frames          uint16
31906                         FrameDuration   float32
31907                         ViewAngleFrames bool
31908                 }))(obj)).FrameDuration
31909                 *p = math.Float32frombits(read32(r))
31910         }
31911         {
31912                 p := &(*(*(struct {
31913                         Frame0          [2]int16
31914                         Frames          uint16
31915                         FrameDuration   float32
31916                         ViewAngleFrames bool
31917                 }))(obj)).ViewAngleFrames
31918                 switch n := read8(r); n {
31919                 case 0:
31920                         *p = false
31921                 case 1:
31922                         *p = true
31923                 default:
31924                         chk(fmt.Errorf("invalid bool: %d", n))
31925                 }
31926         }
31927 }
31928
31929 func (obj *Group) serialize(w io.Writer) {
31930         if len(([]byte((*(*(struct {
31931                 Name   string
31932                 Rating int16
31933         }))(obj)).Name))) > math.MaxUint16 {
31934                 chk(ErrTooLong)
31935         }
31936         {
31937                 x := uint16(len(([]byte((*(*(struct {
31938                         Name   string
31939                         Rating int16
31940                 }))(obj)).Name))))
31941                 write16(w, uint16(x))
31942         }
31943         {
31944                 _, err := w.Write(([]byte((*(*(struct {
31945                         Name   string
31946                         Rating int16
31947                 }))(obj)).Name))[:])
31948                 chk(err)
31949         }
31950         {
31951                 x := (*(*(struct {
31952                         Name   string
31953                         Rating int16
31954                 }))(obj)).Rating
31955                 write16(w, uint16(x))
31956         }
31957 }
31958
31959 func (obj *Group) deserialize(r io.Reader) {
31960         var local351 []uint8
31961         var local352 uint16
31962         {
31963                 p := &local352
31964                 *p = read16(r)
31965         }
31966         (local351) = make([]uint8, local352)
31967         {
31968                 _, err := io.ReadFull(r, (local351)[:])
31969                 chk(err)
31970         }
31971         ((*(*(struct {
31972                 Name   string
31973                 Rating int16
31974         }))(obj)).Name) = string(local351)
31975         {
31976                 p := &(*(*(struct {
31977                         Name   string
31978                         Rating int16
31979                 }))(obj)).Rating
31980                 *p = int16(read16(r))
31981         }
31982 }
31983
31984 func (obj *AOAnim) serialize(w io.Writer) {
31985         for local353 := range (*(*(struct {
31986                 Frames [2]int32
31987                 Speed  float32
31988                 Blend  float32
31989                 NoLoop bool
31990         }))(obj)).Frames {
31991                 {
31992                         x := ((*(*(struct {
31993                                 Frames [2]int32
31994                                 Speed  float32
31995                                 Blend  float32
31996                                 NoLoop bool
31997                         }))(obj)).Frames)[local353]
31998                         write32(w, uint32(x))
31999                 }
32000         }
32001         {
32002                 x := (*(*(struct {
32003                         Frames [2]int32
32004                         Speed  float32
32005                         Blend  float32
32006                         NoLoop bool
32007                 }))(obj)).Speed
32008                 write32(w, math.Float32bits(x))
32009         }
32010         {
32011                 x := (*(*(struct {
32012                         Frames [2]int32
32013                         Speed  float32
32014                         Blend  float32
32015                         NoLoop bool
32016                 }))(obj)).Blend
32017                 write32(w, math.Float32bits(x))
32018         }
32019         {
32020                 x := (*(*(struct {
32021                         Frames [2]int32
32022                         Speed  float32
32023                         Blend  float32
32024                         NoLoop bool
32025                 }))(obj)).NoLoop
32026                 if x {
32027                         write8(w, 1)
32028                 } else {
32029                         write8(w, 0)
32030                 }
32031         }
32032 }
32033
32034 func (obj *AOAnim) deserialize(r io.Reader) {
32035         for local354 := range (*(*(struct {
32036                 Frames [2]int32
32037                 Speed  float32
32038                 Blend  float32
32039                 NoLoop bool
32040         }))(obj)).Frames {
32041                 {
32042                         p := &((*(*(struct {
32043                                 Frames [2]int32
32044                                 Speed  float32
32045                                 Blend  float32
32046                                 NoLoop bool
32047                         }))(obj)).Frames)[local354]
32048                         *p = int32(read32(r))
32049                 }
32050         }
32051         {
32052                 p := &(*(*(struct {
32053                         Frames [2]int32
32054                         Speed  float32
32055                         Blend  float32
32056                         NoLoop bool
32057                 }))(obj)).Speed
32058                 *p = math.Float32frombits(read32(r))
32059         }
32060         {
32061                 p := &(*(*(struct {
32062                         Frames [2]int32
32063                         Speed  float32
32064                         Blend  float32
32065                         NoLoop bool
32066                 }))(obj)).Blend
32067                 *p = math.Float32frombits(read32(r))
32068         }
32069         {
32070                 p := &(*(*(struct {
32071                         Frames [2]int32
32072                         Speed  float32
32073                         Blend  float32
32074                         NoLoop bool
32075                 }))(obj)).NoLoop
32076                 switch n := read8(r); n {
32077                 case 0:
32078                         *p = false
32079                 case 1:
32080                         *p = true
32081                 default:
32082                         chk(fmt.Errorf("invalid bool: %d", n))
32083                 }
32084         }
32085 }
32086
32087 func (obj *AOBonePos) serialize(w io.Writer) {
32088         if err := pcall(func() {
32089                 ((*(*(struct {
32090                         Pos Vec
32091                         Rot [3]float32
32092                 }))(obj)).Pos).serialize(w)
32093         }); err != nil {
32094                 if err == io.EOF {
32095                         chk(io.EOF)
32096                 }
32097                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
32098         }
32099         for local355 := range (*(*(struct {
32100                 Pos Vec
32101                 Rot [3]float32
32102         }))(obj)).Rot {
32103                 {
32104                         x := ((*(*(struct {
32105                                 Pos Vec
32106                                 Rot [3]float32
32107                         }))(obj)).Rot)[local355]
32108                         write32(w, math.Float32bits(x))
32109                 }
32110         }
32111 }
32112
32113 func (obj *AOBonePos) deserialize(r io.Reader) {
32114         if err := pcall(func() {
32115                 ((*(*(struct {
32116                         Pos Vec
32117                         Rot [3]float32
32118                 }))(obj)).Pos).deserialize(r)
32119         }); err != nil {
32120                 if err == io.EOF {
32121                         chk(io.EOF)
32122                 }
32123                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
32124         }
32125         for local356 := range (*(*(struct {
32126                 Pos Vec
32127                 Rot [3]float32
32128         }))(obj)).Rot {
32129                 {
32130                         p := &((*(*(struct {
32131                                 Pos Vec
32132                                 Rot [3]float32
32133                         }))(obj)).Rot)[local356]
32134                         *p = math.Float32frombits(read32(r))
32135                 }
32136         }
32137 }
32138
32139 func (obj *AOAttach) serialize(w io.Writer) {
32140         if err := pcall(func() {
32141                 ((*(*(struct {
32142                         ParentID     AOID
32143                         Bone         string
32144                         Pos          Vec
32145                         Rot          [3]float32
32146                         ForceVisible bool
32147                 }))(obj)).ParentID).serialize(w)
32148         }); err != nil {
32149                 if err == io.EOF {
32150                         chk(io.EOF)
32151                 }
32152                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
32153         }
32154         if len(([]byte((*(*(struct {
32155                 ParentID     AOID
32156                 Bone         string
32157                 Pos          Vec
32158                 Rot          [3]float32
32159                 ForceVisible bool
32160         }))(obj)).Bone))) > math.MaxUint16 {
32161                 chk(ErrTooLong)
32162         }
32163         {
32164                 x := uint16(len(([]byte((*(*(struct {
32165                         ParentID     AOID
32166                         Bone         string
32167                         Pos          Vec
32168                         Rot          [3]float32
32169                         ForceVisible bool
32170                 }))(obj)).Bone))))
32171                 write16(w, uint16(x))
32172         }
32173         {
32174                 _, err := w.Write(([]byte((*(*(struct {
32175                         ParentID     AOID
32176                         Bone         string
32177                         Pos          Vec
32178                         Rot          [3]float32
32179                         ForceVisible bool
32180                 }))(obj)).Bone))[:])
32181                 chk(err)
32182         }
32183         if err := pcall(func() {
32184                 ((*(*(struct {
32185                         ParentID     AOID
32186                         Bone         string
32187                         Pos          Vec
32188                         Rot          [3]float32
32189                         ForceVisible bool
32190                 }))(obj)).Pos).serialize(w)
32191         }); err != nil {
32192                 if err == io.EOF {
32193                         chk(io.EOF)
32194                 }
32195                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
32196         }
32197         for local357 := range (*(*(struct {
32198                 ParentID     AOID
32199                 Bone         string
32200                 Pos          Vec
32201                 Rot          [3]float32
32202                 ForceVisible bool
32203         }))(obj)).Rot {
32204                 {
32205                         x := ((*(*(struct {
32206                                 ParentID     AOID
32207                                 Bone         string
32208                                 Pos          Vec
32209                                 Rot          [3]float32
32210                                 ForceVisible bool
32211                         }))(obj)).Rot)[local357]
32212                         write32(w, math.Float32bits(x))
32213                 }
32214         }
32215         {
32216                 x := (*(*(struct {
32217                         ParentID     AOID
32218                         Bone         string
32219                         Pos          Vec
32220                         Rot          [3]float32
32221                         ForceVisible bool
32222                 }))(obj)).ForceVisible
32223                 if x {
32224                         write8(w, 1)
32225                 } else {
32226                         write8(w, 0)
32227                 }
32228         }
32229 }
32230
32231 func (obj *AOAttach) deserialize(r io.Reader) {
32232         if err := pcall(func() {
32233                 ((*(*(struct {
32234                         ParentID     AOID
32235                         Bone         string
32236                         Pos          Vec
32237                         Rot          [3]float32
32238                         ForceVisible bool
32239                 }))(obj)).ParentID).deserialize(r)
32240         }); err != nil {
32241                 if err == io.EOF {
32242                         chk(io.EOF)
32243                 }
32244                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
32245         }
32246         var local358 []uint8
32247         var local359 uint16
32248         {
32249                 p := &local359
32250                 *p = read16(r)
32251         }
32252         (local358) = make([]uint8, local359)
32253         {
32254                 _, err := io.ReadFull(r, (local358)[:])
32255                 chk(err)
32256         }
32257         ((*(*(struct {
32258                 ParentID     AOID
32259                 Bone         string
32260                 Pos          Vec
32261                 Rot          [3]float32
32262                 ForceVisible bool
32263         }))(obj)).Bone) = string(local358)
32264         if err := pcall(func() {
32265                 ((*(*(struct {
32266                         ParentID     AOID
32267                         Bone         string
32268                         Pos          Vec
32269                         Rot          [3]float32
32270                         ForceVisible bool
32271                 }))(obj)).Pos).deserialize(r)
32272         }); err != nil {
32273                 if err == io.EOF {
32274                         chk(io.EOF)
32275                 }
32276                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
32277         }
32278         for local360 := range (*(*(struct {
32279                 ParentID     AOID
32280                 Bone         string
32281                 Pos          Vec
32282                 Rot          [3]float32
32283                 ForceVisible bool
32284         }))(obj)).Rot {
32285                 {
32286                         p := &((*(*(struct {
32287                                 ParentID     AOID
32288                                 Bone         string
32289                                 Pos          Vec
32290                                 Rot          [3]float32
32291                                 ForceVisible bool
32292                         }))(obj)).Rot)[local360]
32293                         *p = math.Float32frombits(read32(r))
32294                 }
32295         }
32296         {
32297                 p := &(*(*(struct {
32298                         ParentID     AOID
32299                         Bone         string
32300                         Pos          Vec
32301                         Rot          [3]float32
32302                         ForceVisible bool
32303                 }))(obj)).ForceVisible
32304                 switch n := read8(r); n {
32305                 case 0:
32306                         *p = false
32307                 case 1:
32308                         *p = true
32309                 default:
32310                         chk(fmt.Errorf("invalid bool: %d", n))
32311                 }
32312         }
32313 }
32314
32315 func (obj *AOPhysOverride) serialize(w io.Writer) {
32316         {
32317                 x := (*(*(struct {
32318                         Walk, Jump, Gravity float32
32319
32320                         // Player only.
32321                         NoSneak, NoSneakGlitch, OldSneak bool
32322                 }))(obj)).Walk
32323                 write32(w, math.Float32bits(x))
32324         }
32325         {
32326                 x := (*(*(struct {
32327                         Walk, Jump, Gravity float32
32328
32329                         // Player only.
32330                         NoSneak, NoSneakGlitch, OldSneak bool
32331                 }))(obj)).Jump
32332                 write32(w, math.Float32bits(x))
32333         }
32334         {
32335                 x := (*(*(struct {
32336                         Walk, Jump, Gravity float32
32337
32338                         // Player only.
32339                         NoSneak, NoSneakGlitch, OldSneak bool
32340                 }))(obj)).Gravity
32341                 write32(w, math.Float32bits(x))
32342         }
32343         {
32344                 x := (*(*(struct {
32345                         Walk, Jump, Gravity float32
32346
32347                         // Player only.
32348                         NoSneak, NoSneakGlitch, OldSneak bool
32349                 }))(obj)).NoSneak
32350                 if x {
32351                         write8(w, 1)
32352                 } else {
32353                         write8(w, 0)
32354                 }
32355         }
32356         {
32357                 x := (*(*(struct {
32358                         Walk, Jump, Gravity float32
32359
32360                         // Player only.
32361                         NoSneak, NoSneakGlitch, OldSneak bool
32362                 }))(obj)).NoSneakGlitch
32363                 if x {
32364                         write8(w, 1)
32365                 } else {
32366                         write8(w, 0)
32367                 }
32368         }
32369         {
32370                 x := (*(*(struct {
32371                         Walk, Jump, Gravity float32
32372
32373                         // Player only.
32374                         NoSneak, NoSneakGlitch, OldSneak bool
32375                 }))(obj)).OldSneak
32376                 if x {
32377                         write8(w, 1)
32378                 } else {
32379                         write8(w, 0)
32380                 }
32381         }
32382 }
32383
32384 func (obj *AOPhysOverride) deserialize(r io.Reader) {
32385         {
32386                 p := &(*(*(struct {
32387                         Walk, Jump, Gravity float32
32388
32389                         // Player only.
32390                         NoSneak, NoSneakGlitch, OldSneak bool
32391                 }))(obj)).Walk
32392                 *p = math.Float32frombits(read32(r))
32393         }
32394         {
32395                 p := &(*(*(struct {
32396                         Walk, Jump, Gravity float32
32397
32398                         // Player only.
32399                         NoSneak, NoSneakGlitch, OldSneak bool
32400                 }))(obj)).Jump
32401                 *p = math.Float32frombits(read32(r))
32402         }
32403         {
32404                 p := &(*(*(struct {
32405                         Walk, Jump, Gravity float32
32406
32407                         // Player only.
32408                         NoSneak, NoSneakGlitch, OldSneak bool
32409                 }))(obj)).Gravity
32410                 *p = math.Float32frombits(read32(r))
32411         }
32412         {
32413                 p := &(*(*(struct {
32414                         Walk, Jump, Gravity float32
32415
32416                         // Player only.
32417                         NoSneak, NoSneakGlitch, OldSneak bool
32418                 }))(obj)).NoSneak
32419                 switch n := read8(r); n {
32420                 case 0:
32421                         *p = false
32422                 case 1:
32423                         *p = true
32424                 default:
32425                         chk(fmt.Errorf("invalid bool: %d", n))
32426                 }
32427         }
32428         {
32429                 p := &(*(*(struct {
32430                         Walk, Jump, Gravity float32
32431
32432                         // Player only.
32433                         NoSneak, NoSneakGlitch, OldSneak bool
32434                 }))(obj)).NoSneakGlitch
32435                 switch n := read8(r); n {
32436                 case 0:
32437                         *p = false
32438                 case 1:
32439                         *p = true
32440                 default:
32441                         chk(fmt.Errorf("invalid bool: %d", n))
32442                 }
32443         }
32444         {
32445                 p := &(*(*(struct {
32446                         Walk, Jump, Gravity float32
32447
32448                         // Player only.
32449                         NoSneak, NoSneakGlitch, OldSneak bool
32450                 }))(obj)).OldSneak
32451                 switch n := read8(r); n {
32452                 case 0:
32453                         *p = false
32454                 case 1:
32455                         *p = true
32456                 default:
32457                         chk(fmt.Errorf("invalid bool: %d", n))
32458                 }
32459         }
32460 }
32461
32462 func (obj *NodeMetaField) serialize(w io.Writer) {
32463         if err := pcall(func() {
32464                 ((*(*(struct {
32465                         Field
32466                         Private bool
32467                 }))(obj)).Field).serialize(w)
32468         }); err != nil {
32469                 if err == io.EOF {
32470                         chk(io.EOF)
32471                 }
32472                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
32473         }
32474         {
32475                 x := (*(*(struct {
32476                         Field
32477                         Private bool
32478                 }))(obj)).Private
32479                 if x {
32480                         write8(w, 1)
32481                 } else {
32482                         write8(w, 0)
32483                 }
32484         }
32485 }
32486
32487 func (obj *NodeMetaField) deserialize(r io.Reader) {
32488         if err := pcall(func() {
32489                 ((*(*(struct {
32490                         Field
32491                         Private bool
32492                 }))(obj)).Field).deserialize(r)
32493         }); err != nil {
32494                 if err == io.EOF {
32495                         chk(io.EOF)
32496                 }
32497                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
32498         }
32499         {
32500                 p := &(*(*(struct {
32501                         Field
32502                         Private bool
32503                 }))(obj)).Private
32504                 switch n := read8(r); n {
32505                 case 0:
32506                         *p = false
32507                 case 1:
32508                         *p = true
32509                 default:
32510                         chk(fmt.Errorf("invalid bool: %d", n))
32511                 }
32512         }
32513 }
32514
32515 func (obj *MinimapType) serialize(w io.Writer) {
32516         {
32517                 x := *(*(uint16))(obj)
32518                 write16(w, uint16(x))
32519         }
32520 }
32521
32522 func (obj *MinimapType) deserialize(r io.Reader) {
32523         {
32524                 p := &*(*(uint16))(obj)
32525                 *p = read16(r)
32526         }
32527 }
32528
32529 func (obj *Param1Type) serialize(w io.Writer) {
32530         {
32531                 x := *(*(uint8))(obj)
32532                 write8(w, uint8(x))
32533         }
32534 }
32535
32536 func (obj *Param1Type) deserialize(r io.Reader) {
32537         {
32538                 p := &*(*(uint8))(obj)
32539                 *p = read8(r)
32540         }
32541 }
32542
32543 func (obj *Param2Type) serialize(w io.Writer) {
32544         {
32545                 x := *(*(uint8))(obj)
32546                 write8(w, uint8(x))
32547         }
32548 }
32549
32550 func (obj *Param2Type) deserialize(r io.Reader) {
32551         {
32552                 p := &*(*(uint8))(obj)
32553                 *p = read8(r)
32554         }
32555 }
32556
32557 func (obj *DrawType) serialize(w io.Writer) {
32558         {
32559                 x := *(*(uint8))(obj)
32560                 write8(w, uint8(x))
32561         }
32562 }
32563
32564 func (obj *DrawType) deserialize(r io.Reader) {
32565         {
32566                 p := &*(*(uint8))(obj)
32567                 *p = read8(r)
32568         }
32569 }
32570
32571 func (obj *TileDef) serialize(w io.Writer) {
32572         {
32573                 local361 := uint8(6)
32574                 {
32575                         x := local361
32576                         write8(w, uint8(x))
32577                 }
32578         }
32579         if err := pcall(func() {
32580                 ((*(*(struct {
32581                         Texture
32582                         Anim  TileAnim
32583                         Flags TileFlags
32584
32585                         //mt:if %s.Flags&TileColor != 0
32586                         R, G, B uint8
32587
32588                         //mt:if %s.Flags&TileScale != 0
32589                         Scale uint8
32590
32591                         //mt:if %s.Flags&TileAlign != 0
32592                         Align AlignType
32593                 }))(obj)).Texture).serialize(w)
32594         }); err != nil {
32595                 if err == io.EOF {
32596                         chk(io.EOF)
32597                 }
32598                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
32599         }
32600         if err := pcall(func() {
32601                 ((*(*(struct {
32602                         Texture
32603                         Anim  TileAnim
32604                         Flags TileFlags
32605
32606                         //mt:if %s.Flags&TileColor != 0
32607                         R, G, B uint8
32608
32609                         //mt:if %s.Flags&TileScale != 0
32610                         Scale uint8
32611
32612                         //mt:if %s.Flags&TileAlign != 0
32613                         Align AlignType
32614                 }))(obj)).Anim).serialize(w)
32615         }); err != nil {
32616                 if err == io.EOF {
32617                         chk(io.EOF)
32618                 }
32619                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32620         }
32621         if err := pcall(func() {
32622                 ((*(*(struct {
32623                         Texture
32624                         Anim  TileAnim
32625                         Flags TileFlags
32626
32627                         //mt:if %s.Flags&TileColor != 0
32628                         R, G, B uint8
32629
32630                         //mt:if %s.Flags&TileScale != 0
32631                         Scale uint8
32632
32633                         //mt:if %s.Flags&TileAlign != 0
32634                         Align AlignType
32635                 }))(obj)).Flags).serialize(w)
32636         }); err != nil {
32637                 if err == io.EOF {
32638                         chk(io.EOF)
32639                 }
32640                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32641         }
32642         if (*(*(struct {
32643                 Texture
32644                 Anim  TileAnim
32645                 Flags TileFlags
32646
32647                 //mt:if %s.Flags&TileColor != 0
32648                 R, G, B uint8
32649
32650                 //mt:if %s.Flags&TileScale != 0
32651                 Scale uint8
32652
32653                 //mt:if %s.Flags&TileAlign != 0
32654                 Align AlignType
32655         }))(obj)).Flags&TileColor != 0 {
32656                 {
32657                         x := (*(*(struct {
32658                                 Texture
32659                                 Anim  TileAnim
32660                                 Flags TileFlags
32661
32662                                 //mt:if %s.Flags&TileColor != 0
32663                                 R, G, B uint8
32664
32665                                 //mt:if %s.Flags&TileScale != 0
32666                                 Scale uint8
32667
32668                                 //mt:if %s.Flags&TileAlign != 0
32669                                 Align AlignType
32670                         }))(obj)).R
32671                         write8(w, uint8(x))
32672                 }
32673                 {
32674                         x := (*(*(struct {
32675                                 Texture
32676                                 Anim  TileAnim
32677                                 Flags TileFlags
32678
32679                                 //mt:if %s.Flags&TileColor != 0
32680                                 R, G, B uint8
32681
32682                                 //mt:if %s.Flags&TileScale != 0
32683                                 Scale uint8
32684
32685                                 //mt:if %s.Flags&TileAlign != 0
32686                                 Align AlignType
32687                         }))(obj)).G
32688                         write8(w, uint8(x))
32689                 }
32690                 {
32691                         x := (*(*(struct {
32692                                 Texture
32693                                 Anim  TileAnim
32694                                 Flags TileFlags
32695
32696                                 //mt:if %s.Flags&TileColor != 0
32697                                 R, G, B uint8
32698
32699                                 //mt:if %s.Flags&TileScale != 0
32700                                 Scale uint8
32701
32702                                 //mt:if %s.Flags&TileAlign != 0
32703                                 Align AlignType
32704                         }))(obj)).B
32705                         write8(w, uint8(x))
32706                 }
32707         }
32708         if (*(*(struct {
32709                 Texture
32710                 Anim  TileAnim
32711                 Flags TileFlags
32712
32713                 //mt:if %s.Flags&TileColor != 0
32714                 R, G, B uint8
32715
32716                 //mt:if %s.Flags&TileScale != 0
32717                 Scale uint8
32718
32719                 //mt:if %s.Flags&TileAlign != 0
32720                 Align AlignType
32721         }))(obj)).Flags&TileScale != 0 {
32722                 {
32723                         x := (*(*(struct {
32724                                 Texture
32725                                 Anim  TileAnim
32726                                 Flags TileFlags
32727
32728                                 //mt:if %s.Flags&TileColor != 0
32729                                 R, G, B uint8
32730
32731                                 //mt:if %s.Flags&TileScale != 0
32732                                 Scale uint8
32733
32734                                 //mt:if %s.Flags&TileAlign != 0
32735                                 Align AlignType
32736                         }))(obj)).Scale
32737                         write8(w, uint8(x))
32738                 }
32739         }
32740         if (*(*(struct {
32741                 Texture
32742                 Anim  TileAnim
32743                 Flags TileFlags
32744
32745                 //mt:if %s.Flags&TileColor != 0
32746                 R, G, B uint8
32747
32748                 //mt:if %s.Flags&TileScale != 0
32749                 Scale uint8
32750
32751                 //mt:if %s.Flags&TileAlign != 0
32752                 Align AlignType
32753         }))(obj)).Flags&TileAlign != 0 {
32754                 if err := pcall(func() {
32755                         ((*(*(struct {
32756                                 Texture
32757                                 Anim  TileAnim
32758                                 Flags TileFlags
32759
32760                                 //mt:if %s.Flags&TileColor != 0
32761                                 R, G, B uint8
32762
32763                                 //mt:if %s.Flags&TileScale != 0
32764                                 Scale uint8
32765
32766                                 //mt:if %s.Flags&TileAlign != 0
32767                                 Align AlignType
32768                         }))(obj)).Align).serialize(w)
32769                 }); err != nil {
32770                         if err == io.EOF {
32771                                 chk(io.EOF)
32772                         }
32773                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32774                 }
32775         }
32776 }
32777
32778 func (obj *TileDef) deserialize(r io.Reader) {
32779         {
32780                 var local362 uint8
32781                 {
32782                         p := &local362
32783                         *p = read8(r)
32784                 }
32785                 if local362 != (6) {
32786                         chk(fmt.Errorf("const %v: %v", 6, local362))
32787                 }
32788         }
32789         if err := pcall(func() {
32790                 ((*(*(struct {
32791                         Texture
32792                         Anim  TileAnim
32793                         Flags TileFlags
32794
32795                         //mt:if %s.Flags&TileColor != 0
32796                         R, G, B uint8
32797
32798                         //mt:if %s.Flags&TileScale != 0
32799                         Scale uint8
32800
32801                         //mt:if %s.Flags&TileAlign != 0
32802                         Align AlignType
32803                 }))(obj)).Texture).deserialize(r)
32804         }); err != nil {
32805                 if err == io.EOF {
32806                         chk(io.EOF)
32807                 }
32808                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
32809         }
32810         if err := pcall(func() {
32811                 ((*(*(struct {
32812                         Texture
32813                         Anim  TileAnim
32814                         Flags TileFlags
32815
32816                         //mt:if %s.Flags&TileColor != 0
32817                         R, G, B uint8
32818
32819                         //mt:if %s.Flags&TileScale != 0
32820                         Scale uint8
32821
32822                         //mt:if %s.Flags&TileAlign != 0
32823                         Align AlignType
32824                 }))(obj)).Anim).deserialize(r)
32825         }); err != nil {
32826                 if err == io.EOF {
32827                         chk(io.EOF)
32828                 }
32829                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32830         }
32831         if err := pcall(func() {
32832                 ((*(*(struct {
32833                         Texture
32834                         Anim  TileAnim
32835                         Flags TileFlags
32836
32837                         //mt:if %s.Flags&TileColor != 0
32838                         R, G, B uint8
32839
32840                         //mt:if %s.Flags&TileScale != 0
32841                         Scale uint8
32842
32843                         //mt:if %s.Flags&TileAlign != 0
32844                         Align AlignType
32845                 }))(obj)).Flags).deserialize(r)
32846         }); err != nil {
32847                 if err == io.EOF {
32848                         chk(io.EOF)
32849                 }
32850                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32851         }
32852         if (*(*(struct {
32853                 Texture
32854                 Anim  TileAnim
32855                 Flags TileFlags
32856
32857                 //mt:if %s.Flags&TileColor != 0
32858                 R, G, B uint8
32859
32860                 //mt:if %s.Flags&TileScale != 0
32861                 Scale uint8
32862
32863                 //mt:if %s.Flags&TileAlign != 0
32864                 Align AlignType
32865         }))(obj)).Flags&TileColor != 0 {
32866                 {
32867                         p := &(*(*(struct {
32868                                 Texture
32869                                 Anim  TileAnim
32870                                 Flags TileFlags
32871
32872                                 //mt:if %s.Flags&TileColor != 0
32873                                 R, G, B uint8
32874
32875                                 //mt:if %s.Flags&TileScale != 0
32876                                 Scale uint8
32877
32878                                 //mt:if %s.Flags&TileAlign != 0
32879                                 Align AlignType
32880                         }))(obj)).R
32881                         *p = read8(r)
32882                 }
32883                 {
32884                         p := &(*(*(struct {
32885                                 Texture
32886                                 Anim  TileAnim
32887                                 Flags TileFlags
32888
32889                                 //mt:if %s.Flags&TileColor != 0
32890                                 R, G, B uint8
32891
32892                                 //mt:if %s.Flags&TileScale != 0
32893                                 Scale uint8
32894
32895                                 //mt:if %s.Flags&TileAlign != 0
32896                                 Align AlignType
32897                         }))(obj)).G
32898                         *p = read8(r)
32899                 }
32900                 {
32901                         p := &(*(*(struct {
32902                                 Texture
32903                                 Anim  TileAnim
32904                                 Flags TileFlags
32905
32906                                 //mt:if %s.Flags&TileColor != 0
32907                                 R, G, B uint8
32908
32909                                 //mt:if %s.Flags&TileScale != 0
32910                                 Scale uint8
32911
32912                                 //mt:if %s.Flags&TileAlign != 0
32913                                 Align AlignType
32914                         }))(obj)).B
32915                         *p = read8(r)
32916                 }
32917         }
32918         if (*(*(struct {
32919                 Texture
32920                 Anim  TileAnim
32921                 Flags TileFlags
32922
32923                 //mt:if %s.Flags&TileColor != 0
32924                 R, G, B uint8
32925
32926                 //mt:if %s.Flags&TileScale != 0
32927                 Scale uint8
32928
32929                 //mt:if %s.Flags&TileAlign != 0
32930                 Align AlignType
32931         }))(obj)).Flags&TileScale != 0 {
32932                 {
32933                         p := &(*(*(struct {
32934                                 Texture
32935                                 Anim  TileAnim
32936                                 Flags TileFlags
32937
32938                                 //mt:if %s.Flags&TileColor != 0
32939                                 R, G, B uint8
32940
32941                                 //mt:if %s.Flags&TileScale != 0
32942                                 Scale uint8
32943
32944                                 //mt:if %s.Flags&TileAlign != 0
32945                                 Align AlignType
32946                         }))(obj)).Scale
32947                         *p = read8(r)
32948                 }
32949         }
32950         if (*(*(struct {
32951                 Texture
32952                 Anim  TileAnim
32953                 Flags TileFlags
32954
32955                 //mt:if %s.Flags&TileColor != 0
32956                 R, G, B uint8
32957
32958                 //mt:if %s.Flags&TileScale != 0
32959                 Scale uint8
32960
32961                 //mt:if %s.Flags&TileAlign != 0
32962                 Align AlignType
32963         }))(obj)).Flags&TileAlign != 0 {
32964                 if err := pcall(func() {
32965                         ((*(*(struct {
32966                                 Texture
32967                                 Anim  TileAnim
32968                                 Flags TileFlags
32969
32970                                 //mt:if %s.Flags&TileColor != 0
32971                                 R, G, B uint8
32972
32973                                 //mt:if %s.Flags&TileScale != 0
32974                                 Scale uint8
32975
32976                                 //mt:if %s.Flags&TileAlign != 0
32977                                 Align AlignType
32978                         }))(obj)).Align).deserialize(r)
32979                 }); err != nil {
32980                         if err == io.EOF {
32981                                 chk(io.EOF)
32982                         }
32983                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32984                 }
32985         }
32986 }
32987
32988 func (obj *WaveType) serialize(w io.Writer) {
32989         {
32990                 x := *(*(uint8))(obj)
32991                 write8(w, uint8(x))
32992         }
32993 }
32994
32995 func (obj *WaveType) deserialize(r io.Reader) {
32996         {
32997                 p := &*(*(uint8))(obj)
32998                 *p = read8(r)
32999         }
33000 }
33001
33002 func (obj *LiquidType) serialize(w io.Writer) {
33003         {
33004                 x := *(*(uint8))(obj)
33005                 write8(w, uint8(x))
33006         }
33007 }
33008
33009 func (obj *LiquidType) deserialize(r io.Reader) {
33010         {
33011                 p := &*(*(uint8))(obj)
33012                 *p = read8(r)
33013         }
33014 }
33015
33016 func (obj *NodeBox) serialize(w io.Writer) {
33017         {
33018                 local363 := uint8(6)
33019                 {
33020                         x := local363
33021                         write8(w, uint8(x))
33022                 }
33023         }
33024         if err := pcall(func() {
33025                 ((*(*(struct {
33026                         Type NodeBoxType
33027
33028                         //mt:if %s.Type == MountedBox
33029                         WallTop, WallBot, WallSides Box
33030
33031                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33032                         Fixed []Box
33033
33034                         //mt:if %s.Type == ConnectedBox
33035                         ConnDirs, DiscoDirs  DirBoxes
33036                         DiscoAll, DiscoSides []Box
33037                 }))(obj)).Type).serialize(w)
33038         }); err != nil {
33039                 if err == io.EOF {
33040                         chk(io.EOF)
33041                 }
33042                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
33043         }
33044         if !((*(*(struct {
33045                 Type NodeBoxType
33046
33047                 //mt:if %s.Type == MountedBox
33048                 WallTop, WallBot, WallSides Box
33049
33050                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33051                 Fixed []Box
33052
33053                 //mt:if %s.Type == ConnectedBox
33054                 ConnDirs, DiscoDirs  DirBoxes
33055                 DiscoAll, DiscoSides []Box
33056         }))(obj)).Type < maxBox) {
33057                 chk(errors.New("assertion failed: %s.Type < maxBox"))
33058         }
33059         if (*(*(struct {
33060                 Type NodeBoxType
33061
33062                 //mt:if %s.Type == MountedBox
33063                 WallTop, WallBot, WallSides Box
33064
33065                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33066                 Fixed []Box
33067
33068                 //mt:if %s.Type == ConnectedBox
33069                 ConnDirs, DiscoDirs  DirBoxes
33070                 DiscoAll, DiscoSides []Box
33071         }))(obj)).Type == MountedBox {
33072                 if err := pcall(func() {
33073                         ((*(*(struct {
33074                                 Type NodeBoxType
33075
33076                                 //mt:if %s.Type == MountedBox
33077                                 WallTop, WallBot, WallSides Box
33078
33079                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33080                                 Fixed []Box
33081
33082                                 //mt:if %s.Type == ConnectedBox
33083                                 ConnDirs, DiscoDirs  DirBoxes
33084                                 DiscoAll, DiscoSides []Box
33085                         }))(obj)).WallTop).serialize(w)
33086                 }); err != nil {
33087                         if err == io.EOF {
33088                                 chk(io.EOF)
33089                         }
33090                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33091                 }
33092                 if err := pcall(func() {
33093                         ((*(*(struct {
33094                                 Type NodeBoxType
33095
33096                                 //mt:if %s.Type == MountedBox
33097                                 WallTop, WallBot, WallSides Box
33098
33099                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33100                                 Fixed []Box
33101
33102                                 //mt:if %s.Type == ConnectedBox
33103                                 ConnDirs, DiscoDirs  DirBoxes
33104                                 DiscoAll, DiscoSides []Box
33105                         }))(obj)).WallBot).serialize(w)
33106                 }); err != nil {
33107                         if err == io.EOF {
33108                                 chk(io.EOF)
33109                         }
33110                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33111                 }
33112                 if err := pcall(func() {
33113                         ((*(*(struct {
33114                                 Type NodeBoxType
33115
33116                                 //mt:if %s.Type == MountedBox
33117                                 WallTop, WallBot, WallSides Box
33118
33119                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33120                                 Fixed []Box
33121
33122                                 //mt:if %s.Type == ConnectedBox
33123                                 ConnDirs, DiscoDirs  DirBoxes
33124                                 DiscoAll, DiscoSides []Box
33125                         }))(obj)).WallSides).serialize(w)
33126                 }); err != nil {
33127                         if err == io.EOF {
33128                                 chk(io.EOF)
33129                         }
33130                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33131                 }
33132         }
33133         if t := (*(*(struct {
33134                 Type NodeBoxType
33135
33136                 //mt:if %s.Type == MountedBox
33137                 WallTop, WallBot, WallSides Box
33138
33139                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33140                 Fixed []Box
33141
33142                 //mt:if %s.Type == ConnectedBox
33143                 ConnDirs, DiscoDirs  DirBoxes
33144                 DiscoAll, DiscoSides []Box
33145         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
33146                 if len(((*(*(struct {
33147                         Type NodeBoxType
33148
33149                         //mt:if %s.Type == MountedBox
33150                         WallTop, WallBot, WallSides Box
33151
33152                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33153                         Fixed []Box
33154
33155                         //mt:if %s.Type == ConnectedBox
33156                         ConnDirs, DiscoDirs  DirBoxes
33157                         DiscoAll, DiscoSides []Box
33158                 }))(obj)).Fixed)) > math.MaxUint16 {
33159                         chk(ErrTooLong)
33160                 }
33161                 {
33162                         x := uint16(len(((*(*(struct {
33163                                 Type NodeBoxType
33164
33165                                 //mt:if %s.Type == MountedBox
33166                                 WallTop, WallBot, WallSides Box
33167
33168                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33169                                 Fixed []Box
33170
33171                                 //mt:if %s.Type == ConnectedBox
33172                                 ConnDirs, DiscoDirs  DirBoxes
33173                                 DiscoAll, DiscoSides []Box
33174                         }))(obj)).Fixed)))
33175                         write16(w, uint16(x))
33176                 }
33177                 for local364 := range (*(*(struct {
33178                         Type NodeBoxType
33179
33180                         //mt:if %s.Type == MountedBox
33181                         WallTop, WallBot, WallSides Box
33182
33183                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33184                         Fixed []Box
33185
33186                         //mt:if %s.Type == ConnectedBox
33187                         ConnDirs, DiscoDirs  DirBoxes
33188                         DiscoAll, DiscoSides []Box
33189                 }))(obj)).Fixed {
33190                         if err := pcall(func() {
33191                                 (((*(*(struct {
33192                                         Type NodeBoxType
33193
33194                                         //mt:if %s.Type == MountedBox
33195                                         WallTop, WallBot, WallSides Box
33196
33197                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33198                                         Fixed []Box
33199
33200                                         //mt:if %s.Type == ConnectedBox
33201                                         ConnDirs, DiscoDirs  DirBoxes
33202                                         DiscoAll, DiscoSides []Box
33203                                 }))(obj)).Fixed)[local364]).serialize(w)
33204                         }); err != nil {
33205                                 if err == io.EOF {
33206                                         chk(io.EOF)
33207                                 }
33208                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33209                         }
33210                 }
33211         }
33212         if (*(*(struct {
33213                 Type NodeBoxType
33214
33215                 //mt:if %s.Type == MountedBox
33216                 WallTop, WallBot, WallSides Box
33217
33218                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33219                 Fixed []Box
33220
33221                 //mt:if %s.Type == ConnectedBox
33222                 ConnDirs, DiscoDirs  DirBoxes
33223                 DiscoAll, DiscoSides []Box
33224         }))(obj)).Type == ConnectedBox {
33225                 if err := pcall(func() {
33226                         ((*(*(struct {
33227                                 Type NodeBoxType
33228
33229                                 //mt:if %s.Type == MountedBox
33230                                 WallTop, WallBot, WallSides Box
33231
33232                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33233                                 Fixed []Box
33234
33235                                 //mt:if %s.Type == ConnectedBox
33236                                 ConnDirs, DiscoDirs  DirBoxes
33237                                 DiscoAll, DiscoSides []Box
33238                         }))(obj)).ConnDirs).serialize(w)
33239                 }); err != nil {
33240                         if err == io.EOF {
33241                                 chk(io.EOF)
33242                         }
33243                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33244                 }
33245                 if err := pcall(func() {
33246                         ((*(*(struct {
33247                                 Type NodeBoxType
33248
33249                                 //mt:if %s.Type == MountedBox
33250                                 WallTop, WallBot, WallSides Box
33251
33252                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33253                                 Fixed []Box
33254
33255                                 //mt:if %s.Type == ConnectedBox
33256                                 ConnDirs, DiscoDirs  DirBoxes
33257                                 DiscoAll, DiscoSides []Box
33258                         }))(obj)).DiscoDirs).serialize(w)
33259                 }); err != nil {
33260                         if err == io.EOF {
33261                                 chk(io.EOF)
33262                         }
33263                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33264                 }
33265                 if len(((*(*(struct {
33266                         Type NodeBoxType
33267
33268                         //mt:if %s.Type == MountedBox
33269                         WallTop, WallBot, WallSides Box
33270
33271                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33272                         Fixed []Box
33273
33274                         //mt:if %s.Type == ConnectedBox
33275                         ConnDirs, DiscoDirs  DirBoxes
33276                         DiscoAll, DiscoSides []Box
33277                 }))(obj)).DiscoAll)) > math.MaxUint16 {
33278                         chk(ErrTooLong)
33279                 }
33280                 {
33281                         x := uint16(len(((*(*(struct {
33282                                 Type NodeBoxType
33283
33284                                 //mt:if %s.Type == MountedBox
33285                                 WallTop, WallBot, WallSides Box
33286
33287                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33288                                 Fixed []Box
33289
33290                                 //mt:if %s.Type == ConnectedBox
33291                                 ConnDirs, DiscoDirs  DirBoxes
33292                                 DiscoAll, DiscoSides []Box
33293                         }))(obj)).DiscoAll)))
33294                         write16(w, uint16(x))
33295                 }
33296                 for local365 := range (*(*(struct {
33297                         Type NodeBoxType
33298
33299                         //mt:if %s.Type == MountedBox
33300                         WallTop, WallBot, WallSides Box
33301
33302                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33303                         Fixed []Box
33304
33305                         //mt:if %s.Type == ConnectedBox
33306                         ConnDirs, DiscoDirs  DirBoxes
33307                         DiscoAll, DiscoSides []Box
33308                 }))(obj)).DiscoAll {
33309                         if err := pcall(func() {
33310                                 (((*(*(struct {
33311                                         Type NodeBoxType
33312
33313                                         //mt:if %s.Type == MountedBox
33314                                         WallTop, WallBot, WallSides Box
33315
33316                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33317                                         Fixed []Box
33318
33319                                         //mt:if %s.Type == ConnectedBox
33320                                         ConnDirs, DiscoDirs  DirBoxes
33321                                         DiscoAll, DiscoSides []Box
33322                                 }))(obj)).DiscoAll)[local365]).serialize(w)
33323                         }); err != nil {
33324                                 if err == io.EOF {
33325                                         chk(io.EOF)
33326                                 }
33327                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33328                         }
33329                 }
33330                 if len(((*(*(struct {
33331                         Type NodeBoxType
33332
33333                         //mt:if %s.Type == MountedBox
33334                         WallTop, WallBot, WallSides Box
33335
33336                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33337                         Fixed []Box
33338
33339                         //mt:if %s.Type == ConnectedBox
33340                         ConnDirs, DiscoDirs  DirBoxes
33341                         DiscoAll, DiscoSides []Box
33342                 }))(obj)).DiscoSides)) > math.MaxUint16 {
33343                         chk(ErrTooLong)
33344                 }
33345                 {
33346                         x := uint16(len(((*(*(struct {
33347                                 Type NodeBoxType
33348
33349                                 //mt:if %s.Type == MountedBox
33350                                 WallTop, WallBot, WallSides Box
33351
33352                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33353                                 Fixed []Box
33354
33355                                 //mt:if %s.Type == ConnectedBox
33356                                 ConnDirs, DiscoDirs  DirBoxes
33357                                 DiscoAll, DiscoSides []Box
33358                         }))(obj)).DiscoSides)))
33359                         write16(w, uint16(x))
33360                 }
33361                 for local366 := range (*(*(struct {
33362                         Type NodeBoxType
33363
33364                         //mt:if %s.Type == MountedBox
33365                         WallTop, WallBot, WallSides Box
33366
33367                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33368                         Fixed []Box
33369
33370                         //mt:if %s.Type == ConnectedBox
33371                         ConnDirs, DiscoDirs  DirBoxes
33372                         DiscoAll, DiscoSides []Box
33373                 }))(obj)).DiscoSides {
33374                         if err := pcall(func() {
33375                                 (((*(*(struct {
33376                                         Type NodeBoxType
33377
33378                                         //mt:if %s.Type == MountedBox
33379                                         WallTop, WallBot, WallSides Box
33380
33381                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33382                                         Fixed []Box
33383
33384                                         //mt:if %s.Type == ConnectedBox
33385                                         ConnDirs, DiscoDirs  DirBoxes
33386                                         DiscoAll, DiscoSides []Box
33387                                 }))(obj)).DiscoSides)[local366]).serialize(w)
33388                         }); err != nil {
33389                                 if err == io.EOF {
33390                                         chk(io.EOF)
33391                                 }
33392                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33393                         }
33394                 }
33395         }
33396 }
33397
33398 func (obj *NodeBox) deserialize(r io.Reader) {
33399         {
33400                 var local367 uint8
33401                 {
33402                         p := &local367
33403                         *p = read8(r)
33404                 }
33405                 if local367 != (6) {
33406                         chk(fmt.Errorf("const %v: %v", 6, local367))
33407                 }
33408         }
33409         if err := pcall(func() {
33410                 ((*(*(struct {
33411                         Type NodeBoxType
33412
33413                         //mt:if %s.Type == MountedBox
33414                         WallTop, WallBot, WallSides Box
33415
33416                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33417                         Fixed []Box
33418
33419                         //mt:if %s.Type == ConnectedBox
33420                         ConnDirs, DiscoDirs  DirBoxes
33421                         DiscoAll, DiscoSides []Box
33422                 }))(obj)).Type).deserialize(r)
33423         }); err != nil {
33424                 if err == io.EOF {
33425                         chk(io.EOF)
33426                 }
33427                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
33428         }
33429         if !((*(*(struct {
33430                 Type NodeBoxType
33431
33432                 //mt:if %s.Type == MountedBox
33433                 WallTop, WallBot, WallSides Box
33434
33435                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33436                 Fixed []Box
33437
33438                 //mt:if %s.Type == ConnectedBox
33439                 ConnDirs, DiscoDirs  DirBoxes
33440                 DiscoAll, DiscoSides []Box
33441         }))(obj)).Type < maxBox) {
33442                 chk(errors.New("assertion failed: %s.Type < maxBox"))
33443         }
33444         if (*(*(struct {
33445                 Type NodeBoxType
33446
33447                 //mt:if %s.Type == MountedBox
33448                 WallTop, WallBot, WallSides Box
33449
33450                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33451                 Fixed []Box
33452
33453                 //mt:if %s.Type == ConnectedBox
33454                 ConnDirs, DiscoDirs  DirBoxes
33455                 DiscoAll, DiscoSides []Box
33456         }))(obj)).Type == MountedBox {
33457                 if err := pcall(func() {
33458                         ((*(*(struct {
33459                                 Type NodeBoxType
33460
33461                                 //mt:if %s.Type == MountedBox
33462                                 WallTop, WallBot, WallSides Box
33463
33464                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33465                                 Fixed []Box
33466
33467                                 //mt:if %s.Type == ConnectedBox
33468                                 ConnDirs, DiscoDirs  DirBoxes
33469                                 DiscoAll, DiscoSides []Box
33470                         }))(obj)).WallTop).deserialize(r)
33471                 }); err != nil {
33472                         if err == io.EOF {
33473                                 chk(io.EOF)
33474                         }
33475                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33476                 }
33477                 if err := pcall(func() {
33478                         ((*(*(struct {
33479                                 Type NodeBoxType
33480
33481                                 //mt:if %s.Type == MountedBox
33482                                 WallTop, WallBot, WallSides Box
33483
33484                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33485                                 Fixed []Box
33486
33487                                 //mt:if %s.Type == ConnectedBox
33488                                 ConnDirs, DiscoDirs  DirBoxes
33489                                 DiscoAll, DiscoSides []Box
33490                         }))(obj)).WallBot).deserialize(r)
33491                 }); err != nil {
33492                         if err == io.EOF {
33493                                 chk(io.EOF)
33494                         }
33495                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33496                 }
33497                 if err := pcall(func() {
33498                         ((*(*(struct {
33499                                 Type NodeBoxType
33500
33501                                 //mt:if %s.Type == MountedBox
33502                                 WallTop, WallBot, WallSides Box
33503
33504                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33505                                 Fixed []Box
33506
33507                                 //mt:if %s.Type == ConnectedBox
33508                                 ConnDirs, DiscoDirs  DirBoxes
33509                                 DiscoAll, DiscoSides []Box
33510                         }))(obj)).WallSides).deserialize(r)
33511                 }); err != nil {
33512                         if err == io.EOF {
33513                                 chk(io.EOF)
33514                         }
33515                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33516                 }
33517         }
33518         if t := (*(*(struct {
33519                 Type NodeBoxType
33520
33521                 //mt:if %s.Type == MountedBox
33522                 WallTop, WallBot, WallSides Box
33523
33524                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33525                 Fixed []Box
33526
33527                 //mt:if %s.Type == ConnectedBox
33528                 ConnDirs, DiscoDirs  DirBoxes
33529                 DiscoAll, DiscoSides []Box
33530         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
33531                 var local368 uint16
33532                 {
33533                         p := &local368
33534                         *p = read16(r)
33535                 }
33536                 ((*(*(struct {
33537                         Type NodeBoxType
33538
33539                         //mt:if %s.Type == MountedBox
33540                         WallTop, WallBot, WallSides Box
33541
33542                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33543                         Fixed []Box
33544
33545                         //mt:if %s.Type == ConnectedBox
33546                         ConnDirs, DiscoDirs  DirBoxes
33547                         DiscoAll, DiscoSides []Box
33548                 }))(obj)).Fixed) = make([]Box, local368)
33549                 for local369 := range (*(*(struct {
33550                         Type NodeBoxType
33551
33552                         //mt:if %s.Type == MountedBox
33553                         WallTop, WallBot, WallSides Box
33554
33555                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33556                         Fixed []Box
33557
33558                         //mt:if %s.Type == ConnectedBox
33559                         ConnDirs, DiscoDirs  DirBoxes
33560                         DiscoAll, DiscoSides []Box
33561                 }))(obj)).Fixed {
33562                         if err := pcall(func() {
33563                                 (((*(*(struct {
33564                                         Type NodeBoxType
33565
33566                                         //mt:if %s.Type == MountedBox
33567                                         WallTop, WallBot, WallSides Box
33568
33569                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33570                                         Fixed []Box
33571
33572                                         //mt:if %s.Type == ConnectedBox
33573                                         ConnDirs, DiscoDirs  DirBoxes
33574                                         DiscoAll, DiscoSides []Box
33575                                 }))(obj)).Fixed)[local369]).deserialize(r)
33576                         }); err != nil {
33577                                 if err == io.EOF {
33578                                         chk(io.EOF)
33579                                 }
33580                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33581                         }
33582                 }
33583         }
33584         if (*(*(struct {
33585                 Type NodeBoxType
33586
33587                 //mt:if %s.Type == MountedBox
33588                 WallTop, WallBot, WallSides Box
33589
33590                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33591                 Fixed []Box
33592
33593                 //mt:if %s.Type == ConnectedBox
33594                 ConnDirs, DiscoDirs  DirBoxes
33595                 DiscoAll, DiscoSides []Box
33596         }))(obj)).Type == ConnectedBox {
33597                 if err := pcall(func() {
33598                         ((*(*(struct {
33599                                 Type NodeBoxType
33600
33601                                 //mt:if %s.Type == MountedBox
33602                                 WallTop, WallBot, WallSides Box
33603
33604                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33605                                 Fixed []Box
33606
33607                                 //mt:if %s.Type == ConnectedBox
33608                                 ConnDirs, DiscoDirs  DirBoxes
33609                                 DiscoAll, DiscoSides []Box
33610                         }))(obj)).ConnDirs).deserialize(r)
33611                 }); err != nil {
33612                         if err == io.EOF {
33613                                 chk(io.EOF)
33614                         }
33615                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33616                 }
33617                 if err := pcall(func() {
33618                         ((*(*(struct {
33619                                 Type NodeBoxType
33620
33621                                 //mt:if %s.Type == MountedBox
33622                                 WallTop, WallBot, WallSides Box
33623
33624                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33625                                 Fixed []Box
33626
33627                                 //mt:if %s.Type == ConnectedBox
33628                                 ConnDirs, DiscoDirs  DirBoxes
33629                                 DiscoAll, DiscoSides []Box
33630                         }))(obj)).DiscoDirs).deserialize(r)
33631                 }); err != nil {
33632                         if err == io.EOF {
33633                                 chk(io.EOF)
33634                         }
33635                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33636                 }
33637                 var local370 uint16
33638                 {
33639                         p := &local370
33640                         *p = read16(r)
33641                 }
33642                 ((*(*(struct {
33643                         Type NodeBoxType
33644
33645                         //mt:if %s.Type == MountedBox
33646                         WallTop, WallBot, WallSides Box
33647
33648                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33649                         Fixed []Box
33650
33651                         //mt:if %s.Type == ConnectedBox
33652                         ConnDirs, DiscoDirs  DirBoxes
33653                         DiscoAll, DiscoSides []Box
33654                 }))(obj)).DiscoAll) = make([]Box, local370)
33655                 for local371 := range (*(*(struct {
33656                         Type NodeBoxType
33657
33658                         //mt:if %s.Type == MountedBox
33659                         WallTop, WallBot, WallSides Box
33660
33661                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33662                         Fixed []Box
33663
33664                         //mt:if %s.Type == ConnectedBox
33665                         ConnDirs, DiscoDirs  DirBoxes
33666                         DiscoAll, DiscoSides []Box
33667                 }))(obj)).DiscoAll {
33668                         if err := pcall(func() {
33669                                 (((*(*(struct {
33670                                         Type NodeBoxType
33671
33672                                         //mt:if %s.Type == MountedBox
33673                                         WallTop, WallBot, WallSides Box
33674
33675                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33676                                         Fixed []Box
33677
33678                                         //mt:if %s.Type == ConnectedBox
33679                                         ConnDirs, DiscoDirs  DirBoxes
33680                                         DiscoAll, DiscoSides []Box
33681                                 }))(obj)).DiscoAll)[local371]).deserialize(r)
33682                         }); err != nil {
33683                                 if err == io.EOF {
33684                                         chk(io.EOF)
33685                                 }
33686                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33687                         }
33688                 }
33689                 var local372 uint16
33690                 {
33691                         p := &local372
33692                         *p = read16(r)
33693                 }
33694                 ((*(*(struct {
33695                         Type NodeBoxType
33696
33697                         //mt:if %s.Type == MountedBox
33698                         WallTop, WallBot, WallSides Box
33699
33700                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33701                         Fixed []Box
33702
33703                         //mt:if %s.Type == ConnectedBox
33704                         ConnDirs, DiscoDirs  DirBoxes
33705                         DiscoAll, DiscoSides []Box
33706                 }))(obj)).DiscoSides) = make([]Box, local372)
33707                 for local373 := range (*(*(struct {
33708                         Type NodeBoxType
33709
33710                         //mt:if %s.Type == MountedBox
33711                         WallTop, WallBot, WallSides Box
33712
33713                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33714                         Fixed []Box
33715
33716                         //mt:if %s.Type == ConnectedBox
33717                         ConnDirs, DiscoDirs  DirBoxes
33718                         DiscoAll, DiscoSides []Box
33719                 }))(obj)).DiscoSides {
33720                         if err := pcall(func() {
33721                                 (((*(*(struct {
33722                                         Type NodeBoxType
33723
33724                                         //mt:if %s.Type == MountedBox
33725                                         WallTop, WallBot, WallSides Box
33726
33727                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33728                                         Fixed []Box
33729
33730                                         //mt:if %s.Type == ConnectedBox
33731                                         ConnDirs, DiscoDirs  DirBoxes
33732                                         DiscoAll, DiscoSides []Box
33733                                 }))(obj)).DiscoSides)[local373]).deserialize(r)
33734                         }); err != nil {
33735                                 if err == io.EOF {
33736                                         chk(io.EOF)
33737                                 }
33738                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33739                         }
33740                 }
33741         }
33742 }
33743
33744 func (obj *SoundDef) serialize(w io.Writer) {
33745         if len(([]byte((*(*(struct {
33746                 Name              string
33747                 Gain, Pitch, Fade float32
33748         }))(obj)).Name))) > math.MaxUint16 {
33749                 chk(ErrTooLong)
33750         }
33751         {
33752                 x := uint16(len(([]byte((*(*(struct {
33753                         Name              string
33754                         Gain, Pitch, Fade float32
33755                 }))(obj)).Name))))
33756                 write16(w, uint16(x))
33757         }
33758         {
33759                 _, err := w.Write(([]byte((*(*(struct {
33760                         Name              string
33761                         Gain, Pitch, Fade float32
33762                 }))(obj)).Name))[:])
33763                 chk(err)
33764         }
33765         {
33766                 x := (*(*(struct {
33767                         Name              string
33768                         Gain, Pitch, Fade float32
33769                 }))(obj)).Gain
33770                 write32(w, math.Float32bits(x))
33771         }
33772         {
33773                 x := (*(*(struct {
33774                         Name              string
33775                         Gain, Pitch, Fade float32
33776                 }))(obj)).Pitch
33777                 write32(w, math.Float32bits(x))
33778         }
33779         {
33780                 x := (*(*(struct {
33781                         Name              string
33782                         Gain, Pitch, Fade float32
33783                 }))(obj)).Fade
33784                 write32(w, math.Float32bits(x))
33785         }
33786 }
33787
33788 func (obj *SoundDef) deserialize(r io.Reader) {
33789         var local374 []uint8
33790         var local375 uint16
33791         {
33792                 p := &local375
33793                 *p = read16(r)
33794         }
33795         (local374) = make([]uint8, local375)
33796         {
33797                 _, err := io.ReadFull(r, (local374)[:])
33798                 chk(err)
33799         }
33800         ((*(*(struct {
33801                 Name              string
33802                 Gain, Pitch, Fade float32
33803         }))(obj)).Name) = string(local374)
33804         {
33805                 p := &(*(*(struct {
33806                         Name              string
33807                         Gain, Pitch, Fade float32
33808                 }))(obj)).Gain
33809                 *p = math.Float32frombits(read32(r))
33810         }
33811         {
33812                 p := &(*(*(struct {
33813                         Name              string
33814                         Gain, Pitch, Fade float32
33815                 }))(obj)).Pitch
33816                 *p = math.Float32frombits(read32(r))
33817         }
33818         {
33819                 p := &(*(*(struct {
33820                         Name              string
33821                         Gain, Pitch, Fade float32
33822                 }))(obj)).Fade
33823                 *p = math.Float32frombits(read32(r))
33824         }
33825 }
33826
33827 func (obj *AlphaUse) serialize(w io.Writer) {
33828         {
33829                 x := *(*(uint8))(obj)
33830                 write8(w, uint8(x))
33831         }
33832 }
33833
33834 func (obj *AlphaUse) deserialize(r io.Reader) {
33835         {
33836                 p := &*(*(uint8))(obj)
33837                 *p = read8(r)
33838         }
33839 }
33840
33841 func (obj *Keys) serialize(w io.Writer) {
33842         {
33843                 x := *(*(uint32))(obj)
33844                 write32(w, uint32(x))
33845         }
33846 }
33847
33848 func (obj *Keys) deserialize(r io.Reader) {
33849         {
33850                 p := &*(*(uint32))(obj)
33851                 *p = read32(r)
33852         }
33853 }
33854
33855 func (obj *MapBlkFlags) serialize(w io.Writer) {
33856         {
33857                 x := *(*(uint8))(obj)
33858                 write8(w, uint8(x))
33859         }
33860 }
33861
33862 func (obj *MapBlkFlags) deserialize(r io.Reader) {
33863         {
33864                 p := &*(*(uint8))(obj)
33865                 *p = read8(r)
33866         }
33867 }
33868
33869 func (obj *LitFromBlks) serialize(w io.Writer) {
33870         {
33871                 x := *(*(uint16))(obj)
33872                 write16(w, uint16(x))
33873         }
33874 }
33875
33876 func (obj *LitFromBlks) deserialize(r io.Reader) {
33877         {
33878                 p := &*(*(uint16))(obj)
33879                 *p = read16(r)
33880         }
33881 }
33882
33883 func (obj *ItemType) serialize(w io.Writer) {
33884         {
33885                 x := *(*(uint8))(obj)
33886                 write8(w, uint8(x))
33887         }
33888 }
33889
33890 func (obj *ItemType) deserialize(r io.Reader) {
33891         {
33892                 p := &*(*(uint8))(obj)
33893                 *p = read8(r)
33894         }
33895 }
33896
33897 func (obj *ToolCaps) serialize(w io.Writer) {
33898         if _ = (*(*(struct {
33899                 //mt:if _ = %s; false
33900                 NonNil bool `json:"-"`
33901
33902                 AttackCooldown float32 `json:"full_punch_interval"`
33903                 MaxDropLvl     int16   `json:"max_drop_level"`
33904
33905                 //mt:len32
33906                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
33907
33908                 //mt:len32
33909                 DmgGroups []Group `json:"damage_groups"`
33910
33911                 AttackUses uint16 `json:"punch_attack_uses"`
33912         }))(obj)); false {
33913                 {
33914                         x := (*(*(struct {
33915                                 //mt:if _ = %s; false
33916                                 NonNil bool `json:"-"`
33917
33918                                 AttackCooldown float32 `json:"full_punch_interval"`
33919                                 MaxDropLvl     int16   `json:"max_drop_level"`
33920
33921                                 //mt:len32
33922                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
33923
33924                                 //mt:len32
33925                                 DmgGroups []Group `json:"damage_groups"`
33926
33927                                 AttackUses uint16 `json:"punch_attack_uses"`
33928                         }))(obj)).NonNil
33929                         if x {
33930                                 write8(w, 1)
33931                         } else {
33932                                 write8(w, 0)
33933                         }
33934                 }
33935         }
33936         {
33937                 ow := w
33938                 w := new(bytes.Buffer)
33939                 /*
33940                    if r.N > 0 { (*(*(struct {
33941                         //mt:if _ = %s; false
33942                         NonNil  bool    `json:"-"`
33943
33944                         AttackCooldown  float32 `json:"full_punch_interval"`
33945                         MaxDropLvl      int16   `json:"max_drop_level"`
33946
33947                         //mt:len32
33948                         GroupCaps       []ToolGroupCaps `json:"groupcaps"`
33949
33950                         //mt:len32
33951                         DmgGroups       []Group `json:"damage_groups"`
33952
33953                         AttackUses      uint16  `json:"punch_attack_uses"`
33954                    }))(obj)).NonNil = true}; /**/{
33955                         if (*(*(struct {
33956                                 //mt:if _ = %s; false
33957                                 NonNil bool `json:"-"`
33958
33959                                 AttackCooldown float32 `json:"full_punch_interval"`
33960                                 MaxDropLvl     int16   `json:"max_drop_level"`
33961
33962                                 //mt:len32
33963                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
33964
33965                                 //mt:len32
33966                                 DmgGroups []Group `json:"damage_groups"`
33967
33968                                 AttackUses uint16 `json:"punch_attack_uses"`
33969                         }))(obj)).NonNil {
33970                                 {
33971                                         local376 := uint8(5)
33972                                         {
33973                                                 x := local376
33974                                                 write8(w, uint8(x))
33975                                         }
33976                                 }
33977                                 {
33978                                         x := (*(*(struct {
33979                                                 //mt:if _ = %s; false
33980                                                 NonNil bool `json:"-"`
33981
33982                                                 AttackCooldown float32 `json:"full_punch_interval"`
33983                                                 MaxDropLvl     int16   `json:"max_drop_level"`
33984
33985                                                 //mt:len32
33986                                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
33987
33988                                                 //mt:len32
33989                                                 DmgGroups []Group `json:"damage_groups"`
33990
33991                                                 AttackUses uint16 `json:"punch_attack_uses"`
33992                                         }))(obj)).AttackCooldown
33993                                         write32(w, math.Float32bits(x))
33994                                 }
33995                                 {
33996                                         x := (*(*(struct {
33997                                                 //mt:if _ = %s; false
33998                                                 NonNil bool `json:"-"`
33999
34000                                                 AttackCooldown float32 `json:"full_punch_interval"`
34001                                                 MaxDropLvl     int16   `json:"max_drop_level"`
34002
34003                                                 //mt:len32
34004                                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34005
34006                                                 //mt:len32
34007                                                 DmgGroups []Group `json:"damage_groups"`
34008
34009                                                 AttackUses uint16 `json:"punch_attack_uses"`
34010                                         }))(obj)).MaxDropLvl
34011                                         write16(w, uint16(x))
34012                                 }
34013                                 if len(((*(*(struct {
34014                                         //mt:if _ = %s; false
34015                                         NonNil bool `json:"-"`
34016
34017                                         AttackCooldown float32 `json:"full_punch_interval"`
34018                                         MaxDropLvl     int16   `json:"max_drop_level"`
34019
34020                                         //mt:len32
34021                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34022
34023                                         //mt:len32
34024                                         DmgGroups []Group `json:"damage_groups"`
34025
34026                                         AttackUses uint16 `json:"punch_attack_uses"`
34027                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
34028                                         chk(ErrTooLong)
34029                                 }
34030                                 {
34031                                         x := uint32(len(((*(*(struct {
34032                                                 //mt:if _ = %s; false
34033                                                 NonNil bool `json:"-"`
34034
34035                                                 AttackCooldown float32 `json:"full_punch_interval"`
34036                                                 MaxDropLvl     int16   `json:"max_drop_level"`
34037
34038                                                 //mt:len32
34039                                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34040
34041                                                 //mt:len32
34042                                                 DmgGroups []Group `json:"damage_groups"`
34043
34044                                                 AttackUses uint16 `json:"punch_attack_uses"`
34045                                         }))(obj)).GroupCaps)))
34046                                         write32(w, uint32(x))
34047                                 }
34048                                 for local377 := range (*(*(struct {
34049                                         //mt:if _ = %s; false
34050                                         NonNil bool `json:"-"`
34051
34052                                         AttackCooldown float32 `json:"full_punch_interval"`
34053                                         MaxDropLvl     int16   `json:"max_drop_level"`
34054
34055                                         //mt:len32
34056                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34057
34058                                         //mt:len32
34059                                         DmgGroups []Group `json:"damage_groups"`
34060
34061                                         AttackUses uint16 `json:"punch_attack_uses"`
34062                                 }))(obj)).GroupCaps {
34063                                         if err := pcall(func() {
34064                                                 (((*(*(struct {
34065                                                         //mt:if _ = %s; false
34066                                                         NonNil bool `json:"-"`
34067
34068                                                         AttackCooldown float32 `json:"full_punch_interval"`
34069                                                         MaxDropLvl     int16   `json:"max_drop_level"`
34070
34071                                                         //mt:len32
34072                                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34073
34074                                                         //mt:len32
34075                                                         DmgGroups []Group `json:"damage_groups"`
34076
34077                                                         AttackUses uint16 `json:"punch_attack_uses"`
34078                                                 }))(obj)).GroupCaps)[local377]).serialize(w)
34079                                         }); err != nil {
34080                                                 if err == io.EOF {
34081                                                         chk(io.EOF)
34082                                                 }
34083                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCaps", err))
34084                                         }
34085                                 }
34086                                 if len(((*(*(struct {
34087                                         //mt:if _ = %s; false
34088                                         NonNil bool `json:"-"`
34089
34090                                         AttackCooldown float32 `json:"full_punch_interval"`
34091                                         MaxDropLvl     int16   `json:"max_drop_level"`
34092
34093                                         //mt:len32
34094                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34095
34096                                         //mt:len32
34097                                         DmgGroups []Group `json:"damage_groups"`
34098
34099                                         AttackUses uint16 `json:"punch_attack_uses"`
34100                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
34101                                         chk(ErrTooLong)
34102                                 }
34103                                 {
34104                                         x := uint32(len(((*(*(struct {
34105                                                 //mt:if _ = %s; false
34106                                                 NonNil bool `json:"-"`
34107
34108                                                 AttackCooldown float32 `json:"full_punch_interval"`
34109                                                 MaxDropLvl     int16   `json:"max_drop_level"`
34110
34111                                                 //mt:len32
34112                                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34113
34114                                                 //mt:len32
34115                                                 DmgGroups []Group `json:"damage_groups"`
34116
34117                                                 AttackUses uint16 `json:"punch_attack_uses"`
34118                                         }))(obj)).DmgGroups)))
34119                                         write32(w, uint32(x))
34120                                 }
34121                                 for local378 := range (*(*(struct {
34122                                         //mt:if _ = %s; false
34123                                         NonNil bool `json:"-"`
34124
34125                                         AttackCooldown float32 `json:"full_punch_interval"`
34126                                         MaxDropLvl     int16   `json:"max_drop_level"`
34127
34128                                         //mt:len32
34129                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34130
34131                                         //mt:len32
34132                                         DmgGroups []Group `json:"damage_groups"`
34133
34134                                         AttackUses uint16 `json:"punch_attack_uses"`
34135                                 }))(obj)).DmgGroups {
34136                                         if err := pcall(func() {
34137                                                 (((*(*(struct {
34138                                                         //mt:if _ = %s; false
34139                                                         NonNil bool `json:"-"`
34140
34141                                                         AttackCooldown float32 `json:"full_punch_interval"`
34142                                                         MaxDropLvl     int16   `json:"max_drop_level"`
34143
34144                                                         //mt:len32
34145                                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34146
34147                                                         //mt:len32
34148                                                         DmgGroups []Group `json:"damage_groups"`
34149
34150                                                         AttackUses uint16 `json:"punch_attack_uses"`
34151                                                 }))(obj)).DmgGroups)[local378]).serialize(w)
34152                                         }); err != nil {
34153                                                 if err == io.EOF {
34154                                                         chk(io.EOF)
34155                                                 }
34156                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
34157                                         }
34158                                 }
34159                                 {
34160                                         x := (*(*(struct {
34161                                                 //mt:if _ = %s; false
34162                                                 NonNil bool `json:"-"`
34163
34164                                                 AttackCooldown float32 `json:"full_punch_interval"`
34165                                                 MaxDropLvl     int16   `json:"max_drop_level"`
34166
34167                                                 //mt:len32
34168                                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34169
34170                                                 //mt:len32
34171                                                 DmgGroups []Group `json:"damage_groups"`
34172
34173                                                 AttackUses uint16 `json:"punch_attack_uses"`
34174                                         }))(obj)).AttackUses
34175                                         write16(w, uint16(x))
34176                                 }
34177                         }
34178                 }
34179                 {
34180                         buf := w
34181                         w := ow
34182                         if len((buf.Bytes())) > math.MaxUint16 {
34183                                 chk(ErrTooLong)
34184                         }
34185                         {
34186                                 x := uint16(len((buf.Bytes())))
34187                                 write16(w, uint16(x))
34188                         }
34189                         {
34190                                 _, err := w.Write((buf.Bytes())[:])
34191                                 chk(err)
34192                         }
34193                 }
34194         }
34195 }
34196
34197 func (obj *ToolCaps) deserialize(r io.Reader) {
34198         if _ = (*(*(struct {
34199                 //mt:if _ = %s; false
34200                 NonNil bool `json:"-"`
34201
34202                 AttackCooldown float32 `json:"full_punch_interval"`
34203                 MaxDropLvl     int16   `json:"max_drop_level"`
34204
34205                 //mt:len32
34206                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34207
34208                 //mt:len32
34209                 DmgGroups []Group `json:"damage_groups"`
34210
34211                 AttackUses uint16 `json:"punch_attack_uses"`
34212         }))(obj)); false {
34213                 {
34214                         p := &(*(*(struct {
34215                                 //mt:if _ = %s; false
34216                                 NonNil bool `json:"-"`
34217
34218                                 AttackCooldown float32 `json:"full_punch_interval"`
34219                                 MaxDropLvl     int16   `json:"max_drop_level"`
34220
34221                                 //mt:len32
34222                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34223
34224                                 //mt:len32
34225                                 DmgGroups []Group `json:"damage_groups"`
34226
34227                                 AttackUses uint16 `json:"punch_attack_uses"`
34228                         }))(obj)).NonNil
34229                         switch n := read8(r); n {
34230                         case 0:
34231                                 *p = false
34232                         case 1:
34233                                 *p = true
34234                         default:
34235                                 chk(fmt.Errorf("invalid bool: %d", n))
34236                         }
34237                 }
34238         }
34239         {
34240                 var n uint16
34241                 {
34242                         p := &n
34243                         *p = read16(r)
34244                 }
34245                 r := &io.LimitedReader{r, int64(n)}
34246                 if r.N > 0 {
34247                         (*(*(struct {
34248                                 //mt:if _ = %s; false
34249                                 NonNil bool `json:"-"`
34250
34251                                 AttackCooldown float32 `json:"full_punch_interval"`
34252                                 MaxDropLvl     int16   `json:"max_drop_level"`
34253
34254                                 //mt:len32
34255                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34256
34257                                 //mt:len32
34258                                 DmgGroups []Group `json:"damage_groups"`
34259
34260                                 AttackUses uint16 `json:"punch_attack_uses"`
34261                         }))(obj)).NonNil = true
34262                 } /**/
34263                 {
34264                         if (*(*(struct {
34265                                 //mt:if _ = %s; false
34266                                 NonNil bool `json:"-"`
34267
34268                                 AttackCooldown float32 `json:"full_punch_interval"`
34269                                 MaxDropLvl     int16   `json:"max_drop_level"`
34270
34271                                 //mt:len32
34272                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34273
34274                                 //mt:len32
34275                                 DmgGroups []Group `json:"damage_groups"`
34276
34277                                 AttackUses uint16 `json:"punch_attack_uses"`
34278                         }))(obj)).NonNil {
34279                                 {
34280                                         var local379 uint8
34281                                         {
34282                                                 p := &local379
34283                                                 *p = read8(r)
34284                                         }
34285                                         if local379 != (5) {
34286                                                 chk(fmt.Errorf("const %v: %v", 5, local379))
34287                                         }
34288                                 }
34289                                 {
34290                                         p := &(*(*(struct {
34291                                                 //mt:if _ = %s; false
34292                                                 NonNil bool `json:"-"`
34293
34294                                                 AttackCooldown float32 `json:"full_punch_interval"`
34295                                                 MaxDropLvl     int16   `json:"max_drop_level"`
34296
34297                                                 //mt:len32
34298                                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34299
34300                                                 //mt:len32
34301                                                 DmgGroups []Group `json:"damage_groups"`
34302
34303                                                 AttackUses uint16 `json:"punch_attack_uses"`
34304                                         }))(obj)).AttackCooldown
34305                                         *p = math.Float32frombits(read32(r))
34306                                 }
34307                                 {
34308                                         p := &(*(*(struct {
34309                                                 //mt:if _ = %s; false
34310                                                 NonNil bool `json:"-"`
34311
34312                                                 AttackCooldown float32 `json:"full_punch_interval"`
34313                                                 MaxDropLvl     int16   `json:"max_drop_level"`
34314
34315                                                 //mt:len32
34316                                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34317
34318                                                 //mt:len32
34319                                                 DmgGroups []Group `json:"damage_groups"`
34320
34321                                                 AttackUses uint16 `json:"punch_attack_uses"`
34322                                         }))(obj)).MaxDropLvl
34323                                         *p = int16(read16(r))
34324                                 }
34325                                 var local380 uint32
34326                                 {
34327                                         p := &local380
34328                                         *p = read32(r)
34329                                 }
34330                                 ((*(*(struct {
34331                                         //mt:if _ = %s; false
34332                                         NonNil bool `json:"-"`
34333
34334                                         AttackCooldown float32 `json:"full_punch_interval"`
34335                                         MaxDropLvl     int16   `json:"max_drop_level"`
34336
34337                                         //mt:len32
34338                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34339
34340                                         //mt:len32
34341                                         DmgGroups []Group `json:"damage_groups"`
34342
34343                                         AttackUses uint16 `json:"punch_attack_uses"`
34344                                 }))(obj)).GroupCaps) = make([]ToolGroupCaps, local380)
34345                                 for local381 := range (*(*(struct {
34346                                         //mt:if _ = %s; false
34347                                         NonNil bool `json:"-"`
34348
34349                                         AttackCooldown float32 `json:"full_punch_interval"`
34350                                         MaxDropLvl     int16   `json:"max_drop_level"`
34351
34352                                         //mt:len32
34353                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34354
34355                                         //mt:len32
34356                                         DmgGroups []Group `json:"damage_groups"`
34357
34358                                         AttackUses uint16 `json:"punch_attack_uses"`
34359                                 }))(obj)).GroupCaps {
34360                                         if err := pcall(func() {
34361                                                 (((*(*(struct {
34362                                                         //mt:if _ = %s; false
34363                                                         NonNil bool `json:"-"`
34364
34365                                                         AttackCooldown float32 `json:"full_punch_interval"`
34366                                                         MaxDropLvl     int16   `json:"max_drop_level"`
34367
34368                                                         //mt:len32
34369                                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34370
34371                                                         //mt:len32
34372                                                         DmgGroups []Group `json:"damage_groups"`
34373
34374                                                         AttackUses uint16 `json:"punch_attack_uses"`
34375                                                 }))(obj)).GroupCaps)[local381]).deserialize(r)
34376                                         }); err != nil {
34377                                                 if err == io.EOF {
34378                                                         chk(io.EOF)
34379                                                 }
34380                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCaps", err))
34381                                         }
34382                                 }
34383                                 var local382 uint32
34384                                 {
34385                                         p := &local382
34386                                         *p = read32(r)
34387                                 }
34388                                 ((*(*(struct {
34389                                         //mt:if _ = %s; false
34390                                         NonNil bool `json:"-"`
34391
34392                                         AttackCooldown float32 `json:"full_punch_interval"`
34393                                         MaxDropLvl     int16   `json:"max_drop_level"`
34394
34395                                         //mt:len32
34396                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34397
34398                                         //mt:len32
34399                                         DmgGroups []Group `json:"damage_groups"`
34400
34401                                         AttackUses uint16 `json:"punch_attack_uses"`
34402                                 }))(obj)).DmgGroups) = make([]Group, local382)
34403                                 for local383 := range (*(*(struct {
34404                                         //mt:if _ = %s; false
34405                                         NonNil bool `json:"-"`
34406
34407                                         AttackCooldown float32 `json:"full_punch_interval"`
34408                                         MaxDropLvl     int16   `json:"max_drop_level"`
34409
34410                                         //mt:len32
34411                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34412
34413                                         //mt:len32
34414                                         DmgGroups []Group `json:"damage_groups"`
34415
34416                                         AttackUses uint16 `json:"punch_attack_uses"`
34417                                 }))(obj)).DmgGroups {
34418                                         if err := pcall(func() {
34419                                                 (((*(*(struct {
34420                                                         //mt:if _ = %s; false
34421                                                         NonNil bool `json:"-"`
34422
34423                                                         AttackCooldown float32 `json:"full_punch_interval"`
34424                                                         MaxDropLvl     int16   `json:"max_drop_level"`
34425
34426                                                         //mt:len32
34427                                                         GroupCaps []ToolGroupCaps `json:"groupcaps"`
34428
34429                                                         //mt:len32
34430                                                         DmgGroups []Group `json:"damage_groups"`
34431
34432                                                         AttackUses uint16 `json:"punch_attack_uses"`
34433                                                 }))(obj)).DmgGroups)[local383]).deserialize(r)
34434                                         }); err != nil {
34435                                                 if err == io.EOF {
34436                                                         chk(io.EOF)
34437                                                 }
34438                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
34439                                         }
34440                                 }
34441                                 {
34442                                         p := &(*(*(struct {
34443                                                 //mt:if _ = %s; false
34444                                                 NonNil bool `json:"-"`
34445
34446                                                 AttackCooldown float32 `json:"full_punch_interval"`
34447                                                 MaxDropLvl     int16   `json:"max_drop_level"`
34448
34449                                                 //mt:len32
34450                                                 GroupCaps []ToolGroupCaps `json:"groupcaps"`
34451
34452                                                 //mt:len32
34453                                                 DmgGroups []Group `json:"damage_groups"`
34454
34455                                                 AttackUses uint16 `json:"punch_attack_uses"`
34456                                         }))(obj)).AttackUses
34457                                         *p = read16(r)
34458                                 }
34459                         }
34460                 }
34461                 if r.N > 0 {
34462                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34463                 }
34464         }
34465 }
34466
34467 func (obj *AnimType) serialize(w io.Writer) {
34468         {
34469                 x := *(*(uint8))(obj)
34470                 write8(w, uint8(x))
34471         }
34472 }
34473
34474 func (obj *AnimType) deserialize(r io.Reader) {
34475         {
34476                 p := &*(*(uint8))(obj)
34477                 *p = read8(r)
34478         }
34479 }
34480
34481 func (obj *Box) serialize(w io.Writer) {
34482         for local384 := range *(*([2]Vec))(obj) {
34483                 if err := pcall(func() {
34484                         ((*(*([2]Vec))(obj))[local384]).serialize(w)
34485                 }); err != nil {
34486                         if err == io.EOF {
34487                                 chk(io.EOF)
34488                         }
34489                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34490                 }
34491         }
34492 }
34493
34494 func (obj *Box) deserialize(r io.Reader) {
34495         for local385 := range *(*([2]Vec))(obj) {
34496                 if err := pcall(func() {
34497                         ((*(*([2]Vec))(obj))[local385]).deserialize(r)
34498                 }); err != nil {
34499                         if err == io.EOF {
34500                                 chk(io.EOF)
34501                         }
34502                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34503                 }
34504         }
34505 }
34506
34507 func (obj *TileFlags) serialize(w io.Writer) {
34508         {
34509                 x := *(*(uint16))(obj)
34510                 write16(w, uint16(x))
34511         }
34512 }
34513
34514 func (obj *TileFlags) deserialize(r io.Reader) {
34515         {
34516                 p := &*(*(uint16))(obj)
34517                 *p = read16(r)
34518         }
34519 }
34520
34521 func (obj *AlignType) serialize(w io.Writer) {
34522         {
34523                 x := *(*(uint8))(obj)
34524                 write8(w, uint8(x))
34525         }
34526 }
34527
34528 func (obj *AlignType) deserialize(r io.Reader) {
34529         {
34530                 p := &*(*(uint8))(obj)
34531                 *p = read8(r)
34532         }
34533 }
34534
34535 func (obj *NodeBoxType) serialize(w io.Writer) {
34536         {
34537                 x := *(*(uint8))(obj)
34538                 write8(w, uint8(x))
34539         }
34540 }
34541
34542 func (obj *NodeBoxType) deserialize(r io.Reader) {
34543         {
34544                 p := &*(*(uint8))(obj)
34545                 *p = read8(r)
34546         }
34547 }
34548
34549 func (obj *DirBoxes) serialize(w io.Writer) {
34550         if len(((*(*(struct {
34551                 Top, Bot                 []Box
34552                 Front, Left, Back, Right []Box
34553         }))(obj)).Top)) > math.MaxUint16 {
34554                 chk(ErrTooLong)
34555         }
34556         {
34557                 x := uint16(len(((*(*(struct {
34558                         Top, Bot                 []Box
34559                         Front, Left, Back, Right []Box
34560                 }))(obj)).Top)))
34561                 write16(w, uint16(x))
34562         }
34563         for local386 := range (*(*(struct {
34564                 Top, Bot                 []Box
34565                 Front, Left, Back, Right []Box
34566         }))(obj)).Top {
34567                 if err := pcall(func() {
34568                         (((*(*(struct {
34569                                 Top, Bot                 []Box
34570                                 Front, Left, Back, Right []Box
34571                         }))(obj)).Top)[local386]).serialize(w)
34572                 }); err != nil {
34573                         if err == io.EOF {
34574                                 chk(io.EOF)
34575                         }
34576                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34577                 }
34578         }
34579         if len(((*(*(struct {
34580                 Top, Bot                 []Box
34581                 Front, Left, Back, Right []Box
34582         }))(obj)).Bot)) > math.MaxUint16 {
34583                 chk(ErrTooLong)
34584         }
34585         {
34586                 x := uint16(len(((*(*(struct {
34587                         Top, Bot                 []Box
34588                         Front, Left, Back, Right []Box
34589                 }))(obj)).Bot)))
34590                 write16(w, uint16(x))
34591         }
34592         for local387 := range (*(*(struct {
34593                 Top, Bot                 []Box
34594                 Front, Left, Back, Right []Box
34595         }))(obj)).Bot {
34596                 if err := pcall(func() {
34597                         (((*(*(struct {
34598                                 Top, Bot                 []Box
34599                                 Front, Left, Back, Right []Box
34600                         }))(obj)).Bot)[local387]).serialize(w)
34601                 }); err != nil {
34602                         if err == io.EOF {
34603                                 chk(io.EOF)
34604                         }
34605                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34606                 }
34607         }
34608         if len(((*(*(struct {
34609                 Top, Bot                 []Box
34610                 Front, Left, Back, Right []Box
34611         }))(obj)).Front)) > math.MaxUint16 {
34612                 chk(ErrTooLong)
34613         }
34614         {
34615                 x := uint16(len(((*(*(struct {
34616                         Top, Bot                 []Box
34617                         Front, Left, Back, Right []Box
34618                 }))(obj)).Front)))
34619                 write16(w, uint16(x))
34620         }
34621         for local388 := range (*(*(struct {
34622                 Top, Bot                 []Box
34623                 Front, Left, Back, Right []Box
34624         }))(obj)).Front {
34625                 if err := pcall(func() {
34626                         (((*(*(struct {
34627                                 Top, Bot                 []Box
34628                                 Front, Left, Back, Right []Box
34629                         }))(obj)).Front)[local388]).serialize(w)
34630                 }); err != nil {
34631                         if err == io.EOF {
34632                                 chk(io.EOF)
34633                         }
34634                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34635                 }
34636         }
34637         if len(((*(*(struct {
34638                 Top, Bot                 []Box
34639                 Front, Left, Back, Right []Box
34640         }))(obj)).Left)) > math.MaxUint16 {
34641                 chk(ErrTooLong)
34642         }
34643         {
34644                 x := uint16(len(((*(*(struct {
34645                         Top, Bot                 []Box
34646                         Front, Left, Back, Right []Box
34647                 }))(obj)).Left)))
34648                 write16(w, uint16(x))
34649         }
34650         for local389 := range (*(*(struct {
34651                 Top, Bot                 []Box
34652                 Front, Left, Back, Right []Box
34653         }))(obj)).Left {
34654                 if err := pcall(func() {
34655                         (((*(*(struct {
34656                                 Top, Bot                 []Box
34657                                 Front, Left, Back, Right []Box
34658                         }))(obj)).Left)[local389]).serialize(w)
34659                 }); err != nil {
34660                         if err == io.EOF {
34661                                 chk(io.EOF)
34662                         }
34663                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34664                 }
34665         }
34666         if len(((*(*(struct {
34667                 Top, Bot                 []Box
34668                 Front, Left, Back, Right []Box
34669         }))(obj)).Back)) > math.MaxUint16 {
34670                 chk(ErrTooLong)
34671         }
34672         {
34673                 x := uint16(len(((*(*(struct {
34674                         Top, Bot                 []Box
34675                         Front, Left, Back, Right []Box
34676                 }))(obj)).Back)))
34677                 write16(w, uint16(x))
34678         }
34679         for local390 := range (*(*(struct {
34680                 Top, Bot                 []Box
34681                 Front, Left, Back, Right []Box
34682         }))(obj)).Back {
34683                 if err := pcall(func() {
34684                         (((*(*(struct {
34685                                 Top, Bot                 []Box
34686                                 Front, Left, Back, Right []Box
34687                         }))(obj)).Back)[local390]).serialize(w)
34688                 }); err != nil {
34689                         if err == io.EOF {
34690                                 chk(io.EOF)
34691                         }
34692                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34693                 }
34694         }
34695         if len(((*(*(struct {
34696                 Top, Bot                 []Box
34697                 Front, Left, Back, Right []Box
34698         }))(obj)).Right)) > math.MaxUint16 {
34699                 chk(ErrTooLong)
34700         }
34701         {
34702                 x := uint16(len(((*(*(struct {
34703                         Top, Bot                 []Box
34704                         Front, Left, Back, Right []Box
34705                 }))(obj)).Right)))
34706                 write16(w, uint16(x))
34707         }
34708         for local391 := range (*(*(struct {
34709                 Top, Bot                 []Box
34710                 Front, Left, Back, Right []Box
34711         }))(obj)).Right {
34712                 if err := pcall(func() {
34713                         (((*(*(struct {
34714                                 Top, Bot                 []Box
34715                                 Front, Left, Back, Right []Box
34716                         }))(obj)).Right)[local391]).serialize(w)
34717                 }); err != nil {
34718                         if err == io.EOF {
34719                                 chk(io.EOF)
34720                         }
34721                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34722                 }
34723         }
34724 }
34725
34726 func (obj *DirBoxes) deserialize(r io.Reader) {
34727         var local392 uint16
34728         {
34729                 p := &local392
34730                 *p = read16(r)
34731         }
34732         ((*(*(struct {
34733                 Top, Bot                 []Box
34734                 Front, Left, Back, Right []Box
34735         }))(obj)).Top) = make([]Box, local392)
34736         for local393 := range (*(*(struct {
34737                 Top, Bot                 []Box
34738                 Front, Left, Back, Right []Box
34739         }))(obj)).Top {
34740                 if err := pcall(func() {
34741                         (((*(*(struct {
34742                                 Top, Bot                 []Box
34743                                 Front, Left, Back, Right []Box
34744                         }))(obj)).Top)[local393]).deserialize(r)
34745                 }); err != nil {
34746                         if err == io.EOF {
34747                                 chk(io.EOF)
34748                         }
34749                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34750                 }
34751         }
34752         var local394 uint16
34753         {
34754                 p := &local394
34755                 *p = read16(r)
34756         }
34757         ((*(*(struct {
34758                 Top, Bot                 []Box
34759                 Front, Left, Back, Right []Box
34760         }))(obj)).Bot) = make([]Box, local394)
34761         for local395 := range (*(*(struct {
34762                 Top, Bot                 []Box
34763                 Front, Left, Back, Right []Box
34764         }))(obj)).Bot {
34765                 if err := pcall(func() {
34766                         (((*(*(struct {
34767                                 Top, Bot                 []Box
34768                                 Front, Left, Back, Right []Box
34769                         }))(obj)).Bot)[local395]).deserialize(r)
34770                 }); err != nil {
34771                         if err == io.EOF {
34772                                 chk(io.EOF)
34773                         }
34774                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34775                 }
34776         }
34777         var local396 uint16
34778         {
34779                 p := &local396
34780                 *p = read16(r)
34781         }
34782         ((*(*(struct {
34783                 Top, Bot                 []Box
34784                 Front, Left, Back, Right []Box
34785         }))(obj)).Front) = make([]Box, local396)
34786         for local397 := range (*(*(struct {
34787                 Top, Bot                 []Box
34788                 Front, Left, Back, Right []Box
34789         }))(obj)).Front {
34790                 if err := pcall(func() {
34791                         (((*(*(struct {
34792                                 Top, Bot                 []Box
34793                                 Front, Left, Back, Right []Box
34794                         }))(obj)).Front)[local397]).deserialize(r)
34795                 }); err != nil {
34796                         if err == io.EOF {
34797                                 chk(io.EOF)
34798                         }
34799                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34800                 }
34801         }
34802         var local398 uint16
34803         {
34804                 p := &local398
34805                 *p = read16(r)
34806         }
34807         ((*(*(struct {
34808                 Top, Bot                 []Box
34809                 Front, Left, Back, Right []Box
34810         }))(obj)).Left) = make([]Box, local398)
34811         for local399 := range (*(*(struct {
34812                 Top, Bot                 []Box
34813                 Front, Left, Back, Right []Box
34814         }))(obj)).Left {
34815                 if err := pcall(func() {
34816                         (((*(*(struct {
34817                                 Top, Bot                 []Box
34818                                 Front, Left, Back, Right []Box
34819                         }))(obj)).Left)[local399]).deserialize(r)
34820                 }); err != nil {
34821                         if err == io.EOF {
34822                                 chk(io.EOF)
34823                         }
34824                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34825                 }
34826         }
34827         var local400 uint16
34828         {
34829                 p := &local400
34830                 *p = read16(r)
34831         }
34832         ((*(*(struct {
34833                 Top, Bot                 []Box
34834                 Front, Left, Back, Right []Box
34835         }))(obj)).Back) = make([]Box, local400)
34836         for local401 := range (*(*(struct {
34837                 Top, Bot                 []Box
34838                 Front, Left, Back, Right []Box
34839         }))(obj)).Back {
34840                 if err := pcall(func() {
34841                         (((*(*(struct {
34842                                 Top, Bot                 []Box
34843                                 Front, Left, Back, Right []Box
34844                         }))(obj)).Back)[local401]).deserialize(r)
34845                 }); err != nil {
34846                         if err == io.EOF {
34847                                 chk(io.EOF)
34848                         }
34849                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34850                 }
34851         }
34852         var local402 uint16
34853         {
34854                 p := &local402
34855                 *p = read16(r)
34856         }
34857         ((*(*(struct {
34858                 Top, Bot                 []Box
34859                 Front, Left, Back, Right []Box
34860         }))(obj)).Right) = make([]Box, local402)
34861         for local403 := range (*(*(struct {
34862                 Top, Bot                 []Box
34863                 Front, Left, Back, Right []Box
34864         }))(obj)).Right {
34865                 if err := pcall(func() {
34866                         (((*(*(struct {
34867                                 Top, Bot                 []Box
34868                                 Front, Left, Back, Right []Box
34869                         }))(obj)).Right)[local403]).deserialize(r)
34870                 }); err != nil {
34871                         if err == io.EOF {
34872                                 chk(io.EOF)
34873                         }
34874                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34875                 }
34876         }
34877 }
34878
34879 func (obj *ToolGroupCaps) serialize(w io.Writer) {
34880         if len(([]byte((*(*(struct {
34881                 Name   string
34882                 Uses   int16
34883                 MaxLvl int16
34884
34885                 //mt:len32
34886                 Times []DigTime
34887         }))(obj)).Name))) > math.MaxUint16 {
34888                 chk(ErrTooLong)
34889         }
34890         {
34891                 x := uint16(len(([]byte((*(*(struct {
34892                         Name   string
34893                         Uses   int16
34894                         MaxLvl int16
34895
34896                         //mt:len32
34897                         Times []DigTime
34898                 }))(obj)).Name))))
34899                 write16(w, uint16(x))
34900         }
34901         {
34902                 _, err := w.Write(([]byte((*(*(struct {
34903                         Name   string
34904                         Uses   int16
34905                         MaxLvl int16
34906
34907                         //mt:len32
34908                         Times []DigTime
34909                 }))(obj)).Name))[:])
34910                 chk(err)
34911         }
34912         {
34913                 x := (*(*(struct {
34914                         Name   string
34915                         Uses   int16
34916                         MaxLvl int16
34917
34918                         //mt:len32
34919                         Times []DigTime
34920                 }))(obj)).Uses
34921                 write16(w, uint16(x))
34922         }
34923         {
34924                 x := (*(*(struct {
34925                         Name   string
34926                         Uses   int16
34927                         MaxLvl int16
34928
34929                         //mt:len32
34930                         Times []DigTime
34931                 }))(obj)).MaxLvl
34932                 write16(w, uint16(x))
34933         }
34934         if len(((*(*(struct {
34935                 Name   string
34936                 Uses   int16
34937                 MaxLvl int16
34938
34939                 //mt:len32
34940                 Times []DigTime
34941         }))(obj)).Times)) > math.MaxUint32 {
34942                 chk(ErrTooLong)
34943         }
34944         {
34945                 x := uint32(len(((*(*(struct {
34946                         Name   string
34947                         Uses   int16
34948                         MaxLvl int16
34949
34950                         //mt:len32
34951                         Times []DigTime
34952                 }))(obj)).Times)))
34953                 write32(w, uint32(x))
34954         }
34955         for local404 := range (*(*(struct {
34956                 Name   string
34957                 Uses   int16
34958                 MaxLvl int16
34959
34960                 //mt:len32
34961                 Times []DigTime
34962         }))(obj)).Times {
34963                 if err := pcall(func() {
34964                         (((*(*(struct {
34965                                 Name   string
34966                                 Uses   int16
34967                                 MaxLvl int16
34968
34969                                 //mt:len32
34970                                 Times []DigTime
34971                         }))(obj)).Times)[local404]).serialize(w)
34972                 }); err != nil {
34973                         if err == io.EOF {
34974                                 chk(io.EOF)
34975                         }
34976                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34977                 }
34978         }
34979 }
34980
34981 func (obj *ToolGroupCaps) deserialize(r io.Reader) {
34982         var local405 []uint8
34983         var local406 uint16
34984         {
34985                 p := &local406
34986                 *p = read16(r)
34987         }
34988         (local405) = make([]uint8, local406)
34989         {
34990                 _, err := io.ReadFull(r, (local405)[:])
34991                 chk(err)
34992         }
34993         ((*(*(struct {
34994                 Name   string
34995                 Uses   int16
34996                 MaxLvl int16
34997
34998                 //mt:len32
34999                 Times []DigTime
35000         }))(obj)).Name) = string(local405)
35001         {
35002                 p := &(*(*(struct {
35003                         Name   string
35004                         Uses   int16
35005                         MaxLvl int16
35006
35007                         //mt:len32
35008                         Times []DigTime
35009                 }))(obj)).Uses
35010                 *p = int16(read16(r))
35011         }
35012         {
35013                 p := &(*(*(struct {
35014                         Name   string
35015                         Uses   int16
35016                         MaxLvl int16
35017
35018                         //mt:len32
35019                         Times []DigTime
35020                 }))(obj)).MaxLvl
35021                 *p = int16(read16(r))
35022         }
35023         var local407 uint32
35024         {
35025                 p := &local407
35026                 *p = read32(r)
35027         }
35028         ((*(*(struct {
35029                 Name   string
35030                 Uses   int16
35031                 MaxLvl int16
35032
35033                 //mt:len32
35034                 Times []DigTime
35035         }))(obj)).Times) = make([]DigTime, local407)
35036         for local408 := range (*(*(struct {
35037                 Name   string
35038                 Uses   int16
35039                 MaxLvl int16
35040
35041                 //mt:len32
35042                 Times []DigTime
35043         }))(obj)).Times {
35044                 if err := pcall(func() {
35045                         (((*(*(struct {
35046                                 Name   string
35047                                 Uses   int16
35048                                 MaxLvl int16
35049
35050                                 //mt:len32
35051                                 Times []DigTime
35052                         }))(obj)).Times)[local408]).deserialize(r)
35053                 }); err != nil {
35054                         if err == io.EOF {
35055                                 chk(io.EOF)
35056                         }
35057                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
35058                 }
35059         }
35060 }
35061
35062 func (obj *DigTime) serialize(w io.Writer) {
35063         {
35064                 x := (*(*(struct {
35065                         Rating int16
35066                         Time   float32
35067                 }))(obj)).Rating
35068                 write16(w, uint16(x))
35069         }
35070         {
35071                 x := (*(*(struct {
35072                         Rating int16
35073                         Time   float32
35074                 }))(obj)).Time
35075                 write32(w, math.Float32bits(x))
35076         }
35077 }
35078
35079 func (obj *DigTime) deserialize(r io.Reader) {
35080         {
35081                 p := &(*(*(struct {
35082                         Rating int16
35083                         Time   float32
35084                 }))(obj)).Rating
35085                 *p = int16(read16(r))
35086         }
35087         {
35088                 p := &(*(*(struct {
35089                         Rating int16
35090                         Time   float32
35091                 }))(obj)).Time
35092                 *p = math.Float32frombits(read32(r))
35093         }
35094 }