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
  44 func readBuf(r io.Reader, n int) []byte {
  45         buf := make([]byte, n)
  46         _, err := io.ReadFull(r, buf)
  47         chk(err)
  48         return buf
  49 }
  50
  51 func read8(r io.Reader) uint8   { return readBuf(r, 1)[0] }
  52 func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  53 func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  54 func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  55
  56 func (obj *ToSrvNil) serialize(w io.Writer) {
  57 }
  58
  59 func (obj *ToSrvNil) deserialize(r io.Reader) {
  60 }
  61
  62 func (obj *ToSrvInit) serialize(w io.Writer) {
  63         {
  64                 x := (*(*(struct {
  65                         SerializeVer             uint8
  66                         SupportedCompression     CompressionModes
  67                         MinProtoVer, MaxProtoVer uint16
  68                         PlayerName               string
  69
  70                         //mt:opt
  71                         SendFullItemMeta bool
  72                 }))(obj)).SerializeVer
  73                 write8(w, uint8(x))
  74         }
  75         if err := pcall(func() {
  76                 ((*(*(struct {
  77                         SerializeVer             uint8
  78                         SupportedCompression     CompressionModes
  79                         MinProtoVer, MaxProtoVer uint16
  80                         PlayerName               string
  81
  82                         //mt:opt
  83                         SendFullItemMeta bool
  84                 }))(obj)).SupportedCompression).serialize(w)
  85         }); err != nil {
  86                 if err == io.EOF {
  87                         chk(io.EOF)
  88                 }
  89                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
  90         }
  91         {
  92                 x := (*(*(struct {
  93                         SerializeVer             uint8
  94                         SupportedCompression     CompressionModes
  95                         MinProtoVer, MaxProtoVer uint16
  96                         PlayerName               string
  97
  98                         //mt:opt
  99                         SendFullItemMeta bool
 100                 }))(obj)).MinProtoVer
 101                 write16(w, uint16(x))
 102         }
 103         {
 104                 x := (*(*(struct {
 105                         SerializeVer             uint8
 106                         SupportedCompression     CompressionModes
 107                         MinProtoVer, MaxProtoVer uint16
 108                         PlayerName               string
 109
 110                         //mt:opt
 111                         SendFullItemMeta bool
 112                 }))(obj)).MaxProtoVer
 113                 write16(w, uint16(x))
 114         }
 115         if len(([]byte((*(*(struct {
 116                 SerializeVer             uint8
 117                 SupportedCompression     CompressionModes
 118                 MinProtoVer, MaxProtoVer uint16
 119                 PlayerName               string
 120
 121                 //mt:opt
 122                 SendFullItemMeta bool
 123         }))(obj)).PlayerName))) > math.MaxUint16 {
 124                 chk(ErrTooLong)
 125         }
 126         {
 127                 x := uint16(len(([]byte((*(*(struct {
 128                         SerializeVer             uint8
 129                         SupportedCompression     CompressionModes
 130                         MinProtoVer, MaxProtoVer uint16
 131                         PlayerName               string
 132
 133                         //mt:opt
 134                         SendFullItemMeta bool
 135                 }))(obj)).PlayerName))))
 136                 write16(w, uint16(x))
 137         }
 138         {
 139                 _, err := w.Write(([]byte((*(*(struct {
 140                         SerializeVer             uint8
 141                         SupportedCompression     CompressionModes
 142                         MinProtoVer, MaxProtoVer uint16
 143                         PlayerName               string
 144
 145                         //mt:opt
 146                         SendFullItemMeta bool
 147                 }))(obj)).PlayerName))[:])
 148                 chk(err)
 149         }
 150         if err := pcall(func() {
 151                 {
 152                         x := (*(*(struct {
 153                                 SerializeVer             uint8
 154                                 SupportedCompression     CompressionModes
 155                                 MinProtoVer, MaxProtoVer uint16
 156                                 PlayerName               string
 157
 158                                 //mt:opt
 159                                 SendFullItemMeta bool
 160                         }))(obj)).SendFullItemMeta
 161                         if x {
 162                                 write8(w, 1)
 163                         } else {
 164                                 write8(w, 0)
 165                         }
 166
 167                 }
 168         }); err != nil && err != io.EOF {
 169                 chk(err)
 170         }
 171 }
 172
 173 func (obj *ToSrvInit) deserialize(r io.Reader) {
 174         {
 175                 p := &(*(*(struct {
 176                         SerializeVer             uint8
 177                         SupportedCompression     CompressionModes
 178                         MinProtoVer, MaxProtoVer uint16
 179                         PlayerName               string
 180
 181                         //mt:opt
 182                         SendFullItemMeta bool
 183                 }))(obj)).SerializeVer
 184                 *p = read8(r)
 185         }
 186         if err := pcall(func() {
 187                 ((*(*(struct {
 188                         SerializeVer             uint8
 189                         SupportedCompression     CompressionModes
 190                         MinProtoVer, MaxProtoVer uint16
 191                         PlayerName               string
 192
 193                         //mt:opt
 194                         SendFullItemMeta bool
 195                 }))(obj)).SupportedCompression).deserialize(r)
 196         }); err != nil {
 197                 if err == io.EOF {
 198                         chk(io.EOF)
 199                 }
 200                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
 201         }
 202         {
 203                 p := &(*(*(struct {
 204                         SerializeVer             uint8
 205                         SupportedCompression     CompressionModes
 206                         MinProtoVer, MaxProtoVer uint16
 207                         PlayerName               string
 208
 209                         //mt:opt
 210                         SendFullItemMeta bool
 211                 }))(obj)).MinProtoVer
 212                 *p = read16(r)
 213         }
 214         {
 215                 p := &(*(*(struct {
 216                         SerializeVer             uint8
 217                         SupportedCompression     CompressionModes
 218                         MinProtoVer, MaxProtoVer uint16
 219                         PlayerName               string
 220
 221                         //mt:opt
 222                         SendFullItemMeta bool
 223                 }))(obj)).MaxProtoVer
 224                 *p = read16(r)
 225         }
 226         var local1 []uint8
 227         var local2 uint16
 228         {
 229                 p := &local2
 230                 *p = read16(r)
 231         }
 232         (local1) = make([]uint8, local2)
 233         {
 234                 _, err := io.ReadFull(r, (local1)[:])
 235                 chk(err)
 236         }
 237         ((*(*(struct {
 238                 SerializeVer             uint8
 239                 SupportedCompression     CompressionModes
 240                 MinProtoVer, MaxProtoVer uint16
 241                 PlayerName               string
 242
 243                 //mt:opt
 244                 SendFullItemMeta bool
 245         }))(obj)).PlayerName) = string(local1)
 246         if err := pcall(func() {
 247                 {
 248                         p := &(*(*(struct {
 249                                 SerializeVer             uint8
 250                                 SupportedCompression     CompressionModes
 251                                 MinProtoVer, MaxProtoVer uint16
 252                                 PlayerName               string
 253
 254                                 //mt:opt
 255                                 SendFullItemMeta bool
 256                         }))(obj)).SendFullItemMeta
 257                         switch n := read8(r); n {
 258                         case 0:
 259                                 *p = false
 260                         case 1:
 261                                 *p = true
 262                         default:
 263                                 chk(fmt.Errorf("invalid bool: %d", n))
 264                         }
 265
 266                 }
 267         }); err != nil && err != io.EOF {
 268                 chk(err)
 269         }
 270 }
 271
 272 func (obj *ToSrvInit2) serialize(w io.Writer) {
 273         if len(([]byte((*(*(struct {
 274                 Lang string
 275         }))(obj)).Lang))) > math.MaxUint16 {
 276                 chk(ErrTooLong)
 277         }
 278         {
 279                 x := uint16(len(([]byte((*(*(struct {
 280                         Lang string
 281                 }))(obj)).Lang))))
 282                 write16(w, uint16(x))
 283         }
 284         {
 285                 _, err := w.Write(([]byte((*(*(struct {
 286                         Lang string
 287                 }))(obj)).Lang))[:])
 288                 chk(err)
 289         }
 290 }
 291
 292 func (obj *ToSrvInit2) deserialize(r io.Reader) {
 293         var local3 []uint8
 294         var local4 uint16
 295         {
 296                 p := &local4
 297                 *p = read16(r)
 298         }
 299         (local3) = make([]uint8, local4)
 300         {
 301                 _, err := io.ReadFull(r, (local3)[:])
 302                 chk(err)
 303         }
 304         ((*(*(struct {
 305                 Lang string
 306         }))(obj)).Lang) = string(local3)
 307 }
 308
 309 func (obj *ToSrvJoinModChan) serialize(w io.Writer) {
 310         if len(([]byte((*(*(struct {
 311                 Channel string
 312         }))(obj)).Channel))) > math.MaxUint16 {
 313                 chk(ErrTooLong)
 314         }
 315         {
 316                 x := uint16(len(([]byte((*(*(struct {
 317                         Channel string
 318                 }))(obj)).Channel))))
 319                 write16(w, uint16(x))
 320         }
 321         {
 322                 _, err := w.Write(([]byte((*(*(struct {
 323                         Channel string
 324                 }))(obj)).Channel))[:])
 325                 chk(err)
 326         }
 327 }
 328
 329 func (obj *ToSrvJoinModChan) deserialize(r io.Reader) {
 330         var local5 []uint8
 331         var local6 uint16
 332         {
 333                 p := &local6
 334                 *p = read16(r)
 335         }
 336         (local5) = make([]uint8, local6)
 337         {
 338                 _, err := io.ReadFull(r, (local5)[:])
 339                 chk(err)
 340         }
 341         ((*(*(struct {
 342                 Channel string
 343         }))(obj)).Channel) = string(local5)
 344 }
 345
 346 func (obj *ToSrvLeaveModChan) serialize(w io.Writer) {
 347         if len(([]byte((*(*(struct {
 348                 Channel string
 349         }))(obj)).Channel))) > math.MaxUint16 {
 350                 chk(ErrTooLong)
 351         }
 352         {
 353                 x := uint16(len(([]byte((*(*(struct {
 354                         Channel string
 355                 }))(obj)).Channel))))
 356                 write16(w, uint16(x))
 357         }
 358         {
 359                 _, err := w.Write(([]byte((*(*(struct {
 360                         Channel string
 361                 }))(obj)).Channel))[:])
 362                 chk(err)
 363         }
 364 }
 365
 366 func (obj *ToSrvLeaveModChan) deserialize(r io.Reader) {
 367         var local7 []uint8
 368         var local8 uint16
 369         {
 370                 p := &local8
 371                 *p = read16(r)
 372         }
 373         (local7) = make([]uint8, local8)
 374         {
 375                 _, err := io.ReadFull(r, (local7)[:])
 376                 chk(err)
 377         }
 378         ((*(*(struct {
 379                 Channel string
 380         }))(obj)).Channel) = string(local7)
 381 }
 382
 383 func (obj *ToSrvMsgModChan) serialize(w io.Writer) {
 384         if len(([]byte((*(*(struct {
 385                 Channel string
 386                 Msg     string
 387         }))(obj)).Channel))) > math.MaxUint16 {
 388                 chk(ErrTooLong)
 389         }
 390         {
 391                 x := uint16(len(([]byte((*(*(struct {
 392                         Channel string
 393                         Msg     string
 394                 }))(obj)).Channel))))
 395                 write16(w, uint16(x))
 396         }
 397         {
 398                 _, err := w.Write(([]byte((*(*(struct {
 399                         Channel string
 400                         Msg     string
 401                 }))(obj)).Channel))[:])
 402                 chk(err)
 403         }
 404         if len(([]byte((*(*(struct {
 405                 Channel string
 406                 Msg     string
 407         }))(obj)).Msg))) > math.MaxUint16 {
 408                 chk(ErrTooLong)
 409         }
 410         {
 411                 x := uint16(len(([]byte((*(*(struct {
 412                         Channel string
 413                         Msg     string
 414                 }))(obj)).Msg))))
 415                 write16(w, uint16(x))
 416         }
 417         {
 418                 _, err := w.Write(([]byte((*(*(struct {
 419                         Channel string
 420                         Msg     string
 421                 }))(obj)).Msg))[:])
 422                 chk(err)
 423         }
 424 }
 425
 426 func (obj *ToSrvMsgModChan) deserialize(r io.Reader) {
 427         var local9 []uint8
 428         var local10 uint16
 429         {
 430                 p := &local10
 431                 *p = read16(r)
 432         }
 433         (local9) = make([]uint8, local10)
 434         {
 435                 _, err := io.ReadFull(r, (local9)[:])
 436                 chk(err)
 437         }
 438         ((*(*(struct {
 439                 Channel string
 440                 Msg     string
 441         }))(obj)).Channel) = string(local9)
 442         var local11 []uint8
 443         var local12 uint16
 444         {
 445                 p := &local12
 446                 *p = read16(r)
 447         }
 448         (local11) = make([]uint8, local12)
 449         {
 450                 _, err := io.ReadFull(r, (local11)[:])
 451                 chk(err)
 452         }
 453         ((*(*(struct {
 454                 Channel string
 455                 Msg     string
 456         }))(obj)).Msg) = string(local11)
 457 }
 458
 459 func (obj *ToSrvPlayerPos) serialize(w io.Writer) {
 460         if err := pcall(func() {
 461                 ((*(*(struct {
 462                         Pos PlayerPos
 463                 }))(obj)).Pos).serialize(w)
 464         }); err != nil {
 465                 if err == io.EOF {
 466                         chk(io.EOF)
 467                 }
 468                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 469         }
 470 }
 471
 472 func (obj *ToSrvPlayerPos) deserialize(r io.Reader) {
 473         if err := pcall(func() {
 474                 ((*(*(struct {
 475                         Pos PlayerPos
 476                 }))(obj)).Pos).deserialize(r)
 477         }); err != nil {
 478                 if err == io.EOF {
 479                         chk(io.EOF)
 480                 }
 481                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 482         }
 483 }
 484
 485 func (obj *ToSrvGotBlks) serialize(w io.Writer) {
 486         if len(((*(*(struct {
 487                 //mt:len8
 488                 Blks [][3]int16
 489         }))(obj)).Blks)) > math.MaxUint8 {
 490                 chk(ErrTooLong)
 491         }
 492         {
 493                 x := uint8(len(((*(*(struct {
 494                         //mt:len8
 495                         Blks [][3]int16
 496                 }))(obj)).Blks)))
 497                 write8(w, uint8(x))
 498         }
 499         for local13 := range (*(*(struct {
 500                 //mt:len8
 501                 Blks [][3]int16
 502         }))(obj)).Blks {
 503                 for local14 := range ((*(*(struct {
 504                         //mt:len8
 505                         Blks [][3]int16
 506                 }))(obj)).Blks)[local13] {
 507                         {
 508                                 x := (((*(*(struct {
 509                                         //mt:len8
 510                                         Blks [][3]int16
 511                                 }))(obj)).Blks)[local13])[local14]
 512                                 write16(w, uint16(x))
 513                         }
 514                 }
 515         }
 516 }
 517
 518 func (obj *ToSrvGotBlks) deserialize(r io.Reader) {
 519         var local15 uint8
 520         {
 521                 p := &local15
 522                 *p = read8(r)
 523         }
 524         ((*(*(struct {
 525                 //mt:len8
 526                 Blks [][3]int16
 527         }))(obj)).Blks) = make([][3]int16, local15)
 528         for local16 := range (*(*(struct {
 529                 //mt:len8
 530                 Blks [][3]int16
 531         }))(obj)).Blks {
 532                 for local17 := range ((*(*(struct {
 533                         //mt:len8
 534                         Blks [][3]int16
 535                 }))(obj)).Blks)[local16] {
 536                         {
 537                                 p := &(((*(*(struct {
 538                                         //mt:len8
 539                                         Blks [][3]int16
 540                                 }))(obj)).Blks)[local16])[local17]
 541                                 *p = int16(read16(r))
 542                         }
 543                 }
 544         }
 545 }
 546
 547 func (obj *ToSrvDeletedBlks) serialize(w io.Writer) {
 548         if len(((*(*(struct {
 549                 //mt:len8
 550                 Blks [][3]int16
 551         }))(obj)).Blks)) > math.MaxUint8 {
 552                 chk(ErrTooLong)
 553         }
 554         {
 555                 x := uint8(len(((*(*(struct {
 556                         //mt:len8
 557                         Blks [][3]int16
 558                 }))(obj)).Blks)))
 559                 write8(w, uint8(x))
 560         }
 561         for local18 := range (*(*(struct {
 562                 //mt:len8
 563                 Blks [][3]int16
 564         }))(obj)).Blks {
 565                 for local19 := range ((*(*(struct {
 566                         //mt:len8
 567                         Blks [][3]int16
 568                 }))(obj)).Blks)[local18] {
 569                         {
 570                                 x := (((*(*(struct {
 571                                         //mt:len8
 572                                         Blks [][3]int16
 573                                 }))(obj)).Blks)[local18])[local19]
 574                                 write16(w, uint16(x))
 575                         }
 576                 }
 577         }
 578 }
 579
 580 func (obj *ToSrvDeletedBlks) deserialize(r io.Reader) {
 581         var local20 uint8
 582         {
 583                 p := &local20
 584                 *p = read8(r)
 585         }
 586         ((*(*(struct {
 587                 //mt:len8
 588                 Blks [][3]int16
 589         }))(obj)).Blks) = make([][3]int16, local20)
 590         for local21 := range (*(*(struct {
 591                 //mt:len8
 592                 Blks [][3]int16
 593         }))(obj)).Blks {
 594                 for local22 := range ((*(*(struct {
 595                         //mt:len8
 596                         Blks [][3]int16
 597                 }))(obj)).Blks)[local21] {
 598                         {
 599                                 p := &(((*(*(struct {
 600                                         //mt:len8
 601                                         Blks [][3]int16
 602                                 }))(obj)).Blks)[local21])[local22]
 603                                 *p = int16(read16(r))
 604                         }
 605                 }
 606         }
 607 }
 608
 609 func (obj *ToSrvInvAction) serialize(w io.Writer) {
 610         {
 611                 _, err := w.Write(([]byte((*(*(struct {
 612                         //mt:raw
 613                         Action string
 614                 }))(obj)).Action))[:])
 615                 chk(err)
 616         }
 617 }
 618
 619 func (obj *ToSrvInvAction) deserialize(r io.Reader) {
 620         var local23 []uint8
 621         {
 622                 var err error
 623                 (local23), err = io.ReadAll(r)
 624                 chk(err)
 625         }
 626         ((*(*(struct {
 627                 //mt:raw
 628                 Action string
 629         }))(obj)).Action) = string(local23)
 630 }
 631
 632 func (obj *ToSrvChatMsg) serialize(w io.Writer) {
 633         local24 := utf16.Encode([]rune((*(*(struct {
 634                 //mt:utf16
 635                 Msg string
 636         }))(obj)).Msg))
 637         if len((local24)) > math.MaxUint16 {
 638                 chk(ErrTooLong)
 639         }
 640         {
 641                 x := uint16(len((local24)))
 642                 write16(w, uint16(x))
 643         }
 644         for local25 := range local24 {
 645                 {
 646                         x := (local24)[local25]
 647                         write16(w, uint16(x))
 648                 }
 649         }
 650 }
 651
 652 func (obj *ToSrvChatMsg) deserialize(r io.Reader) {
 653         var local26 []uint16
 654         var local27 uint16
 655         {
 656                 p := &local27
 657                 *p = read16(r)
 658         }
 659         (local26) = make([]uint16, local27)
 660         for local28 := range local26 {
 661                 {
 662                         p := &(local26)[local28]
 663                         *p = read16(r)
 664                 }
 665         }
 666         (*(*(struct {
 667                 //mt:utf16
 668                 Msg string
 669         }))(obj)).Msg = string(utf16.Decode(local26))
 670 }
 671
 672 func (obj *ToSrvFallDmg) serialize(w io.Writer) {
 673         {
 674                 x := (*(*(struct {
 675                         Amount uint16
 676                 }))(obj)).Amount
 677                 write16(w, uint16(x))
 678         }
 679 }
 680
 681 func (obj *ToSrvFallDmg) deserialize(r io.Reader) {
 682         {
 683                 p := &(*(*(struct {
 684                         Amount uint16
 685                 }))(obj)).Amount
 686                 *p = read16(r)
 687         }
 688 }
 689
 690 func (obj *ToSrvSelectItem) serialize(w io.Writer) {
 691         {
 692                 x := (*(*(struct {
 693                         Slot uint16
 694                 }))(obj)).Slot
 695                 write16(w, uint16(x))
 696         }
 697 }
 698
 699 func (obj *ToSrvSelectItem) deserialize(r io.Reader) {
 700         {
 701                 p := &(*(*(struct {
 702                         Slot uint16
 703                 }))(obj)).Slot
 704                 *p = read16(r)
 705         }
 706 }
 707
 708 func (obj *ToSrvRespawn) serialize(w io.Writer) {
 709 }
 710
 711 func (obj *ToSrvRespawn) deserialize(r io.Reader) {
 712 }
 713
 714 func (obj *ToSrvInteract) serialize(w io.Writer) {
 715         if err := pcall(func() {
 716                 ((*(*(struct {
 717                         Action   Interaction
 718                         ItemSlot uint16
 719                         //mt:lenhdr 32
 720                         Pointed PointedThing
 721                         //mt:end
 722                         Pos PlayerPos
 723                 }))(obj)).Action).serialize(w)
 724         }); err != nil {
 725                 if err == io.EOF {
 726                         chk(io.EOF)
 727                 }
 728                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Interaction", err))
 729         }
 730         {
 731                 x := (*(*(struct {
 732                         Action   Interaction
 733                         ItemSlot uint16
 734                         //mt:lenhdr 32
 735                         Pointed PointedThing
 736                         //mt:end
 737                         Pos PlayerPos
 738                 }))(obj)).ItemSlot
 739                 write16(w, uint16(x))
 740         }
 741         {
 742                 ow := w
 743                 w := new(bytes.Buffer)
 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)).Pointed
 753                         chk(writePointedThing(w, x))
 754
 755                 }
 756                 {
 757                         buf := w
 758                         w := ow
 759                         if len((buf.Bytes())) > math.MaxUint32 {
 760                                 chk(ErrTooLong)
 761                         }
 762                         {
 763                                 x := uint32(len((buf.Bytes())))
 764                                 write32(w, uint32(x))
 765                         }
 766                         {
 767                                 _, err := w.Write((buf.Bytes())[:])
 768                                 chk(err)
 769                         }
 770                 }
 771         }
 772         if err := pcall(func() {
 773                 ((*(*(struct {
 774                         Action   Interaction
 775                         ItemSlot uint16
 776                         //mt:lenhdr 32
 777                         Pointed PointedThing
 778                         //mt:end
 779                         Pos PlayerPos
 780                 }))(obj)).Pos).serialize(w)
 781         }); err != nil {
 782                 if err == io.EOF {
 783                         chk(io.EOF)
 784                 }
 785                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 786         }
 787 }
 788
 789 func (obj *ToSrvInteract) deserialize(r io.Reader) {
 790         if err := pcall(func() {
 791                 ((*(*(struct {
 792                         Action   Interaction
 793                         ItemSlot uint16
 794                         //mt:lenhdr 32
 795                         Pointed PointedThing
 796                         //mt:end
 797                         Pos PlayerPos
 798                 }))(obj)).Action).deserialize(r)
 799         }); err != nil {
 800                 if err == io.EOF {
 801                         chk(io.EOF)
 802                 }
 803                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Interaction", err))
 804         }
 805         {
 806                 p := &(*(*(struct {
 807                         Action   Interaction
 808                         ItemSlot uint16
 809                         //mt:lenhdr 32
 810                         Pointed PointedThing
 811                         //mt:end
 812                         Pos PlayerPos
 813                 }))(obj)).ItemSlot
 814                 *p = read16(r)
 815         }
 816         {
 817                 var n uint32
 818                 {
 819                         p := &n
 820                         *p = read32(r)
 821                 }
 822                 r := &io.LimitedReader{R: r, N: int64(n)}
 823                 {
 824                         p := &(*(*(struct {
 825                                 Action   Interaction
 826                                 ItemSlot uint16
 827                                 //mt:lenhdr 32
 828                                 Pointed PointedThing
 829                                 //mt:end
 830                                 Pos PlayerPos
 831                         }))(obj)).Pointed
 832                         {
 833                                 var err error
 834                                 *p, err = readPointedThing(r)
 835                                 chk(err)
 836                         }
 837
 838                 }
 839                 if r.N > 0 {
 840                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 841                 }
 842         }
 843         if err := pcall(func() {
 844                 ((*(*(struct {
 845                         Action   Interaction
 846                         ItemSlot uint16
 847                         //mt:lenhdr 32
 848                         Pointed PointedThing
 849                         //mt:end
 850                         Pos PlayerPos
 851                 }))(obj)).Pos).deserialize(r)
 852         }); err != nil {
 853                 if err == io.EOF {
 854                         chk(io.EOF)
 855                 }
 856                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 857         }
 858 }
 859
 860 func (obj *ToSrvRemovedSounds) serialize(w io.Writer) {
 861         if len(((*(*(struct {
 862                 IDs []SoundID
 863         }))(obj)).IDs)) > math.MaxUint16 {
 864                 chk(ErrTooLong)
 865         }
 866         {
 867                 x := uint16(len(((*(*(struct {
 868                         IDs []SoundID
 869                 }))(obj)).IDs)))
 870                 write16(w, uint16(x))
 871         }
 872         for local29 := range (*(*(struct {
 873                 IDs []SoundID
 874         }))(obj)).IDs {
 875                 if err := pcall(func() {
 876                         (((*(*(struct {
 877                                 IDs []SoundID
 878                         }))(obj)).IDs)[local29]).serialize(w)
 879                 }); err != nil {
 880                         if err == io.EOF {
 881                                 chk(io.EOF)
 882                         }
 883                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
 884                 }
 885         }
 886 }
 887
 888 func (obj *ToSrvRemovedSounds) deserialize(r io.Reader) {
 889         var local30 uint16
 890         {
 891                 p := &local30
 892                 *p = read16(r)
 893         }
 894         ((*(*(struct {
 895                 IDs []SoundID
 896         }))(obj)).IDs) = make([]SoundID, local30)
 897         for local31 := range (*(*(struct {
 898                 IDs []SoundID
 899         }))(obj)).IDs {
 900                 if err := pcall(func() {
 901                         (((*(*(struct {
 902                                 IDs []SoundID
 903                         }))(obj)).IDs)[local31]).deserialize(r)
 904                 }); err != nil {
 905                         if err == io.EOF {
 906                                 chk(io.EOF)
 907                         }
 908                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
 909                 }
 910         }
 911 }
 912
 913 func (obj *ToSrvNodeMetaFields) serialize(w io.Writer) {
 914         for local32 := range (*(*(struct {
 915                 Pos      [3]int16
 916                 Formname string
 917                 Fields   []Field
 918         }))(obj)).Pos {
 919                 {
 920                         x := ((*(*(struct {
 921                                 Pos      [3]int16
 922                                 Formname string
 923                                 Fields   []Field
 924                         }))(obj)).Pos)[local32]
 925                         write16(w, uint16(x))
 926                 }
 927         }
 928         if len(([]byte((*(*(struct {
 929                 Pos      [3]int16
 930                 Formname string
 931                 Fields   []Field
 932         }))(obj)).Formname))) > math.MaxUint16 {
 933                 chk(ErrTooLong)
 934         }
 935         {
 936                 x := uint16(len(([]byte((*(*(struct {
 937                         Pos      [3]int16
 938                         Formname string
 939                         Fields   []Field
 940                 }))(obj)).Formname))))
 941                 write16(w, uint16(x))
 942         }
 943         {
 944                 _, err := w.Write(([]byte((*(*(struct {
 945                         Pos      [3]int16
 946                         Formname string
 947                         Fields   []Field
 948                 }))(obj)).Formname))[:])
 949                 chk(err)
 950         }
 951         if len(((*(*(struct {
 952                 Pos      [3]int16
 953                 Formname string
 954                 Fields   []Field
 955         }))(obj)).Fields)) > math.MaxUint16 {
 956                 chk(ErrTooLong)
 957         }
 958         {
 959                 x := uint16(len(((*(*(struct {
 960                         Pos      [3]int16
 961                         Formname string
 962                         Fields   []Field
 963                 }))(obj)).Fields)))
 964                 write16(w, uint16(x))
 965         }
 966         for local33 := range (*(*(struct {
 967                 Pos      [3]int16
 968                 Formname string
 969                 Fields   []Field
 970         }))(obj)).Fields {
 971                 if err := pcall(func() {
 972                         (((*(*(struct {
 973                                 Pos      [3]int16
 974                                 Formname string
 975                                 Fields   []Field
 976                         }))(obj)).Fields)[local33]).serialize(w)
 977                 }); err != nil {
 978                         if err == io.EOF {
 979                                 chk(io.EOF)
 980                         }
 981                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
 982                 }
 983         }
 984 }
 985
 986 func (obj *ToSrvNodeMetaFields) deserialize(r io.Reader) {
 987         for local34 := range (*(*(struct {
 988                 Pos      [3]int16
 989                 Formname string
 990                 Fields   []Field
 991         }))(obj)).Pos {
 992                 {
 993                         p := &((*(*(struct {
 994                                 Pos      [3]int16
 995                                 Formname string
 996                                 Fields   []Field
 997                         }))(obj)).Pos)[local34]
 998                         *p = int16(read16(r))
 999                 }
1000         }
1001         var local35 []uint8
1002         var local36 uint16
1003         {
1004                 p := &local36
1005                 *p = read16(r)
1006         }
1007         (local35) = make([]uint8, local36)
1008         {
1009                 _, err := io.ReadFull(r, (local35)[:])
1010                 chk(err)
1011         }
1012         ((*(*(struct {
1013                 Pos      [3]int16
1014                 Formname string
1015                 Fields   []Field
1016         }))(obj)).Formname) = string(local35)
1017         var local37 uint16
1018         {
1019                 p := &local37
1020                 *p = read16(r)
1021         }
1022         ((*(*(struct {
1023                 Pos      [3]int16
1024                 Formname string
1025                 Fields   []Field
1026         }))(obj)).Fields) = make([]Field, local37)
1027         for local38 := range (*(*(struct {
1028                 Pos      [3]int16
1029                 Formname string
1030                 Fields   []Field
1031         }))(obj)).Fields {
1032                 if err := pcall(func() {
1033                         (((*(*(struct {
1034                                 Pos      [3]int16
1035                                 Formname string
1036                                 Fields   []Field
1037                         }))(obj)).Fields)[local38]).deserialize(r)
1038                 }); err != nil {
1039                         if err == io.EOF {
1040                                 chk(io.EOF)
1041                         }
1042                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1043                 }
1044         }
1045 }
1046
1047 func (obj *ToSrvInvFields) serialize(w io.Writer) {
1048         if len(([]byte((*(*(struct {
1049                 Formname string
1050                 Fields   []Field
1051         }))(obj)).Formname))) > math.MaxUint16 {
1052                 chk(ErrTooLong)
1053         }
1054         {
1055                 x := uint16(len(([]byte((*(*(struct {
1056                         Formname string
1057                         Fields   []Field
1058                 }))(obj)).Formname))))
1059                 write16(w, uint16(x))
1060         }
1061         {
1062                 _, err := w.Write(([]byte((*(*(struct {
1063                         Formname string
1064                         Fields   []Field
1065                 }))(obj)).Formname))[:])
1066                 chk(err)
1067         }
1068         if len(((*(*(struct {
1069                 Formname string
1070                 Fields   []Field
1071         }))(obj)).Fields)) > math.MaxUint16 {
1072                 chk(ErrTooLong)
1073         }
1074         {
1075                 x := uint16(len(((*(*(struct {
1076                         Formname string
1077                         Fields   []Field
1078                 }))(obj)).Fields)))
1079                 write16(w, uint16(x))
1080         }
1081         for local39 := range (*(*(struct {
1082                 Formname string
1083                 Fields   []Field
1084         }))(obj)).Fields {
1085                 if err := pcall(func() {
1086                         (((*(*(struct {
1087                                 Formname string
1088                                 Fields   []Field
1089                         }))(obj)).Fields)[local39]).serialize(w)
1090                 }); err != nil {
1091                         if err == io.EOF {
1092                                 chk(io.EOF)
1093                         }
1094                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1095                 }
1096         }
1097 }
1098
1099 func (obj *ToSrvInvFields) deserialize(r io.Reader) {
1100         var local40 []uint8
1101         var local41 uint16
1102         {
1103                 p := &local41
1104                 *p = read16(r)
1105         }
1106         (local40) = make([]uint8, local41)
1107         {
1108                 _, err := io.ReadFull(r, (local40)[:])
1109                 chk(err)
1110         }
1111         ((*(*(struct {
1112                 Formname string
1113                 Fields   []Field
1114         }))(obj)).Formname) = string(local40)
1115         var local42 uint16
1116         {
1117                 p := &local42
1118                 *p = read16(r)
1119         }
1120         ((*(*(struct {
1121                 Formname string
1122                 Fields   []Field
1123         }))(obj)).Fields) = make([]Field, local42)
1124         for local43 := range (*(*(struct {
1125                 Formname string
1126                 Fields   []Field
1127         }))(obj)).Fields {
1128                 if err := pcall(func() {
1129                         (((*(*(struct {
1130                                 Formname string
1131                                 Fields   []Field
1132                         }))(obj)).Fields)[local43]).deserialize(r)
1133                 }); err != nil {
1134                         if err == io.EOF {
1135                                 chk(io.EOF)
1136                         }
1137                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1138                 }
1139         }
1140 }
1141
1142 func (obj *ToSrvReqMedia) serialize(w io.Writer) {
1143         if len(((*(*(struct {
1144                 Filenames []string
1145         }))(obj)).Filenames)) > math.MaxUint16 {
1146                 chk(ErrTooLong)
1147         }
1148         {
1149                 x := uint16(len(((*(*(struct {
1150                         Filenames []string
1151                 }))(obj)).Filenames)))
1152                 write16(w, uint16(x))
1153         }
1154         for local44 := range (*(*(struct {
1155                 Filenames []string
1156         }))(obj)).Filenames {
1157                 if len(([]byte(((*(*(struct {
1158                         Filenames []string
1159                 }))(obj)).Filenames)[local44]))) > math.MaxUint16 {
1160                         chk(ErrTooLong)
1161                 }
1162                 {
1163                         x := uint16(len(([]byte(((*(*(struct {
1164                                 Filenames []string
1165                         }))(obj)).Filenames)[local44]))))
1166                         write16(w, uint16(x))
1167                 }
1168                 {
1169                         _, err := w.Write(([]byte(((*(*(struct {
1170                                 Filenames []string
1171                         }))(obj)).Filenames)[local44]))[:])
1172                         chk(err)
1173                 }
1174         }
1175 }
1176
1177 func (obj *ToSrvReqMedia) deserialize(r io.Reader) {
1178         var local45 uint16
1179         {
1180                 p := &local45
1181                 *p = read16(r)
1182         }
1183         ((*(*(struct {
1184                 Filenames []string
1185         }))(obj)).Filenames) = make([]string, local45)
1186         for local46 := range (*(*(struct {
1187                 Filenames []string
1188         }))(obj)).Filenames {
1189                 var local47 []uint8
1190                 var local48 uint16
1191                 {
1192                         p := &local48
1193                         *p = read16(r)
1194                 }
1195                 (local47) = make([]uint8, local48)
1196                 {
1197                         _, err := io.ReadFull(r, (local47)[:])
1198                         chk(err)
1199                 }
1200                 (((*(*(struct {
1201                         Filenames []string
1202                 }))(obj)).Filenames)[local46]) = string(local47)
1203         }
1204 }
1205
1206 func (obj *ToSrvCltReady) serialize(w io.Writer) {
1207         {
1208                 x := (*(*(struct {
1209                         // Version information.
1210                         Major, Minor, Patch uint8
1211                         Reserved            uint8
1212                         Version             string
1213                         Formspec            uint16
1214                 }))(obj)).Major
1215                 write8(w, uint8(x))
1216         }
1217         {
1218                 x := (*(*(struct {
1219                         // Version information.
1220                         Major, Minor, Patch uint8
1221                         Reserved            uint8
1222                         Version             string
1223                         Formspec            uint16
1224                 }))(obj)).Minor
1225                 write8(w, uint8(x))
1226         }
1227         {
1228                 x := (*(*(struct {
1229                         // Version information.
1230                         Major, Minor, Patch uint8
1231                         Reserved            uint8
1232                         Version             string
1233                         Formspec            uint16
1234                 }))(obj)).Patch
1235                 write8(w, uint8(x))
1236         }
1237         {
1238                 x := (*(*(struct {
1239                         // Version information.
1240                         Major, Minor, Patch uint8
1241                         Reserved            uint8
1242                         Version             string
1243                         Formspec            uint16
1244                 }))(obj)).Reserved
1245                 write8(w, uint8(x))
1246         }
1247         if len(([]byte((*(*(struct {
1248                 // Version information.
1249                 Major, Minor, Patch uint8
1250                 Reserved            uint8
1251                 Version             string
1252                 Formspec            uint16
1253         }))(obj)).Version))) > math.MaxUint16 {
1254                 chk(ErrTooLong)
1255         }
1256         {
1257                 x := uint16(len(([]byte((*(*(struct {
1258                         // Version information.
1259                         Major, Minor, Patch uint8
1260                         Reserved            uint8
1261                         Version             string
1262                         Formspec            uint16
1263                 }))(obj)).Version))))
1264                 write16(w, uint16(x))
1265         }
1266         {
1267                 _, err := w.Write(([]byte((*(*(struct {
1268                         // Version information.
1269                         Major, Minor, Patch uint8
1270                         Reserved            uint8
1271                         Version             string
1272                         Formspec            uint16
1273                 }))(obj)).Version))[:])
1274                 chk(err)
1275         }
1276         {
1277                 x := (*(*(struct {
1278                         // Version information.
1279                         Major, Minor, Patch uint8
1280                         Reserved            uint8
1281                         Version             string
1282                         Formspec            uint16
1283                 }))(obj)).Formspec
1284                 write16(w, uint16(x))
1285         }
1286 }
1287
1288 func (obj *ToSrvCltReady) deserialize(r io.Reader) {
1289         {
1290                 p := &(*(*(struct {
1291                         // Version information.
1292                         Major, Minor, Patch uint8
1293                         Reserved            uint8
1294                         Version             string
1295                         Formspec            uint16
1296                 }))(obj)).Major
1297                 *p = read8(r)
1298         }
1299         {
1300                 p := &(*(*(struct {
1301                         // Version information.
1302                         Major, Minor, Patch uint8
1303                         Reserved            uint8
1304                         Version             string
1305                         Formspec            uint16
1306                 }))(obj)).Minor
1307                 *p = read8(r)
1308         }
1309         {
1310                 p := &(*(*(struct {
1311                         // Version information.
1312                         Major, Minor, Patch uint8
1313                         Reserved            uint8
1314                         Version             string
1315                         Formspec            uint16
1316                 }))(obj)).Patch
1317                 *p = read8(r)
1318         }
1319         {
1320                 p := &(*(*(struct {
1321                         // Version information.
1322                         Major, Minor, Patch uint8
1323                         Reserved            uint8
1324                         Version             string
1325                         Formspec            uint16
1326                 }))(obj)).Reserved
1327                 *p = read8(r)
1328         }
1329         var local49 []uint8
1330         var local50 uint16
1331         {
1332                 p := &local50
1333                 *p = read16(r)
1334         }
1335         (local49) = make([]uint8, local50)
1336         {
1337                 _, err := io.ReadFull(r, (local49)[:])
1338                 chk(err)
1339         }
1340         ((*(*(struct {
1341                 // Version information.
1342                 Major, Minor, Patch uint8
1343                 Reserved            uint8
1344                 Version             string
1345                 Formspec            uint16
1346         }))(obj)).Version) = string(local49)
1347         {
1348                 p := &(*(*(struct {
1349                         // Version information.
1350                         Major, Minor, Patch uint8
1351                         Reserved            uint8
1352                         Version             string
1353                         Formspec            uint16
1354                 }))(obj)).Formspec
1355                 *p = read16(r)
1356         }
1357 }
1358
1359 func (obj *ToSrvFirstSRP) serialize(w io.Writer) {
1360         if len(((*(*(struct {
1361                 Salt        []byte
1362                 Verifier    []byte
1363                 EmptyPasswd bool
1364         }))(obj)).Salt)) > math.MaxUint16 {
1365                 chk(ErrTooLong)
1366         }
1367         {
1368                 x := uint16(len(((*(*(struct {
1369                         Salt        []byte
1370                         Verifier    []byte
1371                         EmptyPasswd bool
1372                 }))(obj)).Salt)))
1373                 write16(w, uint16(x))
1374         }
1375         {
1376                 _, err := w.Write(((*(*(struct {
1377                         Salt        []byte
1378                         Verifier    []byte
1379                         EmptyPasswd bool
1380                 }))(obj)).Salt)[:])
1381                 chk(err)
1382         }
1383         if len(((*(*(struct {
1384                 Salt        []byte
1385                 Verifier    []byte
1386                 EmptyPasswd bool
1387         }))(obj)).Verifier)) > math.MaxUint16 {
1388                 chk(ErrTooLong)
1389         }
1390         {
1391                 x := uint16(len(((*(*(struct {
1392                         Salt        []byte
1393                         Verifier    []byte
1394                         EmptyPasswd bool
1395                 }))(obj)).Verifier)))
1396                 write16(w, uint16(x))
1397         }
1398         {
1399                 _, err := w.Write(((*(*(struct {
1400                         Salt        []byte
1401                         Verifier    []byte
1402                         EmptyPasswd bool
1403                 }))(obj)).Verifier)[:])
1404                 chk(err)
1405         }
1406         {
1407                 x := (*(*(struct {
1408                         Salt        []byte
1409                         Verifier    []byte
1410                         EmptyPasswd bool
1411                 }))(obj)).EmptyPasswd
1412                 if x {
1413                         write8(w, 1)
1414                 } else {
1415                         write8(w, 0)
1416                 }
1417
1418         }
1419 }
1420
1421 func (obj *ToSrvFirstSRP) deserialize(r io.Reader) {
1422         var local51 uint16
1423         {
1424                 p := &local51
1425                 *p = read16(r)
1426         }
1427         ((*(*(struct {
1428                 Salt        []byte
1429                 Verifier    []byte
1430                 EmptyPasswd bool
1431         }))(obj)).Salt) = make([]byte, local51)
1432         {
1433                 _, err := io.ReadFull(r, ((*(*(struct {
1434                         Salt        []byte
1435                         Verifier    []byte
1436                         EmptyPasswd bool
1437                 }))(obj)).Salt)[:])
1438                 chk(err)
1439         }
1440         var local52 uint16
1441         {
1442                 p := &local52
1443                 *p = read16(r)
1444         }
1445         ((*(*(struct {
1446                 Salt        []byte
1447                 Verifier    []byte
1448                 EmptyPasswd bool
1449         }))(obj)).Verifier) = make([]byte, local52)
1450         {
1451                 _, err := io.ReadFull(r, ((*(*(struct {
1452                         Salt        []byte
1453                         Verifier    []byte
1454                         EmptyPasswd bool
1455                 }))(obj)).Verifier)[:])
1456                 chk(err)
1457         }
1458         {
1459                 p := &(*(*(struct {
1460                         Salt        []byte
1461                         Verifier    []byte
1462                         EmptyPasswd bool
1463                 }))(obj)).EmptyPasswd
1464                 switch n := read8(r); n {
1465                 case 0:
1466                         *p = false
1467                 case 1:
1468                         *p = true
1469                 default:
1470                         chk(fmt.Errorf("invalid bool: %d", n))
1471                 }
1472
1473         }
1474 }
1475
1476 func (obj *ToSrvSRPBytesA) serialize(w io.Writer) {
1477         if len(((*(*(struct {
1478                 A      []byte
1479                 NoSHA1 bool
1480         }))(obj)).A)) > math.MaxUint16 {
1481                 chk(ErrTooLong)
1482         }
1483         {
1484                 x := uint16(len(((*(*(struct {
1485                         A      []byte
1486                         NoSHA1 bool
1487                 }))(obj)).A)))
1488                 write16(w, uint16(x))
1489         }
1490         {
1491                 _, err := w.Write(((*(*(struct {
1492                         A      []byte
1493                         NoSHA1 bool
1494                 }))(obj)).A)[:])
1495                 chk(err)
1496         }
1497         {
1498                 x := (*(*(struct {
1499                         A      []byte
1500                         NoSHA1 bool
1501                 }))(obj)).NoSHA1
1502                 if x {
1503                         write8(w, 1)
1504                 } else {
1505                         write8(w, 0)
1506                 }
1507
1508         }
1509 }
1510
1511 func (obj *ToSrvSRPBytesA) deserialize(r io.Reader) {
1512         var local53 uint16
1513         {
1514                 p := &local53
1515                 *p = read16(r)
1516         }
1517         ((*(*(struct {
1518                 A      []byte
1519                 NoSHA1 bool
1520         }))(obj)).A) = make([]byte, local53)
1521         {
1522                 _, err := io.ReadFull(r, ((*(*(struct {
1523                         A      []byte
1524                         NoSHA1 bool
1525                 }))(obj)).A)[:])
1526                 chk(err)
1527         }
1528         {
1529                 p := &(*(*(struct {
1530                         A      []byte
1531                         NoSHA1 bool
1532                 }))(obj)).NoSHA1
1533                 switch n := read8(r); n {
1534                 case 0:
1535                         *p = false
1536                 case 1:
1537                         *p = true
1538                 default:
1539                         chk(fmt.Errorf("invalid bool: %d", n))
1540                 }
1541
1542         }
1543 }
1544
1545 func (obj *ToSrvSRPBytesM) serialize(w io.Writer) {
1546         if len(((*(*(struct {
1547                 M []byte
1548         }))(obj)).M)) > math.MaxUint16 {
1549                 chk(ErrTooLong)
1550         }
1551         {
1552                 x := uint16(len(((*(*(struct {
1553                         M []byte
1554                 }))(obj)).M)))
1555                 write16(w, uint16(x))
1556         }
1557         {
1558                 _, err := w.Write(((*(*(struct {
1559                         M []byte
1560                 }))(obj)).M)[:])
1561                 chk(err)
1562         }
1563 }
1564
1565 func (obj *ToSrvSRPBytesM) deserialize(r io.Reader) {
1566         var local54 uint16
1567         {
1568                 p := &local54
1569                 *p = read16(r)
1570         }
1571         ((*(*(struct {
1572                 M []byte
1573         }))(obj)).M) = make([]byte, local54)
1574         {
1575                 _, err := io.ReadFull(r, ((*(*(struct {
1576                         M []byte
1577                 }))(obj)).M)[:])
1578                 chk(err)
1579         }
1580 }
1581
1582 func (obj *ToCltHello) serialize(w io.Writer) {
1583         {
1584                 x := (*(*(struct {
1585                         SerializeVer uint8
1586                         Compression  CompressionModes
1587                         ProtoVer     uint16
1588                         AuthMethods
1589                         Username string
1590                 }))(obj)).SerializeVer
1591                 write8(w, uint8(x))
1592         }
1593         if err := pcall(func() {
1594                 ((*(*(struct {
1595                         SerializeVer uint8
1596                         Compression  CompressionModes
1597                         ProtoVer     uint16
1598                         AuthMethods
1599                         Username string
1600                 }))(obj)).Compression).serialize(w)
1601         }); err != nil {
1602                 if err == io.EOF {
1603                         chk(io.EOF)
1604                 }
1605                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
1606         }
1607         {
1608                 x := (*(*(struct {
1609                         SerializeVer uint8
1610                         Compression  CompressionModes
1611                         ProtoVer     uint16
1612                         AuthMethods
1613                         Username string
1614                 }))(obj)).ProtoVer
1615                 write16(w, uint16(x))
1616         }
1617         if err := pcall(func() {
1618                 ((*(*(struct {
1619                         SerializeVer uint8
1620                         Compression  CompressionModes
1621                         ProtoVer     uint16
1622                         AuthMethods
1623                         Username string
1624                 }))(obj)).AuthMethods).serialize(w)
1625         }); err != nil {
1626                 if err == io.EOF {
1627                         chk(io.EOF)
1628                 }
1629                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1630         }
1631         if len(([]byte((*(*(struct {
1632                 SerializeVer uint8
1633                 Compression  CompressionModes
1634                 ProtoVer     uint16
1635                 AuthMethods
1636                 Username string
1637         }))(obj)).Username))) > math.MaxUint16 {
1638                 chk(ErrTooLong)
1639         }
1640         {
1641                 x := uint16(len(([]byte((*(*(struct {
1642                         SerializeVer uint8
1643                         Compression  CompressionModes
1644                         ProtoVer     uint16
1645                         AuthMethods
1646                         Username string
1647                 }))(obj)).Username))))
1648                 write16(w, uint16(x))
1649         }
1650         {
1651                 _, err := w.Write(([]byte((*(*(struct {
1652                         SerializeVer uint8
1653                         Compression  CompressionModes
1654                         ProtoVer     uint16
1655                         AuthMethods
1656                         Username string
1657                 }))(obj)).Username))[:])
1658                 chk(err)
1659         }
1660 }
1661
1662 func (obj *ToCltHello) deserialize(r io.Reader) {
1663         {
1664                 p := &(*(*(struct {
1665                         SerializeVer uint8
1666                         Compression  CompressionModes
1667                         ProtoVer     uint16
1668                         AuthMethods
1669                         Username string
1670                 }))(obj)).SerializeVer
1671                 *p = read8(r)
1672         }
1673         if err := pcall(func() {
1674                 ((*(*(struct {
1675                         SerializeVer uint8
1676                         Compression  CompressionModes
1677                         ProtoVer     uint16
1678                         AuthMethods
1679                         Username string
1680                 }))(obj)).Compression).deserialize(r)
1681         }); err != nil {
1682                 if err == io.EOF {
1683                         chk(io.EOF)
1684                 }
1685                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
1686         }
1687         {
1688                 p := &(*(*(struct {
1689                         SerializeVer uint8
1690                         Compression  CompressionModes
1691                         ProtoVer     uint16
1692                         AuthMethods
1693                         Username string
1694                 }))(obj)).ProtoVer
1695                 *p = read16(r)
1696         }
1697         if err := pcall(func() {
1698                 ((*(*(struct {
1699                         SerializeVer uint8
1700                         Compression  CompressionModes
1701                         ProtoVer     uint16
1702                         AuthMethods
1703                         Username string
1704                 }))(obj)).AuthMethods).deserialize(r)
1705         }); err != nil {
1706                 if err == io.EOF {
1707                         chk(io.EOF)
1708                 }
1709                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1710         }
1711         var local55 []uint8
1712         var local56 uint16
1713         {
1714                 p := &local56
1715                 *p = read16(r)
1716         }
1717         (local55) = make([]uint8, local56)
1718         {
1719                 _, err := io.ReadFull(r, (local55)[:])
1720                 chk(err)
1721         }
1722         ((*(*(struct {
1723                 SerializeVer uint8
1724                 Compression  CompressionModes
1725                 ProtoVer     uint16
1726                 AuthMethods
1727                 Username string
1728         }))(obj)).Username) = string(local55)
1729 }
1730
1731 func (obj *ToCltAcceptAuth) serialize(w io.Writer) {
1732         if err := pcall(func() {
1733                 ((*(*(struct {
1734                         // The client does the equivalent of
1735                         //      PlayerPos[1] -= 5
1736                         // before using PlayerPos.
1737                         PlayerPos Pos
1738
1739                         MapSeed         uint64
1740                         SendInterval    float32
1741                         SudoAuthMethods AuthMethods
1742                 }))(obj)).PlayerPos).serialize(w)
1743         }); err != nil {
1744                 if err == io.EOF {
1745                         chk(io.EOF)
1746                 }
1747                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
1748         }
1749         {
1750                 x := (*(*(struct {
1751                         // The client does the equivalent of
1752                         //      PlayerPos[1] -= 5
1753                         // before using PlayerPos.
1754                         PlayerPos Pos
1755
1756                         MapSeed         uint64
1757                         SendInterval    float32
1758                         SudoAuthMethods AuthMethods
1759                 }))(obj)).MapSeed
1760                 write64(w, uint64(x))
1761
1762         }
1763         {
1764                 x := (*(*(struct {
1765                         // The client does the equivalent of
1766                         //      PlayerPos[1] -= 5
1767                         // before using PlayerPos.
1768                         PlayerPos Pos
1769
1770                         MapSeed         uint64
1771                         SendInterval    float32
1772                         SudoAuthMethods AuthMethods
1773                 }))(obj)).SendInterval
1774                 write32(w, math.Float32bits(x))
1775         }
1776         if err := pcall(func() {
1777                 ((*(*(struct {
1778                         // The client does the equivalent of
1779                         //      PlayerPos[1] -= 5
1780                         // before using PlayerPos.
1781                         PlayerPos Pos
1782
1783                         MapSeed         uint64
1784                         SendInterval    float32
1785                         SudoAuthMethods AuthMethods
1786                 }))(obj)).SudoAuthMethods).serialize(w)
1787         }); err != nil {
1788                 if err == io.EOF {
1789                         chk(io.EOF)
1790                 }
1791                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1792         }
1793 }
1794
1795 func (obj *ToCltAcceptAuth) deserialize(r io.Reader) {
1796         if err := pcall(func() {
1797                 ((*(*(struct {
1798                         // The client does the equivalent of
1799                         //      PlayerPos[1] -= 5
1800                         // before using PlayerPos.
1801                         PlayerPos Pos
1802
1803                         MapSeed         uint64
1804                         SendInterval    float32
1805                         SudoAuthMethods AuthMethods
1806                 }))(obj)).PlayerPos).deserialize(r)
1807         }); err != nil {
1808                 if err == io.EOF {
1809                         chk(io.EOF)
1810                 }
1811                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
1812         }
1813         {
1814                 p := &(*(*(struct {
1815                         // The client does the equivalent of
1816                         //      PlayerPos[1] -= 5
1817                         // before using PlayerPos.
1818                         PlayerPos Pos
1819
1820                         MapSeed         uint64
1821                         SendInterval    float32
1822                         SudoAuthMethods AuthMethods
1823                 }))(obj)).MapSeed
1824                 *p = read64(r)
1825
1826         }
1827         {
1828                 p := &(*(*(struct {
1829                         // The client does the equivalent of
1830                         //      PlayerPos[1] -= 5
1831                         // before using PlayerPos.
1832                         PlayerPos Pos
1833
1834                         MapSeed         uint64
1835                         SendInterval    float32
1836                         SudoAuthMethods AuthMethods
1837                 }))(obj)).SendInterval
1838                 *p = math.Float32frombits(read32(r))
1839         }
1840         if err := pcall(func() {
1841                 ((*(*(struct {
1842                         // The client does the equivalent of
1843                         //      PlayerPos[1] -= 5
1844                         // before using PlayerPos.
1845                         PlayerPos Pos
1846
1847                         MapSeed         uint64
1848                         SendInterval    float32
1849                         SudoAuthMethods AuthMethods
1850                 }))(obj)).SudoAuthMethods).deserialize(r)
1851         }); err != nil {
1852                 if err == io.EOF {
1853                         chk(io.EOF)
1854                 }
1855                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1856         }
1857 }
1858
1859 func (obj *ToCltAcceptSudoMode) serialize(w io.Writer) {
1860         if err := pcall(func() {
1861                 ((*(*(struct {
1862                         SudoAuthMethods AuthMethods
1863                 }))(obj)).SudoAuthMethods).serialize(w)
1864         }); err != nil {
1865                 if err == io.EOF {
1866                         chk(io.EOF)
1867                 }
1868                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1869         }
1870         {
1871                 local57 := [15]byte{}
1872                 {
1873                         _, err := w.Write((local57)[:])
1874                         chk(err)
1875                 }
1876         }
1877 }
1878
1879 func (obj *ToCltAcceptSudoMode) deserialize(r io.Reader) {
1880         if err := pcall(func() {
1881                 ((*(*(struct {
1882                         SudoAuthMethods AuthMethods
1883                 }))(obj)).SudoAuthMethods).deserialize(r)
1884         }); err != nil {
1885                 if err == io.EOF {
1886                         chk(io.EOF)
1887                 }
1888                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1889         }
1890         {
1891                 var local58 [15]byte
1892                 local59 := [15]byte{}
1893                 {
1894                         _, err := io.ReadFull(r, (local58)[:])
1895                         chk(err)
1896                 }
1897                 if local58 != local59 {
1898                         chk(fmt.Errorf("const %v: %v", "[15]byte{}", local58))
1899                 }
1900         }
1901 }
1902
1903 func (obj *ToCltDenySudoMode) serialize(w io.Writer) {
1904 }
1905
1906 func (obj *ToCltDenySudoMode) deserialize(r io.Reader) {
1907 }
1908
1909 func (obj *ToCltKick) serialize(w io.Writer) {
1910         if err := pcall(func() {
1911                 ((*(*(struct {
1912                         Reason KickReason
1913
1914                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1915                         Custom string
1916
1917                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1918                         Reconnect bool
1919                 }))(obj)).Reason).serialize(w)
1920         }); err != nil {
1921                 if err == io.EOF {
1922                         chk(io.EOF)
1923                 }
1924                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.KickReason", err))
1925         }
1926         if !((*(*(struct {
1927                 Reason KickReason
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)).Reason < maxKickReason) {
1935                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
1936         }
1937         if dr := (*(*(struct {
1938                 Reason KickReason
1939
1940                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1941                 Custom string
1942
1943                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1944                 Reconnect bool
1945         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
1946                 if len(([]byte((*(*(struct {
1947                         Reason KickReason
1948
1949                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1950                         Custom string
1951
1952                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1953                         Reconnect bool
1954                 }))(obj)).Custom))) > math.MaxUint16 {
1955                         chk(ErrTooLong)
1956                 }
1957                 {
1958                         x := uint16(len(([]byte((*(*(struct {
1959                                 Reason KickReason
1960
1961                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1962                                 Custom string
1963
1964                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1965                                 Reconnect bool
1966                         }))(obj)).Custom))))
1967                         write16(w, uint16(x))
1968                 }
1969                 {
1970                         _, err := w.Write(([]byte((*(*(struct {
1971                                 Reason KickReason
1972
1973                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1974                                 Custom string
1975
1976                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1977                                 Reconnect bool
1978                         }))(obj)).Custom))[:])
1979                         chk(err)
1980                 }
1981         }
1982         if dr := (*(*(struct {
1983                 Reason KickReason
1984
1985                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1986                 Custom string
1987
1988                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1989                 Reconnect bool
1990         }))(obj)).Reason; dr == Shutdown || dr == Crash {
1991                 {
1992                         x := (*(*(struct {
1993                                 Reason KickReason
1994
1995                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1996                                 Custom string
1997
1998                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1999                                 Reconnect bool
2000                         }))(obj)).Reconnect
2001                         if x {
2002                                 write8(w, 1)
2003                         } else {
2004                                 write8(w, 0)
2005                         }
2006
2007                 }
2008         }
2009 }
2010
2011 func (obj *ToCltKick) deserialize(r io.Reader) {
2012         if err := pcall(func() {
2013                 ((*(*(struct {
2014                         Reason KickReason
2015
2016                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2017                         Custom string
2018
2019                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2020                         Reconnect bool
2021                 }))(obj)).Reason).deserialize(r)
2022         }); err != nil {
2023                 if err == io.EOF {
2024                         chk(io.EOF)
2025                 }
2026                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.KickReason", err))
2027         }
2028         if !((*(*(struct {
2029                 Reason KickReason
2030
2031                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2032                 Custom string
2033
2034                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2035                 Reconnect bool
2036         }))(obj)).Reason < maxKickReason) {
2037                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
2038         }
2039         if dr := (*(*(struct {
2040                 Reason KickReason
2041
2042                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2043                 Custom string
2044
2045                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2046                 Reconnect bool
2047         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
2048                 var local60 []uint8
2049                 var local61 uint16
2050                 {
2051                         p := &local61
2052                         *p = read16(r)
2053                 }
2054                 (local60) = make([]uint8, local61)
2055                 {
2056                         _, err := io.ReadFull(r, (local60)[:])
2057                         chk(err)
2058                 }
2059                 ((*(*(struct {
2060                         Reason KickReason
2061
2062                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2063                         Custom string
2064
2065                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2066                         Reconnect bool
2067                 }))(obj)).Custom) = string(local60)
2068         }
2069         if dr := (*(*(struct {
2070                 Reason KickReason
2071
2072                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2073                 Custom string
2074
2075                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2076                 Reconnect bool
2077         }))(obj)).Reason; dr == Shutdown || dr == Crash {
2078                 {
2079                         p := &(*(*(struct {
2080                                 Reason KickReason
2081
2082                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2083                                 Custom string
2084
2085                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2086                                 Reconnect bool
2087                         }))(obj)).Reconnect
2088                         switch n := read8(r); n {
2089                         case 0:
2090                                 *p = false
2091                         case 1:
2092                                 *p = true
2093                         default:
2094                                 chk(fmt.Errorf("invalid bool: %d", n))
2095                         }
2096
2097                 }
2098         }
2099 }
2100
2101 func (obj *ToCltBlkData) serialize(w io.Writer) {
2102         for local62 := range (*(*(struct {
2103                 Blkpos [3]int16
2104                 Blk    MapBlk
2105         }))(obj)).Blkpos {
2106                 {
2107                         x := ((*(*(struct {
2108                                 Blkpos [3]int16
2109                                 Blk    MapBlk
2110                         }))(obj)).Blkpos)[local62]
2111                         write16(w, uint16(x))
2112                 }
2113         }
2114         if err := pcall(func() {
2115                 ((*(*(struct {
2116                         Blkpos [3]int16
2117                         Blk    MapBlk
2118                 }))(obj)).Blk).serialize(w)
2119         }); err != nil {
2120                 if err == io.EOF {
2121                         chk(io.EOF)
2122                 }
2123                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlk", err))
2124         }
2125 }
2126
2127 func (obj *ToCltBlkData) deserialize(r io.Reader) {
2128         for local63 := range (*(*(struct {
2129                 Blkpos [3]int16
2130                 Blk    MapBlk
2131         }))(obj)).Blkpos {
2132                 {
2133                         p := &((*(*(struct {
2134                                 Blkpos [3]int16
2135                                 Blk    MapBlk
2136                         }))(obj)).Blkpos)[local63]
2137                         *p = int16(read16(r))
2138                 }
2139         }
2140         if err := pcall(func() {
2141                 ((*(*(struct {
2142                         Blkpos [3]int16
2143                         Blk    MapBlk
2144                 }))(obj)).Blk).deserialize(r)
2145         }); err != nil {
2146                 if err == io.EOF {
2147                         chk(io.EOF)
2148                 }
2149                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlk", err))
2150         }
2151 }
2152
2153 func (obj *ToCltAddNode) serialize(w io.Writer) {
2154         for local64 := range (*(*(struct {
2155                 Pos [3]int16
2156                 Node
2157                 KeepMeta bool
2158         }))(obj)).Pos {
2159                 {
2160                         x := ((*(*(struct {
2161                                 Pos [3]int16
2162                                 Node
2163                                 KeepMeta bool
2164                         }))(obj)).Pos)[local64]
2165                         write16(w, uint16(x))
2166                 }
2167         }
2168         if err := pcall(func() {
2169                 ((*(*(struct {
2170                         Pos [3]int16
2171                         Node
2172                         KeepMeta bool
2173                 }))(obj)).Node).serialize(w)
2174         }); err != nil {
2175                 if err == io.EOF {
2176                         chk(io.EOF)
2177                 }
2178                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Node", err))
2179         }
2180         {
2181                 x := (*(*(struct {
2182                         Pos [3]int16
2183                         Node
2184                         KeepMeta bool
2185                 }))(obj)).KeepMeta
2186                 if x {
2187                         write8(w, 1)
2188                 } else {
2189                         write8(w, 0)
2190                 }
2191
2192         }
2193 }
2194
2195 func (obj *ToCltAddNode) deserialize(r io.Reader) {
2196         for local65 := range (*(*(struct {
2197                 Pos [3]int16
2198                 Node
2199                 KeepMeta bool
2200         }))(obj)).Pos {
2201                 {
2202                         p := &((*(*(struct {
2203                                 Pos [3]int16
2204                                 Node
2205                                 KeepMeta bool
2206                         }))(obj)).Pos)[local65]
2207                         *p = int16(read16(r))
2208                 }
2209         }
2210         if err := pcall(func() {
2211                 ((*(*(struct {
2212                         Pos [3]int16
2213                         Node
2214                         KeepMeta bool
2215                 }))(obj)).Node).deserialize(r)
2216         }); err != nil {
2217                 if err == io.EOF {
2218                         chk(io.EOF)
2219                 }
2220                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Node", err))
2221         }
2222         {
2223                 p := &(*(*(struct {
2224                         Pos [3]int16
2225                         Node
2226                         KeepMeta bool
2227                 }))(obj)).KeepMeta
2228                 switch n := read8(r); n {
2229                 case 0:
2230                         *p = false
2231                 case 1:
2232                         *p = true
2233                 default:
2234                         chk(fmt.Errorf("invalid bool: %d", n))
2235                 }
2236
2237         }
2238 }
2239
2240 func (obj *ToCltRemoveNode) serialize(w io.Writer) {
2241         for local66 := range (*(*(struct {
2242                 Pos [3]int16
2243         }))(obj)).Pos {
2244                 {
2245                         x := ((*(*(struct {
2246                                 Pos [3]int16
2247                         }))(obj)).Pos)[local66]
2248                         write16(w, uint16(x))
2249                 }
2250         }
2251 }
2252
2253 func (obj *ToCltRemoveNode) deserialize(r io.Reader) {
2254         for local67 := range (*(*(struct {
2255                 Pos [3]int16
2256         }))(obj)).Pos {
2257                 {
2258                         p := &((*(*(struct {
2259                                 Pos [3]int16
2260                         }))(obj)).Pos)[local67]
2261                         *p = int16(read16(r))
2262                 }
2263         }
2264 }
2265
2266 func (obj *ToCltInv) serialize(w io.Writer) {
2267         {
2268                 _, err := w.Write(([]byte((*(*(struct {
2269                         //mt:raw
2270                         Inv string
2271                 }))(obj)).Inv))[:])
2272                 chk(err)
2273         }
2274 }
2275
2276 func (obj *ToCltInv) deserialize(r io.Reader) {
2277         var local68 []uint8
2278         {
2279                 var err error
2280                 (local68), err = io.ReadAll(r)
2281                 chk(err)
2282         }
2283         ((*(*(struct {
2284                 //mt:raw
2285                 Inv string
2286         }))(obj)).Inv) = string(local68)
2287 }
2288
2289 func (obj *ToCltTimeOfDay) serialize(w io.Writer) {
2290         {
2291                 x := (*(*(struct {
2292                         Time  uint16  // %24000
2293                         Speed float32 // Speed times faster than real time
2294                 }))(obj)).Time
2295                 write16(w, uint16(x))
2296         }
2297         {
2298                 x := (*(*(struct {
2299                         Time  uint16  // %24000
2300                         Speed float32 // Speed times faster than real time
2301                 }))(obj)).Speed
2302                 write32(w, math.Float32bits(x))
2303         }
2304 }
2305
2306 func (obj *ToCltTimeOfDay) deserialize(r io.Reader) {
2307         {
2308                 p := &(*(*(struct {
2309                         Time  uint16  // %24000
2310                         Speed float32 // Speed times faster than real time
2311                 }))(obj)).Time
2312                 *p = read16(r)
2313         }
2314         {
2315                 p := &(*(*(struct {
2316                         Time  uint16  // %24000
2317                         Speed float32 // Speed times faster than real time
2318                 }))(obj)).Speed
2319                 *p = math.Float32frombits(read32(r))
2320         }
2321 }
2322
2323 func (obj *ToCltCSMRestrictionFlags) serialize(w io.Writer) {
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).serialize(w)
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                 x := (*(*(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                 write32(w, uint32(x))
2347         }
2348 }
2349
2350 func (obj *ToCltCSMRestrictionFlags) deserialize(r io.Reader) {
2351         if err := pcall(func() {
2352                 ((*(*(struct {
2353                         Flags CSMRestrictionFlags
2354
2355                         // MapRange is the maximum distance from the player CSMs can read the map
2356                         // if Flags&LimitMapRange != 0.
2357                         MapRange uint32
2358                 }))(obj)).Flags).deserialize(r)
2359         }); err != nil {
2360                 if err == io.EOF {
2361                         chk(io.EOF)
2362                 }
2363                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CSMRestrictionFlags", err))
2364         }
2365         {
2366                 p := &(*(*(struct {
2367                         Flags CSMRestrictionFlags
2368
2369                         // MapRange is the maximum distance from the player CSMs can read the map
2370                         // if Flags&LimitMapRange != 0.
2371                         MapRange uint32
2372                 }))(obj)).MapRange
2373                 *p = read32(r)
2374         }
2375 }
2376
2377 func (obj *ToCltAddPlayerVel) serialize(w io.Writer) {
2378         if err := pcall(func() {
2379                 ((*(*(struct {
2380                         Vel Vec
2381                 }))(obj)).Vel).serialize(w)
2382         }); err != nil {
2383                 if err == io.EOF {
2384                         chk(io.EOF)
2385                 }
2386                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
2387         }
2388 }
2389
2390 func (obj *ToCltAddPlayerVel) deserialize(r io.Reader) {
2391         if err := pcall(func() {
2392                 ((*(*(struct {
2393                         Vel Vec
2394                 }))(obj)).Vel).deserialize(r)
2395         }); err != nil {
2396                 if err == io.EOF {
2397                         chk(io.EOF)
2398                 }
2399                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
2400         }
2401 }
2402
2403 func (obj *ToCltMediaPush) serialize(w io.Writer) {
2404         {
2405                 local69 := uint16(sha1.Size)
2406                 {
2407                         x := local69
2408                         write16(w, uint16(x))
2409                 }
2410         }
2411         {
2412                 _, err := w.Write(((*(*(struct {
2413                         //mt:const uint16(sha1.Size)
2414                         SHA1        [sha1.Size]byte
2415                         Filename    string
2416                         ShouldCache bool
2417
2418                         //mt:len32
2419                         Data []byte
2420                 }))(obj)).SHA1)[:])
2421                 chk(err)
2422         }
2423         if len(([]byte((*(*(struct {
2424                 //mt:const uint16(sha1.Size)
2425                 SHA1        [sha1.Size]byte
2426                 Filename    string
2427                 ShouldCache bool
2428
2429                 //mt:len32
2430                 Data []byte
2431         }))(obj)).Filename))) > math.MaxUint16 {
2432                 chk(ErrTooLong)
2433         }
2434         {
2435                 x := uint16(len(([]byte((*(*(struct {
2436                         //mt:const uint16(sha1.Size)
2437                         SHA1        [sha1.Size]byte
2438                         Filename    string
2439                         ShouldCache bool
2440
2441                         //mt:len32
2442                         Data []byte
2443                 }))(obj)).Filename))))
2444                 write16(w, uint16(x))
2445         }
2446         {
2447                 _, err := w.Write(([]byte((*(*(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)).Filename))[:])
2456                 chk(err)
2457         }
2458         {
2459                 x := (*(*(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)).ShouldCache
2468                 if x {
2469                         write8(w, 1)
2470                 } else {
2471                         write8(w, 0)
2472                 }
2473
2474         }
2475         if len(((*(*(struct {
2476                 //mt:const uint16(sha1.Size)
2477                 SHA1        [sha1.Size]byte
2478                 Filename    string
2479                 ShouldCache bool
2480
2481                 //mt:len32
2482                 Data []byte
2483         }))(obj)).Data)) > math.MaxUint32 {
2484                 chk(ErrTooLong)
2485         }
2486         {
2487                 x := uint32(len(((*(*(struct {
2488                         //mt:const uint16(sha1.Size)
2489                         SHA1        [sha1.Size]byte
2490                         Filename    string
2491                         ShouldCache bool
2492
2493                         //mt:len32
2494                         Data []byte
2495                 }))(obj)).Data)))
2496                 write32(w, uint32(x))
2497         }
2498         {
2499                 _, err := w.Write(((*(*(struct {
2500                         //mt:const uint16(sha1.Size)
2501                         SHA1        [sha1.Size]byte
2502                         Filename    string
2503                         ShouldCache bool
2504
2505                         //mt:len32
2506                         Data []byte
2507                 }))(obj)).Data)[:])
2508                 chk(err)
2509         }
2510 }
2511
2512 func (obj *ToCltMediaPush) deserialize(r io.Reader) {
2513         {
2514                 var local70 uint16
2515                 local71 := uint16(sha1.Size)
2516                 {
2517                         p := &local70
2518                         *p = read16(r)
2519                 }
2520                 if local70 != local71 {
2521                         chk(fmt.Errorf("const %v: %v", "uint16(sha1.Size)", local70))
2522                 }
2523         }
2524         {
2525                 _, err := io.ReadFull(r, ((*(*(struct {
2526                         //mt:const uint16(sha1.Size)
2527                         SHA1        [sha1.Size]byte
2528                         Filename    string
2529                         ShouldCache bool
2530
2531                         //mt:len32
2532                         Data []byte
2533                 }))(obj)).SHA1)[:])
2534                 chk(err)
2535         }
2536         var local72 []uint8
2537         var local73 uint16
2538         {
2539                 p := &local73
2540                 *p = read16(r)
2541         }
2542         (local72) = make([]uint8, local73)
2543         {
2544                 _, err := io.ReadFull(r, (local72)[:])
2545                 chk(err)
2546         }
2547         ((*(*(struct {
2548                 //mt:const uint16(sha1.Size)
2549                 SHA1        [sha1.Size]byte
2550                 Filename    string
2551                 ShouldCache bool
2552
2553                 //mt:len32
2554                 Data []byte
2555         }))(obj)).Filename) = string(local72)
2556         {
2557                 p := &(*(*(struct {
2558                         //mt:const uint16(sha1.Size)
2559                         SHA1        [sha1.Size]byte
2560                         Filename    string
2561                         ShouldCache bool
2562
2563                         //mt:len32
2564                         Data []byte
2565                 }))(obj)).ShouldCache
2566                 switch n := read8(r); n {
2567                 case 0:
2568                         *p = false
2569                 case 1:
2570                         *p = true
2571                 default:
2572                         chk(fmt.Errorf("invalid bool: %d", n))
2573                 }
2574
2575         }
2576         var local74 uint32
2577         {
2578                 p := &local74
2579                 *p = read32(r)
2580         }
2581         ((*(*(struct {
2582                 //mt:const uint16(sha1.Size)
2583                 SHA1        [sha1.Size]byte
2584                 Filename    string
2585                 ShouldCache bool
2586
2587                 //mt:len32
2588                 Data []byte
2589         }))(obj)).Data) = make([]byte, local74)
2590         {
2591                 _, err := io.ReadFull(r, ((*(*(struct {
2592                         //mt:const uint16(sha1.Size)
2593                         SHA1        [sha1.Size]byte
2594                         Filename    string
2595                         ShouldCache bool
2596
2597                         //mt:len32
2598                         Data []byte
2599                 }))(obj)).Data)[:])
2600                 chk(err)
2601         }
2602 }
2603
2604 func (obj *ToCltChatMsg) serialize(w io.Writer) {
2605         {
2606                 local75 := uint8(1)
2607                 {
2608                         x := local75
2609                         write8(w, uint8(x))
2610                 }
2611         }
2612         if err := pcall(func() {
2613                 ((*(*(struct {
2614                         Type ChatMsgType
2615
2616                         //mt:utf16
2617                         Sender, Text string
2618
2619                         Timestamp int64 // Unix time.
2620                 }))(obj)).Type).serialize(w)
2621         }); err != nil {
2622                 if err == io.EOF {
2623                         chk(io.EOF)
2624                 }
2625                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
2626         }
2627         local76 := utf16.Encode([]rune((*(*(struct {
2628                 Type ChatMsgType
2629
2630                 //mt:utf16
2631                 Sender, Text string
2632
2633                 Timestamp int64 // Unix time.
2634         }))(obj)).Sender))
2635         if len((local76)) > math.MaxUint16 {
2636                 chk(ErrTooLong)
2637         }
2638         {
2639                 x := uint16(len((local76)))
2640                 write16(w, uint16(x))
2641         }
2642         for local77 := range local76 {
2643                 {
2644                         x := (local76)[local77]
2645                         write16(w, uint16(x))
2646                 }
2647         }
2648         local78 := utf16.Encode([]rune((*(*(struct {
2649                 Type ChatMsgType
2650
2651                 //mt:utf16
2652                 Sender, Text string
2653
2654                 Timestamp int64 // Unix time.
2655         }))(obj)).Text))
2656         if len((local78)) > math.MaxUint16 {
2657                 chk(ErrTooLong)
2658         }
2659         {
2660                 x := uint16(len((local78)))
2661                 write16(w, uint16(x))
2662         }
2663         for local79 := range local78 {
2664                 {
2665                         x := (local78)[local79]
2666                         write16(w, uint16(x))
2667                 }
2668         }
2669         {
2670                 x := (*(*(struct {
2671                         Type ChatMsgType
2672
2673                         //mt:utf16
2674                         Sender, Text string
2675
2676                         Timestamp int64 // Unix time.
2677                 }))(obj)).Timestamp
2678                 write64(w, uint64(x))
2679
2680         }
2681 }
2682
2683 func (obj *ToCltChatMsg) deserialize(r io.Reader) {
2684         {
2685                 var local80 uint8
2686                 local81 := uint8(1)
2687                 {
2688                         p := &local80
2689                         *p = read8(r)
2690                 }
2691                 if local80 != local81 {
2692                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local80))
2693                 }
2694         }
2695         if err := pcall(func() {
2696                 ((*(*(struct {
2697                         Type ChatMsgType
2698
2699                         //mt:utf16
2700                         Sender, Text string
2701
2702                         Timestamp int64 // Unix time.
2703                 }))(obj)).Type).deserialize(r)
2704         }); err != nil {
2705                 if err == io.EOF {
2706                         chk(io.EOF)
2707                 }
2708                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
2709         }
2710         var local82 []uint16
2711         var local83 uint16
2712         {
2713                 p := &local83
2714                 *p = read16(r)
2715         }
2716         (local82) = make([]uint16, local83)
2717         for local84 := range local82 {
2718                 {
2719                         p := &(local82)[local84]
2720                         *p = read16(r)
2721                 }
2722         }
2723         (*(*(struct {
2724                 Type ChatMsgType
2725
2726                 //mt:utf16
2727                 Sender, Text string
2728
2729                 Timestamp int64 // Unix time.
2730         }))(obj)).Sender = string(utf16.Decode(local82))
2731         var local85 []uint16
2732         var local86 uint16
2733         {
2734                 p := &local86
2735                 *p = read16(r)
2736         }
2737         (local85) = make([]uint16, local86)
2738         for local87 := range local85 {
2739                 {
2740                         p := &(local85)[local87]
2741                         *p = read16(r)
2742                 }
2743         }
2744         (*(*(struct {
2745                 Type ChatMsgType
2746
2747                 //mt:utf16
2748                 Sender, Text string
2749
2750                 Timestamp int64 // Unix time.
2751         }))(obj)).Text = string(utf16.Decode(local85))
2752         {
2753                 p := &(*(*(struct {
2754                         Type ChatMsgType
2755
2756                         //mt:utf16
2757                         Sender, Text string
2758
2759                         Timestamp int64 // Unix time.
2760                 }))(obj)).Timestamp
2761                 *p = int64(read64(r))
2762
2763         }
2764 }
2765
2766 func (obj *ToCltAORmAdd) serialize(w io.Writer) {
2767         if len(((*(*(struct {
2768                 Remove []AOID
2769                 Add    []AOAdd
2770         }))(obj)).Remove)) > math.MaxUint16 {
2771                 chk(ErrTooLong)
2772         }
2773         {
2774                 x := uint16(len(((*(*(struct {
2775                         Remove []AOID
2776                         Add    []AOAdd
2777                 }))(obj)).Remove)))
2778                 write16(w, uint16(x))
2779         }
2780         for local88 := range (*(*(struct {
2781                 Remove []AOID
2782                 Add    []AOAdd
2783         }))(obj)).Remove {
2784                 if err := pcall(func() {
2785                         (((*(*(struct {
2786                                 Remove []AOID
2787                                 Add    []AOAdd
2788                         }))(obj)).Remove)[local88]).serialize(w)
2789                 }); err != nil {
2790                         if err == io.EOF {
2791                                 chk(io.EOF)
2792                         }
2793                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2794                 }
2795         }
2796         if len(((*(*(struct {
2797                 Remove []AOID
2798                 Add    []AOAdd
2799         }))(obj)).Add)) > math.MaxUint16 {
2800                 chk(ErrTooLong)
2801         }
2802         {
2803                 x := uint16(len(((*(*(struct {
2804                         Remove []AOID
2805                         Add    []AOAdd
2806                 }))(obj)).Add)))
2807                 write16(w, uint16(x))
2808         }
2809         for local89 := range (*(*(struct {
2810                 Remove []AOID
2811                 Add    []AOAdd
2812         }))(obj)).Add {
2813                 if err := pcall(func() {
2814                         (((*(*(struct {
2815                                 Remove []AOID
2816                                 Add    []AOAdd
2817                         }))(obj)).Add)[local89]).serialize(w)
2818                 }); err != nil {
2819                         if err == io.EOF {
2820                                 chk(io.EOF)
2821                         }
2822                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAdd", err))
2823                 }
2824         }
2825 }
2826
2827 func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
2828         var local90 uint16
2829         {
2830                 p := &local90
2831                 *p = read16(r)
2832         }
2833         ((*(*(struct {
2834                 Remove []AOID
2835                 Add    []AOAdd
2836         }))(obj)).Remove) = make([]AOID, local90)
2837         for local91 := range (*(*(struct {
2838                 Remove []AOID
2839                 Add    []AOAdd
2840         }))(obj)).Remove {
2841                 if err := pcall(func() {
2842                         (((*(*(struct {
2843                                 Remove []AOID
2844                                 Add    []AOAdd
2845                         }))(obj)).Remove)[local91]).deserialize(r)
2846                 }); err != nil {
2847                         if err == io.EOF {
2848                                 chk(io.EOF)
2849                         }
2850                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2851                 }
2852         }
2853         var local92 uint16
2854         {
2855                 p := &local92
2856                 *p = read16(r)
2857         }
2858         ((*(*(struct {
2859                 Remove []AOID
2860                 Add    []AOAdd
2861         }))(obj)).Add) = make([]AOAdd, local92)
2862         for local93 := range (*(*(struct {
2863                 Remove []AOID
2864                 Add    []AOAdd
2865         }))(obj)).Add {
2866                 if err := pcall(func() {
2867                         (((*(*(struct {
2868                                 Remove []AOID
2869                                 Add    []AOAdd
2870                         }))(obj)).Add)[local93]).deserialize(r)
2871                 }); err != nil {
2872                         if err == io.EOF {
2873                                 chk(io.EOF)
2874                         }
2875                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAdd", err))
2876                 }
2877         }
2878 }
2879
2880 func (obj *ToCltAOMsgs) serialize(w io.Writer) {
2881         for local94 := range (*(*(struct {
2882                 //mt:raw
2883                 Msgs []IDAOMsg
2884         }))(obj)).Msgs {
2885                 if err := pcall(func() {
2886                         (((*(*(struct {
2887                                 //mt:raw
2888                                 Msgs []IDAOMsg
2889                         }))(obj)).Msgs)[local94]).serialize(w)
2890                 }); err != nil {
2891                         if err == io.EOF {
2892                                 chk(io.EOF)
2893                         }
2894                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.IDAOMsg", err))
2895                 }
2896         }
2897 }
2898
2899 func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
2900         for {
2901                 var local95 IDAOMsg
2902                 err := pcall(func() {
2903                         if err := pcall(func() {
2904                                 (local95).deserialize(r)
2905                         }); err != nil {
2906                                 if err == io.EOF {
2907                                         chk(io.EOF)
2908                                 }
2909                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.IDAOMsg", err))
2910                         }
2911                 })
2912                 if err == io.EOF {
2913                         break
2914                 }
2915                 ((*(*(struct {
2916                         //mt:raw
2917                         Msgs []IDAOMsg
2918                 }))(obj)).Msgs) = append(((*(*(struct {
2919                         //mt:raw
2920                         Msgs []IDAOMsg
2921                 }))(obj)).Msgs), local95)
2922                 chk(err)
2923         }
2924 }
2925
2926 func (obj *ToCltHP) serialize(w io.Writer) {
2927         {
2928                 x := (*(*(struct {
2929                         HP uint16
2930                 }))(obj)).HP
2931                 write16(w, uint16(x))
2932         }
2933 }
2934
2935 func (obj *ToCltHP) deserialize(r io.Reader) {
2936         {
2937                 p := &(*(*(struct {
2938                         HP uint16
2939                 }))(obj)).HP
2940                 *p = read16(r)
2941         }
2942 }
2943
2944 func (obj *ToCltMovePlayer) serialize(w io.Writer) {
2945         if err := pcall(func() {
2946                 ((*(*(struct {
2947                         Pos
2948                         Pitch, Yaw float32
2949                 }))(obj)).Pos).serialize(w)
2950         }); err != nil {
2951                 if err == io.EOF {
2952                         chk(io.EOF)
2953                 }
2954                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
2955         }
2956         {
2957                 x := (*(*(struct {
2958                         Pos
2959                         Pitch, Yaw float32
2960                 }))(obj)).Pitch
2961                 write32(w, math.Float32bits(x))
2962         }
2963         {
2964                 x := (*(*(struct {
2965                         Pos
2966                         Pitch, Yaw float32
2967                 }))(obj)).Yaw
2968                 write32(w, math.Float32bits(x))
2969         }
2970 }
2971
2972 func (obj *ToCltMovePlayer) deserialize(r io.Reader) {
2973         if err := pcall(func() {
2974                 ((*(*(struct {
2975                         Pos
2976                         Pitch, Yaw float32
2977                 }))(obj)).Pos).deserialize(r)
2978         }); err != nil {
2979                 if err == io.EOF {
2980                         chk(io.EOF)
2981                 }
2982                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
2983         }
2984         {
2985                 p := &(*(*(struct {
2986                         Pos
2987                         Pitch, Yaw float32
2988                 }))(obj)).Pitch
2989                 *p = math.Float32frombits(read32(r))
2990         }
2991         {
2992                 p := &(*(*(struct {
2993                         Pos
2994                         Pitch, Yaw float32
2995                 }))(obj)).Yaw
2996                 *p = math.Float32frombits(read32(r))
2997         }
2998 }
2999
3000 func (obj *ToCltLegacyKick) serialize(w io.Writer) {
3001         local96 := utf16.Encode([]rune((*(*(struct {
3002                 //mt:utf16
3003                 Reason string
3004         }))(obj)).Reason))
3005         if len((local96)) > math.MaxUint16 {
3006                 chk(ErrTooLong)
3007         }
3008         {
3009                 x := uint16(len((local96)))
3010                 write16(w, uint16(x))
3011         }
3012         for local97 := range local96 {
3013                 {
3014                         x := (local96)[local97]
3015                         write16(w, uint16(x))
3016                 }
3017         }
3018 }
3019
3020 func (obj *ToCltLegacyKick) deserialize(r io.Reader) {
3021         var local98 []uint16
3022         var local99 uint16
3023         {
3024                 p := &local99
3025                 *p = read16(r)
3026         }
3027         (local98) = make([]uint16, local99)
3028         for local100 := range local98 {
3029                 {
3030                         p := &(local98)[local100]
3031                         *p = read16(r)
3032                 }
3033         }
3034         (*(*(struct {
3035                 //mt:utf16
3036                 Reason string
3037         }))(obj)).Reason = string(utf16.Decode(local98))
3038 }
3039
3040 func (obj *ToCltFOV) serialize(w io.Writer) {
3041         {
3042                 x := (*(*(struct {
3043                         FOV            float32
3044                         Multiplier     bool
3045                         TransitionTime float32
3046                 }))(obj)).FOV
3047                 write32(w, math.Float32bits(x))
3048         }
3049         {
3050                 x := (*(*(struct {
3051                         FOV            float32
3052                         Multiplier     bool
3053                         TransitionTime float32
3054                 }))(obj)).Multiplier
3055                 if x {
3056                         write8(w, 1)
3057                 } else {
3058                         write8(w, 0)
3059                 }
3060
3061         }
3062         {
3063                 x := (*(*(struct {
3064                         FOV            float32
3065                         Multiplier     bool
3066                         TransitionTime float32
3067                 }))(obj)).TransitionTime
3068                 write32(w, math.Float32bits(x))
3069         }
3070 }
3071
3072 func (obj *ToCltFOV) deserialize(r io.Reader) {
3073         {
3074                 p := &(*(*(struct {
3075                         FOV            float32
3076                         Multiplier     bool
3077                         TransitionTime float32
3078                 }))(obj)).FOV
3079                 *p = math.Float32frombits(read32(r))
3080         }
3081         {
3082                 p := &(*(*(struct {
3083                         FOV            float32
3084                         Multiplier     bool
3085                         TransitionTime float32
3086                 }))(obj)).Multiplier
3087                 switch n := read8(r); n {
3088                 case 0:
3089                         *p = false
3090                 case 1:
3091                         *p = true
3092                 default:
3093                         chk(fmt.Errorf("invalid bool: %d", n))
3094                 }
3095
3096         }
3097         {
3098                 p := &(*(*(struct {
3099                         FOV            float32
3100                         Multiplier     bool
3101                         TransitionTime float32
3102                 }))(obj)).TransitionTime
3103                 *p = math.Float32frombits(read32(r))
3104         }
3105 }
3106
3107 func (obj *ToCltDeathScreen) serialize(w io.Writer) {
3108         {
3109                 x := (*(*(struct {
3110                         PointCam bool
3111                         PointAt  Pos
3112                 }))(obj)).PointCam
3113                 if x {
3114                         write8(w, 1)
3115                 } else {
3116                         write8(w, 0)
3117                 }
3118
3119         }
3120         if err := pcall(func() {
3121                 ((*(*(struct {
3122                         PointCam bool
3123                         PointAt  Pos
3124                 }))(obj)).PointAt).serialize(w)
3125         }); err != nil {
3126                 if err == io.EOF {
3127                         chk(io.EOF)
3128                 }
3129                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3130         }
3131 }
3132
3133 func (obj *ToCltDeathScreen) deserialize(r io.Reader) {
3134         {
3135                 p := &(*(*(struct {
3136                         PointCam bool
3137                         PointAt  Pos
3138                 }))(obj)).PointCam
3139                 switch n := read8(r); n {
3140                 case 0:
3141                         *p = false
3142                 case 1:
3143                         *p = true
3144                 default:
3145                         chk(fmt.Errorf("invalid bool: %d", n))
3146                 }
3147
3148         }
3149         if err := pcall(func() {
3150                 ((*(*(struct {
3151                         PointCam bool
3152                         PointAt  Pos
3153                 }))(obj)).PointAt).deserialize(r)
3154         }); err != nil {
3155                 if err == io.EOF {
3156                         chk(io.EOF)
3157                 }
3158                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3159         }
3160 }
3161
3162 func (obj *ToCltMedia) serialize(w io.Writer) {
3163         {
3164                 x := (*(*(struct {
3165                         // N is the total number of ToCltMedia packets.
3166                         // I is the index of this packet.
3167                         N, I uint16
3168
3169                         //mt:len32
3170                         Files []struct {
3171                                 Name string
3172
3173                                 //mt:len32
3174                                 Data []byte
3175                         }
3176                 }))(obj)).N
3177                 write16(w, uint16(x))
3178         }
3179         {
3180                 x := (*(*(struct {
3181                         // N is the total number of ToCltMedia packets.
3182                         // I is the index of this packet.
3183                         N, I uint16
3184
3185                         //mt:len32
3186                         Files []struct {
3187                                 Name string
3188
3189                                 //mt:len32
3190                                 Data []byte
3191                         }
3192                 }))(obj)).I
3193                 write16(w, uint16(x))
3194         }
3195         if len(((*(*(struct {
3196                 // N is the total number of ToCltMedia packets.
3197                 // I is the index of this packet.
3198                 N, I uint16
3199
3200                 //mt:len32
3201                 Files []struct {
3202                         Name string
3203
3204                         //mt:len32
3205                         Data []byte
3206                 }
3207         }))(obj)).Files)) > math.MaxUint32 {
3208                 chk(ErrTooLong)
3209         }
3210         {
3211                 x := uint32(len(((*(*(struct {
3212                         // N is the total number of ToCltMedia packets.
3213                         // I is the index of this packet.
3214                         N, I uint16
3215
3216                         //mt:len32
3217                         Files []struct {
3218                                 Name string
3219
3220                                 //mt:len32
3221                                 Data []byte
3222                         }
3223                 }))(obj)).Files)))
3224                 write32(w, uint32(x))
3225         }
3226         for local101 := range (*(*(struct {
3227                 // N is the total number of ToCltMedia packets.
3228                 // I is the index of this packet.
3229                 N, I uint16
3230
3231                 //mt:len32
3232                 Files []struct {
3233                         Name string
3234
3235                         //mt:len32
3236                         Data []byte
3237                 }
3238         }))(obj)).Files {
3239                 if len(([]byte((((*(*(struct {
3240                         // N is the total number of ToCltMedia packets.
3241                         // I is the index of this packet.
3242                         N, I uint16
3243
3244                         //mt:len32
3245                         Files []struct {
3246                                 Name string
3247
3248                                 //mt:len32
3249                                 Data []byte
3250                         }
3251                 }))(obj)).Files)[local101]).Name))) > math.MaxUint16 {
3252                         chk(ErrTooLong)
3253                 }
3254                 {
3255                         x := uint16(len(([]byte((((*(*(struct {
3256                                 // N is the total number of ToCltMedia packets.
3257                                 // I is the index of this packet.
3258                                 N, I uint16
3259
3260                                 //mt:len32
3261                                 Files []struct {
3262                                         Name string
3263
3264                                         //mt:len32
3265                                         Data []byte
3266                                 }
3267                         }))(obj)).Files)[local101]).Name))))
3268                         write16(w, uint16(x))
3269                 }
3270                 {
3271                         _, err := w.Write(([]byte((((*(*(struct {
3272                                 // N is the total number of ToCltMedia packets.
3273                                 // I is the index of this packet.
3274                                 N, I uint16
3275
3276                                 //mt:len32
3277                                 Files []struct {
3278                                         Name string
3279
3280                                         //mt:len32
3281                                         Data []byte
3282                                 }
3283                         }))(obj)).Files)[local101]).Name))[:])
3284                         chk(err)
3285                 }
3286                 if len(((((*(*(struct {
3287                         // N is the total number of ToCltMedia packets.
3288                         // I is the index of this packet.
3289                         N, I uint16
3290
3291                         //mt:len32
3292                         Files []struct {
3293                                 Name string
3294
3295                                 //mt:len32
3296                                 Data []byte
3297                         }
3298                 }))(obj)).Files)[local101]).Data)) > math.MaxUint32 {
3299                         chk(ErrTooLong)
3300                 }
3301                 {
3302                         x := uint32(len(((((*(*(struct {
3303                                 // N is the total number of ToCltMedia packets.
3304                                 // I is the index of this packet.
3305                                 N, I uint16
3306
3307                                 //mt:len32
3308                                 Files []struct {
3309                                         Name string
3310
3311                                         //mt:len32
3312                                         Data []byte
3313                                 }
3314                         }))(obj)).Files)[local101]).Data)))
3315                         write32(w, uint32(x))
3316                 }
3317                 {
3318                         _, err := w.Write(((((*(*(struct {
3319                                 // N is the total number of ToCltMedia packets.
3320                                 // I is the index of this packet.
3321                                 N, I uint16
3322
3323                                 //mt:len32
3324                                 Files []struct {
3325                                         Name string
3326
3327                                         //mt:len32
3328                                         Data []byte
3329                                 }
3330                         }))(obj)).Files)[local101]).Data)[:])
3331                         chk(err)
3332                 }
3333         }
3334 }
3335
3336 func (obj *ToCltMedia) deserialize(r io.Reader) {
3337         {
3338                 p := &(*(*(struct {
3339                         // N is the total number of ToCltMedia packets.
3340                         // I is the index of this packet.
3341                         N, I uint16
3342
3343                         //mt:len32
3344                         Files []struct {
3345                                 Name string
3346
3347                                 //mt:len32
3348                                 Data []byte
3349                         }
3350                 }))(obj)).N
3351                 *p = read16(r)
3352         }
3353         {
3354                 p := &(*(*(struct {
3355                         // N is the total number of ToCltMedia packets.
3356                         // I is the index of this packet.
3357                         N, I uint16
3358
3359                         //mt:len32
3360                         Files []struct {
3361                                 Name string
3362
3363                                 //mt:len32
3364                                 Data []byte
3365                         }
3366                 }))(obj)).I
3367                 *p = read16(r)
3368         }
3369         var local102 uint32
3370         {
3371                 p := &local102
3372                 *p = read32(r)
3373         }
3374         ((*(*(struct {
3375                 // N is the total number of ToCltMedia packets.
3376                 // I is the index of this packet.
3377                 N, I uint16
3378
3379                 //mt:len32
3380                 Files []struct {
3381                         Name string
3382
3383                         //mt:len32
3384                         Data []byte
3385                 }
3386         }))(obj)).Files) = make([]struct {
3387                 Name string
3388                 Data []byte
3389         }, local102)
3390         for local103 := range (*(*(struct {
3391                 // N is the total number of ToCltMedia packets.
3392                 // I is the index of this packet.
3393                 N, I uint16
3394
3395                 //mt:len32
3396                 Files []struct {
3397                         Name string
3398
3399                         //mt:len32
3400                         Data []byte
3401                 }
3402         }))(obj)).Files {
3403                 var local104 []uint8
3404                 var local105 uint16
3405                 {
3406                         p := &local105
3407                         *p = read16(r)
3408                 }
3409                 (local104) = make([]uint8, local105)
3410                 {
3411                         _, err := io.ReadFull(r, (local104)[:])
3412                         chk(err)
3413                 }
3414                 ((((*(*(struct {
3415                         // N is the total number of ToCltMedia packets.
3416                         // I is the index of this packet.
3417                         N, I uint16
3418
3419                         //mt:len32
3420                         Files []struct {
3421                                 Name string
3422
3423                                 //mt:len32
3424                                 Data []byte
3425                         }
3426                 }))(obj)).Files)[local103]).Name) = string(local104)
3427                 var local106 uint32
3428                 {
3429                         p := &local106
3430                         *p = read32(r)
3431                 }
3432                 ((((*(*(struct {
3433                         // N is the total number of ToCltMedia packets.
3434                         // I is the index of this packet.
3435                         N, I uint16
3436
3437                         //mt:len32
3438                         Files []struct {
3439                                 Name string
3440
3441                                 //mt:len32
3442                                 Data []byte
3443                         }
3444                 }))(obj)).Files)[local103]).Data) = make([]byte, local106)
3445                 {
3446                         _, err := io.ReadFull(r, ((((*(*(struct {
3447                                 // N is the total number of ToCltMedia packets.
3448                                 // I is the index of this packet.
3449                                 N, I uint16
3450
3451                                 //mt:len32
3452                                 Files []struct {
3453                                         Name string
3454
3455                                         //mt:len32
3456                                         Data []byte
3457                                 }
3458                         }))(obj)).Files)[local103]).Data)[:])
3459                         chk(err)
3460                 }
3461         }
3462 }
3463
3464 func (obj *ToCltNodeDefs) serialize(w io.Writer) {
3465         {
3466                 ow := w
3467                 w := new(bytes.Buffer)
3468                 {
3469                         w := zlib.NewWriter(w)
3470                         {
3471                                 local107 := uint8(1)
3472                                 {
3473                                         x := local107
3474                                         write8(w, uint8(x))
3475                                 }
3476                         }
3477                         {
3478                                 x := (*(*(struct {
3479
3480                                         // See (de)serialize.fmt.
3481                                         Defs []NodeDef
3482                                 }))(obj)).Defs
3483                                 { // For ToCltNodeDefs.Defs.
3484                                         if len(x) > math.MaxUint16 {
3485                                                 chk(ErrTooLong)
3486                                         }
3487                                         write16(w, uint16(len(x)))
3488                                         var b bytes.Buffer
3489                                         for i := range x {
3490                                                 x[i].serialize(&b)
3491                                         }
3492                                         if b.Len() > math.MaxUint32 {
3493                                                 chk(ErrTooLong)
3494                                         }
3495                                         write32(w, uint32(b.Len()))
3496                                         _, err := b.WriteTo(w)
3497                                         chk(err)
3498                                 }
3499                         }
3500                         chk(w.Close())
3501                 }
3502                 {
3503                         buf := w
3504                         w := ow
3505                         if len((buf.Bytes())) > math.MaxUint32 {
3506                                 chk(ErrTooLong)
3507                         }
3508                         {
3509                                 x := uint32(len((buf.Bytes())))
3510                                 write32(w, uint32(x))
3511                         }
3512                         {
3513                                 _, err := w.Write((buf.Bytes())[:])
3514                                 chk(err)
3515                         }
3516                 }
3517         }
3518 }
3519
3520 func (obj *ToCltNodeDefs) deserialize(r io.Reader) {
3521         {
3522                 var n uint32
3523                 {
3524                         p := &n
3525                         *p = read32(r)
3526                 }
3527                 r := &io.LimitedReader{R: r, N: int64(n)}
3528                 {
3529                         r, err := zlib.NewReader(byteReader{r})
3530                         chk(err)
3531                         {
3532                                 var local108 uint8
3533                                 local109 := uint8(1)
3534                                 {
3535                                         p := &local108
3536                                         *p = read8(r)
3537                                 }
3538                                 if local108 != local109 {
3539                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local108))
3540                                 }
3541                         }
3542                         {
3543                                 p := &(*(*(struct {
3544
3545                                         // See (de)serialize.fmt.
3546                                         Defs []NodeDef
3547                                 }))(obj)).Defs
3548                                 { // For ToCltNodeDefs.Defs.
3549                                         *p = make([]NodeDef, read16(r))
3550                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3551                                         for i := range *p {
3552                                                 (*p)[i].deserialize(r)
3553                                         }
3554                                         if r.N > 0 {
3555                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3556                                         }
3557                                 }
3558                         }
3559                         chk(r.Close())
3560                 }
3561                 if r.N > 0 {
3562                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3563                 }
3564         }
3565 }
3566
3567 func (obj *ToCltAnnounceMedia) serialize(w io.Writer) {
3568         if len(((*(*(struct {
3569                 Files []struct {
3570                         Name       string
3571                         Base64SHA1 string
3572                 }
3573                 URL string
3574         }))(obj)).Files)) > math.MaxUint16 {
3575                 chk(ErrTooLong)
3576         }
3577         {
3578                 x := uint16(len(((*(*(struct {
3579                         Files []struct {
3580                                 Name       string
3581                                 Base64SHA1 string
3582                         }
3583                         URL string
3584                 }))(obj)).Files)))
3585                 write16(w, uint16(x))
3586         }
3587         for local110 := range (*(*(struct {
3588                 Files []struct {
3589                         Name       string
3590                         Base64SHA1 string
3591                 }
3592                 URL string
3593         }))(obj)).Files {
3594                 if len(([]byte((((*(*(struct {
3595                         Files []struct {
3596                                 Name       string
3597                                 Base64SHA1 string
3598                         }
3599                         URL string
3600                 }))(obj)).Files)[local110]).Name))) > math.MaxUint16 {
3601                         chk(ErrTooLong)
3602                 }
3603                 {
3604                         x := uint16(len(([]byte((((*(*(struct {
3605                                 Files []struct {
3606                                         Name       string
3607                                         Base64SHA1 string
3608                                 }
3609                                 URL string
3610                         }))(obj)).Files)[local110]).Name))))
3611                         write16(w, uint16(x))
3612                 }
3613                 {
3614                         _, err := w.Write(([]byte((((*(*(struct {
3615                                 Files []struct {
3616                                         Name       string
3617                                         Base64SHA1 string
3618                                 }
3619                                 URL string
3620                         }))(obj)).Files)[local110]).Name))[:])
3621                         chk(err)
3622                 }
3623                 if len(([]byte((((*(*(struct {
3624                         Files []struct {
3625                                 Name       string
3626                                 Base64SHA1 string
3627                         }
3628                         URL string
3629                 }))(obj)).Files)[local110]).Base64SHA1))) > math.MaxUint16 {
3630                         chk(ErrTooLong)
3631                 }
3632                 {
3633                         x := uint16(len(([]byte((((*(*(struct {
3634                                 Files []struct {
3635                                         Name       string
3636                                         Base64SHA1 string
3637                                 }
3638                                 URL string
3639                         }))(obj)).Files)[local110]).Base64SHA1))))
3640                         write16(w, uint16(x))
3641                 }
3642                 {
3643                         _, err := w.Write(([]byte((((*(*(struct {
3644                                 Files []struct {
3645                                         Name       string
3646                                         Base64SHA1 string
3647                                 }
3648                                 URL string
3649                         }))(obj)).Files)[local110]).Base64SHA1))[:])
3650                         chk(err)
3651                 }
3652         }
3653         if len(([]byte((*(*(struct {
3654                 Files []struct {
3655                         Name       string
3656                         Base64SHA1 string
3657                 }
3658                 URL string
3659         }))(obj)).URL))) > math.MaxUint16 {
3660                 chk(ErrTooLong)
3661         }
3662         {
3663                 x := uint16(len(([]byte((*(*(struct {
3664                         Files []struct {
3665                                 Name       string
3666                                 Base64SHA1 string
3667                         }
3668                         URL string
3669                 }))(obj)).URL))))
3670                 write16(w, uint16(x))
3671         }
3672         {
3673                 _, err := w.Write(([]byte((*(*(struct {
3674                         Files []struct {
3675                                 Name       string
3676                                 Base64SHA1 string
3677                         }
3678                         URL string
3679                 }))(obj)).URL))[:])
3680                 chk(err)
3681         }
3682 }
3683
3684 func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
3685         var local111 uint16
3686         {
3687                 p := &local111
3688                 *p = read16(r)
3689         }
3690         ((*(*(struct {
3691                 Files []struct {
3692                         Name       string
3693                         Base64SHA1 string
3694                 }
3695                 URL string
3696         }))(obj)).Files) = make([]struct {
3697                 Name       string
3698                 Base64SHA1 string
3699         }, local111)
3700         for local112 := range (*(*(struct {
3701                 Files []struct {
3702                         Name       string
3703                         Base64SHA1 string
3704                 }
3705                 URL string
3706         }))(obj)).Files {
3707                 var local113 []uint8
3708                 var local114 uint16
3709                 {
3710                         p := &local114
3711                         *p = read16(r)
3712                 }
3713                 (local113) = make([]uint8, local114)
3714                 {
3715                         _, err := io.ReadFull(r, (local113)[:])
3716                         chk(err)
3717                 }
3718                 ((((*(*(struct {
3719                         Files []struct {
3720                                 Name       string
3721                                 Base64SHA1 string
3722                         }
3723                         URL string
3724                 }))(obj)).Files)[local112]).Name) = string(local113)
3725                 var local115 []uint8
3726                 var local116 uint16
3727                 {
3728                         p := &local116
3729                         *p = read16(r)
3730                 }
3731                 (local115) = make([]uint8, local116)
3732                 {
3733                         _, err := io.ReadFull(r, (local115)[:])
3734                         chk(err)
3735                 }
3736                 ((((*(*(struct {
3737                         Files []struct {
3738                                 Name       string
3739                                 Base64SHA1 string
3740                         }
3741                         URL string
3742                 }))(obj)).Files)[local112]).Base64SHA1) = string(local115)
3743         }
3744         var local117 []uint8
3745         var local118 uint16
3746         {
3747                 p := &local118
3748                 *p = read16(r)
3749         }
3750         (local117) = make([]uint8, local118)
3751         {
3752                 _, err := io.ReadFull(r, (local117)[:])
3753                 chk(err)
3754         }
3755         ((*(*(struct {
3756                 Files []struct {
3757                         Name       string
3758                         Base64SHA1 string
3759                 }
3760                 URL string
3761         }))(obj)).URL) = string(local117)
3762 }
3763
3764 func (obj *ToCltItemDefs) serialize(w io.Writer) {
3765         {
3766                 ow := w
3767                 w := new(bytes.Buffer)
3768                 {
3769                         w := zlib.NewWriter(w)
3770                         {
3771                                 local119 := uint8(0)
3772                                 {
3773                                         x := local119
3774                                         write8(w, uint8(x))
3775                                 }
3776                         }
3777                         if len(((*(*(struct {
3778                                 Defs    []ItemDef
3779                                 Aliases []struct{ Alias, Orig string }
3780                         }))(obj)).Defs)) > math.MaxUint16 {
3781                                 chk(ErrTooLong)
3782                         }
3783                         {
3784                                 x := uint16(len(((*(*(struct {
3785                                         Defs    []ItemDef
3786                                         Aliases []struct{ Alias, Orig string }
3787                                 }))(obj)).Defs)))
3788                                 write16(w, uint16(x))
3789                         }
3790                         for local120 := range (*(*(struct {
3791                                 Defs    []ItemDef
3792                                 Aliases []struct{ Alias, Orig string }
3793                         }))(obj)).Defs {
3794                                 if err := pcall(func() {
3795                                         (((*(*(struct {
3796                                                 Defs    []ItemDef
3797                                                 Aliases []struct{ Alias, Orig string }
3798                                         }))(obj)).Defs)[local120]).serialize(w)
3799                                 }); err != nil {
3800                                         if err == io.EOF {
3801                                                 chk(io.EOF)
3802                                         }
3803                                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
3804                                 }
3805                         }
3806                         if len(((*(*(struct {
3807                                 Defs    []ItemDef
3808                                 Aliases []struct{ Alias, Orig string }
3809                         }))(obj)).Aliases)) > math.MaxUint16 {
3810                                 chk(ErrTooLong)
3811                         }
3812                         {
3813                                 x := uint16(len(((*(*(struct {
3814                                         Defs    []ItemDef
3815                                         Aliases []struct{ Alias, Orig string }
3816                                 }))(obj)).Aliases)))
3817                                 write16(w, uint16(x))
3818                         }
3819                         for local121 := range (*(*(struct {
3820                                 Defs    []ItemDef
3821                                 Aliases []struct{ Alias, Orig string }
3822                         }))(obj)).Aliases {
3823                                 if len(([]byte((((*(*(struct {
3824                                         Defs    []ItemDef
3825                                         Aliases []struct{ Alias, Orig string }
3826                                 }))(obj)).Aliases)[local121]).Alias))) > math.MaxUint16 {
3827                                         chk(ErrTooLong)
3828                                 }
3829                                 {
3830                                         x := uint16(len(([]byte((((*(*(struct {
3831                                                 Defs    []ItemDef
3832                                                 Aliases []struct{ Alias, Orig string }
3833                                         }))(obj)).Aliases)[local121]).Alias))))
3834                                         write16(w, uint16(x))
3835                                 }
3836                                 {
3837                                         _, err := w.Write(([]byte((((*(*(struct {
3838                                                 Defs    []ItemDef
3839                                                 Aliases []struct{ Alias, Orig string }
3840                                         }))(obj)).Aliases)[local121]).Alias))[:])
3841                                         chk(err)
3842                                 }
3843                                 if len(([]byte((((*(*(struct {
3844                                         Defs    []ItemDef
3845                                         Aliases []struct{ Alias, Orig string }
3846                                 }))(obj)).Aliases)[local121]).Orig))) > math.MaxUint16 {
3847                                         chk(ErrTooLong)
3848                                 }
3849                                 {
3850                                         x := uint16(len(([]byte((((*(*(struct {
3851                                                 Defs    []ItemDef
3852                                                 Aliases []struct{ Alias, Orig string }
3853                                         }))(obj)).Aliases)[local121]).Orig))))
3854                                         write16(w, uint16(x))
3855                                 }
3856                                 {
3857                                         _, err := w.Write(([]byte((((*(*(struct {
3858                                                 Defs    []ItemDef
3859                                                 Aliases []struct{ Alias, Orig string }
3860                                         }))(obj)).Aliases)[local121]).Orig))[:])
3861                                         chk(err)
3862                                 }
3863                         }
3864                         chk(w.Close())
3865                 }
3866                 {
3867                         buf := w
3868                         w := ow
3869                         if len((buf.Bytes())) > math.MaxUint32 {
3870                                 chk(ErrTooLong)
3871                         }
3872                         {
3873                                 x := uint32(len((buf.Bytes())))
3874                                 write32(w, uint32(x))
3875                         }
3876                         {
3877                                 _, err := w.Write((buf.Bytes())[:])
3878                                 chk(err)
3879                         }
3880                 }
3881         }
3882 }
3883
3884 func (obj *ToCltItemDefs) deserialize(r io.Reader) {
3885         {
3886                 var n uint32
3887                 {
3888                         p := &n
3889                         *p = read32(r)
3890                 }
3891                 r := &io.LimitedReader{R: r, N: int64(n)}
3892                 {
3893                         r, err := zlib.NewReader(byteReader{r})
3894                         chk(err)
3895                         {
3896                                 var local122 uint8
3897                                 local123 := uint8(0)
3898                                 {
3899                                         p := &local122
3900                                         *p = read8(r)
3901                                 }
3902                                 if local122 != local123 {
3903                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local122))
3904                                 }
3905                         }
3906                         var local124 uint16
3907                         {
3908                                 p := &local124
3909                                 *p = read16(r)
3910                         }
3911                         ((*(*(struct {
3912                                 Defs    []ItemDef
3913                                 Aliases []struct{ Alias, Orig string }
3914                         }))(obj)).Defs) = make([]ItemDef, local124)
3915                         for local125 := range (*(*(struct {
3916                                 Defs    []ItemDef
3917                                 Aliases []struct{ Alias, Orig string }
3918                         }))(obj)).Defs {
3919                                 if err := pcall(func() {
3920                                         (((*(*(struct {
3921                                                 Defs    []ItemDef
3922                                                 Aliases []struct{ Alias, Orig string }
3923                                         }))(obj)).Defs)[local125]).deserialize(r)
3924                                 }); err != nil {
3925                                         if err == io.EOF {
3926                                                 chk(io.EOF)
3927                                         }
3928                                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
3929                                 }
3930                         }
3931                         var local126 uint16
3932                         {
3933                                 p := &local126
3934                                 *p = read16(r)
3935                         }
3936                         ((*(*(struct {
3937                                 Defs    []ItemDef
3938                                 Aliases []struct{ Alias, Orig string }
3939                         }))(obj)).Aliases) = make([]struct {
3940                                 Alias string
3941                                 Orig  string
3942                         }, local126)
3943                         for local127 := range (*(*(struct {
3944                                 Defs    []ItemDef
3945                                 Aliases []struct{ Alias, Orig string }
3946                         }))(obj)).Aliases {
3947                                 var local128 []uint8
3948                                 var local129 uint16
3949                                 {
3950                                         p := &local129
3951                                         *p = read16(r)
3952                                 }
3953                                 (local128) = make([]uint8, local129)
3954                                 {
3955                                         _, err := io.ReadFull(r, (local128)[:])
3956                                         chk(err)
3957                                 }
3958                                 ((((*(*(struct {
3959                                         Defs    []ItemDef
3960                                         Aliases []struct{ Alias, Orig string }
3961                                 }))(obj)).Aliases)[local127]).Alias) = string(local128)
3962                                 var local130 []uint8
3963                                 var local131 uint16
3964                                 {
3965                                         p := &local131
3966                                         *p = read16(r)
3967                                 }
3968                                 (local130) = make([]uint8, local131)
3969                                 {
3970                                         _, err := io.ReadFull(r, (local130)[:])
3971                                         chk(err)
3972                                 }
3973                                 ((((*(*(struct {
3974                                         Defs    []ItemDef
3975                                         Aliases []struct{ Alias, Orig string }
3976                                 }))(obj)).Aliases)[local127]).Orig) = string(local130)
3977                         }
3978                         chk(r.Close())
3979                 }
3980                 if r.N > 0 {
3981                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3982                 }
3983         }
3984 }
3985
3986 func (obj *ToCltPlaySound) serialize(w io.Writer) {
3987         if err := pcall(func() {
3988                 ((*(*(struct {
3989                         ID      SoundID
3990                         Name    string
3991                         Gain    float32
3992                         SrcType SoundSrcType
3993                         Pos
3994                         SrcAOID   AOID
3995                         Loop      bool
3996                         Fade      float32
3997                         Pitch     float32
3998                         Ephemeral bool
3999                 }))(obj)).ID).serialize(w)
4000         }); err != nil {
4001                 if err == io.EOF {
4002                         chk(io.EOF)
4003                 }
4004                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4005         }
4006         if len(([]byte((*(*(struct {
4007                 ID      SoundID
4008                 Name    string
4009                 Gain    float32
4010                 SrcType SoundSrcType
4011                 Pos
4012                 SrcAOID   AOID
4013                 Loop      bool
4014                 Fade      float32
4015                 Pitch     float32
4016                 Ephemeral bool
4017         }))(obj)).Name))) > math.MaxUint16 {
4018                 chk(ErrTooLong)
4019         }
4020         {
4021                 x := uint16(len(([]byte((*(*(struct {
4022                         ID      SoundID
4023                         Name    string
4024                         Gain    float32
4025                         SrcType SoundSrcType
4026                         Pos
4027                         SrcAOID   AOID
4028                         Loop      bool
4029                         Fade      float32
4030                         Pitch     float32
4031                         Ephemeral bool
4032                 }))(obj)).Name))))
4033                 write16(w, uint16(x))
4034         }
4035         {
4036                 _, err := w.Write(([]byte((*(*(struct {
4037                         ID      SoundID
4038                         Name    string
4039                         Gain    float32
4040                         SrcType SoundSrcType
4041                         Pos
4042                         SrcAOID   AOID
4043                         Loop      bool
4044                         Fade      float32
4045                         Pitch     float32
4046                         Ephemeral bool
4047                 }))(obj)).Name))[:])
4048                 chk(err)
4049         }
4050         {
4051                 x := (*(*(struct {
4052                         ID      SoundID
4053                         Name    string
4054                         Gain    float32
4055                         SrcType SoundSrcType
4056                         Pos
4057                         SrcAOID   AOID
4058                         Loop      bool
4059                         Fade      float32
4060                         Pitch     float32
4061                         Ephemeral bool
4062                 }))(obj)).Gain
4063                 write32(w, math.Float32bits(x))
4064         }
4065         if err := pcall(func() {
4066                 ((*(*(struct {
4067                         ID      SoundID
4068                         Name    string
4069                         Gain    float32
4070                         SrcType SoundSrcType
4071                         Pos
4072                         SrcAOID   AOID
4073                         Loop      bool
4074                         Fade      float32
4075                         Pitch     float32
4076                         Ephemeral bool
4077                 }))(obj)).SrcType).serialize(w)
4078         }); err != nil {
4079                 if err == io.EOF {
4080                         chk(io.EOF)
4081                 }
4082                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundSrcType", err))
4083         }
4084         if err := pcall(func() {
4085                 ((*(*(struct {
4086                         ID      SoundID
4087                         Name    string
4088                         Gain    float32
4089                         SrcType SoundSrcType
4090                         Pos
4091                         SrcAOID   AOID
4092                         Loop      bool
4093                         Fade      float32
4094                         Pitch     float32
4095                         Ephemeral bool
4096                 }))(obj)).Pos).serialize(w)
4097         }); err != nil {
4098                 if err == io.EOF {
4099                         chk(io.EOF)
4100                 }
4101                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
4102         }
4103         if err := pcall(func() {
4104                 ((*(*(struct {
4105                         ID      SoundID
4106                         Name    string
4107                         Gain    float32
4108                         SrcType SoundSrcType
4109                         Pos
4110                         SrcAOID   AOID
4111                         Loop      bool
4112                         Fade      float32
4113                         Pitch     float32
4114                         Ephemeral bool
4115                 }))(obj)).SrcAOID).serialize(w)
4116         }); err != nil {
4117                 if err == io.EOF {
4118                         chk(io.EOF)
4119                 }
4120                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
4121         }
4122         {
4123                 x := (*(*(struct {
4124                         ID      SoundID
4125                         Name    string
4126                         Gain    float32
4127                         SrcType SoundSrcType
4128                         Pos
4129                         SrcAOID   AOID
4130                         Loop      bool
4131                         Fade      float32
4132                         Pitch     float32
4133                         Ephemeral bool
4134                 }))(obj)).Loop
4135                 if x {
4136                         write8(w, 1)
4137                 } else {
4138                         write8(w, 0)
4139                 }
4140
4141         }
4142         {
4143                 x := (*(*(struct {
4144                         ID      SoundID
4145                         Name    string
4146                         Gain    float32
4147                         SrcType SoundSrcType
4148                         Pos
4149                         SrcAOID   AOID
4150                         Loop      bool
4151                         Fade      float32
4152                         Pitch     float32
4153                         Ephemeral bool
4154                 }))(obj)).Fade
4155                 write32(w, math.Float32bits(x))
4156         }
4157         {
4158                 x := (*(*(struct {
4159                         ID      SoundID
4160                         Name    string
4161                         Gain    float32
4162                         SrcType SoundSrcType
4163                         Pos
4164                         SrcAOID   AOID
4165                         Loop      bool
4166                         Fade      float32
4167                         Pitch     float32
4168                         Ephemeral bool
4169                 }))(obj)).Pitch
4170                 write32(w, math.Float32bits(x))
4171         }
4172         {
4173                 x := (*(*(struct {
4174                         ID      SoundID
4175                         Name    string
4176                         Gain    float32
4177                         SrcType SoundSrcType
4178                         Pos
4179                         SrcAOID   AOID
4180                         Loop      bool
4181                         Fade      float32
4182                         Pitch     float32
4183                         Ephemeral bool
4184                 }))(obj)).Ephemeral
4185                 if x {
4186                         write8(w, 1)
4187                 } else {
4188                         write8(w, 0)
4189                 }
4190
4191         }
4192 }
4193
4194 func (obj *ToCltPlaySound) deserialize(r io.Reader) {
4195         if err := pcall(func() {
4196                 ((*(*(struct {
4197                         ID      SoundID
4198                         Name    string
4199                         Gain    float32
4200                         SrcType SoundSrcType
4201                         Pos
4202                         SrcAOID   AOID
4203                         Loop      bool
4204                         Fade      float32
4205                         Pitch     float32
4206                         Ephemeral bool
4207                 }))(obj)).ID).deserialize(r)
4208         }); err != nil {
4209                 if err == io.EOF {
4210                         chk(io.EOF)
4211                 }
4212                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4213         }
4214         var local132 []uint8
4215         var local133 uint16
4216         {
4217                 p := &local133
4218                 *p = read16(r)
4219         }
4220         (local132) = make([]uint8, local133)
4221         {
4222                 _, err := io.ReadFull(r, (local132)[:])
4223                 chk(err)
4224         }
4225         ((*(*(struct {
4226                 ID      SoundID
4227                 Name    string
4228                 Gain    float32
4229                 SrcType SoundSrcType
4230                 Pos
4231                 SrcAOID   AOID
4232                 Loop      bool
4233                 Fade      float32
4234                 Pitch     float32
4235                 Ephemeral bool
4236         }))(obj)).Name) = string(local132)
4237         {
4238                 p := &(*(*(struct {
4239                         ID      SoundID
4240                         Name    string
4241                         Gain    float32
4242                         SrcType SoundSrcType
4243                         Pos
4244                         SrcAOID   AOID
4245                         Loop      bool
4246                         Fade      float32
4247                         Pitch     float32
4248                         Ephemeral bool
4249                 }))(obj)).Gain
4250                 *p = math.Float32frombits(read32(r))
4251         }
4252         if err := pcall(func() {
4253                 ((*(*(struct {
4254                         ID      SoundID
4255                         Name    string
4256                         Gain    float32
4257                         SrcType SoundSrcType
4258                         Pos
4259                         SrcAOID   AOID
4260                         Loop      bool
4261                         Fade      float32
4262                         Pitch     float32
4263                         Ephemeral bool
4264                 }))(obj)).SrcType).deserialize(r)
4265         }); err != nil {
4266                 if err == io.EOF {
4267                         chk(io.EOF)
4268                 }
4269                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundSrcType", err))
4270         }
4271         if err := pcall(func() {
4272                 ((*(*(struct {
4273                         ID      SoundID
4274                         Name    string
4275                         Gain    float32
4276                         SrcType SoundSrcType
4277                         Pos
4278                         SrcAOID   AOID
4279                         Loop      bool
4280                         Fade      float32
4281                         Pitch     float32
4282                         Ephemeral bool
4283                 }))(obj)).Pos).deserialize(r)
4284         }); err != nil {
4285                 if err == io.EOF {
4286                         chk(io.EOF)
4287                 }
4288                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
4289         }
4290         if err := pcall(func() {
4291                 ((*(*(struct {
4292                         ID      SoundID
4293                         Name    string
4294                         Gain    float32
4295                         SrcType SoundSrcType
4296                         Pos
4297                         SrcAOID   AOID
4298                         Loop      bool
4299                         Fade      float32
4300                         Pitch     float32
4301                         Ephemeral bool
4302                 }))(obj)).SrcAOID).deserialize(r)
4303         }); err != nil {
4304                 if err == io.EOF {
4305                         chk(io.EOF)
4306                 }
4307                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
4308         }
4309         {
4310                 p := &(*(*(struct {
4311                         ID      SoundID
4312                         Name    string
4313                         Gain    float32
4314                         SrcType SoundSrcType
4315                         Pos
4316                         SrcAOID   AOID
4317                         Loop      bool
4318                         Fade      float32
4319                         Pitch     float32
4320                         Ephemeral bool
4321                 }))(obj)).Loop
4322                 switch n := read8(r); n {
4323                 case 0:
4324                         *p = false
4325                 case 1:
4326                         *p = true
4327                 default:
4328                         chk(fmt.Errorf("invalid bool: %d", n))
4329                 }
4330
4331         }
4332         {
4333                 p := &(*(*(struct {
4334                         ID      SoundID
4335                         Name    string
4336                         Gain    float32
4337                         SrcType SoundSrcType
4338                         Pos
4339                         SrcAOID   AOID
4340                         Loop      bool
4341                         Fade      float32
4342                         Pitch     float32
4343                         Ephemeral bool
4344                 }))(obj)).Fade
4345                 *p = math.Float32frombits(read32(r))
4346         }
4347         {
4348                 p := &(*(*(struct {
4349                         ID      SoundID
4350                         Name    string
4351                         Gain    float32
4352                         SrcType SoundSrcType
4353                         Pos
4354                         SrcAOID   AOID
4355                         Loop      bool
4356                         Fade      float32
4357                         Pitch     float32
4358                         Ephemeral bool
4359                 }))(obj)).Pitch
4360                 *p = math.Float32frombits(read32(r))
4361         }
4362         {
4363                 p := &(*(*(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)).Ephemeral
4375                 switch n := read8(r); n {
4376                 case 0:
4377                         *p = false
4378                 case 1:
4379                         *p = true
4380                 default:
4381                         chk(fmt.Errorf("invalid bool: %d", n))
4382                 }
4383
4384         }
4385 }
4386
4387 func (obj *ToCltStopSound) serialize(w io.Writer) {
4388         if err := pcall(func() {
4389                 ((*(*(struct {
4390                         ID SoundID
4391                 }))(obj)).ID).serialize(w)
4392         }); err != nil {
4393                 if err == io.EOF {
4394                         chk(io.EOF)
4395                 }
4396                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4397         }
4398 }
4399
4400 func (obj *ToCltStopSound) deserialize(r io.Reader) {
4401         if err := pcall(func() {
4402                 ((*(*(struct {
4403                         ID SoundID
4404                 }))(obj)).ID).deserialize(r)
4405         }); err != nil {
4406                 if err == io.EOF {
4407                         chk(io.EOF)
4408                 }
4409                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4410         }
4411 }
4412
4413 func (obj *ToCltPrivs) serialize(w io.Writer) {
4414         if len(((*(*(struct {
4415                 Privs []string
4416         }))(obj)).Privs)) > math.MaxUint16 {
4417                 chk(ErrTooLong)
4418         }
4419         {
4420                 x := uint16(len(((*(*(struct {
4421                         Privs []string
4422                 }))(obj)).Privs)))
4423                 write16(w, uint16(x))
4424         }
4425         for local134 := range (*(*(struct {
4426                 Privs []string
4427         }))(obj)).Privs {
4428                 if len(([]byte(((*(*(struct {
4429                         Privs []string
4430                 }))(obj)).Privs)[local134]))) > math.MaxUint16 {
4431                         chk(ErrTooLong)
4432                 }
4433                 {
4434                         x := uint16(len(([]byte(((*(*(struct {
4435                                 Privs []string
4436                         }))(obj)).Privs)[local134]))))
4437                         write16(w, uint16(x))
4438                 }
4439                 {
4440                         _, err := w.Write(([]byte(((*(*(struct {
4441                                 Privs []string
4442                         }))(obj)).Privs)[local134]))[:])
4443                         chk(err)
4444                 }
4445         }
4446 }
4447
4448 func (obj *ToCltPrivs) deserialize(r io.Reader) {
4449         var local135 uint16
4450         {
4451                 p := &local135
4452                 *p = read16(r)
4453         }
4454         ((*(*(struct {
4455                 Privs []string
4456         }))(obj)).Privs) = make([]string, local135)
4457         for local136 := range (*(*(struct {
4458                 Privs []string
4459         }))(obj)).Privs {
4460                 var local137 []uint8
4461                 var local138 uint16
4462                 {
4463                         p := &local138
4464                         *p = read16(r)
4465                 }
4466                 (local137) = make([]uint8, local138)
4467                 {
4468                         _, err := io.ReadFull(r, (local137)[:])
4469                         chk(err)
4470                 }
4471                 (((*(*(struct {
4472                         Privs []string
4473                 }))(obj)).Privs)[local136]) = string(local137)
4474         }
4475 }
4476
4477 func (obj *ToCltInvFormspec) serialize(w io.Writer) {
4478         if len(([]byte((*(*(struct {
4479                 //mt:len32
4480                 Formspec string
4481         }))(obj)).Formspec))) > math.MaxUint32 {
4482                 chk(ErrTooLong)
4483         }
4484         {
4485                 x := uint32(len(([]byte((*(*(struct {
4486                         //mt:len32
4487                         Formspec string
4488                 }))(obj)).Formspec))))
4489                 write32(w, uint32(x))
4490         }
4491         {
4492                 _, err := w.Write(([]byte((*(*(struct {
4493                         //mt:len32
4494                         Formspec string
4495                 }))(obj)).Formspec))[:])
4496                 chk(err)
4497         }
4498 }
4499
4500 func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
4501         var local139 []uint8
4502         var local140 uint32
4503         {
4504                 p := &local140
4505                 *p = read32(r)
4506         }
4507         (local139) = make([]uint8, local140)
4508         {
4509                 _, err := io.ReadFull(r, (local139)[:])
4510                 chk(err)
4511         }
4512         ((*(*(struct {
4513                 //mt:len32
4514                 Formspec string
4515         }))(obj)).Formspec) = string(local139)
4516 }
4517
4518 func (obj *ToCltDetachedInv) serialize(w io.Writer) {
4519         if len(([]byte((*(*(struct {
4520                 Name string
4521                 Keep bool
4522                 Len  uint16 // deprecated
4523
4524                 //mt:raw
4525                 Inv string
4526         }))(obj)).Name))) > math.MaxUint16 {
4527                 chk(ErrTooLong)
4528         }
4529         {
4530                 x := uint16(len(([]byte((*(*(struct {
4531                         Name string
4532                         Keep bool
4533                         Len  uint16 // deprecated
4534
4535                         //mt:raw
4536                         Inv string
4537                 }))(obj)).Name))))
4538                 write16(w, uint16(x))
4539         }
4540         {
4541                 _, err := w.Write(([]byte((*(*(struct {
4542                         Name string
4543                         Keep bool
4544                         Len  uint16 // deprecated
4545
4546                         //mt:raw
4547                         Inv string
4548                 }))(obj)).Name))[:])
4549                 chk(err)
4550         }
4551         {
4552                 x := (*(*(struct {
4553                         Name string
4554                         Keep bool
4555                         Len  uint16 // deprecated
4556
4557                         //mt:raw
4558                         Inv string
4559                 }))(obj)).Keep
4560                 if x {
4561                         write8(w, 1)
4562                 } else {
4563                         write8(w, 0)
4564                 }
4565
4566         }
4567         {
4568                 x := (*(*(struct {
4569                         Name string
4570                         Keep bool
4571                         Len  uint16 // deprecated
4572
4573                         //mt:raw
4574                         Inv string
4575                 }))(obj)).Len
4576                 write16(w, uint16(x))
4577         }
4578         {
4579                 _, err := w.Write(([]byte((*(*(struct {
4580                         Name string
4581                         Keep bool
4582                         Len  uint16 // deprecated
4583
4584                         //mt:raw
4585                         Inv string
4586                 }))(obj)).Inv))[:])
4587                 chk(err)
4588         }
4589 }
4590
4591 func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
4592         var local141 []uint8
4593         var local142 uint16
4594         {
4595                 p := &local142
4596                 *p = read16(r)
4597         }
4598         (local141) = make([]uint8, local142)
4599         {
4600                 _, err := io.ReadFull(r, (local141)[:])
4601                 chk(err)
4602         }
4603         ((*(*(struct {
4604                 Name string
4605                 Keep bool
4606                 Len  uint16 // deprecated
4607
4608                 //mt:raw
4609                 Inv string
4610         }))(obj)).Name) = string(local141)
4611         {
4612                 p := &(*(*(struct {
4613                         Name string
4614                         Keep bool
4615                         Len  uint16 // deprecated
4616
4617                         //mt:raw
4618                         Inv string
4619                 }))(obj)).Keep
4620                 switch n := read8(r); n {
4621                 case 0:
4622                         *p = false
4623                 case 1:
4624                         *p = true
4625                 default:
4626                         chk(fmt.Errorf("invalid bool: %d", n))
4627                 }
4628
4629         }
4630         {
4631                 p := &(*(*(struct {
4632                         Name string
4633                         Keep bool
4634                         Len  uint16 // deprecated
4635
4636                         //mt:raw
4637                         Inv string
4638                 }))(obj)).Len
4639                 *p = read16(r)
4640         }
4641         var local143 []uint8
4642         {
4643                 var err error
4644                 (local143), err = io.ReadAll(r)
4645                 chk(err)
4646         }
4647         ((*(*(struct {
4648                 Name string
4649                 Keep bool
4650                 Len  uint16 // deprecated
4651
4652                 //mt:raw
4653                 Inv string
4654         }))(obj)).Inv) = string(local143)
4655 }
4656
4657 func (obj *ToCltShowFormspec) serialize(w io.Writer) {
4658         if len(([]byte((*(*(struct {
4659                 //mt:len32
4660                 Formspec string
4661
4662                 Formname string
4663         }))(obj)).Formspec))) > math.MaxUint32 {
4664                 chk(ErrTooLong)
4665         }
4666         {
4667                 x := uint32(len(([]byte((*(*(struct {
4668                         //mt:len32
4669                         Formspec string
4670
4671                         Formname string
4672                 }))(obj)).Formspec))))
4673                 write32(w, uint32(x))
4674         }
4675         {
4676                 _, err := w.Write(([]byte((*(*(struct {
4677                         //mt:len32
4678                         Formspec string
4679
4680                         Formname string
4681                 }))(obj)).Formspec))[:])
4682                 chk(err)
4683         }
4684         if len(([]byte((*(*(struct {
4685                 //mt:len32
4686                 Formspec string
4687
4688                 Formname string
4689         }))(obj)).Formname))) > math.MaxUint16 {
4690                 chk(ErrTooLong)
4691         }
4692         {
4693                 x := uint16(len(([]byte((*(*(struct {
4694                         //mt:len32
4695                         Formspec string
4696
4697                         Formname string
4698                 }))(obj)).Formname))))
4699                 write16(w, uint16(x))
4700         }
4701         {
4702                 _, err := w.Write(([]byte((*(*(struct {
4703                         //mt:len32
4704                         Formspec string
4705
4706                         Formname string
4707                 }))(obj)).Formname))[:])
4708                 chk(err)
4709         }
4710 }
4711
4712 func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
4713         var local144 []uint8
4714         var local145 uint32
4715         {
4716                 p := &local145
4717                 *p = read32(r)
4718         }
4719         (local144) = make([]uint8, local145)
4720         {
4721                 _, err := io.ReadFull(r, (local144)[:])
4722                 chk(err)
4723         }
4724         ((*(*(struct {
4725                 //mt:len32
4726                 Formspec string
4727
4728                 Formname string
4729         }))(obj)).Formspec) = string(local144)
4730         var local146 []uint8
4731         var local147 uint16
4732         {
4733                 p := &local147
4734                 *p = read16(r)
4735         }
4736         (local146) = make([]uint8, local147)
4737         {
4738                 _, err := io.ReadFull(r, (local146)[:])
4739                 chk(err)
4740         }
4741         ((*(*(struct {
4742                 //mt:len32
4743                 Formspec string
4744
4745                 Formname string
4746         }))(obj)).Formname) = string(local146)
4747 }
4748
4749 func (obj *ToCltMovement) serialize(w io.Writer) {
4750         {
4751                 x := (*(*(struct {
4752                         DefaultAccel, AirAccel, FastAccel,
4753                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4754                         Fluidity, Smoothing, Sink,
4755                         Gravity float32
4756                 }))(obj)).DefaultAccel
4757                 write32(w, math.Float32bits(x))
4758         }
4759         {
4760                 x := (*(*(struct {
4761                         DefaultAccel, AirAccel, FastAccel,
4762                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4763                         Fluidity, Smoothing, Sink,
4764                         Gravity float32
4765                 }))(obj)).AirAccel
4766                 write32(w, math.Float32bits(x))
4767         }
4768         {
4769                 x := (*(*(struct {
4770                         DefaultAccel, AirAccel, FastAccel,
4771                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4772                         Fluidity, Smoothing, Sink,
4773                         Gravity float32
4774                 }))(obj)).FastAccel
4775                 write32(w, math.Float32bits(x))
4776         }
4777         {
4778                 x := (*(*(struct {
4779                         DefaultAccel, AirAccel, FastAccel,
4780                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4781                         Fluidity, Smoothing, Sink,
4782                         Gravity float32
4783                 }))(obj)).WalkSpeed
4784                 write32(w, math.Float32bits(x))
4785         }
4786         {
4787                 x := (*(*(struct {
4788                         DefaultAccel, AirAccel, FastAccel,
4789                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4790                         Fluidity, Smoothing, Sink,
4791                         Gravity float32
4792                 }))(obj)).CrouchSpeed
4793                 write32(w, math.Float32bits(x))
4794         }
4795         {
4796                 x := (*(*(struct {
4797                         DefaultAccel, AirAccel, FastAccel,
4798                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4799                         Fluidity, Smoothing, Sink,
4800                         Gravity float32
4801                 }))(obj)).FastSpeed
4802                 write32(w, math.Float32bits(x))
4803         }
4804         {
4805                 x := (*(*(struct {
4806                         DefaultAccel, AirAccel, FastAccel,
4807                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4808                         Fluidity, Smoothing, Sink,
4809                         Gravity float32
4810                 }))(obj)).ClimbSpeed
4811                 write32(w, math.Float32bits(x))
4812         }
4813         {
4814                 x := (*(*(struct {
4815                         DefaultAccel, AirAccel, FastAccel,
4816                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4817                         Fluidity, Smoothing, Sink,
4818                         Gravity float32
4819                 }))(obj)).JumpSpeed
4820                 write32(w, math.Float32bits(x))
4821         }
4822         {
4823                 x := (*(*(struct {
4824                         DefaultAccel, AirAccel, FastAccel,
4825                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4826                         Fluidity, Smoothing, Sink,
4827                         Gravity float32
4828                 }))(obj)).Fluidity
4829                 write32(w, math.Float32bits(x))
4830         }
4831         {
4832                 x := (*(*(struct {
4833                         DefaultAccel, AirAccel, FastAccel,
4834                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4835                         Fluidity, Smoothing, Sink,
4836                         Gravity float32
4837                 }))(obj)).Smoothing
4838                 write32(w, math.Float32bits(x))
4839         }
4840         {
4841                 x := (*(*(struct {
4842                         DefaultAccel, AirAccel, FastAccel,
4843                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4844                         Fluidity, Smoothing, Sink,
4845                         Gravity float32
4846                 }))(obj)).Sink
4847                 write32(w, math.Float32bits(x))
4848         }
4849         {
4850                 x := (*(*(struct {
4851                         DefaultAccel, AirAccel, FastAccel,
4852                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4853                         Fluidity, Smoothing, Sink,
4854                         Gravity float32
4855                 }))(obj)).Gravity
4856                 write32(w, math.Float32bits(x))
4857         }
4858 }
4859
4860 func (obj *ToCltMovement) deserialize(r io.Reader) {
4861         {
4862                 p := &(*(*(struct {
4863                         DefaultAccel, AirAccel, FastAccel,
4864                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4865                         Fluidity, Smoothing, Sink,
4866                         Gravity float32
4867                 }))(obj)).DefaultAccel
4868                 *p = math.Float32frombits(read32(r))
4869         }
4870         {
4871                 p := &(*(*(struct {
4872                         DefaultAccel, AirAccel, FastAccel,
4873                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4874                         Fluidity, Smoothing, Sink,
4875                         Gravity float32
4876                 }))(obj)).AirAccel
4877                 *p = math.Float32frombits(read32(r))
4878         }
4879         {
4880                 p := &(*(*(struct {
4881                         DefaultAccel, AirAccel, FastAccel,
4882                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4883                         Fluidity, Smoothing, Sink,
4884                         Gravity float32
4885                 }))(obj)).FastAccel
4886                 *p = math.Float32frombits(read32(r))
4887         }
4888         {
4889                 p := &(*(*(struct {
4890                         DefaultAccel, AirAccel, FastAccel,
4891                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4892                         Fluidity, Smoothing, Sink,
4893                         Gravity float32
4894                 }))(obj)).WalkSpeed
4895                 *p = math.Float32frombits(read32(r))
4896         }
4897         {
4898                 p := &(*(*(struct {
4899                         DefaultAccel, AirAccel, FastAccel,
4900                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4901                         Fluidity, Smoothing, Sink,
4902                         Gravity float32
4903                 }))(obj)).CrouchSpeed
4904                 *p = math.Float32frombits(read32(r))
4905         }
4906         {
4907                 p := &(*(*(struct {
4908                         DefaultAccel, AirAccel, FastAccel,
4909                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4910                         Fluidity, Smoothing, Sink,
4911                         Gravity float32
4912                 }))(obj)).FastSpeed
4913                 *p = math.Float32frombits(read32(r))
4914         }
4915         {
4916                 p := &(*(*(struct {
4917                         DefaultAccel, AirAccel, FastAccel,
4918                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4919                         Fluidity, Smoothing, Sink,
4920                         Gravity float32
4921                 }))(obj)).ClimbSpeed
4922                 *p = math.Float32frombits(read32(r))
4923         }
4924         {
4925                 p := &(*(*(struct {
4926                         DefaultAccel, AirAccel, FastAccel,
4927                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4928                         Fluidity, Smoothing, Sink,
4929                         Gravity float32
4930                 }))(obj)).JumpSpeed
4931                 *p = math.Float32frombits(read32(r))
4932         }
4933         {
4934                 p := &(*(*(struct {
4935                         DefaultAccel, AirAccel, FastAccel,
4936                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4937                         Fluidity, Smoothing, Sink,
4938                         Gravity float32
4939                 }))(obj)).Fluidity
4940                 *p = math.Float32frombits(read32(r))
4941         }
4942         {
4943                 p := &(*(*(struct {
4944                         DefaultAccel, AirAccel, FastAccel,
4945                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4946                         Fluidity, Smoothing, Sink,
4947                         Gravity float32
4948                 }))(obj)).Smoothing
4949                 *p = math.Float32frombits(read32(r))
4950         }
4951         {
4952                 p := &(*(*(struct {
4953                         DefaultAccel, AirAccel, FastAccel,
4954                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4955                         Fluidity, Smoothing, Sink,
4956                         Gravity float32
4957                 }))(obj)).Sink
4958                 *p = math.Float32frombits(read32(r))
4959         }
4960         {
4961                 p := &(*(*(struct {
4962                         DefaultAccel, AirAccel, FastAccel,
4963                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4964                         Fluidity, Smoothing, Sink,
4965                         Gravity float32
4966                 }))(obj)).Gravity
4967                 *p = math.Float32frombits(read32(r))
4968         }
4969 }
4970
4971 func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
4972         for local148 := range (*(*(struct {
4973                 Pos, Vel, Acc  [3]float32
4974                 ExpirationTime float32 // in seconds.
4975                 Size           float32
4976                 Collide        bool
4977
4978                 //mt:len32
4979                 Texture
4980
4981                 Vertical    bool
4982                 CollisionRm bool
4983                 AnimParams  TileAnim
4984                 Glow        uint8
4985                 AOCollision bool
4986                 NodeParam0  Content
4987                 NodeParam2  uint8
4988                 NodeTile    uint8
4989         }))(obj)).Pos {
4990                 {
4991                         x := ((*(*(struct {
4992                                 Pos, Vel, Acc  [3]float32
4993                                 ExpirationTime float32 // in seconds.
4994                                 Size           float32
4995                                 Collide        bool
4996
4997                                 //mt:len32
4998                                 Texture
4999
5000                                 Vertical    bool
5001                                 CollisionRm bool
5002                                 AnimParams  TileAnim
5003                                 Glow        uint8
5004                                 AOCollision bool
5005                                 NodeParam0  Content
5006                                 NodeParam2  uint8
5007                                 NodeTile    uint8
5008                         }))(obj)).Pos)[local148]
5009                         write32(w, math.Float32bits(x))
5010                 }
5011         }
5012         for local149 := range (*(*(struct {
5013                 Pos, Vel, Acc  [3]float32
5014                 ExpirationTime float32 // in seconds.
5015                 Size           float32
5016                 Collide        bool
5017
5018                 //mt:len32
5019                 Texture
5020
5021                 Vertical    bool
5022                 CollisionRm bool
5023                 AnimParams  TileAnim
5024                 Glow        uint8
5025                 AOCollision bool
5026                 NodeParam0  Content
5027                 NodeParam2  uint8
5028                 NodeTile    uint8
5029         }))(obj)).Vel {
5030                 {
5031                         x := ((*(*(struct {
5032                                 Pos, Vel, Acc  [3]float32
5033                                 ExpirationTime float32 // in seconds.
5034                                 Size           float32
5035                                 Collide        bool
5036
5037                                 //mt:len32
5038                                 Texture
5039
5040                                 Vertical    bool
5041                                 CollisionRm bool
5042                                 AnimParams  TileAnim
5043                                 Glow        uint8
5044                                 AOCollision bool
5045                                 NodeParam0  Content
5046                                 NodeParam2  uint8
5047                                 NodeTile    uint8
5048                         }))(obj)).Vel)[local149]
5049                         write32(w, math.Float32bits(x))
5050                 }
5051         }
5052         for local150 := range (*(*(struct {
5053                 Pos, Vel, Acc  [3]float32
5054                 ExpirationTime float32 // in seconds.
5055                 Size           float32
5056                 Collide        bool
5057
5058                 //mt:len32
5059                 Texture
5060
5061                 Vertical    bool
5062                 CollisionRm bool
5063                 AnimParams  TileAnim
5064                 Glow        uint8
5065                 AOCollision bool
5066                 NodeParam0  Content
5067                 NodeParam2  uint8
5068                 NodeTile    uint8
5069         }))(obj)).Acc {
5070                 {
5071                         x := ((*(*(struct {
5072                                 Pos, Vel, Acc  [3]float32
5073                                 ExpirationTime float32 // in seconds.
5074                                 Size           float32
5075                                 Collide        bool
5076
5077                                 //mt:len32
5078                                 Texture
5079
5080                                 Vertical    bool
5081                                 CollisionRm bool
5082                                 AnimParams  TileAnim
5083                                 Glow        uint8
5084                                 AOCollision bool
5085                                 NodeParam0  Content
5086                                 NodeParam2  uint8
5087                                 NodeTile    uint8
5088                         }))(obj)).Acc)[local150]
5089                         write32(w, math.Float32bits(x))
5090                 }
5091         }
5092         {
5093                 x := (*(*(struct {
5094                         Pos, Vel, Acc  [3]float32
5095                         ExpirationTime float32 // in seconds.
5096                         Size           float32
5097                         Collide        bool
5098
5099                         //mt:len32
5100                         Texture
5101
5102                         Vertical    bool
5103                         CollisionRm bool
5104                         AnimParams  TileAnim
5105                         Glow        uint8
5106                         AOCollision bool
5107                         NodeParam0  Content
5108                         NodeParam2  uint8
5109                         NodeTile    uint8
5110                 }))(obj)).ExpirationTime
5111                 write32(w, math.Float32bits(x))
5112         }
5113         {
5114                 x := (*(*(struct {
5115                         Pos, Vel, Acc  [3]float32
5116                         ExpirationTime float32 // in seconds.
5117                         Size           float32
5118                         Collide        bool
5119
5120                         //mt:len32
5121                         Texture
5122
5123                         Vertical    bool
5124                         CollisionRm bool
5125                         AnimParams  TileAnim
5126                         Glow        uint8
5127                         AOCollision bool
5128                         NodeParam0  Content
5129                         NodeParam2  uint8
5130                         NodeTile    uint8
5131                 }))(obj)).Size
5132                 write32(w, math.Float32bits(x))
5133         }
5134         {
5135                 x := (*(*(struct {
5136                         Pos, Vel, Acc  [3]float32
5137                         ExpirationTime float32 // in seconds.
5138                         Size           float32
5139                         Collide        bool
5140
5141                         //mt:len32
5142                         Texture
5143
5144                         Vertical    bool
5145                         CollisionRm bool
5146                         AnimParams  TileAnim
5147                         Glow        uint8
5148                         AOCollision bool
5149                         NodeParam0  Content
5150                         NodeParam2  uint8
5151                         NodeTile    uint8
5152                 }))(obj)).Collide
5153                 if x {
5154                         write8(w, 1)
5155                 } else {
5156                         write8(w, 0)
5157                 }
5158
5159         }
5160         if len(([]byte(*(*string)(&((*(*(struct {
5161                 Pos, Vel, Acc  [3]float32
5162                 ExpirationTime float32 // in seconds.
5163                 Size           float32
5164                 Collide        bool
5165
5166                 //mt:len32
5167                 Texture
5168
5169                 Vertical    bool
5170                 CollisionRm bool
5171                 AnimParams  TileAnim
5172                 Glow        uint8
5173                 AOCollision bool
5174                 NodeParam0  Content
5175                 NodeParam2  uint8
5176                 NodeTile    uint8
5177         }))(obj)).Texture))))) > math.MaxUint32 {
5178                 chk(ErrTooLong)
5179         }
5180         {
5181                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5182                         Pos, Vel, Acc  [3]float32
5183                         ExpirationTime float32 // in seconds.
5184                         Size           float32
5185                         Collide        bool
5186
5187                         //mt:len32
5188                         Texture
5189
5190                         Vertical    bool
5191                         CollisionRm bool
5192                         AnimParams  TileAnim
5193                         Glow        uint8
5194                         AOCollision bool
5195                         NodeParam0  Content
5196                         NodeParam2  uint8
5197                         NodeTile    uint8
5198                 }))(obj)).Texture))))))
5199                 write32(w, uint32(x))
5200         }
5201         {
5202                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5203                         Pos, Vel, Acc  [3]float32
5204                         ExpirationTime float32 // in seconds.
5205                         Size           float32
5206                         Collide        bool
5207
5208                         //mt:len32
5209                         Texture
5210
5211                         Vertical    bool
5212                         CollisionRm bool
5213                         AnimParams  TileAnim
5214                         Glow        uint8
5215                         AOCollision bool
5216                         NodeParam0  Content
5217                         NodeParam2  uint8
5218                         NodeTile    uint8
5219                 }))(obj)).Texture))))[:])
5220                 chk(err)
5221         }
5222         {
5223                 x := (*(*(struct {
5224                         Pos, Vel, Acc  [3]float32
5225                         ExpirationTime float32 // in seconds.
5226                         Size           float32
5227                         Collide        bool
5228
5229                         //mt:len32
5230                         Texture
5231
5232                         Vertical    bool
5233                         CollisionRm bool
5234                         AnimParams  TileAnim
5235                         Glow        uint8
5236                         AOCollision bool
5237                         NodeParam0  Content
5238                         NodeParam2  uint8
5239                         NodeTile    uint8
5240                 }))(obj)).Vertical
5241                 if x {
5242                         write8(w, 1)
5243                 } else {
5244                         write8(w, 0)
5245                 }
5246
5247         }
5248         {
5249                 x := (*(*(struct {
5250                         Pos, Vel, Acc  [3]float32
5251                         ExpirationTime float32 // in seconds.
5252                         Size           float32
5253                         Collide        bool
5254
5255                         //mt:len32
5256                         Texture
5257
5258                         Vertical    bool
5259                         CollisionRm bool
5260                         AnimParams  TileAnim
5261                         Glow        uint8
5262                         AOCollision bool
5263                         NodeParam0  Content
5264                         NodeParam2  uint8
5265                         NodeTile    uint8
5266                 }))(obj)).CollisionRm
5267                 if x {
5268                         write8(w, 1)
5269                 } else {
5270                         write8(w, 0)
5271                 }
5272
5273         }
5274         if err := pcall(func() {
5275                 ((*(*(struct {
5276                         Pos, Vel, Acc  [3]float32
5277                         ExpirationTime float32 // in seconds.
5278                         Size           float32
5279                         Collide        bool
5280
5281                         //mt:len32
5282                         Texture
5283
5284                         Vertical    bool
5285                         CollisionRm bool
5286                         AnimParams  TileAnim
5287                         Glow        uint8
5288                         AOCollision bool
5289                         NodeParam0  Content
5290                         NodeParam2  uint8
5291                         NodeTile    uint8
5292                 }))(obj)).AnimParams).serialize(w)
5293         }); err != nil {
5294                 if err == io.EOF {
5295                         chk(io.EOF)
5296                 }
5297                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
5298         }
5299         {
5300                 x := (*(*(struct {
5301                         Pos, Vel, Acc  [3]float32
5302                         ExpirationTime float32 // in seconds.
5303                         Size           float32
5304                         Collide        bool
5305
5306                         //mt:len32
5307                         Texture
5308
5309                         Vertical    bool
5310                         CollisionRm bool
5311                         AnimParams  TileAnim
5312                         Glow        uint8
5313                         AOCollision bool
5314                         NodeParam0  Content
5315                         NodeParam2  uint8
5316                         NodeTile    uint8
5317                 }))(obj)).Glow
5318                 write8(w, uint8(x))
5319         }
5320         {
5321                 x := (*(*(struct {
5322                         Pos, Vel, Acc  [3]float32
5323                         ExpirationTime float32 // in seconds.
5324                         Size           float32
5325                         Collide        bool
5326
5327                         //mt:len32
5328                         Texture
5329
5330                         Vertical    bool
5331                         CollisionRm bool
5332                         AnimParams  TileAnim
5333                         Glow        uint8
5334                         AOCollision bool
5335                         NodeParam0  Content
5336                         NodeParam2  uint8
5337                         NodeTile    uint8
5338                 }))(obj)).AOCollision
5339                 if x {
5340                         write8(w, 1)
5341                 } else {
5342                         write8(w, 0)
5343                 }
5344
5345         }
5346         if err := pcall(func() {
5347                 ((*(*(struct {
5348                         Pos, Vel, Acc  [3]float32
5349                         ExpirationTime float32 // in seconds.
5350                         Size           float32
5351                         Collide        bool
5352
5353                         //mt:len32
5354                         Texture
5355
5356                         Vertical    bool
5357                         CollisionRm bool
5358                         AnimParams  TileAnim
5359                         Glow        uint8
5360                         AOCollision bool
5361                         NodeParam0  Content
5362                         NodeParam2  uint8
5363                         NodeTile    uint8
5364                 }))(obj)).NodeParam0).serialize(w)
5365         }); err != nil {
5366                 if err == io.EOF {
5367                         chk(io.EOF)
5368                 }
5369                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
5370         }
5371         {
5372                 x := (*(*(struct {
5373                         Pos, Vel, Acc  [3]float32
5374                         ExpirationTime float32 // in seconds.
5375                         Size           float32
5376                         Collide        bool
5377
5378                         //mt:len32
5379                         Texture
5380
5381                         Vertical    bool
5382                         CollisionRm bool
5383                         AnimParams  TileAnim
5384                         Glow        uint8
5385                         AOCollision bool
5386                         NodeParam0  Content
5387                         NodeParam2  uint8
5388                         NodeTile    uint8
5389                 }))(obj)).NodeParam2
5390                 write8(w, uint8(x))
5391         }
5392         {
5393                 x := (*(*(struct {
5394                         Pos, Vel, Acc  [3]float32
5395                         ExpirationTime float32 // in seconds.
5396                         Size           float32
5397                         Collide        bool
5398
5399                         //mt:len32
5400                         Texture
5401
5402                         Vertical    bool
5403                         CollisionRm bool
5404                         AnimParams  TileAnim
5405                         Glow        uint8
5406                         AOCollision bool
5407                         NodeParam0  Content
5408                         NodeParam2  uint8
5409                         NodeTile    uint8
5410                 }))(obj)).NodeTile
5411                 write8(w, uint8(x))
5412         }
5413 }
5414
5415 func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
5416         for local151 := range (*(*(struct {
5417                 Pos, Vel, Acc  [3]float32
5418                 ExpirationTime float32 // in seconds.
5419                 Size           float32
5420                 Collide        bool
5421
5422                 //mt:len32
5423                 Texture
5424
5425                 Vertical    bool
5426                 CollisionRm bool
5427                 AnimParams  TileAnim
5428                 Glow        uint8
5429                 AOCollision bool
5430                 NodeParam0  Content
5431                 NodeParam2  uint8
5432                 NodeTile    uint8
5433         }))(obj)).Pos {
5434                 {
5435                         p := &((*(*(struct {
5436                                 Pos, Vel, Acc  [3]float32
5437                                 ExpirationTime float32 // in seconds.
5438                                 Size           float32
5439                                 Collide        bool
5440
5441                                 //mt:len32
5442                                 Texture
5443
5444                                 Vertical    bool
5445                                 CollisionRm bool
5446                                 AnimParams  TileAnim
5447                                 Glow        uint8
5448                                 AOCollision bool
5449                                 NodeParam0  Content
5450                                 NodeParam2  uint8
5451                                 NodeTile    uint8
5452                         }))(obj)).Pos)[local151]
5453                         *p = math.Float32frombits(read32(r))
5454                 }
5455         }
5456         for local152 := range (*(*(struct {
5457                 Pos, Vel, Acc  [3]float32
5458                 ExpirationTime float32 // in seconds.
5459                 Size           float32
5460                 Collide        bool
5461
5462                 //mt:len32
5463                 Texture
5464
5465                 Vertical    bool
5466                 CollisionRm bool
5467                 AnimParams  TileAnim
5468                 Glow        uint8
5469                 AOCollision bool
5470                 NodeParam0  Content
5471                 NodeParam2  uint8
5472                 NodeTile    uint8
5473         }))(obj)).Vel {
5474                 {
5475                         p := &((*(*(struct {
5476                                 Pos, Vel, Acc  [3]float32
5477                                 ExpirationTime float32 // in seconds.
5478                                 Size           float32
5479                                 Collide        bool
5480
5481                                 //mt:len32
5482                                 Texture
5483
5484                                 Vertical    bool
5485                                 CollisionRm bool
5486                                 AnimParams  TileAnim
5487                                 Glow        uint8
5488                                 AOCollision bool
5489                                 NodeParam0  Content
5490                                 NodeParam2  uint8
5491                                 NodeTile    uint8
5492                         }))(obj)).Vel)[local152]
5493                         *p = math.Float32frombits(read32(r))
5494                 }
5495         }
5496         for local153 := range (*(*(struct {
5497                 Pos, Vel, Acc  [3]float32
5498                 ExpirationTime float32 // in seconds.
5499                 Size           float32
5500                 Collide        bool
5501
5502                 //mt:len32
5503                 Texture
5504
5505                 Vertical    bool
5506                 CollisionRm bool
5507                 AnimParams  TileAnim
5508                 Glow        uint8
5509                 AOCollision bool
5510                 NodeParam0  Content
5511                 NodeParam2  uint8
5512                 NodeTile    uint8
5513         }))(obj)).Acc {
5514                 {
5515                         p := &((*(*(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)).Acc)[local153]
5533                         *p = math.Float32frombits(read32(r))
5534                 }
5535         }
5536         {
5537                 p := &(*(*(struct {
5538                         Pos, Vel, Acc  [3]float32
5539                         ExpirationTime float32 // in seconds.
5540                         Size           float32
5541                         Collide        bool
5542
5543                         //mt:len32
5544                         Texture
5545
5546                         Vertical    bool
5547                         CollisionRm bool
5548                         AnimParams  TileAnim
5549                         Glow        uint8
5550                         AOCollision bool
5551                         NodeParam0  Content
5552                         NodeParam2  uint8
5553                         NodeTile    uint8
5554                 }))(obj)).ExpirationTime
5555                 *p = math.Float32frombits(read32(r))
5556         }
5557         {
5558                 p := &(*(*(struct {
5559                         Pos, Vel, Acc  [3]float32
5560                         ExpirationTime float32 // in seconds.
5561                         Size           float32
5562                         Collide        bool
5563
5564                         //mt:len32
5565                         Texture
5566
5567                         Vertical    bool
5568                         CollisionRm bool
5569                         AnimParams  TileAnim
5570                         Glow        uint8
5571                         AOCollision bool
5572                         NodeParam0  Content
5573                         NodeParam2  uint8
5574                         NodeTile    uint8
5575                 }))(obj)).Size
5576                 *p = math.Float32frombits(read32(r))
5577         }
5578         {
5579                 p := &(*(*(struct {
5580                         Pos, Vel, Acc  [3]float32
5581                         ExpirationTime float32 // in seconds.
5582                         Size           float32
5583                         Collide        bool
5584
5585                         //mt:len32
5586                         Texture
5587
5588                         Vertical    bool
5589                         CollisionRm bool
5590                         AnimParams  TileAnim
5591                         Glow        uint8
5592                         AOCollision bool
5593                         NodeParam0  Content
5594                         NodeParam2  uint8
5595                         NodeTile    uint8
5596                 }))(obj)).Collide
5597                 switch n := read8(r); n {
5598                 case 0:
5599                         *p = false
5600                 case 1:
5601                         *p = true
5602                 default:
5603                         chk(fmt.Errorf("invalid bool: %d", n))
5604                 }
5605
5606         }
5607         var local154 []uint8
5608         var local155 uint32
5609         {
5610                 p := &local155
5611                 *p = read32(r)
5612         }
5613         (local154) = make([]uint8, local155)
5614         {
5615                 _, err := io.ReadFull(r, (local154)[:])
5616                 chk(err)
5617         }
5618         (*(*string)(&((*(*(struct {
5619                 Pos, Vel, Acc  [3]float32
5620                 ExpirationTime float32 // in seconds.
5621                 Size           float32
5622                 Collide        bool
5623
5624                 //mt:len32
5625                 Texture
5626
5627                 Vertical    bool
5628                 CollisionRm bool
5629                 AnimParams  TileAnim
5630                 Glow        uint8
5631                 AOCollision bool
5632                 NodeParam0  Content
5633                 NodeParam2  uint8
5634                 NodeTile    uint8
5635         }))(obj)).Texture))) = string(local154)
5636         {
5637                 p := &(*(*(struct {
5638                         Pos, Vel, Acc  [3]float32
5639                         ExpirationTime float32 // in seconds.
5640                         Size           float32
5641                         Collide        bool
5642
5643                         //mt:len32
5644                         Texture
5645
5646                         Vertical    bool
5647                         CollisionRm bool
5648                         AnimParams  TileAnim
5649                         Glow        uint8
5650                         AOCollision bool
5651                         NodeParam0  Content
5652                         NodeParam2  uint8
5653                         NodeTile    uint8
5654                 }))(obj)).Vertical
5655                 switch n := read8(r); n {
5656                 case 0:
5657                         *p = false
5658                 case 1:
5659                         *p = true
5660                 default:
5661                         chk(fmt.Errorf("invalid bool: %d", n))
5662                 }
5663
5664         }
5665         {
5666                 p := &(*(*(struct {
5667                         Pos, Vel, Acc  [3]float32
5668                         ExpirationTime float32 // in seconds.
5669                         Size           float32
5670                         Collide        bool
5671
5672                         //mt:len32
5673                         Texture
5674
5675                         Vertical    bool
5676                         CollisionRm bool
5677                         AnimParams  TileAnim
5678                         Glow        uint8
5679                         AOCollision bool
5680                         NodeParam0  Content
5681                         NodeParam2  uint8
5682                         NodeTile    uint8
5683                 }))(obj)).CollisionRm
5684                 switch n := read8(r); n {
5685                 case 0:
5686                         *p = false
5687                 case 1:
5688                         *p = true
5689                 default:
5690                         chk(fmt.Errorf("invalid bool: %d", n))
5691                 }
5692
5693         }
5694         if err := pcall(func() {
5695                 ((*(*(struct {
5696                         Pos, Vel, Acc  [3]float32
5697                         ExpirationTime float32 // in seconds.
5698                         Size           float32
5699                         Collide        bool
5700
5701                         //mt:len32
5702                         Texture
5703
5704                         Vertical    bool
5705                         CollisionRm bool
5706                         AnimParams  TileAnim
5707                         Glow        uint8
5708                         AOCollision bool
5709                         NodeParam0  Content
5710                         NodeParam2  uint8
5711                         NodeTile    uint8
5712                 }))(obj)).AnimParams).deserialize(r)
5713         }); err != nil {
5714                 if err == io.EOF {
5715                         chk(io.EOF)
5716                 }
5717                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
5718         }
5719         {
5720                 p := &(*(*(struct {
5721                         Pos, Vel, Acc  [3]float32
5722                         ExpirationTime float32 // in seconds.
5723                         Size           float32
5724                         Collide        bool
5725
5726                         //mt:len32
5727                         Texture
5728
5729                         Vertical    bool
5730                         CollisionRm bool
5731                         AnimParams  TileAnim
5732                         Glow        uint8
5733                         AOCollision bool
5734                         NodeParam0  Content
5735                         NodeParam2  uint8
5736                         NodeTile    uint8
5737                 }))(obj)).Glow
5738                 *p = read8(r)
5739         }
5740         {
5741                 p := &(*(*(struct {
5742                         Pos, Vel, Acc  [3]float32
5743                         ExpirationTime float32 // in seconds.
5744                         Size           float32
5745                         Collide        bool
5746
5747                         //mt:len32
5748                         Texture
5749
5750                         Vertical    bool
5751                         CollisionRm bool
5752                         AnimParams  TileAnim
5753                         Glow        uint8
5754                         AOCollision bool
5755                         NodeParam0  Content
5756                         NodeParam2  uint8
5757                         NodeTile    uint8
5758                 }))(obj)).AOCollision
5759                 switch n := read8(r); n {
5760                 case 0:
5761                         *p = false
5762                 case 1:
5763                         *p = true
5764                 default:
5765                         chk(fmt.Errorf("invalid bool: %d", n))
5766                 }
5767
5768         }
5769         if err := pcall(func() {
5770                 ((*(*(struct {
5771                         Pos, Vel, Acc  [3]float32
5772                         ExpirationTime float32 // in seconds.
5773                         Size           float32
5774                         Collide        bool
5775
5776                         //mt:len32
5777                         Texture
5778
5779                         Vertical    bool
5780                         CollisionRm bool
5781                         AnimParams  TileAnim
5782                         Glow        uint8
5783                         AOCollision bool
5784                         NodeParam0  Content
5785                         NodeParam2  uint8
5786                         NodeTile    uint8
5787                 }))(obj)).NodeParam0).deserialize(r)
5788         }); err != nil {
5789                 if err == io.EOF {
5790                         chk(io.EOF)
5791                 }
5792                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
5793         }
5794         {
5795                 p := &(*(*(struct {
5796                         Pos, Vel, Acc  [3]float32
5797                         ExpirationTime float32 // in seconds.
5798                         Size           float32
5799                         Collide        bool
5800
5801                         //mt:len32
5802                         Texture
5803
5804                         Vertical    bool
5805                         CollisionRm bool
5806                         AnimParams  TileAnim
5807                         Glow        uint8
5808                         AOCollision bool
5809                         NodeParam0  Content
5810                         NodeParam2  uint8
5811                         NodeTile    uint8
5812                 }))(obj)).NodeParam2
5813                 *p = read8(r)
5814         }
5815         {
5816                 p := &(*(*(struct {
5817                         Pos, Vel, Acc  [3]float32
5818                         ExpirationTime float32 // in seconds.
5819                         Size           float32
5820                         Collide        bool
5821
5822                         //mt:len32
5823                         Texture
5824
5825                         Vertical    bool
5826                         CollisionRm bool
5827                         AnimParams  TileAnim
5828                         Glow        uint8
5829                         AOCollision bool
5830                         NodeParam0  Content
5831                         NodeParam2  uint8
5832                         NodeTile    uint8
5833                 }))(obj)).NodeTile
5834                 *p = read8(r)
5835         }
5836 }
5837
5838 func (obj *ToCltAddParticleSpawner) serialize(w io.Writer) {
5839         {
5840                 x := (*(*(struct {
5841                         Amount         uint16
5842                         Duration       float32
5843                         Pos, Vel, Acc  [2][3]float32
5844                         ExpirationTime [2]float32 // in seconds.
5845                         Size           [2]float32
5846                         Collide        bool
5847
5848                         //mt:len32
5849                         Texture
5850
5851                         ID           ParticleSpawnerID
5852                         Vertical     bool
5853                         CollisionRm  bool
5854                         AttachedAOID AOID
5855                         AnimParams   TileAnim
5856                         Glow         uint8
5857                         AOCollision  bool
5858                         NodeParam0   Content
5859                         NodeParam2   uint8
5860                         NodeTile     uint8
5861                 }))(obj)).Amount
5862                 write16(w, uint16(x))
5863         }
5864         {
5865                 x := (*(*(struct {
5866                         Amount         uint16
5867                         Duration       float32
5868                         Pos, Vel, Acc  [2][3]float32
5869                         ExpirationTime [2]float32 // in seconds.
5870                         Size           [2]float32
5871                         Collide        bool
5872
5873                         //mt:len32
5874                         Texture
5875
5876                         ID           ParticleSpawnerID
5877                         Vertical     bool
5878                         CollisionRm  bool
5879                         AttachedAOID AOID
5880                         AnimParams   TileAnim
5881                         Glow         uint8
5882                         AOCollision  bool
5883                         NodeParam0   Content
5884                         NodeParam2   uint8
5885                         NodeTile     uint8
5886                 }))(obj)).Duration
5887                 write32(w, math.Float32bits(x))
5888         }
5889         for local156 := range (*(*(struct {
5890                 Amount         uint16
5891                 Duration       float32
5892                 Pos, Vel, Acc  [2][3]float32
5893                 ExpirationTime [2]float32 // in seconds.
5894                 Size           [2]float32
5895                 Collide        bool
5896
5897                 //mt:len32
5898                 Texture
5899
5900                 ID           ParticleSpawnerID
5901                 Vertical     bool
5902                 CollisionRm  bool
5903                 AttachedAOID AOID
5904                 AnimParams   TileAnim
5905                 Glow         uint8
5906                 AOCollision  bool
5907                 NodeParam0   Content
5908                 NodeParam2   uint8
5909                 NodeTile     uint8
5910         }))(obj)).Pos {
5911                 for local157 := range ((*(*(struct {
5912                         Amount         uint16
5913                         Duration       float32
5914                         Pos, Vel, Acc  [2][3]float32
5915                         ExpirationTime [2]float32 // in seconds.
5916                         Size           [2]float32
5917                         Collide        bool
5918
5919                         //mt:len32
5920                         Texture
5921
5922                         ID           ParticleSpawnerID
5923                         Vertical     bool
5924                         CollisionRm  bool
5925                         AttachedAOID AOID
5926                         AnimParams   TileAnim
5927                         Glow         uint8
5928                         AOCollision  bool
5929                         NodeParam0   Content
5930                         NodeParam2   uint8
5931                         NodeTile     uint8
5932                 }))(obj)).Pos)[local156] {
5933                         {
5934                                 x := (((*(*(struct {
5935                                         Amount         uint16
5936                                         Duration       float32
5937                                         Pos, Vel, Acc  [2][3]float32
5938                                         ExpirationTime [2]float32 // in seconds.
5939                                         Size           [2]float32
5940                                         Collide        bool
5941
5942                                         //mt:len32
5943                                         Texture
5944
5945                                         ID           ParticleSpawnerID
5946                                         Vertical     bool
5947                                         CollisionRm  bool
5948                                         AttachedAOID AOID
5949                                         AnimParams   TileAnim
5950                                         Glow         uint8
5951                                         AOCollision  bool
5952                                         NodeParam0   Content
5953                                         NodeParam2   uint8
5954                                         NodeTile     uint8
5955                                 }))(obj)).Pos)[local156])[local157]
5956                                 write32(w, math.Float32bits(x))
5957                         }
5958                 }
5959         }
5960         for local158 := range (*(*(struct {
5961                 Amount         uint16
5962                 Duration       float32
5963                 Pos, Vel, Acc  [2][3]float32
5964                 ExpirationTime [2]float32 // in seconds.
5965                 Size           [2]float32
5966                 Collide        bool
5967
5968                 //mt:len32
5969                 Texture
5970
5971                 ID           ParticleSpawnerID
5972                 Vertical     bool
5973                 CollisionRm  bool
5974                 AttachedAOID AOID
5975                 AnimParams   TileAnim
5976                 Glow         uint8
5977                 AOCollision  bool
5978                 NodeParam0   Content
5979                 NodeParam2   uint8
5980                 NodeTile     uint8
5981         }))(obj)).Vel {
5982                 for local159 := range ((*(*(struct {
5983                         Amount         uint16
5984                         Duration       float32
5985                         Pos, Vel, Acc  [2][3]float32
5986                         ExpirationTime [2]float32 // in seconds.
5987                         Size           [2]float32
5988                         Collide        bool
5989
5990                         //mt:len32
5991                         Texture
5992
5993                         ID           ParticleSpawnerID
5994                         Vertical     bool
5995                         CollisionRm  bool
5996                         AttachedAOID AOID
5997                         AnimParams   TileAnim
5998                         Glow         uint8
5999                         AOCollision  bool
6000                         NodeParam0   Content
6001                         NodeParam2   uint8
6002                         NodeTile     uint8
6003                 }))(obj)).Vel)[local158] {
6004                         {
6005                                 x := (((*(*(struct {
6006                                         Amount         uint16
6007                                         Duration       float32
6008                                         Pos, Vel, Acc  [2][3]float32
6009                                         ExpirationTime [2]float32 // in seconds.
6010                                         Size           [2]float32
6011                                         Collide        bool
6012
6013                                         //mt:len32
6014                                         Texture
6015
6016                                         ID           ParticleSpawnerID
6017                                         Vertical     bool
6018                                         CollisionRm  bool
6019                                         AttachedAOID AOID
6020                                         AnimParams   TileAnim
6021                                         Glow         uint8
6022                                         AOCollision  bool
6023                                         NodeParam0   Content
6024                                         NodeParam2   uint8
6025                                         NodeTile     uint8
6026                                 }))(obj)).Vel)[local158])[local159]
6027                                 write32(w, math.Float32bits(x))
6028                         }
6029                 }
6030         }
6031         for local160 := range (*(*(struct {
6032                 Amount         uint16
6033                 Duration       float32
6034                 Pos, Vel, Acc  [2][3]float32
6035                 ExpirationTime [2]float32 // in seconds.
6036                 Size           [2]float32
6037                 Collide        bool
6038
6039                 //mt:len32
6040                 Texture
6041
6042                 ID           ParticleSpawnerID
6043                 Vertical     bool
6044                 CollisionRm  bool
6045                 AttachedAOID AOID
6046                 AnimParams   TileAnim
6047                 Glow         uint8
6048                 AOCollision  bool
6049                 NodeParam0   Content
6050                 NodeParam2   uint8
6051                 NodeTile     uint8
6052         }))(obj)).Acc {
6053                 for local161 := 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)).Acc)[local160] {
6075                         {
6076                                 x := (((*(*(struct {
6077                                         Amount         uint16
6078                                         Duration       float32
6079                                         Pos, Vel, Acc  [2][3]float32
6080                                         ExpirationTime [2]float32 // in seconds.
6081                                         Size           [2]float32
6082                                         Collide        bool
6083
6084                                         //mt:len32
6085                                         Texture
6086
6087                                         ID           ParticleSpawnerID
6088                                         Vertical     bool
6089                                         CollisionRm  bool
6090                                         AttachedAOID AOID
6091                                         AnimParams   TileAnim
6092                                         Glow         uint8
6093                                         AOCollision  bool
6094                                         NodeParam0   Content
6095                                         NodeParam2   uint8
6096                                         NodeTile     uint8
6097                                 }))(obj)).Acc)[local160])[local161]
6098                                 write32(w, math.Float32bits(x))
6099                         }
6100                 }
6101         }
6102         for local162 := range (*(*(struct {
6103                 Amount         uint16
6104                 Duration       float32
6105                 Pos, Vel, Acc  [2][3]float32
6106                 ExpirationTime [2]float32 // in seconds.
6107                 Size           [2]float32
6108                 Collide        bool
6109
6110                 //mt:len32
6111                 Texture
6112
6113                 ID           ParticleSpawnerID
6114                 Vertical     bool
6115                 CollisionRm  bool
6116                 AttachedAOID AOID
6117                 AnimParams   TileAnim
6118                 Glow         uint8
6119                 AOCollision  bool
6120                 NodeParam0   Content
6121                 NodeParam2   uint8
6122                 NodeTile     uint8
6123         }))(obj)).ExpirationTime {
6124                 {
6125                         x := ((*(*(struct {
6126                                 Amount         uint16
6127                                 Duration       float32
6128                                 Pos, Vel, Acc  [2][3]float32
6129                                 ExpirationTime [2]float32 // in seconds.
6130                                 Size           [2]float32
6131                                 Collide        bool
6132
6133                                 //mt:len32
6134                                 Texture
6135
6136                                 ID           ParticleSpawnerID
6137                                 Vertical     bool
6138                                 CollisionRm  bool
6139                                 AttachedAOID AOID
6140                                 AnimParams   TileAnim
6141                                 Glow         uint8
6142                                 AOCollision  bool
6143                                 NodeParam0   Content
6144                                 NodeParam2   uint8
6145                                 NodeTile     uint8
6146                         }))(obj)).ExpirationTime)[local162]
6147                         write32(w, math.Float32bits(x))
6148                 }
6149         }
6150         for local163 := range (*(*(struct {
6151                 Amount         uint16
6152                 Duration       float32
6153                 Pos, Vel, Acc  [2][3]float32
6154                 ExpirationTime [2]float32 // in seconds.
6155                 Size           [2]float32
6156                 Collide        bool
6157
6158                 //mt:len32
6159                 Texture
6160
6161                 ID           ParticleSpawnerID
6162                 Vertical     bool
6163                 CollisionRm  bool
6164                 AttachedAOID AOID
6165                 AnimParams   TileAnim
6166                 Glow         uint8
6167                 AOCollision  bool
6168                 NodeParam0   Content
6169                 NodeParam2   uint8
6170                 NodeTile     uint8
6171         }))(obj)).Size {
6172                 {
6173                         x := ((*(*(struct {
6174                                 Amount         uint16
6175                                 Duration       float32
6176                                 Pos, Vel, Acc  [2][3]float32
6177                                 ExpirationTime [2]float32 // in seconds.
6178                                 Size           [2]float32
6179                                 Collide        bool
6180
6181                                 //mt:len32
6182                                 Texture
6183
6184                                 ID           ParticleSpawnerID
6185                                 Vertical     bool
6186                                 CollisionRm  bool
6187                                 AttachedAOID AOID
6188                                 AnimParams   TileAnim
6189                                 Glow         uint8
6190                                 AOCollision  bool
6191                                 NodeParam0   Content
6192                                 NodeParam2   uint8
6193                                 NodeTile     uint8
6194                         }))(obj)).Size)[local163]
6195                         write32(w, math.Float32bits(x))
6196                 }
6197         }
6198         {
6199                 x := (*(*(struct {
6200                         Amount         uint16
6201                         Duration       float32
6202                         Pos, Vel, Acc  [2][3]float32
6203                         ExpirationTime [2]float32 // in seconds.
6204                         Size           [2]float32
6205                         Collide        bool
6206
6207                         //mt:len32
6208                         Texture
6209
6210                         ID           ParticleSpawnerID
6211                         Vertical     bool
6212                         CollisionRm  bool
6213                         AttachedAOID AOID
6214                         AnimParams   TileAnim
6215                         Glow         uint8
6216                         AOCollision  bool
6217                         NodeParam0   Content
6218                         NodeParam2   uint8
6219                         NodeTile     uint8
6220                 }))(obj)).Collide
6221                 if x {
6222                         write8(w, 1)
6223                 } else {
6224                         write8(w, 0)
6225                 }
6226
6227         }
6228         if len(([]byte(*(*string)(&((*(*(struct {
6229                 Amount         uint16
6230                 Duration       float32
6231                 Pos, Vel, Acc  [2][3]float32
6232                 ExpirationTime [2]float32 // in seconds.
6233                 Size           [2]float32
6234                 Collide        bool
6235
6236                 //mt:len32
6237                 Texture
6238
6239                 ID           ParticleSpawnerID
6240                 Vertical     bool
6241                 CollisionRm  bool
6242                 AttachedAOID AOID
6243                 AnimParams   TileAnim
6244                 Glow         uint8
6245                 AOCollision  bool
6246                 NodeParam0   Content
6247                 NodeParam2   uint8
6248                 NodeTile     uint8
6249         }))(obj)).Texture))))) > math.MaxUint32 {
6250                 chk(ErrTooLong)
6251         }
6252         {
6253                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6254                         Amount         uint16
6255                         Duration       float32
6256                         Pos, Vel, Acc  [2][3]float32
6257                         ExpirationTime [2]float32 // in seconds.
6258                         Size           [2]float32
6259                         Collide        bool
6260
6261                         //mt:len32
6262                         Texture
6263
6264                         ID           ParticleSpawnerID
6265                         Vertical     bool
6266                         CollisionRm  bool
6267                         AttachedAOID AOID
6268                         AnimParams   TileAnim
6269                         Glow         uint8
6270                         AOCollision  bool
6271                         NodeParam0   Content
6272                         NodeParam2   uint8
6273                         NodeTile     uint8
6274                 }))(obj)).Texture))))))
6275                 write32(w, uint32(x))
6276         }
6277         {
6278                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6279                         Amount         uint16
6280                         Duration       float32
6281                         Pos, Vel, Acc  [2][3]float32
6282                         ExpirationTime [2]float32 // in seconds.
6283                         Size           [2]float32
6284                         Collide        bool
6285
6286                         //mt:len32
6287                         Texture
6288
6289                         ID           ParticleSpawnerID
6290                         Vertical     bool
6291                         CollisionRm  bool
6292                         AttachedAOID AOID
6293                         AnimParams   TileAnim
6294                         Glow         uint8
6295                         AOCollision  bool
6296                         NodeParam0   Content
6297                         NodeParam2   uint8
6298                         NodeTile     uint8
6299                 }))(obj)).Texture))))[:])
6300                 chk(err)
6301         }
6302         if err := pcall(func() {
6303                 ((*(*(struct {
6304                         Amount         uint16
6305                         Duration       float32
6306                         Pos, Vel, Acc  [2][3]float32
6307                         ExpirationTime [2]float32 // in seconds.
6308                         Size           [2]float32
6309                         Collide        bool
6310
6311                         //mt:len32
6312                         Texture
6313
6314                         ID           ParticleSpawnerID
6315                         Vertical     bool
6316                         CollisionRm  bool
6317                         AttachedAOID AOID
6318                         AnimParams   TileAnim
6319                         Glow         uint8
6320                         AOCollision  bool
6321                         NodeParam0   Content
6322                         NodeParam2   uint8
6323                         NodeTile     uint8
6324                 }))(obj)).ID).serialize(w)
6325         }); err != nil {
6326                 if err == io.EOF {
6327                         chk(io.EOF)
6328                 }
6329                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
6330         }
6331         {
6332                 x := (*(*(struct {
6333                         Amount         uint16
6334                         Duration       float32
6335                         Pos, Vel, Acc  [2][3]float32
6336                         ExpirationTime [2]float32 // in seconds.
6337                         Size           [2]float32
6338                         Collide        bool
6339
6340                         //mt:len32
6341                         Texture
6342
6343                         ID           ParticleSpawnerID
6344                         Vertical     bool
6345                         CollisionRm  bool
6346                         AttachedAOID AOID
6347                         AnimParams   TileAnim
6348                         Glow         uint8
6349                         AOCollision  bool
6350                         NodeParam0   Content
6351                         NodeParam2   uint8
6352                         NodeTile     uint8
6353                 }))(obj)).Vertical
6354                 if x {
6355                         write8(w, 1)
6356                 } else {
6357                         write8(w, 0)
6358                 }
6359
6360         }
6361         {
6362                 x := (*(*(struct {
6363                         Amount         uint16
6364                         Duration       float32
6365                         Pos, Vel, Acc  [2][3]float32
6366                         ExpirationTime [2]float32 // in seconds.
6367                         Size           [2]float32
6368                         Collide        bool
6369
6370                         //mt:len32
6371                         Texture
6372
6373                         ID           ParticleSpawnerID
6374                         Vertical     bool
6375                         CollisionRm  bool
6376                         AttachedAOID AOID
6377                         AnimParams   TileAnim
6378                         Glow         uint8
6379                         AOCollision  bool
6380                         NodeParam0   Content
6381                         NodeParam2   uint8
6382                         NodeTile     uint8
6383                 }))(obj)).CollisionRm
6384                 if x {
6385                         write8(w, 1)
6386                 } else {
6387                         write8(w, 0)
6388                 }
6389
6390         }
6391         if err := pcall(func() {
6392                 ((*(*(struct {
6393                         Amount         uint16
6394                         Duration       float32
6395                         Pos, Vel, Acc  [2][3]float32
6396                         ExpirationTime [2]float32 // in seconds.
6397                         Size           [2]float32
6398                         Collide        bool
6399
6400                         //mt:len32
6401                         Texture
6402
6403                         ID           ParticleSpawnerID
6404                         Vertical     bool
6405                         CollisionRm  bool
6406                         AttachedAOID AOID
6407                         AnimParams   TileAnim
6408                         Glow         uint8
6409                         AOCollision  bool
6410                         NodeParam0   Content
6411                         NodeParam2   uint8
6412                         NodeTile     uint8
6413                 }))(obj)).AttachedAOID).serialize(w)
6414         }); err != nil {
6415                 if err == io.EOF {
6416                         chk(io.EOF)
6417                 }
6418                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
6419         }
6420         if err := pcall(func() {
6421                 ((*(*(struct {
6422                         Amount         uint16
6423                         Duration       float32
6424                         Pos, Vel, Acc  [2][3]float32
6425                         ExpirationTime [2]float32 // in seconds.
6426                         Size           [2]float32
6427                         Collide        bool
6428
6429                         //mt:len32
6430                         Texture
6431
6432                         ID           ParticleSpawnerID
6433                         Vertical     bool
6434                         CollisionRm  bool
6435                         AttachedAOID AOID
6436                         AnimParams   TileAnim
6437                         Glow         uint8
6438                         AOCollision  bool
6439                         NodeParam0   Content
6440                         NodeParam2   uint8
6441                         NodeTile     uint8
6442                 }))(obj)).AnimParams).serialize(w)
6443         }); err != nil {
6444                 if err == io.EOF {
6445                         chk(io.EOF)
6446                 }
6447                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
6448         }
6449         {
6450                 x := (*(*(struct {
6451                         Amount         uint16
6452                         Duration       float32
6453                         Pos, Vel, Acc  [2][3]float32
6454                         ExpirationTime [2]float32 // in seconds.
6455                         Size           [2]float32
6456                         Collide        bool
6457
6458                         //mt:len32
6459                         Texture
6460
6461                         ID           ParticleSpawnerID
6462                         Vertical     bool
6463                         CollisionRm  bool
6464                         AttachedAOID AOID
6465                         AnimParams   TileAnim
6466                         Glow         uint8
6467                         AOCollision  bool
6468                         NodeParam0   Content
6469                         NodeParam2   uint8
6470                         NodeTile     uint8
6471                 }))(obj)).Glow
6472                 write8(w, uint8(x))
6473         }
6474         {
6475                 x := (*(*(struct {
6476                         Amount         uint16
6477                         Duration       float32
6478                         Pos, Vel, Acc  [2][3]float32
6479                         ExpirationTime [2]float32 // in seconds.
6480                         Size           [2]float32
6481                         Collide        bool
6482
6483                         //mt:len32
6484                         Texture
6485
6486                         ID           ParticleSpawnerID
6487                         Vertical     bool
6488                         CollisionRm  bool
6489                         AttachedAOID AOID
6490                         AnimParams   TileAnim
6491                         Glow         uint8
6492                         AOCollision  bool
6493                         NodeParam0   Content
6494                         NodeParam2   uint8
6495                         NodeTile     uint8
6496                 }))(obj)).AOCollision
6497                 if x {
6498                         write8(w, 1)
6499                 } else {
6500                         write8(w, 0)
6501                 }
6502
6503         }
6504         if err := pcall(func() {
6505                 ((*(*(struct {
6506                         Amount         uint16
6507                         Duration       float32
6508                         Pos, Vel, Acc  [2][3]float32
6509                         ExpirationTime [2]float32 // in seconds.
6510                         Size           [2]float32
6511                         Collide        bool
6512
6513                         //mt:len32
6514                         Texture
6515
6516                         ID           ParticleSpawnerID
6517                         Vertical     bool
6518                         CollisionRm  bool
6519                         AttachedAOID AOID
6520                         AnimParams   TileAnim
6521                         Glow         uint8
6522                         AOCollision  bool
6523                         NodeParam0   Content
6524                         NodeParam2   uint8
6525                         NodeTile     uint8
6526                 }))(obj)).NodeParam0).serialize(w)
6527         }); err != nil {
6528                 if err == io.EOF {
6529                         chk(io.EOF)
6530                 }
6531                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
6532         }
6533         {
6534                 x := (*(*(struct {
6535                         Amount         uint16
6536                         Duration       float32
6537                         Pos, Vel, Acc  [2][3]float32
6538                         ExpirationTime [2]float32 // in seconds.
6539                         Size           [2]float32
6540                         Collide        bool
6541
6542                         //mt:len32
6543                         Texture
6544
6545                         ID           ParticleSpawnerID
6546                         Vertical     bool
6547                         CollisionRm  bool
6548                         AttachedAOID AOID
6549                         AnimParams   TileAnim
6550                         Glow         uint8
6551                         AOCollision  bool
6552                         NodeParam0   Content
6553                         NodeParam2   uint8
6554                         NodeTile     uint8
6555                 }))(obj)).NodeParam2
6556                 write8(w, uint8(x))
6557         }
6558         {
6559                 x := (*(*(struct {
6560                         Amount         uint16
6561                         Duration       float32
6562                         Pos, Vel, Acc  [2][3]float32
6563                         ExpirationTime [2]float32 // in seconds.
6564                         Size           [2]float32
6565                         Collide        bool
6566
6567                         //mt:len32
6568                         Texture
6569
6570                         ID           ParticleSpawnerID
6571                         Vertical     bool
6572                         CollisionRm  bool
6573                         AttachedAOID AOID
6574                         AnimParams   TileAnim
6575                         Glow         uint8
6576                         AOCollision  bool
6577                         NodeParam0   Content
6578                         NodeParam2   uint8
6579                         NodeTile     uint8
6580                 }))(obj)).NodeTile
6581                 write8(w, uint8(x))
6582         }
6583 }
6584
6585 func (obj *ToCltAddParticleSpawner) deserialize(r io.Reader) {
6586         {
6587                 p := &(*(*(struct {
6588                         Amount         uint16
6589                         Duration       float32
6590                         Pos, Vel, Acc  [2][3]float32
6591                         ExpirationTime [2]float32 // in seconds.
6592                         Size           [2]float32
6593                         Collide        bool
6594
6595                         //mt:len32
6596                         Texture
6597
6598                         ID           ParticleSpawnerID
6599                         Vertical     bool
6600                         CollisionRm  bool
6601                         AttachedAOID AOID
6602                         AnimParams   TileAnim
6603                         Glow         uint8
6604                         AOCollision  bool
6605                         NodeParam0   Content
6606                         NodeParam2   uint8
6607                         NodeTile     uint8
6608                 }))(obj)).Amount
6609                 *p = read16(r)
6610         }
6611         {
6612                 p := &(*(*(struct {
6613                         Amount         uint16
6614                         Duration       float32
6615                         Pos, Vel, Acc  [2][3]float32
6616                         ExpirationTime [2]float32 // in seconds.
6617                         Size           [2]float32
6618                         Collide        bool
6619
6620                         //mt:len32
6621                         Texture
6622
6623                         ID           ParticleSpawnerID
6624                         Vertical     bool
6625                         CollisionRm  bool
6626                         AttachedAOID AOID
6627                         AnimParams   TileAnim
6628                         Glow         uint8
6629                         AOCollision  bool
6630                         NodeParam0   Content
6631                         NodeParam2   uint8
6632                         NodeTile     uint8
6633                 }))(obj)).Duration
6634                 *p = math.Float32frombits(read32(r))
6635         }
6636         for local164 := range (*(*(struct {
6637                 Amount         uint16
6638                 Duration       float32
6639                 Pos, Vel, Acc  [2][3]float32
6640                 ExpirationTime [2]float32 // in seconds.
6641                 Size           [2]float32
6642                 Collide        bool
6643
6644                 //mt:len32
6645                 Texture
6646
6647                 ID           ParticleSpawnerID
6648                 Vertical     bool
6649                 CollisionRm  bool
6650                 AttachedAOID AOID
6651                 AnimParams   TileAnim
6652                 Glow         uint8
6653                 AOCollision  bool
6654                 NodeParam0   Content
6655                 NodeParam2   uint8
6656                 NodeTile     uint8
6657         }))(obj)).Pos {
6658                 for local165 := range ((*(*(struct {
6659                         Amount         uint16
6660                         Duration       float32
6661                         Pos, Vel, Acc  [2][3]float32
6662                         ExpirationTime [2]float32 // in seconds.
6663                         Size           [2]float32
6664                         Collide        bool
6665
6666                         //mt:len32
6667                         Texture
6668
6669                         ID           ParticleSpawnerID
6670                         Vertical     bool
6671                         CollisionRm  bool
6672                         AttachedAOID AOID
6673                         AnimParams   TileAnim
6674                         Glow         uint8
6675                         AOCollision  bool
6676                         NodeParam0   Content
6677                         NodeParam2   uint8
6678                         NodeTile     uint8
6679                 }))(obj)).Pos)[local164] {
6680                         {
6681                                 p := &(((*(*(struct {
6682                                         Amount         uint16
6683                                         Duration       float32
6684                                         Pos, Vel, Acc  [2][3]float32
6685                                         ExpirationTime [2]float32 // in seconds.
6686                                         Size           [2]float32
6687                                         Collide        bool
6688
6689                                         //mt:len32
6690                                         Texture
6691
6692                                         ID           ParticleSpawnerID
6693                                         Vertical     bool
6694                                         CollisionRm  bool
6695                                         AttachedAOID AOID
6696                                         AnimParams   TileAnim
6697                                         Glow         uint8
6698                                         AOCollision  bool
6699                                         NodeParam0   Content
6700                                         NodeParam2   uint8
6701                                         NodeTile     uint8
6702                                 }))(obj)).Pos)[local164])[local165]
6703                                 *p = math.Float32frombits(read32(r))
6704                         }
6705                 }
6706         }
6707         for local166 := range (*(*(struct {
6708                 Amount         uint16
6709                 Duration       float32
6710                 Pos, Vel, Acc  [2][3]float32
6711                 ExpirationTime [2]float32 // in seconds.
6712                 Size           [2]float32
6713                 Collide        bool
6714
6715                 //mt:len32
6716                 Texture
6717
6718                 ID           ParticleSpawnerID
6719                 Vertical     bool
6720                 CollisionRm  bool
6721                 AttachedAOID AOID
6722                 AnimParams   TileAnim
6723                 Glow         uint8
6724                 AOCollision  bool
6725                 NodeParam0   Content
6726                 NodeParam2   uint8
6727                 NodeTile     uint8
6728         }))(obj)).Vel {
6729                 for local167 := range ((*(*(struct {
6730                         Amount         uint16
6731                         Duration       float32
6732                         Pos, Vel, Acc  [2][3]float32
6733                         ExpirationTime [2]float32 // in seconds.
6734                         Size           [2]float32
6735                         Collide        bool
6736
6737                         //mt:len32
6738                         Texture
6739
6740                         ID           ParticleSpawnerID
6741                         Vertical     bool
6742                         CollisionRm  bool
6743                         AttachedAOID AOID
6744                         AnimParams   TileAnim
6745                         Glow         uint8
6746                         AOCollision  bool
6747                         NodeParam0   Content
6748                         NodeParam2   uint8
6749                         NodeTile     uint8
6750                 }))(obj)).Vel)[local166] {
6751                         {
6752                                 p := &(((*(*(struct {
6753                                         Amount         uint16
6754                                         Duration       float32
6755                                         Pos, Vel, Acc  [2][3]float32
6756                                         ExpirationTime [2]float32 // in seconds.
6757                                         Size           [2]float32
6758                                         Collide        bool
6759
6760                                         //mt:len32
6761                                         Texture
6762
6763                                         ID           ParticleSpawnerID
6764                                         Vertical     bool
6765                                         CollisionRm  bool
6766                                         AttachedAOID AOID
6767                                         AnimParams   TileAnim
6768                                         Glow         uint8
6769                                         AOCollision  bool
6770                                         NodeParam0   Content
6771                                         NodeParam2   uint8
6772                                         NodeTile     uint8
6773                                 }))(obj)).Vel)[local166])[local167]
6774                                 *p = math.Float32frombits(read32(r))
6775                         }
6776                 }
6777         }
6778         for local168 := range (*(*(struct {
6779                 Amount         uint16
6780                 Duration       float32
6781                 Pos, Vel, Acc  [2][3]float32
6782                 ExpirationTime [2]float32 // in seconds.
6783                 Size           [2]float32
6784                 Collide        bool
6785
6786                 //mt:len32
6787                 Texture
6788
6789                 ID           ParticleSpawnerID
6790                 Vertical     bool
6791                 CollisionRm  bool
6792                 AttachedAOID AOID
6793                 AnimParams   TileAnim
6794                 Glow         uint8
6795                 AOCollision  bool
6796                 NodeParam0   Content
6797                 NodeParam2   uint8
6798                 NodeTile     uint8
6799         }))(obj)).Acc {
6800                 for local169 := range ((*(*(struct {
6801                         Amount         uint16
6802                         Duration       float32
6803                         Pos, Vel, Acc  [2][3]float32
6804                         ExpirationTime [2]float32 // in seconds.
6805                         Size           [2]float32
6806                         Collide        bool
6807
6808                         //mt:len32
6809                         Texture
6810
6811                         ID           ParticleSpawnerID
6812                         Vertical     bool
6813                         CollisionRm  bool
6814                         AttachedAOID AOID
6815                         AnimParams   TileAnim
6816                         Glow         uint8
6817                         AOCollision  bool
6818                         NodeParam0   Content
6819                         NodeParam2   uint8
6820                         NodeTile     uint8
6821                 }))(obj)).Acc)[local168] {
6822                         {
6823                                 p := &(((*(*(struct {
6824                                         Amount         uint16
6825                                         Duration       float32
6826                                         Pos, Vel, Acc  [2][3]float32
6827                                         ExpirationTime [2]float32 // in seconds.
6828                                         Size           [2]float32
6829                                         Collide        bool
6830
6831                                         //mt:len32
6832                                         Texture
6833
6834                                         ID           ParticleSpawnerID
6835                                         Vertical     bool
6836                                         CollisionRm  bool
6837                                         AttachedAOID AOID
6838                                         AnimParams   TileAnim
6839                                         Glow         uint8
6840                                         AOCollision  bool
6841                                         NodeParam0   Content
6842                                         NodeParam2   uint8
6843                                         NodeTile     uint8
6844                                 }))(obj)).Acc)[local168])[local169]
6845                                 *p = math.Float32frombits(read32(r))
6846                         }
6847                 }
6848         }
6849         for local170 := range (*(*(struct {
6850                 Amount         uint16
6851                 Duration       float32
6852                 Pos, Vel, Acc  [2][3]float32
6853                 ExpirationTime [2]float32 // in seconds.
6854                 Size           [2]float32
6855                 Collide        bool
6856
6857                 //mt:len32
6858                 Texture
6859
6860                 ID           ParticleSpawnerID
6861                 Vertical     bool
6862                 CollisionRm  bool
6863                 AttachedAOID AOID
6864                 AnimParams   TileAnim
6865                 Glow         uint8
6866                 AOCollision  bool
6867                 NodeParam0   Content
6868                 NodeParam2   uint8
6869                 NodeTile     uint8
6870         }))(obj)).ExpirationTime {
6871                 {
6872                         p := &((*(*(struct {
6873                                 Amount         uint16
6874                                 Duration       float32
6875                                 Pos, Vel, Acc  [2][3]float32
6876                                 ExpirationTime [2]float32 // in seconds.
6877                                 Size           [2]float32
6878                                 Collide        bool
6879
6880                                 //mt:len32
6881                                 Texture
6882
6883                                 ID           ParticleSpawnerID
6884                                 Vertical     bool
6885                                 CollisionRm  bool
6886                                 AttachedAOID AOID
6887                                 AnimParams   TileAnim
6888                                 Glow         uint8
6889                                 AOCollision  bool
6890                                 NodeParam0   Content
6891                                 NodeParam2   uint8
6892                                 NodeTile     uint8
6893                         }))(obj)).ExpirationTime)[local170]
6894                         *p = math.Float32frombits(read32(r))
6895                 }
6896         }
6897         for local171 := range (*(*(struct {
6898                 Amount         uint16
6899                 Duration       float32
6900                 Pos, Vel, Acc  [2][3]float32
6901                 ExpirationTime [2]float32 // in seconds.
6902                 Size           [2]float32
6903                 Collide        bool
6904
6905                 //mt:len32
6906                 Texture
6907
6908                 ID           ParticleSpawnerID
6909                 Vertical     bool
6910                 CollisionRm  bool
6911                 AttachedAOID AOID
6912                 AnimParams   TileAnim
6913                 Glow         uint8
6914                 AOCollision  bool
6915                 NodeParam0   Content
6916                 NodeParam2   uint8
6917                 NodeTile     uint8
6918         }))(obj)).Size {
6919                 {
6920                         p := &((*(*(struct {
6921                                 Amount         uint16
6922                                 Duration       float32
6923                                 Pos, Vel, Acc  [2][3]float32
6924                                 ExpirationTime [2]float32 // in seconds.
6925                                 Size           [2]float32
6926                                 Collide        bool
6927
6928                                 //mt:len32
6929                                 Texture
6930
6931                                 ID           ParticleSpawnerID
6932                                 Vertical     bool
6933                                 CollisionRm  bool
6934                                 AttachedAOID AOID
6935                                 AnimParams   TileAnim
6936                                 Glow         uint8
6937                                 AOCollision  bool
6938                                 NodeParam0   Content
6939                                 NodeParam2   uint8
6940                                 NodeTile     uint8
6941                         }))(obj)).Size)[local171]
6942                         *p = math.Float32frombits(read32(r))
6943                 }
6944         }
6945         {
6946                 p := &(*(*(struct {
6947                         Amount         uint16
6948                         Duration       float32
6949                         Pos, Vel, Acc  [2][3]float32
6950                         ExpirationTime [2]float32 // in seconds.
6951                         Size           [2]float32
6952                         Collide        bool
6953
6954                         //mt:len32
6955                         Texture
6956
6957                         ID           ParticleSpawnerID
6958                         Vertical     bool
6959                         CollisionRm  bool
6960                         AttachedAOID AOID
6961                         AnimParams   TileAnim
6962                         Glow         uint8
6963                         AOCollision  bool
6964                         NodeParam0   Content
6965                         NodeParam2   uint8
6966                         NodeTile     uint8
6967                 }))(obj)).Collide
6968                 switch n := read8(r); n {
6969                 case 0:
6970                         *p = false
6971                 case 1:
6972                         *p = true
6973                 default:
6974                         chk(fmt.Errorf("invalid bool: %d", n))
6975                 }
6976
6977         }
6978         var local172 []uint8
6979         var local173 uint32
6980         {
6981                 p := &local173
6982                 *p = read32(r)
6983         }
6984         (local172) = make([]uint8, local173)
6985         {
6986                 _, err := io.ReadFull(r, (local172)[:])
6987                 chk(err)
6988         }
6989         (*(*string)(&((*(*(struct {
6990                 Amount         uint16
6991                 Duration       float32
6992                 Pos, Vel, Acc  [2][3]float32
6993                 ExpirationTime [2]float32 // in seconds.
6994                 Size           [2]float32
6995                 Collide        bool
6996
6997                 //mt:len32
6998                 Texture
6999
7000                 ID           ParticleSpawnerID
7001                 Vertical     bool
7002                 CollisionRm  bool
7003                 AttachedAOID AOID
7004                 AnimParams   TileAnim
7005                 Glow         uint8
7006                 AOCollision  bool
7007                 NodeParam0   Content
7008                 NodeParam2   uint8
7009                 NodeTile     uint8
7010         }))(obj)).Texture))) = string(local172)
7011         if err := pcall(func() {
7012                 ((*(*(struct {
7013                         Amount         uint16
7014                         Duration       float32
7015                         Pos, Vel, Acc  [2][3]float32
7016                         ExpirationTime [2]float32 // in seconds.
7017                         Size           [2]float32
7018                         Collide        bool
7019
7020                         //mt:len32
7021                         Texture
7022
7023                         ID           ParticleSpawnerID
7024                         Vertical     bool
7025                         CollisionRm  bool
7026                         AttachedAOID AOID
7027                         AnimParams   TileAnim
7028                         Glow         uint8
7029                         AOCollision  bool
7030                         NodeParam0   Content
7031                         NodeParam2   uint8
7032                         NodeTile     uint8
7033                 }))(obj)).ID).deserialize(r)
7034         }); err != nil {
7035                 if err == io.EOF {
7036                         chk(io.EOF)
7037                 }
7038                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
7039         }
7040         {
7041                 p := &(*(*(struct {
7042                         Amount         uint16
7043                         Duration       float32
7044                         Pos, Vel, Acc  [2][3]float32
7045                         ExpirationTime [2]float32 // in seconds.
7046                         Size           [2]float32
7047                         Collide        bool
7048
7049                         //mt:len32
7050                         Texture
7051
7052                         ID           ParticleSpawnerID
7053                         Vertical     bool
7054                         CollisionRm  bool
7055                         AttachedAOID AOID
7056                         AnimParams   TileAnim
7057                         Glow         uint8
7058                         AOCollision  bool
7059                         NodeParam0   Content
7060                         NodeParam2   uint8
7061                         NodeTile     uint8
7062                 }))(obj)).Vertical
7063                 switch n := read8(r); n {
7064                 case 0:
7065                         *p = false
7066                 case 1:
7067                         *p = true
7068                 default:
7069                         chk(fmt.Errorf("invalid bool: %d", n))
7070                 }
7071
7072         }
7073         {
7074                 p := &(*(*(struct {
7075                         Amount         uint16
7076                         Duration       float32
7077                         Pos, Vel, Acc  [2][3]float32
7078                         ExpirationTime [2]float32 // in seconds.
7079                         Size           [2]float32
7080                         Collide        bool
7081
7082                         //mt:len32
7083                         Texture
7084
7085                         ID           ParticleSpawnerID
7086                         Vertical     bool
7087                         CollisionRm  bool
7088                         AttachedAOID AOID
7089                         AnimParams   TileAnim
7090                         Glow         uint8
7091                         AOCollision  bool
7092                         NodeParam0   Content
7093                         NodeParam2   uint8
7094                         NodeTile     uint8
7095                 }))(obj)).CollisionRm
7096                 switch n := read8(r); n {
7097                 case 0:
7098                         *p = false
7099                 case 1:
7100                         *p = true
7101                 default:
7102                         chk(fmt.Errorf("invalid bool: %d", n))
7103                 }
7104
7105         }
7106         if err := pcall(func() {
7107                 ((*(*(struct {
7108                         Amount         uint16
7109                         Duration       float32
7110                         Pos, Vel, Acc  [2][3]float32
7111                         ExpirationTime [2]float32 // in seconds.
7112                         Size           [2]float32
7113                         Collide        bool
7114
7115                         //mt:len32
7116                         Texture
7117
7118                         ID           ParticleSpawnerID
7119                         Vertical     bool
7120                         CollisionRm  bool
7121                         AttachedAOID AOID
7122                         AnimParams   TileAnim
7123                         Glow         uint8
7124                         AOCollision  bool
7125                         NodeParam0   Content
7126                         NodeParam2   uint8
7127                         NodeTile     uint8
7128                 }))(obj)).AttachedAOID).deserialize(r)
7129         }); err != nil {
7130                 if err == io.EOF {
7131                         chk(io.EOF)
7132                 }
7133                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
7134         }
7135         if err := pcall(func() {
7136                 ((*(*(struct {
7137                         Amount         uint16
7138                         Duration       float32
7139                         Pos, Vel, Acc  [2][3]float32
7140                         ExpirationTime [2]float32 // in seconds.
7141                         Size           [2]float32
7142                         Collide        bool
7143
7144                         //mt:len32
7145                         Texture
7146
7147                         ID           ParticleSpawnerID
7148                         Vertical     bool
7149                         CollisionRm  bool
7150                         AttachedAOID AOID
7151                         AnimParams   TileAnim
7152                         Glow         uint8
7153                         AOCollision  bool
7154                         NodeParam0   Content
7155                         NodeParam2   uint8
7156                         NodeTile     uint8
7157                 }))(obj)).AnimParams).deserialize(r)
7158         }); err != nil {
7159                 if err == io.EOF {
7160                         chk(io.EOF)
7161                 }
7162                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
7163         }
7164         {
7165                 p := &(*(*(struct {
7166                         Amount         uint16
7167                         Duration       float32
7168                         Pos, Vel, Acc  [2][3]float32
7169                         ExpirationTime [2]float32 // in seconds.
7170                         Size           [2]float32
7171                         Collide        bool
7172
7173                         //mt:len32
7174                         Texture
7175
7176                         ID           ParticleSpawnerID
7177                         Vertical     bool
7178                         CollisionRm  bool
7179                         AttachedAOID AOID
7180                         AnimParams   TileAnim
7181                         Glow         uint8
7182                         AOCollision  bool
7183                         NodeParam0   Content
7184                         NodeParam2   uint8
7185                         NodeTile     uint8
7186                 }))(obj)).Glow
7187                 *p = read8(r)
7188         }
7189         {
7190                 p := &(*(*(struct {
7191                         Amount         uint16
7192                         Duration       float32
7193                         Pos, Vel, Acc  [2][3]float32
7194                         ExpirationTime [2]float32 // in seconds.
7195                         Size           [2]float32
7196                         Collide        bool
7197
7198                         //mt:len32
7199                         Texture
7200
7201                         ID           ParticleSpawnerID
7202                         Vertical     bool
7203                         CollisionRm  bool
7204                         AttachedAOID AOID
7205                         AnimParams   TileAnim
7206                         Glow         uint8
7207                         AOCollision  bool
7208                         NodeParam0   Content
7209                         NodeParam2   uint8
7210                         NodeTile     uint8
7211                 }))(obj)).AOCollision
7212                 switch n := read8(r); n {
7213                 case 0:
7214                         *p = false
7215                 case 1:
7216                         *p = true
7217                 default:
7218                         chk(fmt.Errorf("invalid bool: %d", n))
7219                 }
7220
7221         }
7222         if err := pcall(func() {
7223                 ((*(*(struct {
7224                         Amount         uint16
7225                         Duration       float32
7226                         Pos, Vel, Acc  [2][3]float32
7227                         ExpirationTime [2]float32 // in seconds.
7228                         Size           [2]float32
7229                         Collide        bool
7230
7231                         //mt:len32
7232                         Texture
7233
7234                         ID           ParticleSpawnerID
7235                         Vertical     bool
7236                         CollisionRm  bool
7237                         AttachedAOID AOID
7238                         AnimParams   TileAnim
7239                         Glow         uint8
7240                         AOCollision  bool
7241                         NodeParam0   Content
7242                         NodeParam2   uint8
7243                         NodeTile     uint8
7244                 }))(obj)).NodeParam0).deserialize(r)
7245         }); err != nil {
7246                 if err == io.EOF {
7247                         chk(io.EOF)
7248                 }
7249                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
7250         }
7251         {
7252                 p := &(*(*(struct {
7253                         Amount         uint16
7254                         Duration       float32
7255                         Pos, Vel, Acc  [2][3]float32
7256                         ExpirationTime [2]float32 // in seconds.
7257                         Size           [2]float32
7258                         Collide        bool
7259
7260                         //mt:len32
7261                         Texture
7262
7263                         ID           ParticleSpawnerID
7264                         Vertical     bool
7265                         CollisionRm  bool
7266                         AttachedAOID AOID
7267                         AnimParams   TileAnim
7268                         Glow         uint8
7269                         AOCollision  bool
7270                         NodeParam0   Content
7271                         NodeParam2   uint8
7272                         NodeTile     uint8
7273                 }))(obj)).NodeParam2
7274                 *p = read8(r)
7275         }
7276         {
7277                 p := &(*(*(struct {
7278                         Amount         uint16
7279                         Duration       float32
7280                         Pos, Vel, Acc  [2][3]float32
7281                         ExpirationTime [2]float32 // in seconds.
7282                         Size           [2]float32
7283                         Collide        bool
7284
7285                         //mt:len32
7286                         Texture
7287
7288                         ID           ParticleSpawnerID
7289                         Vertical     bool
7290                         CollisionRm  bool
7291                         AttachedAOID AOID
7292                         AnimParams   TileAnim
7293                         Glow         uint8
7294                         AOCollision  bool
7295                         NodeParam0   Content
7296                         NodeParam2   uint8
7297                         NodeTile     uint8
7298                 }))(obj)).NodeTile
7299                 *p = read8(r)
7300         }
7301 }
7302
7303 func (obj *ToCltAddHUD) serialize(w io.Writer) {
7304         if err := pcall(func() {
7305                 ((*(*(struct {
7306                         ID HUDID
7307                         HUD
7308                 }))(obj)).ID).serialize(w)
7309         }); err != nil {
7310                 if err == io.EOF {
7311                         chk(io.EOF)
7312                 }
7313                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7314         }
7315         if err := pcall(func() {
7316                 ((*(*(struct {
7317                         ID HUDID
7318                         HUD
7319                 }))(obj)).HUD).serialize(w)
7320         }); err != nil {
7321                 if err == io.EOF {
7322                         chk(io.EOF)
7323                 }
7324                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUD", err))
7325         }
7326 }
7327
7328 func (obj *ToCltAddHUD) deserialize(r io.Reader) {
7329         if err := pcall(func() {
7330                 ((*(*(struct {
7331                         ID HUDID
7332                         HUD
7333                 }))(obj)).ID).deserialize(r)
7334         }); err != nil {
7335                 if err == io.EOF {
7336                         chk(io.EOF)
7337                 }
7338                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7339         }
7340         if err := pcall(func() {
7341                 ((*(*(struct {
7342                         ID HUDID
7343                         HUD
7344                 }))(obj)).HUD).deserialize(r)
7345         }); err != nil {
7346                 if err == io.EOF {
7347                         chk(io.EOF)
7348                 }
7349                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUD", err))
7350         }
7351 }
7352
7353 func (obj *ToCltRmHUD) serialize(w io.Writer) {
7354         if err := pcall(func() {
7355                 ((*(*(struct {
7356                         ID HUDID
7357                 }))(obj)).ID).serialize(w)
7358         }); err != nil {
7359                 if err == io.EOF {
7360                         chk(io.EOF)
7361                 }
7362                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7363         }
7364 }
7365
7366 func (obj *ToCltRmHUD) deserialize(r io.Reader) {
7367         if err := pcall(func() {
7368                 ((*(*(struct {
7369                         ID HUDID
7370                 }))(obj)).ID).deserialize(r)
7371         }); err != nil {
7372                 if err == io.EOF {
7373                         chk(io.EOF)
7374                 }
7375                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7376         }
7377 }
7378
7379 func (obj *ToCltChangeHUD) serialize(w io.Writer) {
7380         if err := pcall(func() {
7381                 ((*(*(struct {
7382                         ID HUDID
7383
7384                         Field HUDField
7385
7386                         //mt:if %s.Field == HUDPos
7387                         Pos [2]float32
7388
7389                         //mt:if %s.Field == HUDName
7390                         Name string
7391
7392                         //mt:if %s.Field == HUDScale
7393                         Scale [2]float32
7394
7395                         //mt:if %s.Field == HUDText
7396                         Text string
7397
7398                         //mt:if %s.Field == HUDNumber
7399                         Number uint32
7400
7401                         //mt:if %s.Field == HUDItem
7402                         Item uint32
7403
7404                         //mt:if %s.Field == HUDDir
7405                         Dir uint32
7406
7407                         //mt:if %s.Field == HUDAlign
7408                         Align [2]float32
7409
7410                         //mt:if %s.Field == HUDOffset
7411                         Offset [2]float32
7412
7413                         //mt:if %s.Field == HUDWorldPos
7414                         WorldPos Pos
7415
7416                         //mt:if %s.Field == HUDSize
7417                         Size [2]int32
7418
7419                         //mt:if %s.Field == HUDZIndex
7420                         ZIndex int32
7421
7422                         //mt:if %s.Field == HUDText2
7423                         Text2 string
7424                 }))(obj)).ID).serialize(w)
7425         }); err != nil {
7426                 if err == io.EOF {
7427                         chk(io.EOF)
7428                 }
7429                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7430         }
7431         if err := pcall(func() {
7432                 ((*(*(struct {
7433                         ID HUDID
7434
7435                         Field HUDField
7436
7437                         //mt:if %s.Field == HUDPos
7438                         Pos [2]float32
7439
7440                         //mt:if %s.Field == HUDName
7441                         Name string
7442
7443                         //mt:if %s.Field == HUDScale
7444                         Scale [2]float32
7445
7446                         //mt:if %s.Field == HUDText
7447                         Text string
7448
7449                         //mt:if %s.Field == HUDNumber
7450                         Number uint32
7451
7452                         //mt:if %s.Field == HUDItem
7453                         Item uint32
7454
7455                         //mt:if %s.Field == HUDDir
7456                         Dir uint32
7457
7458                         //mt:if %s.Field == HUDAlign
7459                         Align [2]float32
7460
7461                         //mt:if %s.Field == HUDOffset
7462                         Offset [2]float32
7463
7464                         //mt:if %s.Field == HUDWorldPos
7465                         WorldPos Pos
7466
7467                         //mt:if %s.Field == HUDSize
7468                         Size [2]int32
7469
7470                         //mt:if %s.Field == HUDZIndex
7471                         ZIndex int32
7472
7473                         //mt:if %s.Field == HUDText2
7474                         Text2 string
7475                 }))(obj)).Field).serialize(w)
7476         }); err != nil {
7477                 if err == io.EOF {
7478                         chk(io.EOF)
7479                 }
7480                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDField", err))
7481         }
7482         if !((*(*(struct {
7483                 ID HUDID
7484
7485                 Field HUDField
7486
7487                 //mt:if %s.Field == HUDPos
7488                 Pos [2]float32
7489
7490                 //mt:if %s.Field == HUDName
7491                 Name string
7492
7493                 //mt:if %s.Field == HUDScale
7494                 Scale [2]float32
7495
7496                 //mt:if %s.Field == HUDText
7497                 Text string
7498
7499                 //mt:if %s.Field == HUDNumber
7500                 Number uint32
7501
7502                 //mt:if %s.Field == HUDItem
7503                 Item uint32
7504
7505                 //mt:if %s.Field == HUDDir
7506                 Dir uint32
7507
7508                 //mt:if %s.Field == HUDAlign
7509                 Align [2]float32
7510
7511                 //mt:if %s.Field == HUDOffset
7512                 Offset [2]float32
7513
7514                 //mt:if %s.Field == HUDWorldPos
7515                 WorldPos Pos
7516
7517                 //mt:if %s.Field == HUDSize
7518                 Size [2]int32
7519
7520                 //mt:if %s.Field == HUDZIndex
7521                 ZIndex int32
7522
7523                 //mt:if %s.Field == HUDText2
7524                 Text2 string
7525         }))(obj)).Field < hudMax) {
7526                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7527         }
7528         if (*(*(struct {
7529                 ID HUDID
7530
7531                 Field HUDField
7532
7533                 //mt:if %s.Field == HUDPos
7534                 Pos [2]float32
7535
7536                 //mt:if %s.Field == HUDName
7537                 Name string
7538
7539                 //mt:if %s.Field == HUDScale
7540                 Scale [2]float32
7541
7542                 //mt:if %s.Field == HUDText
7543                 Text string
7544
7545                 //mt:if %s.Field == HUDNumber
7546                 Number uint32
7547
7548                 //mt:if %s.Field == HUDItem
7549                 Item uint32
7550
7551                 //mt:if %s.Field == HUDDir
7552                 Dir uint32
7553
7554                 //mt:if %s.Field == HUDAlign
7555                 Align [2]float32
7556
7557                 //mt:if %s.Field == HUDOffset
7558                 Offset [2]float32
7559
7560                 //mt:if %s.Field == HUDWorldPos
7561                 WorldPos Pos
7562
7563                 //mt:if %s.Field == HUDSize
7564                 Size [2]int32
7565
7566                 //mt:if %s.Field == HUDZIndex
7567                 ZIndex int32
7568
7569                 //mt:if %s.Field == HUDText2
7570                 Text2 string
7571         }))(obj)).Field == HUDPos {
7572                 for local174 := range (*(*(struct {
7573                         ID HUDID
7574
7575                         Field HUDField
7576
7577                         //mt:if %s.Field == HUDPos
7578                         Pos [2]float32
7579
7580                         //mt:if %s.Field == HUDName
7581                         Name string
7582
7583                         //mt:if %s.Field == HUDScale
7584                         Scale [2]float32
7585
7586                         //mt:if %s.Field == HUDText
7587                         Text string
7588
7589                         //mt:if %s.Field == HUDNumber
7590                         Number uint32
7591
7592                         //mt:if %s.Field == HUDItem
7593                         Item uint32
7594
7595                         //mt:if %s.Field == HUDDir
7596                         Dir uint32
7597
7598                         //mt:if %s.Field == HUDAlign
7599                         Align [2]float32
7600
7601                         //mt:if %s.Field == HUDOffset
7602                         Offset [2]float32
7603
7604                         //mt:if %s.Field == HUDWorldPos
7605                         WorldPos Pos
7606
7607                         //mt:if %s.Field == HUDSize
7608                         Size [2]int32
7609
7610                         //mt:if %s.Field == HUDZIndex
7611                         ZIndex int32
7612
7613                         //mt:if %s.Field == HUDText2
7614                         Text2 string
7615                 }))(obj)).Pos {
7616                         {
7617                                 x := ((*(*(struct {
7618                                         ID HUDID
7619
7620                                         Field HUDField
7621
7622                                         //mt:if %s.Field == HUDPos
7623                                         Pos [2]float32
7624
7625                                         //mt:if %s.Field == HUDName
7626                                         Name string
7627
7628                                         //mt:if %s.Field == HUDScale
7629                                         Scale [2]float32
7630
7631                                         //mt:if %s.Field == HUDText
7632                                         Text string
7633
7634                                         //mt:if %s.Field == HUDNumber
7635                                         Number uint32
7636
7637                                         //mt:if %s.Field == HUDItem
7638                                         Item uint32
7639
7640                                         //mt:if %s.Field == HUDDir
7641                                         Dir uint32
7642
7643                                         //mt:if %s.Field == HUDAlign
7644                                         Align [2]float32
7645
7646                                         //mt:if %s.Field == HUDOffset
7647                                         Offset [2]float32
7648
7649                                         //mt:if %s.Field == HUDWorldPos
7650                                         WorldPos Pos
7651
7652                                         //mt:if %s.Field == HUDSize
7653                                         Size [2]int32
7654
7655                                         //mt:if %s.Field == HUDZIndex
7656                                         ZIndex int32
7657
7658                                         //mt:if %s.Field == HUDText2
7659                                         Text2 string
7660                                 }))(obj)).Pos)[local174]
7661                                 write32(w, math.Float32bits(x))
7662                         }
7663                 }
7664         }
7665         if (*(*(struct {
7666                 ID HUDID
7667
7668                 Field HUDField
7669
7670                 //mt:if %s.Field == HUDPos
7671                 Pos [2]float32
7672
7673                 //mt:if %s.Field == HUDName
7674                 Name string
7675
7676                 //mt:if %s.Field == HUDScale
7677                 Scale [2]float32
7678
7679                 //mt:if %s.Field == HUDText
7680                 Text string
7681
7682                 //mt:if %s.Field == HUDNumber
7683                 Number uint32
7684
7685                 //mt:if %s.Field == HUDItem
7686                 Item uint32
7687
7688                 //mt:if %s.Field == HUDDir
7689                 Dir uint32
7690
7691                 //mt:if %s.Field == HUDAlign
7692                 Align [2]float32
7693
7694                 //mt:if %s.Field == HUDOffset
7695                 Offset [2]float32
7696
7697                 //mt:if %s.Field == HUDWorldPos
7698                 WorldPos Pos
7699
7700                 //mt:if %s.Field == HUDSize
7701                 Size [2]int32
7702
7703                 //mt:if %s.Field == HUDZIndex
7704                 ZIndex int32
7705
7706                 //mt:if %s.Field == HUDText2
7707                 Text2 string
7708         }))(obj)).Field == HUDName {
7709                 if len(([]byte((*(*(struct {
7710                         ID HUDID
7711
7712                         Field HUDField
7713
7714                         //mt:if %s.Field == HUDPos
7715                         Pos [2]float32
7716
7717                         //mt:if %s.Field == HUDName
7718                         Name string
7719
7720                         //mt:if %s.Field == HUDScale
7721                         Scale [2]float32
7722
7723                         //mt:if %s.Field == HUDText
7724                         Text string
7725
7726                         //mt:if %s.Field == HUDNumber
7727                         Number uint32
7728
7729                         //mt:if %s.Field == HUDItem
7730                         Item uint32
7731
7732                         //mt:if %s.Field == HUDDir
7733                         Dir uint32
7734
7735                         //mt:if %s.Field == HUDAlign
7736                         Align [2]float32
7737
7738                         //mt:if %s.Field == HUDOffset
7739                         Offset [2]float32
7740
7741                         //mt:if %s.Field == HUDWorldPos
7742                         WorldPos Pos
7743
7744                         //mt:if %s.Field == HUDSize
7745                         Size [2]int32
7746
7747                         //mt:if %s.Field == HUDZIndex
7748                         ZIndex int32
7749
7750                         //mt:if %s.Field == HUDText2
7751                         Text2 string
7752                 }))(obj)).Name))) > math.MaxUint16 {
7753                         chk(ErrTooLong)
7754                 }
7755                 {
7756                         x := uint16(len(([]byte((*(*(struct {
7757                                 ID HUDID
7758
7759                                 Field HUDField
7760
7761                                 //mt:if %s.Field == HUDPos
7762                                 Pos [2]float32
7763
7764                                 //mt:if %s.Field == HUDName
7765                                 Name string
7766
7767                                 //mt:if %s.Field == HUDScale
7768                                 Scale [2]float32
7769
7770                                 //mt:if %s.Field == HUDText
7771                                 Text string
7772
7773                                 //mt:if %s.Field == HUDNumber
7774                                 Number uint32
7775
7776                                 //mt:if %s.Field == HUDItem
7777                                 Item uint32
7778
7779                                 //mt:if %s.Field == HUDDir
7780                                 Dir uint32
7781
7782                                 //mt:if %s.Field == HUDAlign
7783                                 Align [2]float32
7784
7785                                 //mt:if %s.Field == HUDOffset
7786                                 Offset [2]float32
7787
7788                                 //mt:if %s.Field == HUDWorldPos
7789                                 WorldPos Pos
7790
7791                                 //mt:if %s.Field == HUDSize
7792                                 Size [2]int32
7793
7794                                 //mt:if %s.Field == HUDZIndex
7795                                 ZIndex int32
7796
7797                                 //mt:if %s.Field == HUDText2
7798                                 Text2 string
7799                         }))(obj)).Name))))
7800                         write16(w, uint16(x))
7801                 }
7802                 {
7803                         _, err := w.Write(([]byte((*(*(struct {
7804                                 ID HUDID
7805
7806                                 Field HUDField
7807
7808                                 //mt:if %s.Field == HUDPos
7809                                 Pos [2]float32
7810
7811                                 //mt:if %s.Field == HUDName
7812                                 Name string
7813
7814                                 //mt:if %s.Field == HUDScale
7815                                 Scale [2]float32
7816
7817                                 //mt:if %s.Field == HUDText
7818                                 Text string
7819
7820                                 //mt:if %s.Field == HUDNumber
7821                                 Number uint32
7822
7823                                 //mt:if %s.Field == HUDItem
7824                                 Item uint32
7825
7826                                 //mt:if %s.Field == HUDDir
7827                                 Dir uint32
7828
7829                                 //mt:if %s.Field == HUDAlign
7830                                 Align [2]float32
7831
7832                                 //mt:if %s.Field == HUDOffset
7833                                 Offset [2]float32
7834
7835                                 //mt:if %s.Field == HUDWorldPos
7836                                 WorldPos Pos
7837
7838                                 //mt:if %s.Field == HUDSize
7839                                 Size [2]int32
7840
7841                                 //mt:if %s.Field == HUDZIndex
7842                                 ZIndex int32
7843
7844                                 //mt:if %s.Field == HUDText2
7845                                 Text2 string
7846                         }))(obj)).Name))[:])
7847                         chk(err)
7848                 }
7849         }
7850         if (*(*(struct {
7851                 ID HUDID
7852
7853                 Field HUDField
7854
7855                 //mt:if %s.Field == HUDPos
7856                 Pos [2]float32
7857
7858                 //mt:if %s.Field == HUDName
7859                 Name string
7860
7861                 //mt:if %s.Field == HUDScale
7862                 Scale [2]float32
7863
7864                 //mt:if %s.Field == HUDText
7865                 Text string
7866
7867                 //mt:if %s.Field == HUDNumber
7868                 Number uint32
7869
7870                 //mt:if %s.Field == HUDItem
7871                 Item uint32
7872
7873                 //mt:if %s.Field == HUDDir
7874                 Dir uint32
7875
7876                 //mt:if %s.Field == HUDAlign
7877                 Align [2]float32
7878
7879                 //mt:if %s.Field == HUDOffset
7880                 Offset [2]float32
7881
7882                 //mt:if %s.Field == HUDWorldPos
7883                 WorldPos Pos
7884
7885                 //mt:if %s.Field == HUDSize
7886                 Size [2]int32
7887
7888                 //mt:if %s.Field == HUDZIndex
7889                 ZIndex int32
7890
7891                 //mt:if %s.Field == HUDText2
7892                 Text2 string
7893         }))(obj)).Field == HUDScale {
7894                 for local175 := range (*(*(struct {
7895                         ID HUDID
7896
7897                         Field HUDField
7898
7899                         //mt:if %s.Field == HUDPos
7900                         Pos [2]float32
7901
7902                         //mt:if %s.Field == HUDName
7903                         Name string
7904
7905                         //mt:if %s.Field == HUDScale
7906                         Scale [2]float32
7907
7908                         //mt:if %s.Field == HUDText
7909                         Text string
7910
7911                         //mt:if %s.Field == HUDNumber
7912                         Number uint32
7913
7914                         //mt:if %s.Field == HUDItem
7915                         Item uint32
7916
7917                         //mt:if %s.Field == HUDDir
7918                         Dir uint32
7919
7920                         //mt:if %s.Field == HUDAlign
7921                         Align [2]float32
7922
7923                         //mt:if %s.Field == HUDOffset
7924                         Offset [2]float32
7925
7926                         //mt:if %s.Field == HUDWorldPos
7927                         WorldPos Pos
7928
7929                         //mt:if %s.Field == HUDSize
7930                         Size [2]int32
7931
7932                         //mt:if %s.Field == HUDZIndex
7933                         ZIndex int32
7934
7935                         //mt:if %s.Field == HUDText2
7936                         Text2 string
7937                 }))(obj)).Scale {
7938                         {
7939                                 x := ((*(*(struct {
7940                                         ID HUDID
7941
7942                                         Field HUDField
7943
7944                                         //mt:if %s.Field == HUDPos
7945                                         Pos [2]float32
7946
7947                                         //mt:if %s.Field == HUDName
7948                                         Name string
7949
7950                                         //mt:if %s.Field == HUDScale
7951                                         Scale [2]float32
7952
7953                                         //mt:if %s.Field == HUDText
7954                                         Text string
7955
7956                                         //mt:if %s.Field == HUDNumber
7957                                         Number uint32
7958
7959                                         //mt:if %s.Field == HUDItem
7960                                         Item uint32
7961
7962                                         //mt:if %s.Field == HUDDir
7963                                         Dir uint32
7964
7965                                         //mt:if %s.Field == HUDAlign
7966                                         Align [2]float32
7967
7968                                         //mt:if %s.Field == HUDOffset
7969                                         Offset [2]float32
7970
7971                                         //mt:if %s.Field == HUDWorldPos
7972                                         WorldPos Pos
7973
7974                                         //mt:if %s.Field == HUDSize
7975                                         Size [2]int32
7976
7977                                         //mt:if %s.Field == HUDZIndex
7978                                         ZIndex int32
7979
7980                                         //mt:if %s.Field == HUDText2
7981                                         Text2 string
7982                                 }))(obj)).Scale)[local175]
7983                                 write32(w, math.Float32bits(x))
7984                         }
7985                 }
7986         }
7987         if (*(*(struct {
7988                 ID HUDID
7989
7990                 Field HUDField
7991
7992                 //mt:if %s.Field == HUDPos
7993                 Pos [2]float32
7994
7995                 //mt:if %s.Field == HUDName
7996                 Name string
7997
7998                 //mt:if %s.Field == HUDScale
7999                 Scale [2]float32
8000
8001                 //mt:if %s.Field == HUDText
8002                 Text string
8003
8004                 //mt:if %s.Field == HUDNumber
8005                 Number uint32
8006
8007                 //mt:if %s.Field == HUDItem
8008                 Item uint32
8009
8010                 //mt:if %s.Field == HUDDir
8011                 Dir uint32
8012
8013                 //mt:if %s.Field == HUDAlign
8014                 Align [2]float32
8015
8016                 //mt:if %s.Field == HUDOffset
8017                 Offset [2]float32
8018
8019                 //mt:if %s.Field == HUDWorldPos
8020                 WorldPos Pos
8021
8022                 //mt:if %s.Field == HUDSize
8023                 Size [2]int32
8024
8025                 //mt:if %s.Field == HUDZIndex
8026                 ZIndex int32
8027
8028                 //mt:if %s.Field == HUDText2
8029                 Text2 string
8030         }))(obj)).Field == HUDText {
8031                 if len(([]byte((*(*(struct {
8032                         ID HUDID
8033
8034                         Field HUDField
8035
8036                         //mt:if %s.Field == HUDPos
8037                         Pos [2]float32
8038
8039                         //mt:if %s.Field == HUDName
8040                         Name string
8041
8042                         //mt:if %s.Field == HUDScale
8043                         Scale [2]float32
8044
8045                         //mt:if %s.Field == HUDText
8046                         Text string
8047
8048                         //mt:if %s.Field == HUDNumber
8049                         Number uint32
8050
8051                         //mt:if %s.Field == HUDItem
8052                         Item uint32
8053
8054                         //mt:if %s.Field == HUDDir
8055                         Dir uint32
8056
8057                         //mt:if %s.Field == HUDAlign
8058                         Align [2]float32
8059
8060                         //mt:if %s.Field == HUDOffset
8061                         Offset [2]float32
8062
8063                         //mt:if %s.Field == HUDWorldPos
8064                         WorldPos Pos
8065
8066                         //mt:if %s.Field == HUDSize
8067                         Size [2]int32
8068
8069                         //mt:if %s.Field == HUDZIndex
8070                         ZIndex int32
8071
8072                         //mt:if %s.Field == HUDText2
8073                         Text2 string
8074                 }))(obj)).Text))) > math.MaxUint16 {
8075                         chk(ErrTooLong)
8076                 }
8077                 {
8078                         x := uint16(len(([]byte((*(*(struct {
8079                                 ID HUDID
8080
8081                                 Field HUDField
8082
8083                                 //mt:if %s.Field == HUDPos
8084                                 Pos [2]float32
8085
8086                                 //mt:if %s.Field == HUDName
8087                                 Name string
8088
8089                                 //mt:if %s.Field == HUDScale
8090                                 Scale [2]float32
8091
8092                                 //mt:if %s.Field == HUDText
8093                                 Text string
8094
8095                                 //mt:if %s.Field == HUDNumber
8096                                 Number uint32
8097
8098                                 //mt:if %s.Field == HUDItem
8099                                 Item uint32
8100
8101                                 //mt:if %s.Field == HUDDir
8102                                 Dir uint32
8103
8104                                 //mt:if %s.Field == HUDAlign
8105                                 Align [2]float32
8106
8107                                 //mt:if %s.Field == HUDOffset
8108                                 Offset [2]float32
8109
8110                                 //mt:if %s.Field == HUDWorldPos
8111                                 WorldPos Pos
8112
8113                                 //mt:if %s.Field == HUDSize
8114                                 Size [2]int32
8115
8116                                 //mt:if %s.Field == HUDZIndex
8117                                 ZIndex int32
8118
8119                                 //mt:if %s.Field == HUDText2
8120                                 Text2 string
8121                         }))(obj)).Text))))
8122                         write16(w, uint16(x))
8123                 }
8124                 {
8125                         _, err := w.Write(([]byte((*(*(struct {
8126                                 ID HUDID
8127
8128                                 Field HUDField
8129
8130                                 //mt:if %s.Field == HUDPos
8131                                 Pos [2]float32
8132
8133                                 //mt:if %s.Field == HUDName
8134                                 Name string
8135
8136                                 //mt:if %s.Field == HUDScale
8137                                 Scale [2]float32
8138
8139                                 //mt:if %s.Field == HUDText
8140                                 Text string
8141
8142                                 //mt:if %s.Field == HUDNumber
8143                                 Number uint32
8144
8145                                 //mt:if %s.Field == HUDItem
8146                                 Item uint32
8147
8148                                 //mt:if %s.Field == HUDDir
8149                                 Dir uint32
8150
8151                                 //mt:if %s.Field == HUDAlign
8152                                 Align [2]float32
8153
8154                                 //mt:if %s.Field == HUDOffset
8155                                 Offset [2]float32
8156
8157                                 //mt:if %s.Field == HUDWorldPos
8158                                 WorldPos Pos
8159
8160                                 //mt:if %s.Field == HUDSize
8161                                 Size [2]int32
8162
8163                                 //mt:if %s.Field == HUDZIndex
8164                                 ZIndex int32
8165
8166                                 //mt:if %s.Field == HUDText2
8167                                 Text2 string
8168                         }))(obj)).Text))[:])
8169                         chk(err)
8170                 }
8171         }
8172         if (*(*(struct {
8173                 ID HUDID
8174
8175                 Field HUDField
8176
8177                 //mt:if %s.Field == HUDPos
8178                 Pos [2]float32
8179
8180                 //mt:if %s.Field == HUDName
8181                 Name string
8182
8183                 //mt:if %s.Field == HUDScale
8184                 Scale [2]float32
8185
8186                 //mt:if %s.Field == HUDText
8187                 Text string
8188
8189                 //mt:if %s.Field == HUDNumber
8190                 Number uint32
8191
8192                 //mt:if %s.Field == HUDItem
8193                 Item uint32
8194
8195                 //mt:if %s.Field == HUDDir
8196                 Dir uint32
8197
8198                 //mt:if %s.Field == HUDAlign
8199                 Align [2]float32
8200
8201                 //mt:if %s.Field == HUDOffset
8202                 Offset [2]float32
8203
8204                 //mt:if %s.Field == HUDWorldPos
8205                 WorldPos Pos
8206
8207                 //mt:if %s.Field == HUDSize
8208                 Size [2]int32
8209
8210                 //mt:if %s.Field == HUDZIndex
8211                 ZIndex int32
8212
8213                 //mt:if %s.Field == HUDText2
8214                 Text2 string
8215         }))(obj)).Field == HUDNumber {
8216                 {
8217                         x := (*(*(struct {
8218                                 ID HUDID
8219
8220                                 Field HUDField
8221
8222                                 //mt:if %s.Field == HUDPos
8223                                 Pos [2]float32
8224
8225                                 //mt:if %s.Field == HUDName
8226                                 Name string
8227
8228                                 //mt:if %s.Field == HUDScale
8229                                 Scale [2]float32
8230
8231                                 //mt:if %s.Field == HUDText
8232                                 Text string
8233
8234                                 //mt:if %s.Field == HUDNumber
8235                                 Number uint32
8236
8237                                 //mt:if %s.Field == HUDItem
8238                                 Item uint32
8239
8240                                 //mt:if %s.Field == HUDDir
8241                                 Dir uint32
8242
8243                                 //mt:if %s.Field == HUDAlign
8244                                 Align [2]float32
8245
8246                                 //mt:if %s.Field == HUDOffset
8247                                 Offset [2]float32
8248
8249                                 //mt:if %s.Field == HUDWorldPos
8250                                 WorldPos Pos
8251
8252                                 //mt:if %s.Field == HUDSize
8253                                 Size [2]int32
8254
8255                                 //mt:if %s.Field == HUDZIndex
8256                                 ZIndex int32
8257
8258                                 //mt:if %s.Field == HUDText2
8259                                 Text2 string
8260                         }))(obj)).Number
8261                         write32(w, uint32(x))
8262                 }
8263         }
8264         if (*(*(struct {
8265                 ID HUDID
8266
8267                 Field HUDField
8268
8269                 //mt:if %s.Field == HUDPos
8270                 Pos [2]float32
8271
8272                 //mt:if %s.Field == HUDName
8273                 Name string
8274
8275                 //mt:if %s.Field == HUDScale
8276                 Scale [2]float32
8277
8278                 //mt:if %s.Field == HUDText
8279                 Text string
8280
8281                 //mt:if %s.Field == HUDNumber
8282                 Number uint32
8283
8284                 //mt:if %s.Field == HUDItem
8285                 Item uint32
8286
8287                 //mt:if %s.Field == HUDDir
8288                 Dir uint32
8289
8290                 //mt:if %s.Field == HUDAlign
8291                 Align [2]float32
8292
8293                 //mt:if %s.Field == HUDOffset
8294                 Offset [2]float32
8295
8296                 //mt:if %s.Field == HUDWorldPos
8297                 WorldPos Pos
8298
8299                 //mt:if %s.Field == HUDSize
8300                 Size [2]int32
8301
8302                 //mt:if %s.Field == HUDZIndex
8303                 ZIndex int32
8304
8305                 //mt:if %s.Field == HUDText2
8306                 Text2 string
8307         }))(obj)).Field == HUDItem {
8308                 {
8309                         x := (*(*(struct {
8310                                 ID HUDID
8311
8312                                 Field HUDField
8313
8314                                 //mt:if %s.Field == HUDPos
8315                                 Pos [2]float32
8316
8317                                 //mt:if %s.Field == HUDName
8318                                 Name string
8319
8320                                 //mt:if %s.Field == HUDScale
8321                                 Scale [2]float32
8322
8323                                 //mt:if %s.Field == HUDText
8324                                 Text string
8325
8326                                 //mt:if %s.Field == HUDNumber
8327                                 Number uint32
8328
8329                                 //mt:if %s.Field == HUDItem
8330                                 Item uint32
8331
8332                                 //mt:if %s.Field == HUDDir
8333                                 Dir uint32
8334
8335                                 //mt:if %s.Field == HUDAlign
8336                                 Align [2]float32
8337
8338                                 //mt:if %s.Field == HUDOffset
8339                                 Offset [2]float32
8340
8341                                 //mt:if %s.Field == HUDWorldPos
8342                                 WorldPos Pos
8343
8344                                 //mt:if %s.Field == HUDSize
8345                                 Size [2]int32
8346
8347                                 //mt:if %s.Field == HUDZIndex
8348                                 ZIndex int32
8349
8350                                 //mt:if %s.Field == HUDText2
8351                                 Text2 string
8352                         }))(obj)).Item
8353                         write32(w, uint32(x))
8354                 }
8355         }
8356         if (*(*(struct {
8357                 ID HUDID
8358
8359                 Field HUDField
8360
8361                 //mt:if %s.Field == HUDPos
8362                 Pos [2]float32
8363
8364                 //mt:if %s.Field == HUDName
8365                 Name string
8366
8367                 //mt:if %s.Field == HUDScale
8368                 Scale [2]float32
8369
8370                 //mt:if %s.Field == HUDText
8371                 Text string
8372
8373                 //mt:if %s.Field == HUDNumber
8374                 Number uint32
8375
8376                 //mt:if %s.Field == HUDItem
8377                 Item uint32
8378
8379                 //mt:if %s.Field == HUDDir
8380                 Dir uint32
8381
8382                 //mt:if %s.Field == HUDAlign
8383                 Align [2]float32
8384
8385                 //mt:if %s.Field == HUDOffset
8386                 Offset [2]float32
8387
8388                 //mt:if %s.Field == HUDWorldPos
8389                 WorldPos Pos
8390
8391                 //mt:if %s.Field == HUDSize
8392                 Size [2]int32
8393
8394                 //mt:if %s.Field == HUDZIndex
8395                 ZIndex int32
8396
8397                 //mt:if %s.Field == HUDText2
8398                 Text2 string
8399         }))(obj)).Field == HUDDir {
8400                 {
8401                         x := (*(*(struct {
8402                                 ID HUDID
8403
8404                                 Field HUDField
8405
8406                                 //mt:if %s.Field == HUDPos
8407                                 Pos [2]float32
8408
8409                                 //mt:if %s.Field == HUDName
8410                                 Name string
8411
8412                                 //mt:if %s.Field == HUDScale
8413                                 Scale [2]float32
8414
8415                                 //mt:if %s.Field == HUDText
8416                                 Text string
8417
8418                                 //mt:if %s.Field == HUDNumber
8419                                 Number uint32
8420
8421                                 //mt:if %s.Field == HUDItem
8422                                 Item uint32
8423
8424                                 //mt:if %s.Field == HUDDir
8425                                 Dir uint32
8426
8427                                 //mt:if %s.Field == HUDAlign
8428                                 Align [2]float32
8429
8430                                 //mt:if %s.Field == HUDOffset
8431                                 Offset [2]float32
8432
8433                                 //mt:if %s.Field == HUDWorldPos
8434                                 WorldPos Pos
8435
8436                                 //mt:if %s.Field == HUDSize
8437                                 Size [2]int32
8438
8439                                 //mt:if %s.Field == HUDZIndex
8440                                 ZIndex int32
8441
8442                                 //mt:if %s.Field == HUDText2
8443                                 Text2 string
8444                         }))(obj)).Dir
8445                         write32(w, uint32(x))
8446                 }
8447         }
8448         if (*(*(struct {
8449                 ID HUDID
8450
8451                 Field HUDField
8452
8453                 //mt:if %s.Field == HUDPos
8454                 Pos [2]float32
8455
8456                 //mt:if %s.Field == HUDName
8457                 Name string
8458
8459                 //mt:if %s.Field == HUDScale
8460                 Scale [2]float32
8461
8462                 //mt:if %s.Field == HUDText
8463                 Text string
8464
8465                 //mt:if %s.Field == HUDNumber
8466                 Number uint32
8467
8468                 //mt:if %s.Field == HUDItem
8469                 Item uint32
8470
8471                 //mt:if %s.Field == HUDDir
8472                 Dir uint32
8473
8474                 //mt:if %s.Field == HUDAlign
8475                 Align [2]float32
8476
8477                 //mt:if %s.Field == HUDOffset
8478                 Offset [2]float32
8479
8480                 //mt:if %s.Field == HUDWorldPos
8481                 WorldPos Pos
8482
8483                 //mt:if %s.Field == HUDSize
8484                 Size [2]int32
8485
8486                 //mt:if %s.Field == HUDZIndex
8487                 ZIndex int32
8488
8489                 //mt:if %s.Field == HUDText2
8490                 Text2 string
8491         }))(obj)).Field == HUDAlign {
8492                 for local176 := range (*(*(struct {
8493                         ID HUDID
8494
8495                         Field HUDField
8496
8497                         //mt:if %s.Field == HUDPos
8498                         Pos [2]float32
8499
8500                         //mt:if %s.Field == HUDName
8501                         Name string
8502
8503                         //mt:if %s.Field == HUDScale
8504                         Scale [2]float32
8505
8506                         //mt:if %s.Field == HUDText
8507                         Text string
8508
8509                         //mt:if %s.Field == HUDNumber
8510                         Number uint32
8511
8512                         //mt:if %s.Field == HUDItem
8513                         Item uint32
8514
8515                         //mt:if %s.Field == HUDDir
8516                         Dir uint32
8517
8518                         //mt:if %s.Field == HUDAlign
8519                         Align [2]float32
8520
8521                         //mt:if %s.Field == HUDOffset
8522                         Offset [2]float32
8523
8524                         //mt:if %s.Field == HUDWorldPos
8525                         WorldPos Pos
8526
8527                         //mt:if %s.Field == HUDSize
8528                         Size [2]int32
8529
8530                         //mt:if %s.Field == HUDZIndex
8531                         ZIndex int32
8532
8533                         //mt:if %s.Field == HUDText2
8534                         Text2 string
8535                 }))(obj)).Align {
8536                         {
8537                                 x := ((*(*(struct {
8538                                         ID HUDID
8539
8540                                         Field HUDField
8541
8542                                         //mt:if %s.Field == HUDPos
8543                                         Pos [2]float32
8544
8545                                         //mt:if %s.Field == HUDName
8546                                         Name string
8547
8548                                         //mt:if %s.Field == HUDScale
8549                                         Scale [2]float32
8550
8551                                         //mt:if %s.Field == HUDText
8552                                         Text string
8553
8554                                         //mt:if %s.Field == HUDNumber
8555                                         Number uint32
8556
8557                                         //mt:if %s.Field == HUDItem
8558                                         Item uint32
8559
8560                                         //mt:if %s.Field == HUDDir
8561                                         Dir uint32
8562
8563                                         //mt:if %s.Field == HUDAlign
8564                                         Align [2]float32
8565
8566                                         //mt:if %s.Field == HUDOffset
8567                                         Offset [2]float32
8568
8569                                         //mt:if %s.Field == HUDWorldPos
8570                                         WorldPos Pos
8571
8572                                         //mt:if %s.Field == HUDSize
8573                                         Size [2]int32
8574
8575                                         //mt:if %s.Field == HUDZIndex
8576                                         ZIndex int32
8577
8578                                         //mt:if %s.Field == HUDText2
8579                                         Text2 string
8580                                 }))(obj)).Align)[local176]
8581                                 write32(w, math.Float32bits(x))
8582                         }
8583                 }
8584         }
8585         if (*(*(struct {
8586                 ID HUDID
8587
8588                 Field HUDField
8589
8590                 //mt:if %s.Field == HUDPos
8591                 Pos [2]float32
8592
8593                 //mt:if %s.Field == HUDName
8594                 Name string
8595
8596                 //mt:if %s.Field == HUDScale
8597                 Scale [2]float32
8598
8599                 //mt:if %s.Field == HUDText
8600                 Text string
8601
8602                 //mt:if %s.Field == HUDNumber
8603                 Number uint32
8604
8605                 //mt:if %s.Field == HUDItem
8606                 Item uint32
8607
8608                 //mt:if %s.Field == HUDDir
8609                 Dir uint32
8610
8611                 //mt:if %s.Field == HUDAlign
8612                 Align [2]float32
8613
8614                 //mt:if %s.Field == HUDOffset
8615                 Offset [2]float32
8616
8617                 //mt:if %s.Field == HUDWorldPos
8618                 WorldPos Pos
8619
8620                 //mt:if %s.Field == HUDSize
8621                 Size [2]int32
8622
8623                 //mt:if %s.Field == HUDZIndex
8624                 ZIndex int32
8625
8626                 //mt:if %s.Field == HUDText2
8627                 Text2 string
8628         }))(obj)).Field == HUDOffset {
8629                 for local177 := range (*(*(struct {
8630                         ID HUDID
8631
8632                         Field HUDField
8633
8634                         //mt:if %s.Field == HUDPos
8635                         Pos [2]float32
8636
8637                         //mt:if %s.Field == HUDName
8638                         Name string
8639
8640                         //mt:if %s.Field == HUDScale
8641                         Scale [2]float32
8642
8643                         //mt:if %s.Field == HUDText
8644                         Text string
8645
8646                         //mt:if %s.Field == HUDNumber
8647                         Number uint32
8648
8649                         //mt:if %s.Field == HUDItem
8650                         Item uint32
8651
8652                         //mt:if %s.Field == HUDDir
8653                         Dir uint32
8654
8655                         //mt:if %s.Field == HUDAlign
8656                         Align [2]float32
8657
8658                         //mt:if %s.Field == HUDOffset
8659                         Offset [2]float32
8660
8661                         //mt:if %s.Field == HUDWorldPos
8662                         WorldPos Pos
8663
8664                         //mt:if %s.Field == HUDSize
8665                         Size [2]int32
8666
8667                         //mt:if %s.Field == HUDZIndex
8668                         ZIndex int32
8669
8670                         //mt:if %s.Field == HUDText2
8671                         Text2 string
8672                 }))(obj)).Offset {
8673                         {
8674                                 x := ((*(*(struct {
8675                                         ID HUDID
8676
8677                                         Field HUDField
8678
8679                                         //mt:if %s.Field == HUDPos
8680                                         Pos [2]float32
8681
8682                                         //mt:if %s.Field == HUDName
8683                                         Name string
8684
8685                                         //mt:if %s.Field == HUDScale
8686                                         Scale [2]float32
8687
8688                                         //mt:if %s.Field == HUDText
8689                                         Text string
8690
8691                                         //mt:if %s.Field == HUDNumber
8692                                         Number uint32
8693
8694                                         //mt:if %s.Field == HUDItem
8695                                         Item uint32
8696
8697                                         //mt:if %s.Field == HUDDir
8698                                         Dir uint32
8699
8700                                         //mt:if %s.Field == HUDAlign
8701                                         Align [2]float32
8702
8703                                         //mt:if %s.Field == HUDOffset
8704                                         Offset [2]float32
8705
8706                                         //mt:if %s.Field == HUDWorldPos
8707                                         WorldPos Pos
8708
8709                                         //mt:if %s.Field == HUDSize
8710                                         Size [2]int32
8711
8712                                         //mt:if %s.Field == HUDZIndex
8713                                         ZIndex int32
8714
8715                                         //mt:if %s.Field == HUDText2
8716                                         Text2 string
8717                                 }))(obj)).Offset)[local177]
8718                                 write32(w, math.Float32bits(x))
8719                         }
8720                 }
8721         }
8722         if (*(*(struct {
8723                 ID HUDID
8724
8725                 Field HUDField
8726
8727                 //mt:if %s.Field == HUDPos
8728                 Pos [2]float32
8729
8730                 //mt:if %s.Field == HUDName
8731                 Name string
8732
8733                 //mt:if %s.Field == HUDScale
8734                 Scale [2]float32
8735
8736                 //mt:if %s.Field == HUDText
8737                 Text string
8738
8739                 //mt:if %s.Field == HUDNumber
8740                 Number uint32
8741
8742                 //mt:if %s.Field == HUDItem
8743                 Item uint32
8744
8745                 //mt:if %s.Field == HUDDir
8746                 Dir uint32
8747
8748                 //mt:if %s.Field == HUDAlign
8749                 Align [2]float32
8750
8751                 //mt:if %s.Field == HUDOffset
8752                 Offset [2]float32
8753
8754                 //mt:if %s.Field == HUDWorldPos
8755                 WorldPos Pos
8756
8757                 //mt:if %s.Field == HUDSize
8758                 Size [2]int32
8759
8760                 //mt:if %s.Field == HUDZIndex
8761                 ZIndex int32
8762
8763                 //mt:if %s.Field == HUDText2
8764                 Text2 string
8765         }))(obj)).Field == HUDWorldPos {
8766                 if err := pcall(func() {
8767                         ((*(*(struct {
8768                                 ID HUDID
8769
8770                                 Field HUDField
8771
8772                                 //mt:if %s.Field == HUDPos
8773                                 Pos [2]float32
8774
8775                                 //mt:if %s.Field == HUDName
8776                                 Name string
8777
8778                                 //mt:if %s.Field == HUDScale
8779                                 Scale [2]float32
8780
8781                                 //mt:if %s.Field == HUDText
8782                                 Text string
8783
8784                                 //mt:if %s.Field == HUDNumber
8785                                 Number uint32
8786
8787                                 //mt:if %s.Field == HUDItem
8788                                 Item uint32
8789
8790                                 //mt:if %s.Field == HUDDir
8791                                 Dir uint32
8792
8793                                 //mt:if %s.Field == HUDAlign
8794                                 Align [2]float32
8795
8796                                 //mt:if %s.Field == HUDOffset
8797                                 Offset [2]float32
8798
8799                                 //mt:if %s.Field == HUDWorldPos
8800                                 WorldPos Pos
8801
8802                                 //mt:if %s.Field == HUDSize
8803                                 Size [2]int32
8804
8805                                 //mt:if %s.Field == HUDZIndex
8806                                 ZIndex int32
8807
8808                                 //mt:if %s.Field == HUDText2
8809                                 Text2 string
8810                         }))(obj)).WorldPos).serialize(w)
8811                 }); err != nil {
8812                         if err == io.EOF {
8813                                 chk(io.EOF)
8814                         }
8815                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
8816                 }
8817         }
8818         if (*(*(struct {
8819                 ID HUDID
8820
8821                 Field HUDField
8822
8823                 //mt:if %s.Field == HUDPos
8824                 Pos [2]float32
8825
8826                 //mt:if %s.Field == HUDName
8827                 Name string
8828
8829                 //mt:if %s.Field == HUDScale
8830                 Scale [2]float32
8831
8832                 //mt:if %s.Field == HUDText
8833                 Text string
8834
8835                 //mt:if %s.Field == HUDNumber
8836                 Number uint32
8837
8838                 //mt:if %s.Field == HUDItem
8839                 Item uint32
8840
8841                 //mt:if %s.Field == HUDDir
8842                 Dir uint32
8843
8844                 //mt:if %s.Field == HUDAlign
8845                 Align [2]float32
8846
8847                 //mt:if %s.Field == HUDOffset
8848                 Offset [2]float32
8849
8850                 //mt:if %s.Field == HUDWorldPos
8851                 WorldPos Pos
8852
8853                 //mt:if %s.Field == HUDSize
8854                 Size [2]int32
8855
8856                 //mt:if %s.Field == HUDZIndex
8857                 ZIndex int32
8858
8859                 //mt:if %s.Field == HUDText2
8860                 Text2 string
8861         }))(obj)).Field == HUDSize {
8862                 for local178 := range (*(*(struct {
8863                         ID HUDID
8864
8865                         Field HUDField
8866
8867                         //mt:if %s.Field == HUDPos
8868                         Pos [2]float32
8869
8870                         //mt:if %s.Field == HUDName
8871                         Name string
8872
8873                         //mt:if %s.Field == HUDScale
8874                         Scale [2]float32
8875
8876                         //mt:if %s.Field == HUDText
8877                         Text string
8878
8879                         //mt:if %s.Field == HUDNumber
8880                         Number uint32
8881
8882                         //mt:if %s.Field == HUDItem
8883                         Item uint32
8884
8885                         //mt:if %s.Field == HUDDir
8886                         Dir uint32
8887
8888                         //mt:if %s.Field == HUDAlign
8889                         Align [2]float32
8890
8891                         //mt:if %s.Field == HUDOffset
8892                         Offset [2]float32
8893
8894                         //mt:if %s.Field == HUDWorldPos
8895                         WorldPos Pos
8896
8897                         //mt:if %s.Field == HUDSize
8898                         Size [2]int32
8899
8900                         //mt:if %s.Field == HUDZIndex
8901                         ZIndex int32
8902
8903                         //mt:if %s.Field == HUDText2
8904                         Text2 string
8905                 }))(obj)).Size {
8906                         {
8907                                 x := ((*(*(struct {
8908                                         ID HUDID
8909
8910                                         Field HUDField
8911
8912                                         //mt:if %s.Field == HUDPos
8913                                         Pos [2]float32
8914
8915                                         //mt:if %s.Field == HUDName
8916                                         Name string
8917
8918                                         //mt:if %s.Field == HUDScale
8919                                         Scale [2]float32
8920
8921                                         //mt:if %s.Field == HUDText
8922                                         Text string
8923
8924                                         //mt:if %s.Field == HUDNumber
8925                                         Number uint32
8926
8927                                         //mt:if %s.Field == HUDItem
8928                                         Item uint32
8929
8930                                         //mt:if %s.Field == HUDDir
8931                                         Dir uint32
8932
8933                                         //mt:if %s.Field == HUDAlign
8934                                         Align [2]float32
8935
8936                                         //mt:if %s.Field == HUDOffset
8937                                         Offset [2]float32
8938
8939                                         //mt:if %s.Field == HUDWorldPos
8940                                         WorldPos Pos
8941
8942                                         //mt:if %s.Field == HUDSize
8943                                         Size [2]int32
8944
8945                                         //mt:if %s.Field == HUDZIndex
8946                                         ZIndex int32
8947
8948                                         //mt:if %s.Field == HUDText2
8949                                         Text2 string
8950                                 }))(obj)).Size)[local178]
8951                                 write32(w, uint32(x))
8952                         }
8953                 }
8954         }
8955         if (*(*(struct {
8956                 ID HUDID
8957
8958                 Field HUDField
8959
8960                 //mt:if %s.Field == HUDPos
8961                 Pos [2]float32
8962
8963                 //mt:if %s.Field == HUDName
8964                 Name string
8965
8966                 //mt:if %s.Field == HUDScale
8967                 Scale [2]float32
8968
8969                 //mt:if %s.Field == HUDText
8970                 Text string
8971
8972                 //mt:if %s.Field == HUDNumber
8973                 Number uint32
8974
8975                 //mt:if %s.Field == HUDItem
8976                 Item uint32
8977
8978                 //mt:if %s.Field == HUDDir
8979                 Dir uint32
8980
8981                 //mt:if %s.Field == HUDAlign
8982                 Align [2]float32
8983
8984                 //mt:if %s.Field == HUDOffset
8985                 Offset [2]float32
8986
8987                 //mt:if %s.Field == HUDWorldPos
8988                 WorldPos Pos
8989
8990                 //mt:if %s.Field == HUDSize
8991                 Size [2]int32
8992
8993                 //mt:if %s.Field == HUDZIndex
8994                 ZIndex int32
8995
8996                 //mt:if %s.Field == HUDText2
8997                 Text2 string
8998         }))(obj)).Field == HUDZIndex {
8999                 {
9000                         x := (*(*(struct {
9001                                 ID HUDID
9002
9003                                 Field HUDField
9004
9005                                 //mt:if %s.Field == HUDPos
9006                                 Pos [2]float32
9007
9008                                 //mt:if %s.Field == HUDName
9009                                 Name string
9010
9011                                 //mt:if %s.Field == HUDScale
9012                                 Scale [2]float32
9013
9014                                 //mt:if %s.Field == HUDText
9015                                 Text string
9016
9017                                 //mt:if %s.Field == HUDNumber
9018                                 Number uint32
9019
9020                                 //mt:if %s.Field == HUDItem
9021                                 Item uint32
9022
9023                                 //mt:if %s.Field == HUDDir
9024                                 Dir uint32
9025
9026                                 //mt:if %s.Field == HUDAlign
9027                                 Align [2]float32
9028
9029                                 //mt:if %s.Field == HUDOffset
9030                                 Offset [2]float32
9031
9032                                 //mt:if %s.Field == HUDWorldPos
9033                                 WorldPos Pos
9034
9035                                 //mt:if %s.Field == HUDSize
9036                                 Size [2]int32
9037
9038                                 //mt:if %s.Field == HUDZIndex
9039                                 ZIndex int32
9040
9041                                 //mt:if %s.Field == HUDText2
9042                                 Text2 string
9043                         }))(obj)).ZIndex
9044                         write32(w, uint32(x))
9045                 }
9046         }
9047         if (*(*(struct {
9048                 ID HUDID
9049
9050                 Field HUDField
9051
9052                 //mt:if %s.Field == HUDPos
9053                 Pos [2]float32
9054
9055                 //mt:if %s.Field == HUDName
9056                 Name string
9057
9058                 //mt:if %s.Field == HUDScale
9059                 Scale [2]float32
9060
9061                 //mt:if %s.Field == HUDText
9062                 Text string
9063
9064                 //mt:if %s.Field == HUDNumber
9065                 Number uint32
9066
9067                 //mt:if %s.Field == HUDItem
9068                 Item uint32
9069
9070                 //mt:if %s.Field == HUDDir
9071                 Dir uint32
9072
9073                 //mt:if %s.Field == HUDAlign
9074                 Align [2]float32
9075
9076                 //mt:if %s.Field == HUDOffset
9077                 Offset [2]float32
9078
9079                 //mt:if %s.Field == HUDWorldPos
9080                 WorldPos Pos
9081
9082                 //mt:if %s.Field == HUDSize
9083                 Size [2]int32
9084
9085                 //mt:if %s.Field == HUDZIndex
9086                 ZIndex int32
9087
9088                 //mt:if %s.Field == HUDText2
9089                 Text2 string
9090         }))(obj)).Field == HUDText2 {
9091                 if len(([]byte((*(*(struct {
9092                         ID HUDID
9093
9094                         Field HUDField
9095
9096                         //mt:if %s.Field == HUDPos
9097                         Pos [2]float32
9098
9099                         //mt:if %s.Field == HUDName
9100                         Name string
9101
9102                         //mt:if %s.Field == HUDScale
9103                         Scale [2]float32
9104
9105                         //mt:if %s.Field == HUDText
9106                         Text string
9107
9108                         //mt:if %s.Field == HUDNumber
9109                         Number uint32
9110
9111                         //mt:if %s.Field == HUDItem
9112                         Item uint32
9113
9114                         //mt:if %s.Field == HUDDir
9115                         Dir uint32
9116
9117                         //mt:if %s.Field == HUDAlign
9118                         Align [2]float32
9119
9120                         //mt:if %s.Field == HUDOffset
9121                         Offset [2]float32
9122
9123                         //mt:if %s.Field == HUDWorldPos
9124                         WorldPos Pos
9125
9126                         //mt:if %s.Field == HUDSize
9127                         Size [2]int32
9128
9129                         //mt:if %s.Field == HUDZIndex
9130                         ZIndex int32
9131
9132                         //mt:if %s.Field == HUDText2
9133                         Text2 string
9134                 }))(obj)).Text2))) > math.MaxUint16 {
9135                         chk(ErrTooLong)
9136                 }
9137                 {
9138                         x := uint16(len(([]byte((*(*(struct {
9139                                 ID HUDID
9140
9141                                 Field HUDField
9142
9143                                 //mt:if %s.Field == HUDPos
9144                                 Pos [2]float32
9145
9146                                 //mt:if %s.Field == HUDName
9147                                 Name string
9148
9149                                 //mt:if %s.Field == HUDScale
9150                                 Scale [2]float32
9151
9152                                 //mt:if %s.Field == HUDText
9153                                 Text string
9154
9155                                 //mt:if %s.Field == HUDNumber
9156                                 Number uint32
9157
9158                                 //mt:if %s.Field == HUDItem
9159                                 Item uint32
9160
9161                                 //mt:if %s.Field == HUDDir
9162                                 Dir uint32
9163
9164                                 //mt:if %s.Field == HUDAlign
9165                                 Align [2]float32
9166
9167                                 //mt:if %s.Field == HUDOffset
9168                                 Offset [2]float32
9169
9170                                 //mt:if %s.Field == HUDWorldPos
9171                                 WorldPos Pos
9172
9173                                 //mt:if %s.Field == HUDSize
9174                                 Size [2]int32
9175
9176                                 //mt:if %s.Field == HUDZIndex
9177                                 ZIndex int32
9178
9179                                 //mt:if %s.Field == HUDText2
9180                                 Text2 string
9181                         }))(obj)).Text2))))
9182                         write16(w, uint16(x))
9183                 }
9184                 {
9185                         _, err := w.Write(([]byte((*(*(struct {
9186                                 ID HUDID
9187
9188                                 Field HUDField
9189
9190                                 //mt:if %s.Field == HUDPos
9191                                 Pos [2]float32
9192
9193                                 //mt:if %s.Field == HUDName
9194                                 Name string
9195
9196                                 //mt:if %s.Field == HUDScale
9197                                 Scale [2]float32
9198
9199                                 //mt:if %s.Field == HUDText
9200                                 Text string
9201
9202                                 //mt:if %s.Field == HUDNumber
9203                                 Number uint32
9204
9205                                 //mt:if %s.Field == HUDItem
9206                                 Item uint32
9207
9208                                 //mt:if %s.Field == HUDDir
9209                                 Dir uint32
9210
9211                                 //mt:if %s.Field == HUDAlign
9212                                 Align [2]float32
9213
9214                                 //mt:if %s.Field == HUDOffset
9215                                 Offset [2]float32
9216
9217                                 //mt:if %s.Field == HUDWorldPos
9218                                 WorldPos Pos
9219
9220                                 //mt:if %s.Field == HUDSize
9221                                 Size [2]int32
9222
9223                                 //mt:if %s.Field == HUDZIndex
9224                                 ZIndex int32
9225
9226                                 //mt:if %s.Field == HUDText2
9227                                 Text2 string
9228                         }))(obj)).Text2))[:])
9229                         chk(err)
9230                 }
9231         }
9232 }
9233
9234 func (obj *ToCltChangeHUD) deserialize(r io.Reader) {
9235         if err := pcall(func() {
9236                 ((*(*(struct {
9237                         ID HUDID
9238
9239                         Field HUDField
9240
9241                         //mt:if %s.Field == HUDPos
9242                         Pos [2]float32
9243
9244                         //mt:if %s.Field == HUDName
9245                         Name string
9246
9247                         //mt:if %s.Field == HUDScale
9248                         Scale [2]float32
9249
9250                         //mt:if %s.Field == HUDText
9251                         Text string
9252
9253                         //mt:if %s.Field == HUDNumber
9254                         Number uint32
9255
9256                         //mt:if %s.Field == HUDItem
9257                         Item uint32
9258
9259                         //mt:if %s.Field == HUDDir
9260                         Dir uint32
9261
9262                         //mt:if %s.Field == HUDAlign
9263                         Align [2]float32
9264
9265                         //mt:if %s.Field == HUDOffset
9266                         Offset [2]float32
9267
9268                         //mt:if %s.Field == HUDWorldPos
9269                         WorldPos Pos
9270
9271                         //mt:if %s.Field == HUDSize
9272                         Size [2]int32
9273
9274                         //mt:if %s.Field == HUDZIndex
9275                         ZIndex int32
9276
9277                         //mt:if %s.Field == HUDText2
9278                         Text2 string
9279                 }))(obj)).ID).deserialize(r)
9280         }); err != nil {
9281                 if err == io.EOF {
9282                         chk(io.EOF)
9283                 }
9284                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
9285         }
9286         if err := pcall(func() {
9287                 ((*(*(struct {
9288                         ID HUDID
9289
9290                         Field HUDField
9291
9292                         //mt:if %s.Field == HUDPos
9293                         Pos [2]float32
9294
9295                         //mt:if %s.Field == HUDName
9296                         Name string
9297
9298                         //mt:if %s.Field == HUDScale
9299                         Scale [2]float32
9300
9301                         //mt:if %s.Field == HUDText
9302                         Text string
9303
9304                         //mt:if %s.Field == HUDNumber
9305                         Number uint32
9306
9307                         //mt:if %s.Field == HUDItem
9308                         Item uint32
9309
9310                         //mt:if %s.Field == HUDDir
9311                         Dir uint32
9312
9313                         //mt:if %s.Field == HUDAlign
9314                         Align [2]float32
9315
9316                         //mt:if %s.Field == HUDOffset
9317                         Offset [2]float32
9318
9319                         //mt:if %s.Field == HUDWorldPos
9320                         WorldPos Pos
9321
9322                         //mt:if %s.Field == HUDSize
9323                         Size [2]int32
9324
9325                         //mt:if %s.Field == HUDZIndex
9326                         ZIndex int32
9327
9328                         //mt:if %s.Field == HUDText2
9329                         Text2 string
9330                 }))(obj)).Field).deserialize(r)
9331         }); err != nil {
9332                 if err == io.EOF {
9333                         chk(io.EOF)
9334                 }
9335                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDField", err))
9336         }
9337         if !((*(*(struct {
9338                 ID HUDID
9339
9340                 Field HUDField
9341
9342                 //mt:if %s.Field == HUDPos
9343                 Pos [2]float32
9344
9345                 //mt:if %s.Field == HUDName
9346                 Name string
9347
9348                 //mt:if %s.Field == HUDScale
9349                 Scale [2]float32
9350
9351                 //mt:if %s.Field == HUDText
9352                 Text string
9353
9354                 //mt:if %s.Field == HUDNumber
9355                 Number uint32
9356
9357                 //mt:if %s.Field == HUDItem
9358                 Item uint32
9359
9360                 //mt:if %s.Field == HUDDir
9361                 Dir uint32
9362
9363                 //mt:if %s.Field == HUDAlign
9364                 Align [2]float32
9365
9366                 //mt:if %s.Field == HUDOffset
9367                 Offset [2]float32
9368
9369                 //mt:if %s.Field == HUDWorldPos
9370                 WorldPos Pos
9371
9372                 //mt:if %s.Field == HUDSize
9373                 Size [2]int32
9374
9375                 //mt:if %s.Field == HUDZIndex
9376                 ZIndex int32
9377
9378                 //mt:if %s.Field == HUDText2
9379                 Text2 string
9380         }))(obj)).Field < hudMax) {
9381                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9382         }
9383         if (*(*(struct {
9384                 ID HUDID
9385
9386                 Field HUDField
9387
9388                 //mt:if %s.Field == HUDPos
9389                 Pos [2]float32
9390
9391                 //mt:if %s.Field == HUDName
9392                 Name string
9393
9394                 //mt:if %s.Field == HUDScale
9395                 Scale [2]float32
9396
9397                 //mt:if %s.Field == HUDText
9398                 Text string
9399
9400                 //mt:if %s.Field == HUDNumber
9401                 Number uint32
9402
9403                 //mt:if %s.Field == HUDItem
9404                 Item uint32
9405
9406                 //mt:if %s.Field == HUDDir
9407                 Dir uint32
9408
9409                 //mt:if %s.Field == HUDAlign
9410                 Align [2]float32
9411
9412                 //mt:if %s.Field == HUDOffset
9413                 Offset [2]float32
9414
9415                 //mt:if %s.Field == HUDWorldPos
9416                 WorldPos Pos
9417
9418                 //mt:if %s.Field == HUDSize
9419                 Size [2]int32
9420
9421                 //mt:if %s.Field == HUDZIndex
9422                 ZIndex int32
9423
9424                 //mt:if %s.Field == HUDText2
9425                 Text2 string
9426         }))(obj)).Field == HUDPos {
9427                 for local179 := range (*(*(struct {
9428                         ID HUDID
9429
9430                         Field HUDField
9431
9432                         //mt:if %s.Field == HUDPos
9433                         Pos [2]float32
9434
9435                         //mt:if %s.Field == HUDName
9436                         Name string
9437
9438                         //mt:if %s.Field == HUDScale
9439                         Scale [2]float32
9440
9441                         //mt:if %s.Field == HUDText
9442                         Text string
9443
9444                         //mt:if %s.Field == HUDNumber
9445                         Number uint32
9446
9447                         //mt:if %s.Field == HUDItem
9448                         Item uint32
9449
9450                         //mt:if %s.Field == HUDDir
9451                         Dir uint32
9452
9453                         //mt:if %s.Field == HUDAlign
9454                         Align [2]float32
9455
9456                         //mt:if %s.Field == HUDOffset
9457                         Offset [2]float32
9458
9459                         //mt:if %s.Field == HUDWorldPos
9460                         WorldPos Pos
9461
9462                         //mt:if %s.Field == HUDSize
9463                         Size [2]int32
9464
9465                         //mt:if %s.Field == HUDZIndex
9466                         ZIndex int32
9467
9468                         //mt:if %s.Field == HUDText2
9469                         Text2 string
9470                 }))(obj)).Pos {
9471                         {
9472                                 p := &((*(*(struct {
9473                                         ID HUDID
9474
9475                                         Field HUDField
9476
9477                                         //mt:if %s.Field == HUDPos
9478                                         Pos [2]float32
9479
9480                                         //mt:if %s.Field == HUDName
9481                                         Name string
9482
9483                                         //mt:if %s.Field == HUDScale
9484                                         Scale [2]float32
9485
9486                                         //mt:if %s.Field == HUDText
9487                                         Text string
9488
9489                                         //mt:if %s.Field == HUDNumber
9490                                         Number uint32
9491
9492                                         //mt:if %s.Field == HUDItem
9493                                         Item uint32
9494
9495                                         //mt:if %s.Field == HUDDir
9496                                         Dir uint32
9497
9498                                         //mt:if %s.Field == HUDAlign
9499                                         Align [2]float32
9500
9501                                         //mt:if %s.Field == HUDOffset
9502                                         Offset [2]float32
9503
9504                                         //mt:if %s.Field == HUDWorldPos
9505                                         WorldPos Pos
9506
9507                                         //mt:if %s.Field == HUDSize
9508                                         Size [2]int32
9509
9510                                         //mt:if %s.Field == HUDZIndex
9511                                         ZIndex int32
9512
9513                                         //mt:if %s.Field == HUDText2
9514                                         Text2 string
9515                                 }))(obj)).Pos)[local179]
9516                                 *p = math.Float32frombits(read32(r))
9517                         }
9518                 }
9519         }
9520         if (*(*(struct {
9521                 ID HUDID
9522
9523                 Field HUDField
9524
9525                 //mt:if %s.Field == HUDPos
9526                 Pos [2]float32
9527
9528                 //mt:if %s.Field == HUDName
9529                 Name string
9530
9531                 //mt:if %s.Field == HUDScale
9532                 Scale [2]float32
9533
9534                 //mt:if %s.Field == HUDText
9535                 Text string
9536
9537                 //mt:if %s.Field == HUDNumber
9538                 Number uint32
9539
9540                 //mt:if %s.Field == HUDItem
9541                 Item uint32
9542
9543                 //mt:if %s.Field == HUDDir
9544                 Dir uint32
9545
9546                 //mt:if %s.Field == HUDAlign
9547                 Align [2]float32
9548
9549                 //mt:if %s.Field == HUDOffset
9550                 Offset [2]float32
9551
9552                 //mt:if %s.Field == HUDWorldPos
9553                 WorldPos Pos
9554
9555                 //mt:if %s.Field == HUDSize
9556                 Size [2]int32
9557
9558                 //mt:if %s.Field == HUDZIndex
9559                 ZIndex int32
9560
9561                 //mt:if %s.Field == HUDText2
9562                 Text2 string
9563         }))(obj)).Field == HUDName {
9564                 var local180 []uint8
9565                 var local181 uint16
9566                 {
9567                         p := &local181
9568                         *p = read16(r)
9569                 }
9570                 (local180) = make([]uint8, local181)
9571                 {
9572                         _, err := io.ReadFull(r, (local180)[:])
9573                         chk(err)
9574                 }
9575                 ((*(*(struct {
9576                         ID HUDID
9577
9578                         Field HUDField
9579
9580                         //mt:if %s.Field == HUDPos
9581                         Pos [2]float32
9582
9583                         //mt:if %s.Field == HUDName
9584                         Name string
9585
9586                         //mt:if %s.Field == HUDScale
9587                         Scale [2]float32
9588
9589                         //mt:if %s.Field == HUDText
9590                         Text string
9591
9592                         //mt:if %s.Field == HUDNumber
9593                         Number uint32
9594
9595                         //mt:if %s.Field == HUDItem
9596                         Item uint32
9597
9598                         //mt:if %s.Field == HUDDir
9599                         Dir uint32
9600
9601                         //mt:if %s.Field == HUDAlign
9602                         Align [2]float32
9603
9604                         //mt:if %s.Field == HUDOffset
9605                         Offset [2]float32
9606
9607                         //mt:if %s.Field == HUDWorldPos
9608                         WorldPos Pos
9609
9610                         //mt:if %s.Field == HUDSize
9611                         Size [2]int32
9612
9613                         //mt:if %s.Field == HUDZIndex
9614                         ZIndex int32
9615
9616                         //mt:if %s.Field == HUDText2
9617                         Text2 string
9618                 }))(obj)).Name) = string(local180)
9619         }
9620         if (*(*(struct {
9621                 ID HUDID
9622
9623                 Field HUDField
9624
9625                 //mt:if %s.Field == HUDPos
9626                 Pos [2]float32
9627
9628                 //mt:if %s.Field == HUDName
9629                 Name string
9630
9631                 //mt:if %s.Field == HUDScale
9632                 Scale [2]float32
9633
9634                 //mt:if %s.Field == HUDText
9635                 Text string
9636
9637                 //mt:if %s.Field == HUDNumber
9638                 Number uint32
9639
9640                 //mt:if %s.Field == HUDItem
9641                 Item uint32
9642
9643                 //mt:if %s.Field == HUDDir
9644                 Dir uint32
9645
9646                 //mt:if %s.Field == HUDAlign
9647                 Align [2]float32
9648
9649                 //mt:if %s.Field == HUDOffset
9650                 Offset [2]float32
9651
9652                 //mt:if %s.Field == HUDWorldPos
9653                 WorldPos Pos
9654
9655                 //mt:if %s.Field == HUDSize
9656                 Size [2]int32
9657
9658                 //mt:if %s.Field == HUDZIndex
9659                 ZIndex int32
9660
9661                 //mt:if %s.Field == HUDText2
9662                 Text2 string
9663         }))(obj)).Field == HUDScale {
9664                 for local182 := range (*(*(struct {
9665                         ID HUDID
9666
9667                         Field HUDField
9668
9669                         //mt:if %s.Field == HUDPos
9670                         Pos [2]float32
9671
9672                         //mt:if %s.Field == HUDName
9673                         Name string
9674
9675                         //mt:if %s.Field == HUDScale
9676                         Scale [2]float32
9677
9678                         //mt:if %s.Field == HUDText
9679                         Text string
9680
9681                         //mt:if %s.Field == HUDNumber
9682                         Number uint32
9683
9684                         //mt:if %s.Field == HUDItem
9685                         Item uint32
9686
9687                         //mt:if %s.Field == HUDDir
9688                         Dir uint32
9689
9690                         //mt:if %s.Field == HUDAlign
9691                         Align [2]float32
9692
9693                         //mt:if %s.Field == HUDOffset
9694                         Offset [2]float32
9695
9696                         //mt:if %s.Field == HUDWorldPos
9697                         WorldPos Pos
9698
9699                         //mt:if %s.Field == HUDSize
9700                         Size [2]int32
9701
9702                         //mt:if %s.Field == HUDZIndex
9703                         ZIndex int32
9704
9705                         //mt:if %s.Field == HUDText2
9706                         Text2 string
9707                 }))(obj)).Scale {
9708                         {
9709                                 p := &((*(*(struct {
9710                                         ID HUDID
9711
9712                                         Field HUDField
9713
9714                                         //mt:if %s.Field == HUDPos
9715                                         Pos [2]float32
9716
9717                                         //mt:if %s.Field == HUDName
9718                                         Name string
9719
9720                                         //mt:if %s.Field == HUDScale
9721                                         Scale [2]float32
9722
9723                                         //mt:if %s.Field == HUDText
9724                                         Text string
9725
9726                                         //mt:if %s.Field == HUDNumber
9727                                         Number uint32
9728
9729                                         //mt:if %s.Field == HUDItem
9730                                         Item uint32
9731
9732                                         //mt:if %s.Field == HUDDir
9733                                         Dir uint32
9734
9735                                         //mt:if %s.Field == HUDAlign
9736                                         Align [2]float32
9737
9738                                         //mt:if %s.Field == HUDOffset
9739                                         Offset [2]float32
9740
9741                                         //mt:if %s.Field == HUDWorldPos
9742                                         WorldPos Pos
9743
9744                                         //mt:if %s.Field == HUDSize
9745                                         Size [2]int32
9746
9747                                         //mt:if %s.Field == HUDZIndex
9748                                         ZIndex int32
9749
9750                                         //mt:if %s.Field == HUDText2
9751                                         Text2 string
9752                                 }))(obj)).Scale)[local182]
9753                                 *p = math.Float32frombits(read32(r))
9754                         }
9755                 }
9756         }
9757         if (*(*(struct {
9758                 ID HUDID
9759
9760                 Field HUDField
9761
9762                 //mt:if %s.Field == HUDPos
9763                 Pos [2]float32
9764
9765                 //mt:if %s.Field == HUDName
9766                 Name string
9767
9768                 //mt:if %s.Field == HUDScale
9769                 Scale [2]float32
9770
9771                 //mt:if %s.Field == HUDText
9772                 Text string
9773
9774                 //mt:if %s.Field == HUDNumber
9775                 Number uint32
9776
9777                 //mt:if %s.Field == HUDItem
9778                 Item uint32
9779
9780                 //mt:if %s.Field == HUDDir
9781                 Dir uint32
9782
9783                 //mt:if %s.Field == HUDAlign
9784                 Align [2]float32
9785
9786                 //mt:if %s.Field == HUDOffset
9787                 Offset [2]float32
9788
9789                 //mt:if %s.Field == HUDWorldPos
9790                 WorldPos Pos
9791
9792                 //mt:if %s.Field == HUDSize
9793                 Size [2]int32
9794
9795                 //mt:if %s.Field == HUDZIndex
9796                 ZIndex int32
9797
9798                 //mt:if %s.Field == HUDText2
9799                 Text2 string
9800         }))(obj)).Field == HUDText {
9801                 var local183 []uint8
9802                 var local184 uint16
9803                 {
9804                         p := &local184
9805                         *p = read16(r)
9806                 }
9807                 (local183) = make([]uint8, local184)
9808                 {
9809                         _, err := io.ReadFull(r, (local183)[:])
9810                         chk(err)
9811                 }
9812                 ((*(*(struct {
9813                         ID HUDID
9814
9815                         Field HUDField
9816
9817                         //mt:if %s.Field == HUDPos
9818                         Pos [2]float32
9819
9820                         //mt:if %s.Field == HUDName
9821                         Name string
9822
9823                         //mt:if %s.Field == HUDScale
9824                         Scale [2]float32
9825
9826                         //mt:if %s.Field == HUDText
9827                         Text string
9828
9829                         //mt:if %s.Field == HUDNumber
9830                         Number uint32
9831
9832                         //mt:if %s.Field == HUDItem
9833                         Item uint32
9834
9835                         //mt:if %s.Field == HUDDir
9836                         Dir uint32
9837
9838                         //mt:if %s.Field == HUDAlign
9839                         Align [2]float32
9840
9841                         //mt:if %s.Field == HUDOffset
9842                         Offset [2]float32
9843
9844                         //mt:if %s.Field == HUDWorldPos
9845                         WorldPos Pos
9846
9847                         //mt:if %s.Field == HUDSize
9848                         Size [2]int32
9849
9850                         //mt:if %s.Field == HUDZIndex
9851                         ZIndex int32
9852
9853                         //mt:if %s.Field == HUDText2
9854                         Text2 string
9855                 }))(obj)).Text) = string(local183)
9856         }
9857         if (*(*(struct {
9858                 ID HUDID
9859
9860                 Field HUDField
9861
9862                 //mt:if %s.Field == HUDPos
9863                 Pos [2]float32
9864
9865                 //mt:if %s.Field == HUDName
9866                 Name string
9867
9868                 //mt:if %s.Field == HUDScale
9869                 Scale [2]float32
9870
9871                 //mt:if %s.Field == HUDText
9872                 Text string
9873
9874                 //mt:if %s.Field == HUDNumber
9875                 Number uint32
9876
9877                 //mt:if %s.Field == HUDItem
9878                 Item uint32
9879
9880                 //mt:if %s.Field == HUDDir
9881                 Dir uint32
9882
9883                 //mt:if %s.Field == HUDAlign
9884                 Align [2]float32
9885
9886                 //mt:if %s.Field == HUDOffset
9887                 Offset [2]float32
9888
9889                 //mt:if %s.Field == HUDWorldPos
9890                 WorldPos Pos
9891
9892                 //mt:if %s.Field == HUDSize
9893                 Size [2]int32
9894
9895                 //mt:if %s.Field == HUDZIndex
9896                 ZIndex int32
9897
9898                 //mt:if %s.Field == HUDText2
9899                 Text2 string
9900         }))(obj)).Field == HUDNumber {
9901                 {
9902                         p := &(*(*(struct {
9903                                 ID HUDID
9904
9905                                 Field HUDField
9906
9907                                 //mt:if %s.Field == HUDPos
9908                                 Pos [2]float32
9909
9910                                 //mt:if %s.Field == HUDName
9911                                 Name string
9912
9913                                 //mt:if %s.Field == HUDScale
9914                                 Scale [2]float32
9915
9916                                 //mt:if %s.Field == HUDText
9917                                 Text string
9918
9919                                 //mt:if %s.Field == HUDNumber
9920                                 Number uint32
9921
9922                                 //mt:if %s.Field == HUDItem
9923                                 Item uint32
9924
9925                                 //mt:if %s.Field == HUDDir
9926                                 Dir uint32
9927
9928                                 //mt:if %s.Field == HUDAlign
9929                                 Align [2]float32
9930
9931                                 //mt:if %s.Field == HUDOffset
9932                                 Offset [2]float32
9933
9934                                 //mt:if %s.Field == HUDWorldPos
9935                                 WorldPos Pos
9936
9937                                 //mt:if %s.Field == HUDSize
9938                                 Size [2]int32
9939
9940                                 //mt:if %s.Field == HUDZIndex
9941                                 ZIndex int32
9942
9943                                 //mt:if %s.Field == HUDText2
9944                                 Text2 string
9945                         }))(obj)).Number
9946                         *p = read32(r)
9947                 }
9948         }
9949         if (*(*(struct {
9950                 ID HUDID
9951
9952                 Field HUDField
9953
9954                 //mt:if %s.Field == HUDPos
9955                 Pos [2]float32
9956
9957                 //mt:if %s.Field == HUDName
9958                 Name string
9959
9960                 //mt:if %s.Field == HUDScale
9961                 Scale [2]float32
9962
9963                 //mt:if %s.Field == HUDText
9964                 Text string
9965
9966                 //mt:if %s.Field == HUDNumber
9967                 Number uint32
9968
9969                 //mt:if %s.Field == HUDItem
9970                 Item uint32
9971
9972                 //mt:if %s.Field == HUDDir
9973                 Dir uint32
9974
9975                 //mt:if %s.Field == HUDAlign
9976                 Align [2]float32
9977
9978                 //mt:if %s.Field == HUDOffset
9979                 Offset [2]float32
9980
9981                 //mt:if %s.Field == HUDWorldPos
9982                 WorldPos Pos
9983
9984                 //mt:if %s.Field == HUDSize
9985                 Size [2]int32
9986
9987                 //mt:if %s.Field == HUDZIndex
9988                 ZIndex int32
9989
9990                 //mt:if %s.Field == HUDText2
9991                 Text2 string
9992         }))(obj)).Field == HUDItem {
9993                 {
9994                         p := &(*(*(struct {
9995                                 ID HUDID
9996
9997                                 Field HUDField
9998
9999                                 //mt:if %s.Field == HUDPos
10000                                 Pos [2]float32
10001
10002                                 //mt:if %s.Field == HUDName
10003                                 Name string
10004
10005                                 //mt:if %s.Field == HUDScale
10006                                 Scale [2]float32
10007
10008                                 //mt:if %s.Field == HUDText
10009                                 Text string
10010
10011                                 //mt:if %s.Field == HUDNumber
10012                                 Number uint32
10013
10014                                 //mt:if %s.Field == HUDItem
10015                                 Item uint32
10016
10017                                 //mt:if %s.Field == HUDDir
10018                                 Dir uint32
10019
10020                                 //mt:if %s.Field == HUDAlign
10021                                 Align [2]float32
10022
10023                                 //mt:if %s.Field == HUDOffset
10024                                 Offset [2]float32
10025
10026                                 //mt:if %s.Field == HUDWorldPos
10027                                 WorldPos Pos
10028
10029                                 //mt:if %s.Field == HUDSize
10030                                 Size [2]int32
10031
10032                                 //mt:if %s.Field == HUDZIndex
10033                                 ZIndex int32
10034
10035                                 //mt:if %s.Field == HUDText2
10036                                 Text2 string
10037                         }))(obj)).Item
10038                         *p = read32(r)
10039                 }
10040         }
10041         if (*(*(struct {
10042                 ID HUDID
10043
10044                 Field HUDField
10045
10046                 //mt:if %s.Field == HUDPos
10047                 Pos [2]float32
10048
10049                 //mt:if %s.Field == HUDName
10050                 Name string
10051
10052                 //mt:if %s.Field == HUDScale
10053                 Scale [2]float32
10054
10055                 //mt:if %s.Field == HUDText
10056                 Text string
10057
10058                 //mt:if %s.Field == HUDNumber
10059                 Number uint32
10060
10061                 //mt:if %s.Field == HUDItem
10062                 Item uint32
10063
10064                 //mt:if %s.Field == HUDDir
10065                 Dir uint32
10066
10067                 //mt:if %s.Field == HUDAlign
10068                 Align [2]float32
10069
10070                 //mt:if %s.Field == HUDOffset
10071                 Offset [2]float32
10072
10073                 //mt:if %s.Field == HUDWorldPos
10074                 WorldPos Pos
10075
10076                 //mt:if %s.Field == HUDSize
10077                 Size [2]int32
10078
10079                 //mt:if %s.Field == HUDZIndex
10080                 ZIndex int32
10081
10082                 //mt:if %s.Field == HUDText2
10083                 Text2 string
10084         }))(obj)).Field == HUDDir {
10085                 {
10086                         p := &(*(*(struct {
10087                                 ID HUDID
10088
10089                                 Field HUDField
10090
10091                                 //mt:if %s.Field == HUDPos
10092                                 Pos [2]float32
10093
10094                                 //mt:if %s.Field == HUDName
10095                                 Name string
10096
10097                                 //mt:if %s.Field == HUDScale
10098                                 Scale [2]float32
10099
10100                                 //mt:if %s.Field == HUDText
10101                                 Text string
10102
10103                                 //mt:if %s.Field == HUDNumber
10104                                 Number uint32
10105
10106                                 //mt:if %s.Field == HUDItem
10107                                 Item uint32
10108
10109                                 //mt:if %s.Field == HUDDir
10110                                 Dir uint32
10111
10112                                 //mt:if %s.Field == HUDAlign
10113                                 Align [2]float32
10114
10115                                 //mt:if %s.Field == HUDOffset
10116                                 Offset [2]float32
10117
10118                                 //mt:if %s.Field == HUDWorldPos
10119                                 WorldPos Pos
10120
10121                                 //mt:if %s.Field == HUDSize
10122                                 Size [2]int32
10123
10124                                 //mt:if %s.Field == HUDZIndex
10125                                 ZIndex int32
10126
10127                                 //mt:if %s.Field == HUDText2
10128                                 Text2 string
10129                         }))(obj)).Dir
10130                         *p = read32(r)
10131                 }
10132         }
10133         if (*(*(struct {
10134                 ID HUDID
10135
10136                 Field HUDField
10137
10138                 //mt:if %s.Field == HUDPos
10139                 Pos [2]float32
10140
10141                 //mt:if %s.Field == HUDName
10142                 Name string
10143
10144                 //mt:if %s.Field == HUDScale
10145                 Scale [2]float32
10146
10147                 //mt:if %s.Field == HUDText
10148                 Text string
10149
10150                 //mt:if %s.Field == HUDNumber
10151                 Number uint32
10152
10153                 //mt:if %s.Field == HUDItem
10154                 Item uint32
10155
10156                 //mt:if %s.Field == HUDDir
10157                 Dir uint32
10158
10159                 //mt:if %s.Field == HUDAlign
10160                 Align [2]float32
10161
10162                 //mt:if %s.Field == HUDOffset
10163                 Offset [2]float32
10164
10165                 //mt:if %s.Field == HUDWorldPos
10166                 WorldPos Pos
10167
10168                 //mt:if %s.Field == HUDSize
10169                 Size [2]int32
10170
10171                 //mt:if %s.Field == HUDZIndex
10172                 ZIndex int32
10173
10174                 //mt:if %s.Field == HUDText2
10175                 Text2 string
10176         }))(obj)).Field == HUDAlign {
10177                 for local185 := range (*(*(struct {
10178                         ID HUDID
10179
10180                         Field HUDField
10181
10182                         //mt:if %s.Field == HUDPos
10183                         Pos [2]float32
10184
10185                         //mt:if %s.Field == HUDName
10186                         Name string
10187
10188                         //mt:if %s.Field == HUDScale
10189                         Scale [2]float32
10190
10191                         //mt:if %s.Field == HUDText
10192                         Text string
10193
10194                         //mt:if %s.Field == HUDNumber
10195                         Number uint32
10196
10197                         //mt:if %s.Field == HUDItem
10198                         Item uint32
10199
10200                         //mt:if %s.Field == HUDDir
10201                         Dir uint32
10202
10203                         //mt:if %s.Field == HUDAlign
10204                         Align [2]float32
10205
10206                         //mt:if %s.Field == HUDOffset
10207                         Offset [2]float32
10208
10209                         //mt:if %s.Field == HUDWorldPos
10210                         WorldPos Pos
10211
10212                         //mt:if %s.Field == HUDSize
10213                         Size [2]int32
10214
10215                         //mt:if %s.Field == HUDZIndex
10216                         ZIndex int32
10217
10218                         //mt:if %s.Field == HUDText2
10219                         Text2 string
10220                 }))(obj)).Align {
10221                         {
10222                                 p := &((*(*(struct {
10223                                         ID HUDID
10224
10225                                         Field HUDField
10226
10227                                         //mt:if %s.Field == HUDPos
10228                                         Pos [2]float32
10229
10230                                         //mt:if %s.Field == HUDName
10231                                         Name string
10232
10233                                         //mt:if %s.Field == HUDScale
10234                                         Scale [2]float32
10235
10236                                         //mt:if %s.Field == HUDText
10237                                         Text string
10238
10239                                         //mt:if %s.Field == HUDNumber
10240                                         Number uint32
10241
10242                                         //mt:if %s.Field == HUDItem
10243                                         Item uint32
10244
10245                                         //mt:if %s.Field == HUDDir
10246                                         Dir uint32
10247
10248                                         //mt:if %s.Field == HUDAlign
10249                                         Align [2]float32
10250
10251                                         //mt:if %s.Field == HUDOffset
10252                                         Offset [2]float32
10253
10254                                         //mt:if %s.Field == HUDWorldPos
10255                                         WorldPos Pos
10256
10257                                         //mt:if %s.Field == HUDSize
10258                                         Size [2]int32
10259
10260                                         //mt:if %s.Field == HUDZIndex
10261                                         ZIndex int32
10262
10263                                         //mt:if %s.Field == HUDText2
10264                                         Text2 string
10265                                 }))(obj)).Align)[local185]
10266                                 *p = math.Float32frombits(read32(r))
10267                         }
10268                 }
10269         }
10270         if (*(*(struct {
10271                 ID HUDID
10272
10273                 Field HUDField
10274
10275                 //mt:if %s.Field == HUDPos
10276                 Pos [2]float32
10277
10278                 //mt:if %s.Field == HUDName
10279                 Name string
10280
10281                 //mt:if %s.Field == HUDScale
10282                 Scale [2]float32
10283
10284                 //mt:if %s.Field == HUDText
10285                 Text string
10286
10287                 //mt:if %s.Field == HUDNumber
10288                 Number uint32
10289
10290                 //mt:if %s.Field == HUDItem
10291                 Item uint32
10292
10293                 //mt:if %s.Field == HUDDir
10294                 Dir uint32
10295
10296                 //mt:if %s.Field == HUDAlign
10297                 Align [2]float32
10298
10299                 //mt:if %s.Field == HUDOffset
10300                 Offset [2]float32
10301
10302                 //mt:if %s.Field == HUDWorldPos
10303                 WorldPos Pos
10304
10305                 //mt:if %s.Field == HUDSize
10306                 Size [2]int32
10307
10308                 //mt:if %s.Field == HUDZIndex
10309                 ZIndex int32
10310
10311                 //mt:if %s.Field == HUDText2
10312                 Text2 string
10313         }))(obj)).Field == HUDOffset {
10314                 for local186 := range (*(*(struct {
10315                         ID HUDID
10316
10317                         Field HUDField
10318
10319                         //mt:if %s.Field == HUDPos
10320                         Pos [2]float32
10321
10322                         //mt:if %s.Field == HUDName
10323                         Name string
10324
10325                         //mt:if %s.Field == HUDScale
10326                         Scale [2]float32
10327
10328                         //mt:if %s.Field == HUDText
10329                         Text string
10330
10331                         //mt:if %s.Field == HUDNumber
10332                         Number uint32
10333
10334                         //mt:if %s.Field == HUDItem
10335                         Item uint32
10336
10337                         //mt:if %s.Field == HUDDir
10338                         Dir uint32
10339
10340                         //mt:if %s.Field == HUDAlign
10341                         Align [2]float32
10342
10343                         //mt:if %s.Field == HUDOffset
10344                         Offset [2]float32
10345
10346                         //mt:if %s.Field == HUDWorldPos
10347                         WorldPos Pos
10348
10349                         //mt:if %s.Field == HUDSize
10350                         Size [2]int32
10351
10352                         //mt:if %s.Field == HUDZIndex
10353                         ZIndex int32
10354
10355                         //mt:if %s.Field == HUDText2
10356                         Text2 string
10357                 }))(obj)).Offset {
10358                         {
10359                                 p := &((*(*(struct {
10360                                         ID HUDID
10361
10362                                         Field HUDField
10363
10364                                         //mt:if %s.Field == HUDPos
10365                                         Pos [2]float32
10366
10367                                         //mt:if %s.Field == HUDName
10368                                         Name string
10369
10370                                         //mt:if %s.Field == HUDScale
10371                                         Scale [2]float32
10372
10373                                         //mt:if %s.Field == HUDText
10374                                         Text string
10375
10376                                         //mt:if %s.Field == HUDNumber
10377                                         Number uint32
10378
10379                                         //mt:if %s.Field == HUDItem
10380                                         Item uint32
10381
10382                                         //mt:if %s.Field == HUDDir
10383                                         Dir uint32
10384
10385                                         //mt:if %s.Field == HUDAlign
10386                                         Align [2]float32
10387
10388                                         //mt:if %s.Field == HUDOffset
10389                                         Offset [2]float32
10390
10391                                         //mt:if %s.Field == HUDWorldPos
10392                                         WorldPos Pos
10393
10394                                         //mt:if %s.Field == HUDSize
10395                                         Size [2]int32
10396
10397                                         //mt:if %s.Field == HUDZIndex
10398                                         ZIndex int32
10399
10400                                         //mt:if %s.Field == HUDText2
10401                                         Text2 string
10402                                 }))(obj)).Offset)[local186]
10403                                 *p = math.Float32frombits(read32(r))
10404                         }
10405                 }
10406         }
10407         if (*(*(struct {
10408                 ID HUDID
10409
10410                 Field HUDField
10411
10412                 //mt:if %s.Field == HUDPos
10413                 Pos [2]float32
10414
10415                 //mt:if %s.Field == HUDName
10416                 Name string
10417
10418                 //mt:if %s.Field == HUDScale
10419                 Scale [2]float32
10420
10421                 //mt:if %s.Field == HUDText
10422                 Text string
10423
10424                 //mt:if %s.Field == HUDNumber
10425                 Number uint32
10426
10427                 //mt:if %s.Field == HUDItem
10428                 Item uint32
10429
10430                 //mt:if %s.Field == HUDDir
10431                 Dir uint32
10432
10433                 //mt:if %s.Field == HUDAlign
10434                 Align [2]float32
10435
10436                 //mt:if %s.Field == HUDOffset
10437                 Offset [2]float32
10438
10439                 //mt:if %s.Field == HUDWorldPos
10440                 WorldPos Pos
10441
10442                 //mt:if %s.Field == HUDSize
10443                 Size [2]int32
10444
10445                 //mt:if %s.Field == HUDZIndex
10446                 ZIndex int32
10447
10448                 //mt:if %s.Field == HUDText2
10449                 Text2 string
10450         }))(obj)).Field == HUDWorldPos {
10451                 if err := pcall(func() {
10452                         ((*(*(struct {
10453                                 ID HUDID
10454
10455                                 Field HUDField
10456
10457                                 //mt:if %s.Field == HUDPos
10458                                 Pos [2]float32
10459
10460                                 //mt:if %s.Field == HUDName
10461                                 Name string
10462
10463                                 //mt:if %s.Field == HUDScale
10464                                 Scale [2]float32
10465
10466                                 //mt:if %s.Field == HUDText
10467                                 Text string
10468
10469                                 //mt:if %s.Field == HUDNumber
10470                                 Number uint32
10471
10472                                 //mt:if %s.Field == HUDItem
10473                                 Item uint32
10474
10475                                 //mt:if %s.Field == HUDDir
10476                                 Dir uint32
10477
10478                                 //mt:if %s.Field == HUDAlign
10479                                 Align [2]float32
10480
10481                                 //mt:if %s.Field == HUDOffset
10482                                 Offset [2]float32
10483
10484                                 //mt:if %s.Field == HUDWorldPos
10485                                 WorldPos Pos
10486
10487                                 //mt:if %s.Field == HUDSize
10488                                 Size [2]int32
10489
10490                                 //mt:if %s.Field == HUDZIndex
10491                                 ZIndex int32
10492
10493                                 //mt:if %s.Field == HUDText2
10494                                 Text2 string
10495                         }))(obj)).WorldPos).deserialize(r)
10496                 }); err != nil {
10497                         if err == io.EOF {
10498                                 chk(io.EOF)
10499                         }
10500                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
10501                 }
10502         }
10503         if (*(*(struct {
10504                 ID HUDID
10505
10506                 Field HUDField
10507
10508                 //mt:if %s.Field == HUDPos
10509                 Pos [2]float32
10510
10511                 //mt:if %s.Field == HUDName
10512                 Name string
10513
10514                 //mt:if %s.Field == HUDScale
10515                 Scale [2]float32
10516
10517                 //mt:if %s.Field == HUDText
10518                 Text string
10519
10520                 //mt:if %s.Field == HUDNumber
10521                 Number uint32
10522
10523                 //mt:if %s.Field == HUDItem
10524                 Item uint32
10525
10526                 //mt:if %s.Field == HUDDir
10527                 Dir uint32
10528
10529                 //mt:if %s.Field == HUDAlign
10530                 Align [2]float32
10531
10532                 //mt:if %s.Field == HUDOffset
10533                 Offset [2]float32
10534
10535                 //mt:if %s.Field == HUDWorldPos
10536                 WorldPos Pos
10537
10538                 //mt:if %s.Field == HUDSize
10539                 Size [2]int32
10540
10541                 //mt:if %s.Field == HUDZIndex
10542                 ZIndex int32
10543
10544                 //mt:if %s.Field == HUDText2
10545                 Text2 string
10546         }))(obj)).Field == HUDSize {
10547                 for local187 := range (*(*(struct {
10548                         ID HUDID
10549
10550                         Field HUDField
10551
10552                         //mt:if %s.Field == HUDPos
10553                         Pos [2]float32
10554
10555                         //mt:if %s.Field == HUDName
10556                         Name string
10557
10558                         //mt:if %s.Field == HUDScale
10559                         Scale [2]float32
10560
10561                         //mt:if %s.Field == HUDText
10562                         Text string
10563
10564                         //mt:if %s.Field == HUDNumber
10565                         Number uint32
10566
10567                         //mt:if %s.Field == HUDItem
10568                         Item uint32
10569
10570                         //mt:if %s.Field == HUDDir
10571                         Dir uint32
10572
10573                         //mt:if %s.Field == HUDAlign
10574                         Align [2]float32
10575
10576                         //mt:if %s.Field == HUDOffset
10577                         Offset [2]float32
10578
10579                         //mt:if %s.Field == HUDWorldPos
10580                         WorldPos Pos
10581
10582                         //mt:if %s.Field == HUDSize
10583                         Size [2]int32
10584
10585                         //mt:if %s.Field == HUDZIndex
10586                         ZIndex int32
10587
10588                         //mt:if %s.Field == HUDText2
10589                         Text2 string
10590                 }))(obj)).Size {
10591                         {
10592                                 p := &((*(*(struct {
10593                                         ID HUDID
10594
10595                                         Field HUDField
10596
10597                                         //mt:if %s.Field == HUDPos
10598                                         Pos [2]float32
10599
10600                                         //mt:if %s.Field == HUDName
10601                                         Name string
10602
10603                                         //mt:if %s.Field == HUDScale
10604                                         Scale [2]float32
10605
10606                                         //mt:if %s.Field == HUDText
10607                                         Text string
10608
10609                                         //mt:if %s.Field == HUDNumber
10610                                         Number uint32
10611
10612                                         //mt:if %s.Field == HUDItem
10613                                         Item uint32
10614
10615                                         //mt:if %s.Field == HUDDir
10616                                         Dir uint32
10617
10618                                         //mt:if %s.Field == HUDAlign
10619                                         Align [2]float32
10620
10621                                         //mt:if %s.Field == HUDOffset
10622                                         Offset [2]float32
10623
10624                                         //mt:if %s.Field == HUDWorldPos
10625                                         WorldPos Pos
10626
10627                                         //mt:if %s.Field == HUDSize
10628                                         Size [2]int32
10629
10630                                         //mt:if %s.Field == HUDZIndex
10631                                         ZIndex int32
10632
10633                                         //mt:if %s.Field == HUDText2
10634                                         Text2 string
10635                                 }))(obj)).Size)[local187]
10636                                 *p = int32(read32(r))
10637                         }
10638                 }
10639         }
10640         if (*(*(struct {
10641                 ID HUDID
10642
10643                 Field HUDField
10644
10645                 //mt:if %s.Field == HUDPos
10646                 Pos [2]float32
10647
10648                 //mt:if %s.Field == HUDName
10649                 Name string
10650
10651                 //mt:if %s.Field == HUDScale
10652                 Scale [2]float32
10653
10654                 //mt:if %s.Field == HUDText
10655                 Text string
10656
10657                 //mt:if %s.Field == HUDNumber
10658                 Number uint32
10659
10660                 //mt:if %s.Field == HUDItem
10661                 Item uint32
10662
10663                 //mt:if %s.Field == HUDDir
10664                 Dir uint32
10665
10666                 //mt:if %s.Field == HUDAlign
10667                 Align [2]float32
10668
10669                 //mt:if %s.Field == HUDOffset
10670                 Offset [2]float32
10671
10672                 //mt:if %s.Field == HUDWorldPos
10673                 WorldPos Pos
10674
10675                 //mt:if %s.Field == HUDSize
10676                 Size [2]int32
10677
10678                 //mt:if %s.Field == HUDZIndex
10679                 ZIndex int32
10680
10681                 //mt:if %s.Field == HUDText2
10682                 Text2 string
10683         }))(obj)).Field == HUDZIndex {
10684                 {
10685                         p := &(*(*(struct {
10686                                 ID HUDID
10687
10688                                 Field HUDField
10689
10690                                 //mt:if %s.Field == HUDPos
10691                                 Pos [2]float32
10692
10693                                 //mt:if %s.Field == HUDName
10694                                 Name string
10695
10696                                 //mt:if %s.Field == HUDScale
10697                                 Scale [2]float32
10698
10699                                 //mt:if %s.Field == HUDText
10700                                 Text string
10701
10702                                 //mt:if %s.Field == HUDNumber
10703                                 Number uint32
10704
10705                                 //mt:if %s.Field == HUDItem
10706                                 Item uint32
10707
10708                                 //mt:if %s.Field == HUDDir
10709                                 Dir uint32
10710
10711                                 //mt:if %s.Field == HUDAlign
10712                                 Align [2]float32
10713
10714                                 //mt:if %s.Field == HUDOffset
10715                                 Offset [2]float32
10716
10717                                 //mt:if %s.Field == HUDWorldPos
10718                                 WorldPos Pos
10719
10720                                 //mt:if %s.Field == HUDSize
10721                                 Size [2]int32
10722
10723                                 //mt:if %s.Field == HUDZIndex
10724                                 ZIndex int32
10725
10726                                 //mt:if %s.Field == HUDText2
10727                                 Text2 string
10728                         }))(obj)).ZIndex
10729                         *p = int32(read32(r))
10730                 }
10731         }
10732         if (*(*(struct {
10733                 ID HUDID
10734
10735                 Field HUDField
10736
10737                 //mt:if %s.Field == HUDPos
10738                 Pos [2]float32
10739
10740                 //mt:if %s.Field == HUDName
10741                 Name string
10742
10743                 //mt:if %s.Field == HUDScale
10744                 Scale [2]float32
10745
10746                 //mt:if %s.Field == HUDText
10747                 Text string
10748
10749                 //mt:if %s.Field == HUDNumber
10750                 Number uint32
10751
10752                 //mt:if %s.Field == HUDItem
10753                 Item uint32
10754
10755                 //mt:if %s.Field == HUDDir
10756                 Dir uint32
10757
10758                 //mt:if %s.Field == HUDAlign
10759                 Align [2]float32
10760
10761                 //mt:if %s.Field == HUDOffset
10762                 Offset [2]float32
10763
10764                 //mt:if %s.Field == HUDWorldPos
10765                 WorldPos Pos
10766
10767                 //mt:if %s.Field == HUDSize
10768                 Size [2]int32
10769
10770                 //mt:if %s.Field == HUDZIndex
10771                 ZIndex int32
10772
10773                 //mt:if %s.Field == HUDText2
10774                 Text2 string
10775         }))(obj)).Field == HUDText2 {
10776                 var local188 []uint8
10777                 var local189 uint16
10778                 {
10779                         p := &local189
10780                         *p = read16(r)
10781                 }
10782                 (local188) = make([]uint8, local189)
10783                 {
10784                         _, err := io.ReadFull(r, (local188)[:])
10785                         chk(err)
10786                 }
10787                 ((*(*(struct {
10788                         ID HUDID
10789
10790                         Field HUDField
10791
10792                         //mt:if %s.Field == HUDPos
10793                         Pos [2]float32
10794
10795                         //mt:if %s.Field == HUDName
10796                         Name string
10797
10798                         //mt:if %s.Field == HUDScale
10799                         Scale [2]float32
10800
10801                         //mt:if %s.Field == HUDText
10802                         Text string
10803
10804                         //mt:if %s.Field == HUDNumber
10805                         Number uint32
10806
10807                         //mt:if %s.Field == HUDItem
10808                         Item uint32
10809
10810                         //mt:if %s.Field == HUDDir
10811                         Dir uint32
10812
10813                         //mt:if %s.Field == HUDAlign
10814                         Align [2]float32
10815
10816                         //mt:if %s.Field == HUDOffset
10817                         Offset [2]float32
10818
10819                         //mt:if %s.Field == HUDWorldPos
10820                         WorldPos Pos
10821
10822                         //mt:if %s.Field == HUDSize
10823                         Size [2]int32
10824
10825                         //mt:if %s.Field == HUDZIndex
10826                         ZIndex int32
10827
10828                         //mt:if %s.Field == HUDText2
10829                         Text2 string
10830                 }))(obj)).Text2) = string(local188)
10831         }
10832 }
10833
10834 func (obj *ToCltHUDFlags) serialize(w io.Writer) {
10835         if err := pcall(func() {
10836                 ((*(*(struct {
10837                         // &^= Mask
10838                         // |= Flags
10839                         Flags, Mask HUDFlags
10840                 }))(obj)).Flags).serialize(w)
10841         }); err != nil {
10842                 if err == io.EOF {
10843                         chk(io.EOF)
10844                 }
10845                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10846         }
10847         if err := pcall(func() {
10848                 ((*(*(struct {
10849                         // &^= Mask
10850                         // |= Flags
10851                         Flags, Mask HUDFlags
10852                 }))(obj)).Mask).serialize(w)
10853         }); err != nil {
10854                 if err == io.EOF {
10855                         chk(io.EOF)
10856                 }
10857                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10858         }
10859 }
10860
10861 func (obj *ToCltHUDFlags) deserialize(r io.Reader) {
10862         if err := pcall(func() {
10863                 ((*(*(struct {
10864                         // &^= Mask
10865                         // |= Flags
10866                         Flags, Mask HUDFlags
10867                 }))(obj)).Flags).deserialize(r)
10868         }); err != nil {
10869                 if err == io.EOF {
10870                         chk(io.EOF)
10871                 }
10872                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10873         }
10874         if err := pcall(func() {
10875                 ((*(*(struct {
10876                         // &^= Mask
10877                         // |= Flags
10878                         Flags, Mask HUDFlags
10879                 }))(obj)).Mask).deserialize(r)
10880         }); err != nil {
10881                 if err == io.EOF {
10882                         chk(io.EOF)
10883                 }
10884                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10885         }
10886 }
10887
10888 func (obj *ToCltSetHotbarParam) serialize(w io.Writer) {
10889         if err := pcall(func() {
10890                 ((*(*(struct {
10891                         Param HotbarParam
10892
10893                         //mt:if %s.Param == HotbarSize
10894                         //mt:const uint16(4) // Size of Size field.
10895                         Size int32
10896
10897                         //mt:if %s.Param != HotbarSize
10898                         Img Texture
10899                 }))(obj)).Param).serialize(w)
10900         }); err != nil {
10901                 if err == io.EOF {
10902                         chk(io.EOF)
10903                 }
10904                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HotbarParam", err))
10905         }
10906         if (*(*(struct {
10907                 Param HotbarParam
10908
10909                 //mt:if %s.Param == HotbarSize
10910                 //mt:const uint16(4) // Size of Size field.
10911                 Size int32
10912
10913                 //mt:if %s.Param != HotbarSize
10914                 Img Texture
10915         }))(obj)).Param == HotbarSize {
10916                 {
10917                         local190 := uint16(4) // Size of Size field.
10918                         {
10919                                 x := local190
10920                                 write16(w, uint16(x))
10921                         }
10922                 }
10923                 {
10924                         x := (*(*(struct {
10925                                 Param HotbarParam
10926
10927                                 //mt:if %s.Param == HotbarSize
10928                                 //mt:const uint16(4) // Size of Size field.
10929                                 Size int32
10930
10931                                 //mt:if %s.Param != HotbarSize
10932                                 Img Texture
10933                         }))(obj)).Size
10934                         write32(w, uint32(x))
10935                 }
10936         }
10937         if (*(*(struct {
10938                 Param HotbarParam
10939
10940                 //mt:if %s.Param == HotbarSize
10941                 //mt:const uint16(4) // Size of Size field.
10942                 Size int32
10943
10944                 //mt:if %s.Param != HotbarSize
10945                 Img Texture
10946         }))(obj)).Param != HotbarSize {
10947                 if err := pcall(func() {
10948                         ((*(*(struct {
10949                                 Param HotbarParam
10950
10951                                 //mt:if %s.Param == HotbarSize
10952                                 //mt:const uint16(4) // Size of Size field.
10953                                 Size int32
10954
10955                                 //mt:if %s.Param != HotbarSize
10956                                 Img Texture
10957                         }))(obj)).Img).serialize(w)
10958                 }); err != nil {
10959                         if err == io.EOF {
10960                                 chk(io.EOF)
10961                         }
10962                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
10963                 }
10964         }
10965 }
10966
10967 func (obj *ToCltSetHotbarParam) deserialize(r io.Reader) {
10968         if err := pcall(func() {
10969                 ((*(*(struct {
10970                         Param HotbarParam
10971
10972                         //mt:if %s.Param == HotbarSize
10973                         //mt:const uint16(4) // Size of Size field.
10974                         Size int32
10975
10976                         //mt:if %s.Param != HotbarSize
10977                         Img Texture
10978                 }))(obj)).Param).deserialize(r)
10979         }); err != nil {
10980                 if err == io.EOF {
10981                         chk(io.EOF)
10982                 }
10983                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HotbarParam", err))
10984         }
10985         if (*(*(struct {
10986                 Param HotbarParam
10987
10988                 //mt:if %s.Param == HotbarSize
10989                 //mt:const uint16(4) // Size of Size field.
10990                 Size int32
10991
10992                 //mt:if %s.Param != HotbarSize
10993                 Img Texture
10994         }))(obj)).Param == HotbarSize {
10995                 {
10996                         var local191 uint16
10997                         local192 := uint16(4) // Size of Size field.
10998                         {
10999                                 p := &local191
11000                                 *p = read16(r)
11001                         }
11002                         if local191 != local192 {
11003                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local191))
11004                         }
11005                 }
11006                 {
11007                         p := &(*(*(struct {
11008                                 Param HotbarParam
11009
11010                                 //mt:if %s.Param == HotbarSize
11011                                 //mt:const uint16(4) // Size of Size field.
11012                                 Size int32
11013
11014                                 //mt:if %s.Param != HotbarSize
11015                                 Img Texture
11016                         }))(obj)).Size
11017                         *p = int32(read32(r))
11018                 }
11019         }
11020         if (*(*(struct {
11021                 Param HotbarParam
11022
11023                 //mt:if %s.Param == HotbarSize
11024                 //mt:const uint16(4) // Size of Size field.
11025                 Size int32
11026
11027                 //mt:if %s.Param != HotbarSize
11028                 Img Texture
11029         }))(obj)).Param != HotbarSize {
11030                 if err := pcall(func() {
11031                         ((*(*(struct {
11032                                 Param HotbarParam
11033
11034                                 //mt:if %s.Param == HotbarSize
11035                                 //mt:const uint16(4) // Size of Size field.
11036                                 Size int32
11037
11038                                 //mt:if %s.Param != HotbarSize
11039                                 Img Texture
11040                         }))(obj)).Img).deserialize(r)
11041                 }); err != nil {
11042                         if err == io.EOF {
11043                                 chk(io.EOF)
11044                         }
11045                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
11046                 }
11047         }
11048 }
11049
11050 func (obj *ToCltBreath) serialize(w io.Writer) {
11051         {
11052                 x := (*(*(struct {
11053                         Breath uint16
11054                 }))(obj)).Breath
11055                 write16(w, uint16(x))
11056         }
11057 }
11058
11059 func (obj *ToCltBreath) deserialize(r io.Reader) {
11060         {
11061                 p := &(*(*(struct {
11062                         Breath uint16
11063                 }))(obj)).Breath
11064                 *p = read16(r)
11065         }
11066 }
11067
11068 func (obj *ToCltSkyParams) serialize(w io.Writer) {
11069         {
11070                 x := (*(*(struct {
11071                         BgColor     color.NRGBA
11072                         Type        string
11073                         Clouds      bool
11074                         SunFogTint  color.NRGBA
11075                         MoonFogTint color.NRGBA
11076                         FogTintType string
11077
11078                         //mt:if %s.Type == "skybox"
11079                         Textures []Texture
11080
11081                         //mt:if %s.Type == "regular"
11082                         DaySky, DayHorizon,
11083                         DawnSky, DawnHorizon,
11084                         NightSky, NightHorizon,
11085                         Indoor color.NRGBA
11086                 }))(obj)).BgColor
11087                 w.Write([]byte{x.A, x.R, x.G, x.B})
11088
11089         }
11090         if len(([]byte((*(*(struct {
11091                 BgColor     color.NRGBA
11092                 Type        string
11093                 Clouds      bool
11094                 SunFogTint  color.NRGBA
11095                 MoonFogTint color.NRGBA
11096                 FogTintType string
11097
11098                 //mt:if %s.Type == "skybox"
11099                 Textures []Texture
11100
11101                 //mt:if %s.Type == "regular"
11102                 DaySky, DayHorizon,
11103                 DawnSky, DawnHorizon,
11104                 NightSky, NightHorizon,
11105                 Indoor color.NRGBA
11106         }))(obj)).Type))) > math.MaxUint16 {
11107                 chk(ErrTooLong)
11108         }
11109         {
11110                 x := uint16(len(([]byte((*(*(struct {
11111                         BgColor     color.NRGBA
11112                         Type        string
11113                         Clouds      bool
11114                         SunFogTint  color.NRGBA
11115                         MoonFogTint color.NRGBA
11116                         FogTintType string
11117
11118                         //mt:if %s.Type == "skybox"
11119                         Textures []Texture
11120
11121                         //mt:if %s.Type == "regular"
11122                         DaySky, DayHorizon,
11123                         DawnSky, DawnHorizon,
11124                         NightSky, NightHorizon,
11125                         Indoor color.NRGBA
11126                 }))(obj)).Type))))
11127                 write16(w, uint16(x))
11128         }
11129         {
11130                 _, err := w.Write(([]byte((*(*(struct {
11131                         BgColor     color.NRGBA
11132                         Type        string
11133                         Clouds      bool
11134                         SunFogTint  color.NRGBA
11135                         MoonFogTint color.NRGBA
11136                         FogTintType string
11137
11138                         //mt:if %s.Type == "skybox"
11139                         Textures []Texture
11140
11141                         //mt:if %s.Type == "regular"
11142                         DaySky, DayHorizon,
11143                         DawnSky, DawnHorizon,
11144                         NightSky, NightHorizon,
11145                         Indoor color.NRGBA
11146                 }))(obj)).Type))[:])
11147                 chk(err)
11148         }
11149         {
11150                 x := (*(*(struct {
11151                         BgColor     color.NRGBA
11152                         Type        string
11153                         Clouds      bool
11154                         SunFogTint  color.NRGBA
11155                         MoonFogTint color.NRGBA
11156                         FogTintType string
11157
11158                         //mt:if %s.Type == "skybox"
11159                         Textures []Texture
11160
11161                         //mt:if %s.Type == "regular"
11162                         DaySky, DayHorizon,
11163                         DawnSky, DawnHorizon,
11164                         NightSky, NightHorizon,
11165                         Indoor color.NRGBA
11166                 }))(obj)).Clouds
11167                 if x {
11168                         write8(w, 1)
11169                 } else {
11170                         write8(w, 0)
11171                 }
11172
11173         }
11174         {
11175                 x := (*(*(struct {
11176                         BgColor     color.NRGBA
11177                         Type        string
11178                         Clouds      bool
11179                         SunFogTint  color.NRGBA
11180                         MoonFogTint color.NRGBA
11181                         FogTintType string
11182
11183                         //mt:if %s.Type == "skybox"
11184                         Textures []Texture
11185
11186                         //mt:if %s.Type == "regular"
11187                         DaySky, DayHorizon,
11188                         DawnSky, DawnHorizon,
11189                         NightSky, NightHorizon,
11190                         Indoor color.NRGBA
11191                 }))(obj)).SunFogTint
11192                 w.Write([]byte{x.A, x.R, x.G, x.B})
11193
11194         }
11195         {
11196                 x := (*(*(struct {
11197                         BgColor     color.NRGBA
11198                         Type        string
11199                         Clouds      bool
11200                         SunFogTint  color.NRGBA
11201                         MoonFogTint color.NRGBA
11202                         FogTintType string
11203
11204                         //mt:if %s.Type == "skybox"
11205                         Textures []Texture
11206
11207                         //mt:if %s.Type == "regular"
11208                         DaySky, DayHorizon,
11209                         DawnSky, DawnHorizon,
11210                         NightSky, NightHorizon,
11211                         Indoor color.NRGBA
11212                 }))(obj)).MoonFogTint
11213                 w.Write([]byte{x.A, x.R, x.G, x.B})
11214
11215         }
11216         if len(([]byte((*(*(struct {
11217                 BgColor     color.NRGBA
11218                 Type        string
11219                 Clouds      bool
11220                 SunFogTint  color.NRGBA
11221                 MoonFogTint color.NRGBA
11222                 FogTintType string
11223
11224                 //mt:if %s.Type == "skybox"
11225                 Textures []Texture
11226
11227                 //mt:if %s.Type == "regular"
11228                 DaySky, DayHorizon,
11229                 DawnSky, DawnHorizon,
11230                 NightSky, NightHorizon,
11231                 Indoor color.NRGBA
11232         }))(obj)).FogTintType))) > math.MaxUint16 {
11233                 chk(ErrTooLong)
11234         }
11235         {
11236                 x := uint16(len(([]byte((*(*(struct {
11237                         BgColor     color.NRGBA
11238                         Type        string
11239                         Clouds      bool
11240                         SunFogTint  color.NRGBA
11241                         MoonFogTint color.NRGBA
11242                         FogTintType string
11243
11244                         //mt:if %s.Type == "skybox"
11245                         Textures []Texture
11246
11247                         //mt:if %s.Type == "regular"
11248                         DaySky, DayHorizon,
11249                         DawnSky, DawnHorizon,
11250                         NightSky, NightHorizon,
11251                         Indoor color.NRGBA
11252                 }))(obj)).FogTintType))))
11253                 write16(w, uint16(x))
11254         }
11255         {
11256                 _, err := w.Write(([]byte((*(*(struct {
11257                         BgColor     color.NRGBA
11258                         Type        string
11259                         Clouds      bool
11260                         SunFogTint  color.NRGBA
11261                         MoonFogTint color.NRGBA
11262                         FogTintType string
11263
11264                         //mt:if %s.Type == "skybox"
11265                         Textures []Texture
11266
11267                         //mt:if %s.Type == "regular"
11268                         DaySky, DayHorizon,
11269                         DawnSky, DawnHorizon,
11270                         NightSky, NightHorizon,
11271                         Indoor color.NRGBA
11272                 }))(obj)).FogTintType))[:])
11273                 chk(err)
11274         }
11275         if (*(*(struct {
11276                 BgColor     color.NRGBA
11277                 Type        string
11278                 Clouds      bool
11279                 SunFogTint  color.NRGBA
11280                 MoonFogTint color.NRGBA
11281                 FogTintType string
11282
11283                 //mt:if %s.Type == "skybox"
11284                 Textures []Texture
11285
11286                 //mt:if %s.Type == "regular"
11287                 DaySky, DayHorizon,
11288                 DawnSky, DawnHorizon,
11289                 NightSky, NightHorizon,
11290                 Indoor color.NRGBA
11291         }))(obj)).Type == "skybox" {
11292                 if len(((*(*(struct {
11293                         BgColor     color.NRGBA
11294                         Type        string
11295                         Clouds      bool
11296                         SunFogTint  color.NRGBA
11297                         MoonFogTint color.NRGBA
11298                         FogTintType string
11299
11300                         //mt:if %s.Type == "skybox"
11301                         Textures []Texture
11302
11303                         //mt:if %s.Type == "regular"
11304                         DaySky, DayHorizon,
11305                         DawnSky, DawnHorizon,
11306                         NightSky, NightHorizon,
11307                         Indoor color.NRGBA
11308                 }))(obj)).Textures)) > math.MaxUint16 {
11309                         chk(ErrTooLong)
11310                 }
11311                 {
11312                         x := uint16(len(((*(*(struct {
11313                                 BgColor     color.NRGBA
11314                                 Type        string
11315                                 Clouds      bool
11316                                 SunFogTint  color.NRGBA
11317                                 MoonFogTint color.NRGBA
11318                                 FogTintType string
11319
11320                                 //mt:if %s.Type == "skybox"
11321                                 Textures []Texture
11322
11323                                 //mt:if %s.Type == "regular"
11324                                 DaySky, DayHorizon,
11325                                 DawnSky, DawnHorizon,
11326                                 NightSky, NightHorizon,
11327                                 Indoor color.NRGBA
11328                         }))(obj)).Textures)))
11329                         write16(w, uint16(x))
11330                 }
11331                 for local193 := range (*(*(struct {
11332                         BgColor     color.NRGBA
11333                         Type        string
11334                         Clouds      bool
11335                         SunFogTint  color.NRGBA
11336                         MoonFogTint color.NRGBA
11337                         FogTintType string
11338
11339                         //mt:if %s.Type == "skybox"
11340                         Textures []Texture
11341
11342                         //mt:if %s.Type == "regular"
11343                         DaySky, DayHorizon,
11344                         DawnSky, DawnHorizon,
11345                         NightSky, NightHorizon,
11346                         Indoor color.NRGBA
11347                 }))(obj)).Textures {
11348                         if err := pcall(func() {
11349                                 (((*(*(struct {
11350                                         BgColor     color.NRGBA
11351                                         Type        string
11352                                         Clouds      bool
11353                                         SunFogTint  color.NRGBA
11354                                         MoonFogTint color.NRGBA
11355                                         FogTintType string
11356
11357                                         //mt:if %s.Type == "skybox"
11358                                         Textures []Texture
11359
11360                                         //mt:if %s.Type == "regular"
11361                                         DaySky, DayHorizon,
11362                                         DawnSky, DawnHorizon,
11363                                         NightSky, NightHorizon,
11364                                         Indoor color.NRGBA
11365                                 }))(obj)).Textures)[local193]).serialize(w)
11366                         }); err != nil {
11367                                 if err == io.EOF {
11368                                         chk(io.EOF)
11369                                 }
11370                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
11371                         }
11372                 }
11373         }
11374         if (*(*(struct {
11375                 BgColor     color.NRGBA
11376                 Type        string
11377                 Clouds      bool
11378                 SunFogTint  color.NRGBA
11379                 MoonFogTint color.NRGBA
11380                 FogTintType string
11381
11382                 //mt:if %s.Type == "skybox"
11383                 Textures []Texture
11384
11385                 //mt:if %s.Type == "regular"
11386                 DaySky, DayHorizon,
11387                 DawnSky, DawnHorizon,
11388                 NightSky, NightHorizon,
11389                 Indoor color.NRGBA
11390         }))(obj)).Type == "regular" {
11391                 {
11392                         x := (*(*(struct {
11393                                 BgColor     color.NRGBA
11394                                 Type        string
11395                                 Clouds      bool
11396                                 SunFogTint  color.NRGBA
11397                                 MoonFogTint color.NRGBA
11398                                 FogTintType string
11399
11400                                 //mt:if %s.Type == "skybox"
11401                                 Textures []Texture
11402
11403                                 //mt:if %s.Type == "regular"
11404                                 DaySky, DayHorizon,
11405                                 DawnSky, DawnHorizon,
11406                                 NightSky, NightHorizon,
11407                                 Indoor color.NRGBA
11408                         }))(obj)).DaySky
11409                         w.Write([]byte{x.A, x.R, x.G, x.B})
11410
11411                 }
11412                 {
11413                         x := (*(*(struct {
11414                                 BgColor     color.NRGBA
11415                                 Type        string
11416                                 Clouds      bool
11417                                 SunFogTint  color.NRGBA
11418                                 MoonFogTint color.NRGBA
11419                                 FogTintType string
11420
11421                                 //mt:if %s.Type == "skybox"
11422                                 Textures []Texture
11423
11424                                 //mt:if %s.Type == "regular"
11425                                 DaySky, DayHorizon,
11426                                 DawnSky, DawnHorizon,
11427                                 NightSky, NightHorizon,
11428                                 Indoor color.NRGBA
11429                         }))(obj)).DayHorizon
11430                         w.Write([]byte{x.A, x.R, x.G, x.B})
11431
11432                 }
11433                 {
11434                         x := (*(*(struct {
11435                                 BgColor     color.NRGBA
11436                                 Type        string
11437                                 Clouds      bool
11438                                 SunFogTint  color.NRGBA
11439                                 MoonFogTint color.NRGBA
11440                                 FogTintType string
11441
11442                                 //mt:if %s.Type == "skybox"
11443                                 Textures []Texture
11444
11445                                 //mt:if %s.Type == "regular"
11446                                 DaySky, DayHorizon,
11447                                 DawnSky, DawnHorizon,
11448                                 NightSky, NightHorizon,
11449                                 Indoor color.NRGBA
11450                         }))(obj)).DawnSky
11451                         w.Write([]byte{x.A, x.R, x.G, x.B})
11452
11453                 }
11454                 {
11455                         x := (*(*(struct {
11456                                 BgColor     color.NRGBA
11457                                 Type        string
11458                                 Clouds      bool
11459                                 SunFogTint  color.NRGBA
11460                                 MoonFogTint color.NRGBA
11461                                 FogTintType string
11462
11463                                 //mt:if %s.Type == "skybox"
11464                                 Textures []Texture
11465
11466                                 //mt:if %s.Type == "regular"
11467                                 DaySky, DayHorizon,
11468                                 DawnSky, DawnHorizon,
11469                                 NightSky, NightHorizon,
11470                                 Indoor color.NRGBA
11471                         }))(obj)).DawnHorizon
11472                         w.Write([]byte{x.A, x.R, x.G, x.B})
11473
11474                 }
11475                 {
11476                         x := (*(*(struct {
11477                                 BgColor     color.NRGBA
11478                                 Type        string
11479                                 Clouds      bool
11480                                 SunFogTint  color.NRGBA
11481                                 MoonFogTint color.NRGBA
11482                                 FogTintType string
11483
11484                                 //mt:if %s.Type == "skybox"
11485                                 Textures []Texture
11486
11487                                 //mt:if %s.Type == "regular"
11488                                 DaySky, DayHorizon,
11489                                 DawnSky, DawnHorizon,
11490                                 NightSky, NightHorizon,
11491                                 Indoor color.NRGBA
11492                         }))(obj)).NightSky
11493                         w.Write([]byte{x.A, x.R, x.G, x.B})
11494
11495                 }
11496                 {
11497                         x := (*(*(struct {
11498                                 BgColor     color.NRGBA
11499                                 Type        string
11500                                 Clouds      bool
11501                                 SunFogTint  color.NRGBA
11502                                 MoonFogTint color.NRGBA
11503                                 FogTintType string
11504
11505                                 //mt:if %s.Type == "skybox"
11506                                 Textures []Texture
11507
11508                                 //mt:if %s.Type == "regular"
11509                                 DaySky, DayHorizon,
11510                                 DawnSky, DawnHorizon,
11511                                 NightSky, NightHorizon,
11512                                 Indoor color.NRGBA
11513                         }))(obj)).NightHorizon
11514                         w.Write([]byte{x.A, x.R, x.G, x.B})
11515
11516                 }
11517                 {
11518                         x := (*(*(struct {
11519                                 BgColor     color.NRGBA
11520                                 Type        string
11521                                 Clouds      bool
11522                                 SunFogTint  color.NRGBA
11523                                 MoonFogTint color.NRGBA
11524                                 FogTintType string
11525
11526                                 //mt:if %s.Type == "skybox"
11527                                 Textures []Texture
11528
11529                                 //mt:if %s.Type == "regular"
11530                                 DaySky, DayHorizon,
11531                                 DawnSky, DawnHorizon,
11532                                 NightSky, NightHorizon,
11533                                 Indoor color.NRGBA
11534                         }))(obj)).Indoor
11535                         w.Write([]byte{x.A, x.R, x.G, x.B})
11536
11537                 }
11538         }
11539 }
11540
11541 func (obj *ToCltSkyParams) deserialize(r io.Reader) {
11542         {
11543                 p := &(*(*(struct {
11544                         BgColor     color.NRGBA
11545                         Type        string
11546                         Clouds      bool
11547                         SunFogTint  color.NRGBA
11548                         MoonFogTint color.NRGBA
11549                         FogTintType string
11550
11551                         //mt:if %s.Type == "skybox"
11552                         Textures []Texture
11553
11554                         //mt:if %s.Type == "regular"
11555                         DaySky, DayHorizon,
11556                         DawnSky, DawnHorizon,
11557                         NightSky, NightHorizon,
11558                         Indoor color.NRGBA
11559                 }))(obj)).BgColor
11560                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11561
11562         }
11563         var local194 []uint8
11564         var local195 uint16
11565         {
11566                 p := &local195
11567                 *p = read16(r)
11568         }
11569         (local194) = make([]uint8, local195)
11570         {
11571                 _, err := io.ReadFull(r, (local194)[:])
11572                 chk(err)
11573         }
11574         ((*(*(struct {
11575                 BgColor     color.NRGBA
11576                 Type        string
11577                 Clouds      bool
11578                 SunFogTint  color.NRGBA
11579                 MoonFogTint color.NRGBA
11580                 FogTintType string
11581
11582                 //mt:if %s.Type == "skybox"
11583                 Textures []Texture
11584
11585                 //mt:if %s.Type == "regular"
11586                 DaySky, DayHorizon,
11587                 DawnSky, DawnHorizon,
11588                 NightSky, NightHorizon,
11589                 Indoor color.NRGBA
11590         }))(obj)).Type) = string(local194)
11591         {
11592                 p := &(*(*(struct {
11593                         BgColor     color.NRGBA
11594                         Type        string
11595                         Clouds      bool
11596                         SunFogTint  color.NRGBA
11597                         MoonFogTint color.NRGBA
11598                         FogTintType string
11599
11600                         //mt:if %s.Type == "skybox"
11601                         Textures []Texture
11602
11603                         //mt:if %s.Type == "regular"
11604                         DaySky, DayHorizon,
11605                         DawnSky, DawnHorizon,
11606                         NightSky, NightHorizon,
11607                         Indoor color.NRGBA
11608                 }))(obj)).Clouds
11609                 switch n := read8(r); n {
11610                 case 0:
11611                         *p = false
11612                 case 1:
11613                         *p = true
11614                 default:
11615                         chk(fmt.Errorf("invalid bool: %d", n))
11616                 }
11617
11618         }
11619         {
11620                 p := &(*(*(struct {
11621                         BgColor     color.NRGBA
11622                         Type        string
11623                         Clouds      bool
11624                         SunFogTint  color.NRGBA
11625                         MoonFogTint color.NRGBA
11626                         FogTintType string
11627
11628                         //mt:if %s.Type == "skybox"
11629                         Textures []Texture
11630
11631                         //mt:if %s.Type == "regular"
11632                         DaySky, DayHorizon,
11633                         DawnSky, DawnHorizon,
11634                         NightSky, NightHorizon,
11635                         Indoor color.NRGBA
11636                 }))(obj)).SunFogTint
11637                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11638
11639         }
11640         {
11641                 p := &(*(*(struct {
11642                         BgColor     color.NRGBA
11643                         Type        string
11644                         Clouds      bool
11645                         SunFogTint  color.NRGBA
11646                         MoonFogTint color.NRGBA
11647                         FogTintType string
11648
11649                         //mt:if %s.Type == "skybox"
11650                         Textures []Texture
11651
11652                         //mt:if %s.Type == "regular"
11653                         DaySky, DayHorizon,
11654                         DawnSky, DawnHorizon,
11655                         NightSky, NightHorizon,
11656                         Indoor color.NRGBA
11657                 }))(obj)).MoonFogTint
11658                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11659
11660         }
11661         var local196 []uint8
11662         var local197 uint16
11663         {
11664                 p := &local197
11665                 *p = read16(r)
11666         }
11667         (local196) = make([]uint8, local197)
11668         {
11669                 _, err := io.ReadFull(r, (local196)[:])
11670                 chk(err)
11671         }
11672         ((*(*(struct {
11673                 BgColor     color.NRGBA
11674                 Type        string
11675                 Clouds      bool
11676                 SunFogTint  color.NRGBA
11677                 MoonFogTint color.NRGBA
11678                 FogTintType string
11679
11680                 //mt:if %s.Type == "skybox"
11681                 Textures []Texture
11682
11683                 //mt:if %s.Type == "regular"
11684                 DaySky, DayHorizon,
11685                 DawnSky, DawnHorizon,
11686                 NightSky, NightHorizon,
11687                 Indoor color.NRGBA
11688         }))(obj)).FogTintType) = string(local196)
11689         if (*(*(struct {
11690                 BgColor     color.NRGBA
11691                 Type        string
11692                 Clouds      bool
11693                 SunFogTint  color.NRGBA
11694                 MoonFogTint color.NRGBA
11695                 FogTintType string
11696
11697                 //mt:if %s.Type == "skybox"
11698                 Textures []Texture
11699
11700                 //mt:if %s.Type == "regular"
11701                 DaySky, DayHorizon,
11702                 DawnSky, DawnHorizon,
11703                 NightSky, NightHorizon,
11704                 Indoor color.NRGBA
11705         }))(obj)).Type == "skybox" {
11706                 var local198 uint16
11707                 {
11708                         p := &local198
11709                         *p = read16(r)
11710                 }
11711                 ((*(*(struct {
11712                         BgColor     color.NRGBA
11713                         Type        string
11714                         Clouds      bool
11715                         SunFogTint  color.NRGBA
11716                         MoonFogTint color.NRGBA
11717                         FogTintType string
11718
11719                         //mt:if %s.Type == "skybox"
11720                         Textures []Texture
11721
11722                         //mt:if %s.Type == "regular"
11723                         DaySky, DayHorizon,
11724                         DawnSky, DawnHorizon,
11725                         NightSky, NightHorizon,
11726                         Indoor color.NRGBA
11727                 }))(obj)).Textures) = make([]Texture, local198)
11728                 for local199 := range (*(*(struct {
11729                         BgColor     color.NRGBA
11730                         Type        string
11731                         Clouds      bool
11732                         SunFogTint  color.NRGBA
11733                         MoonFogTint color.NRGBA
11734                         FogTintType string
11735
11736                         //mt:if %s.Type == "skybox"
11737                         Textures []Texture
11738
11739                         //mt:if %s.Type == "regular"
11740                         DaySky, DayHorizon,
11741                         DawnSky, DawnHorizon,
11742                         NightSky, NightHorizon,
11743                         Indoor color.NRGBA
11744                 }))(obj)).Textures {
11745                         if err := pcall(func() {
11746                                 (((*(*(struct {
11747                                         BgColor     color.NRGBA
11748                                         Type        string
11749                                         Clouds      bool
11750                                         SunFogTint  color.NRGBA
11751                                         MoonFogTint color.NRGBA
11752                                         FogTintType string
11753
11754                                         //mt:if %s.Type == "skybox"
11755                                         Textures []Texture
11756
11757                                         //mt:if %s.Type == "regular"
11758                                         DaySky, DayHorizon,
11759                                         DawnSky, DawnHorizon,
11760                                         NightSky, NightHorizon,
11761                                         Indoor color.NRGBA
11762                                 }))(obj)).Textures)[local199]).deserialize(r)
11763                         }); err != nil {
11764                                 if err == io.EOF {
11765                                         chk(io.EOF)
11766                                 }
11767                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
11768                         }
11769                 }
11770         }
11771         if (*(*(struct {
11772                 BgColor     color.NRGBA
11773                 Type        string
11774                 Clouds      bool
11775                 SunFogTint  color.NRGBA
11776                 MoonFogTint color.NRGBA
11777                 FogTintType string
11778
11779                 //mt:if %s.Type == "skybox"
11780                 Textures []Texture
11781
11782                 //mt:if %s.Type == "regular"
11783                 DaySky, DayHorizon,
11784                 DawnSky, DawnHorizon,
11785                 NightSky, NightHorizon,
11786                 Indoor color.NRGBA
11787         }))(obj)).Type == "regular" {
11788                 {
11789                         p := &(*(*(struct {
11790                                 BgColor     color.NRGBA
11791                                 Type        string
11792                                 Clouds      bool
11793                                 SunFogTint  color.NRGBA
11794                                 MoonFogTint color.NRGBA
11795                                 FogTintType string
11796
11797                                 //mt:if %s.Type == "skybox"
11798                                 Textures []Texture
11799
11800                                 //mt:if %s.Type == "regular"
11801                                 DaySky, DayHorizon,
11802                                 DawnSky, DawnHorizon,
11803                                 NightSky, NightHorizon,
11804                                 Indoor color.NRGBA
11805                         }))(obj)).DaySky
11806                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11807
11808                 }
11809                 {
11810                         p := &(*(*(struct {
11811                                 BgColor     color.NRGBA
11812                                 Type        string
11813                                 Clouds      bool
11814                                 SunFogTint  color.NRGBA
11815                                 MoonFogTint color.NRGBA
11816                                 FogTintType string
11817
11818                                 //mt:if %s.Type == "skybox"
11819                                 Textures []Texture
11820
11821                                 //mt:if %s.Type == "regular"
11822                                 DaySky, DayHorizon,
11823                                 DawnSky, DawnHorizon,
11824                                 NightSky, NightHorizon,
11825                                 Indoor color.NRGBA
11826                         }))(obj)).DayHorizon
11827                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11828
11829                 }
11830                 {
11831                         p := &(*(*(struct {
11832                                 BgColor     color.NRGBA
11833                                 Type        string
11834                                 Clouds      bool
11835                                 SunFogTint  color.NRGBA
11836                                 MoonFogTint color.NRGBA
11837                                 FogTintType string
11838
11839                                 //mt:if %s.Type == "skybox"
11840                                 Textures []Texture
11841
11842                                 //mt:if %s.Type == "regular"
11843                                 DaySky, DayHorizon,
11844                                 DawnSky, DawnHorizon,
11845                                 NightSky, NightHorizon,
11846                                 Indoor color.NRGBA
11847                         }))(obj)).DawnSky
11848                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11849
11850                 }
11851                 {
11852                         p := &(*(*(struct {
11853                                 BgColor     color.NRGBA
11854                                 Type        string
11855                                 Clouds      bool
11856                                 SunFogTint  color.NRGBA
11857                                 MoonFogTint color.NRGBA
11858                                 FogTintType string
11859
11860                                 //mt:if %s.Type == "skybox"
11861                                 Textures []Texture
11862
11863                                 //mt:if %s.Type == "regular"
11864                                 DaySky, DayHorizon,
11865                                 DawnSky, DawnHorizon,
11866                                 NightSky, NightHorizon,
11867                                 Indoor color.NRGBA
11868                         }))(obj)).DawnHorizon
11869                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11870
11871                 }
11872                 {
11873                         p := &(*(*(struct {
11874                                 BgColor     color.NRGBA
11875                                 Type        string
11876                                 Clouds      bool
11877                                 SunFogTint  color.NRGBA
11878                                 MoonFogTint color.NRGBA
11879                                 FogTintType string
11880
11881                                 //mt:if %s.Type == "skybox"
11882                                 Textures []Texture
11883
11884                                 //mt:if %s.Type == "regular"
11885                                 DaySky, DayHorizon,
11886                                 DawnSky, DawnHorizon,
11887                                 NightSky, NightHorizon,
11888                                 Indoor color.NRGBA
11889                         }))(obj)).NightSky
11890                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11891
11892                 }
11893                 {
11894                         p := &(*(*(struct {
11895                                 BgColor     color.NRGBA
11896                                 Type        string
11897                                 Clouds      bool
11898                                 SunFogTint  color.NRGBA
11899                                 MoonFogTint color.NRGBA
11900                                 FogTintType string
11901
11902                                 //mt:if %s.Type == "skybox"
11903                                 Textures []Texture
11904
11905                                 //mt:if %s.Type == "regular"
11906                                 DaySky, DayHorizon,
11907                                 DawnSky, DawnHorizon,
11908                                 NightSky, NightHorizon,
11909                                 Indoor color.NRGBA
11910                         }))(obj)).NightHorizon
11911                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11912
11913                 }
11914                 {
11915                         p := &(*(*(struct {
11916                                 BgColor     color.NRGBA
11917                                 Type        string
11918                                 Clouds      bool
11919                                 SunFogTint  color.NRGBA
11920                                 MoonFogTint color.NRGBA
11921                                 FogTintType string
11922
11923                                 //mt:if %s.Type == "skybox"
11924                                 Textures []Texture
11925
11926                                 //mt:if %s.Type == "regular"
11927                                 DaySky, DayHorizon,
11928                                 DawnSky, DawnHorizon,
11929                                 NightSky, NightHorizon,
11930                                 Indoor color.NRGBA
11931                         }))(obj)).Indoor
11932                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11933
11934                 }
11935         }
11936 }
11937
11938 func (obj *ToCltOverrideDayNightRatio) serialize(w io.Writer) {
11939         {
11940                 x := (*(*(struct {
11941                         Override bool
11942                         Ratio    uint16
11943                 }))(obj)).Override
11944                 if x {
11945                         write8(w, 1)
11946                 } else {
11947                         write8(w, 0)
11948                 }
11949
11950         }
11951         {
11952                 x := (*(*(struct {
11953                         Override bool
11954                         Ratio    uint16
11955                 }))(obj)).Ratio
11956                 write16(w, uint16(x))
11957         }
11958 }
11959
11960 func (obj *ToCltOverrideDayNightRatio) deserialize(r io.Reader) {
11961         {
11962                 p := &(*(*(struct {
11963                         Override bool
11964                         Ratio    uint16
11965                 }))(obj)).Override
11966                 switch n := read8(r); n {
11967                 case 0:
11968                         *p = false
11969                 case 1:
11970                         *p = true
11971                 default:
11972                         chk(fmt.Errorf("invalid bool: %d", n))
11973                 }
11974
11975         }
11976         {
11977                 p := &(*(*(struct {
11978                         Override bool
11979                         Ratio    uint16
11980                 }))(obj)).Ratio
11981                 *p = read16(r)
11982         }
11983 }
11984
11985 func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
11986         for local200 := range (*(*(struct {
11987                 Idle, Walk, Dig, WalkDig [2]int32
11988                 Speed                    float32
11989         }))(obj)).Idle {
11990                 {
11991                         x := ((*(*(struct {
11992                                 Idle, Walk, Dig, WalkDig [2]int32
11993                                 Speed                    float32
11994                         }))(obj)).Idle)[local200]
11995                         write32(w, uint32(x))
11996                 }
11997         }
11998         for local201 := range (*(*(struct {
11999                 Idle, Walk, Dig, WalkDig [2]int32
12000                 Speed                    float32
12001         }))(obj)).Walk {
12002                 {
12003                         x := ((*(*(struct {
12004                                 Idle, Walk, Dig, WalkDig [2]int32
12005                                 Speed                    float32
12006                         }))(obj)).Walk)[local201]
12007                         write32(w, uint32(x))
12008                 }
12009         }
12010         for local202 := range (*(*(struct {
12011                 Idle, Walk, Dig, WalkDig [2]int32
12012                 Speed                    float32
12013         }))(obj)).Dig {
12014                 {
12015                         x := ((*(*(struct {
12016                                 Idle, Walk, Dig, WalkDig [2]int32
12017                                 Speed                    float32
12018                         }))(obj)).Dig)[local202]
12019                         write32(w, uint32(x))
12020                 }
12021         }
12022         for local203 := range (*(*(struct {
12023                 Idle, Walk, Dig, WalkDig [2]int32
12024                 Speed                    float32
12025         }))(obj)).WalkDig {
12026                 {
12027                         x := ((*(*(struct {
12028                                 Idle, Walk, Dig, WalkDig [2]int32
12029                                 Speed                    float32
12030                         }))(obj)).WalkDig)[local203]
12031                         write32(w, uint32(x))
12032                 }
12033         }
12034         {
12035                 x := (*(*(struct {
12036                         Idle, Walk, Dig, WalkDig [2]int32
12037                         Speed                    float32
12038                 }))(obj)).Speed
12039                 write32(w, math.Float32bits(x))
12040         }
12041 }
12042
12043 func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
12044         for local204 := range (*(*(struct {
12045                 Idle, Walk, Dig, WalkDig [2]int32
12046                 Speed                    float32
12047         }))(obj)).Idle {
12048                 {
12049                         p := &((*(*(struct {
12050                                 Idle, Walk, Dig, WalkDig [2]int32
12051                                 Speed                    float32
12052                         }))(obj)).Idle)[local204]
12053                         *p = int32(read32(r))
12054                 }
12055         }
12056         for local205 := range (*(*(struct {
12057                 Idle, Walk, Dig, WalkDig [2]int32
12058                 Speed                    float32
12059         }))(obj)).Walk {
12060                 {
12061                         p := &((*(*(struct {
12062                                 Idle, Walk, Dig, WalkDig [2]int32
12063                                 Speed                    float32
12064                         }))(obj)).Walk)[local205]
12065                         *p = int32(read32(r))
12066                 }
12067         }
12068         for local206 := range (*(*(struct {
12069                 Idle, Walk, Dig, WalkDig [2]int32
12070                 Speed                    float32
12071         }))(obj)).Dig {
12072                 {
12073                         p := &((*(*(struct {
12074                                 Idle, Walk, Dig, WalkDig [2]int32
12075                                 Speed                    float32
12076                         }))(obj)).Dig)[local206]
12077                         *p = int32(read32(r))
12078                 }
12079         }
12080         for local207 := range (*(*(struct {
12081                 Idle, Walk, Dig, WalkDig [2]int32
12082                 Speed                    float32
12083         }))(obj)).WalkDig {
12084                 {
12085                         p := &((*(*(struct {
12086                                 Idle, Walk, Dig, WalkDig [2]int32
12087                                 Speed                    float32
12088                         }))(obj)).WalkDig)[local207]
12089                         *p = int32(read32(r))
12090                 }
12091         }
12092         {
12093                 p := &(*(*(struct {
12094                         Idle, Walk, Dig, WalkDig [2]int32
12095                         Speed                    float32
12096                 }))(obj)).Speed
12097                 *p = math.Float32frombits(read32(r))
12098         }
12099 }
12100
12101 func (obj *ToCltEyeOffset) serialize(w io.Writer) {
12102         if err := pcall(func() {
12103                 ((*(*(struct {
12104                         First, Third Vec
12105                 }))(obj)).First).serialize(w)
12106         }); err != nil {
12107                 if err == io.EOF {
12108                         chk(io.EOF)
12109                 }
12110                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12111         }
12112         if err := pcall(func() {
12113                 ((*(*(struct {
12114                         First, Third Vec
12115                 }))(obj)).Third).serialize(w)
12116         }); err != nil {
12117                 if err == io.EOF {
12118                         chk(io.EOF)
12119                 }
12120                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12121         }
12122 }
12123
12124 func (obj *ToCltEyeOffset) deserialize(r io.Reader) {
12125         if err := pcall(func() {
12126                 ((*(*(struct {
12127                         First, Third Vec
12128                 }))(obj)).First).deserialize(r)
12129         }); err != nil {
12130                 if err == io.EOF {
12131                         chk(io.EOF)
12132                 }
12133                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12134         }
12135         if err := pcall(func() {
12136                 ((*(*(struct {
12137                         First, Third Vec
12138                 }))(obj)).Third).deserialize(r)
12139         }); err != nil {
12140                 if err == io.EOF {
12141                         chk(io.EOF)
12142                 }
12143                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12144         }
12145 }
12146
12147 func (obj *ToCltDelParticleSpawner) serialize(w io.Writer) {
12148         if err := pcall(func() {
12149                 ((*(*(struct {
12150                         ID ParticleSpawnerID
12151                 }))(obj)).ID).serialize(w)
12152         }); err != nil {
12153                 if err == io.EOF {
12154                         chk(io.EOF)
12155                 }
12156                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
12157         }
12158 }
12159
12160 func (obj *ToCltDelParticleSpawner) deserialize(r io.Reader) {
12161         if err := pcall(func() {
12162                 ((*(*(struct {
12163                         ID ParticleSpawnerID
12164                 }))(obj)).ID).deserialize(r)
12165         }); err != nil {
12166                 if err == io.EOF {
12167                         chk(io.EOF)
12168                 }
12169                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
12170         }
12171 }
12172
12173 func (obj *ToCltCloudParams) serialize(w io.Writer) {
12174         {
12175                 x := (*(*(struct {
12176                         Density      float32
12177                         DiffuseColor color.NRGBA
12178                         AmbientColor color.NRGBA
12179                         Height       float32
12180                         Thickness    float32
12181                         Speed        [2]float32
12182                 }))(obj)).Density
12183                 write32(w, math.Float32bits(x))
12184         }
12185         {
12186                 x := (*(*(struct {
12187                         Density      float32
12188                         DiffuseColor color.NRGBA
12189                         AmbientColor color.NRGBA
12190                         Height       float32
12191                         Thickness    float32
12192                         Speed        [2]float32
12193                 }))(obj)).DiffuseColor
12194                 w.Write([]byte{x.A, x.R, x.G, x.B})
12195
12196         }
12197         {
12198                 x := (*(*(struct {
12199                         Density      float32
12200                         DiffuseColor color.NRGBA
12201                         AmbientColor color.NRGBA
12202                         Height       float32
12203                         Thickness    float32
12204                         Speed        [2]float32
12205                 }))(obj)).AmbientColor
12206                 w.Write([]byte{x.A, x.R, x.G, x.B})
12207
12208         }
12209         {
12210                 x := (*(*(struct {
12211                         Density      float32
12212                         DiffuseColor color.NRGBA
12213                         AmbientColor color.NRGBA
12214                         Height       float32
12215                         Thickness    float32
12216                         Speed        [2]float32
12217                 }))(obj)).Height
12218                 write32(w, math.Float32bits(x))
12219         }
12220         {
12221                 x := (*(*(struct {
12222                         Density      float32
12223                         DiffuseColor color.NRGBA
12224                         AmbientColor color.NRGBA
12225                         Height       float32
12226                         Thickness    float32
12227                         Speed        [2]float32
12228                 }))(obj)).Thickness
12229                 write32(w, math.Float32bits(x))
12230         }
12231         for local208 := range (*(*(struct {
12232                 Density      float32
12233                 DiffuseColor color.NRGBA
12234                 AmbientColor color.NRGBA
12235                 Height       float32
12236                 Thickness    float32
12237                 Speed        [2]float32
12238         }))(obj)).Speed {
12239                 {
12240                         x := ((*(*(struct {
12241                                 Density      float32
12242                                 DiffuseColor color.NRGBA
12243                                 AmbientColor color.NRGBA
12244                                 Height       float32
12245                                 Thickness    float32
12246                                 Speed        [2]float32
12247                         }))(obj)).Speed)[local208]
12248                         write32(w, math.Float32bits(x))
12249                 }
12250         }
12251 }
12252
12253 func (obj *ToCltCloudParams) deserialize(r io.Reader) {
12254         {
12255                 p := &(*(*(struct {
12256                         Density      float32
12257                         DiffuseColor color.NRGBA
12258                         AmbientColor color.NRGBA
12259                         Height       float32
12260                         Thickness    float32
12261                         Speed        [2]float32
12262                 }))(obj)).Density
12263                 *p = math.Float32frombits(read32(r))
12264         }
12265         {
12266                 p := &(*(*(struct {
12267                         Density      float32
12268                         DiffuseColor color.NRGBA
12269                         AmbientColor color.NRGBA
12270                         Height       float32
12271                         Thickness    float32
12272                         Speed        [2]float32
12273                 }))(obj)).DiffuseColor
12274                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12275
12276         }
12277         {
12278                 p := &(*(*(struct {
12279                         Density      float32
12280                         DiffuseColor color.NRGBA
12281                         AmbientColor color.NRGBA
12282                         Height       float32
12283                         Thickness    float32
12284                         Speed        [2]float32
12285                 }))(obj)).AmbientColor
12286                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12287
12288         }
12289         {
12290                 p := &(*(*(struct {
12291                         Density      float32
12292                         DiffuseColor color.NRGBA
12293                         AmbientColor color.NRGBA
12294                         Height       float32
12295                         Thickness    float32
12296                         Speed        [2]float32
12297                 }))(obj)).Height
12298                 *p = math.Float32frombits(read32(r))
12299         }
12300         {
12301                 p := &(*(*(struct {
12302                         Density      float32
12303                         DiffuseColor color.NRGBA
12304                         AmbientColor color.NRGBA
12305                         Height       float32
12306                         Thickness    float32
12307                         Speed        [2]float32
12308                 }))(obj)).Thickness
12309                 *p = math.Float32frombits(read32(r))
12310         }
12311         for local209 := range (*(*(struct {
12312                 Density      float32
12313                 DiffuseColor color.NRGBA
12314                 AmbientColor color.NRGBA
12315                 Height       float32
12316                 Thickness    float32
12317                 Speed        [2]float32
12318         }))(obj)).Speed {
12319                 {
12320                         p := &((*(*(struct {
12321                                 Density      float32
12322                                 DiffuseColor color.NRGBA
12323                                 AmbientColor color.NRGBA
12324                                 Height       float32
12325                                 Thickness    float32
12326                                 Speed        [2]float32
12327                         }))(obj)).Speed)[local209]
12328                         *p = math.Float32frombits(read32(r))
12329                 }
12330         }
12331 }
12332
12333 func (obj *ToCltFadeSound) serialize(w io.Writer) {
12334         if err := pcall(func() {
12335                 ((*(*(struct {
12336                         ID   SoundID
12337                         Step float32
12338                         Gain float32
12339                 }))(obj)).ID).serialize(w)
12340         }); err != nil {
12341                 if err == io.EOF {
12342                         chk(io.EOF)
12343                 }
12344                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
12345         }
12346         {
12347                 x := (*(*(struct {
12348                         ID   SoundID
12349                         Step float32
12350                         Gain float32
12351                 }))(obj)).Step
12352                 write32(w, math.Float32bits(x))
12353         }
12354         {
12355                 x := (*(*(struct {
12356                         ID   SoundID
12357                         Step float32
12358                         Gain float32
12359                 }))(obj)).Gain
12360                 write32(w, math.Float32bits(x))
12361         }
12362 }
12363
12364 func (obj *ToCltFadeSound) deserialize(r io.Reader) {
12365         if err := pcall(func() {
12366                 ((*(*(struct {
12367                         ID   SoundID
12368                         Step float32
12369                         Gain float32
12370                 }))(obj)).ID).deserialize(r)
12371         }); err != nil {
12372                 if err == io.EOF {
12373                         chk(io.EOF)
12374                 }
12375                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
12376         }
12377         {
12378                 p := &(*(*(struct {
12379                         ID   SoundID
12380                         Step float32
12381                         Gain float32
12382                 }))(obj)).Step
12383                 *p = math.Float32frombits(read32(r))
12384         }
12385         {
12386                 p := &(*(*(struct {
12387                         ID   SoundID
12388                         Step float32
12389                         Gain float32
12390                 }))(obj)).Gain
12391                 *p = math.Float32frombits(read32(r))
12392         }
12393 }
12394
12395 func (obj *ToCltUpdatePlayerList) serialize(w io.Writer) {
12396         if err := pcall(func() {
12397                 ((*(*(struct {
12398                         Type    PlayerListUpdateType
12399                         Players []string
12400                 }))(obj)).Type).serialize(w)
12401         }); err != nil {
12402                 if err == io.EOF {
12403                         chk(io.EOF)
12404                 }
12405                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
12406         }
12407         if len(((*(*(struct {
12408                 Type    PlayerListUpdateType
12409                 Players []string
12410         }))(obj)).Players)) > math.MaxUint16 {
12411                 chk(ErrTooLong)
12412         }
12413         {
12414                 x := uint16(len(((*(*(struct {
12415                         Type    PlayerListUpdateType
12416                         Players []string
12417                 }))(obj)).Players)))
12418                 write16(w, uint16(x))
12419         }
12420         for local210 := range (*(*(struct {
12421                 Type    PlayerListUpdateType
12422                 Players []string
12423         }))(obj)).Players {
12424                 if len(([]byte(((*(*(struct {
12425                         Type    PlayerListUpdateType
12426                         Players []string
12427                 }))(obj)).Players)[local210]))) > math.MaxUint16 {
12428                         chk(ErrTooLong)
12429                 }
12430                 {
12431                         x := uint16(len(([]byte(((*(*(struct {
12432                                 Type    PlayerListUpdateType
12433                                 Players []string
12434                         }))(obj)).Players)[local210]))))
12435                         write16(w, uint16(x))
12436                 }
12437                 {
12438                         _, err := w.Write(([]byte(((*(*(struct {
12439                                 Type    PlayerListUpdateType
12440                                 Players []string
12441                         }))(obj)).Players)[local210]))[:])
12442                         chk(err)
12443                 }
12444         }
12445 }
12446
12447 func (obj *ToCltUpdatePlayerList) deserialize(r io.Reader) {
12448         if err := pcall(func() {
12449                 ((*(*(struct {
12450                         Type    PlayerListUpdateType
12451                         Players []string
12452                 }))(obj)).Type).deserialize(r)
12453         }); err != nil {
12454                 if err == io.EOF {
12455                         chk(io.EOF)
12456                 }
12457                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
12458         }
12459         var local211 uint16
12460         {
12461                 p := &local211
12462                 *p = read16(r)
12463         }
12464         ((*(*(struct {
12465                 Type    PlayerListUpdateType
12466                 Players []string
12467         }))(obj)).Players) = make([]string, local211)
12468         for local212 := range (*(*(struct {
12469                 Type    PlayerListUpdateType
12470                 Players []string
12471         }))(obj)).Players {
12472                 var local213 []uint8
12473                 var local214 uint16
12474                 {
12475                         p := &local214
12476                         *p = read16(r)
12477                 }
12478                 (local213) = make([]uint8, local214)
12479                 {
12480                         _, err := io.ReadFull(r, (local213)[:])
12481                         chk(err)
12482                 }
12483                 (((*(*(struct {
12484                         Type    PlayerListUpdateType
12485                         Players []string
12486                 }))(obj)).Players)[local212]) = string(local213)
12487         }
12488 }
12489
12490 func (obj *ToCltModChanMsg) serialize(w io.Writer) {
12491         if len(([]byte((*(*(struct {
12492                 Channel string
12493                 Sender  string
12494                 Msg     string
12495         }))(obj)).Channel))) > math.MaxUint16 {
12496                 chk(ErrTooLong)
12497         }
12498         {
12499                 x := uint16(len(([]byte((*(*(struct {
12500                         Channel string
12501                         Sender  string
12502                         Msg     string
12503                 }))(obj)).Channel))))
12504                 write16(w, uint16(x))
12505         }
12506         {
12507                 _, err := w.Write(([]byte((*(*(struct {
12508                         Channel string
12509                         Sender  string
12510                         Msg     string
12511                 }))(obj)).Channel))[:])
12512                 chk(err)
12513         }
12514         if len(([]byte((*(*(struct {
12515                 Channel string
12516                 Sender  string
12517                 Msg     string
12518         }))(obj)).Sender))) > math.MaxUint16 {
12519                 chk(ErrTooLong)
12520         }
12521         {
12522                 x := uint16(len(([]byte((*(*(struct {
12523                         Channel string
12524                         Sender  string
12525                         Msg     string
12526                 }))(obj)).Sender))))
12527                 write16(w, uint16(x))
12528         }
12529         {
12530                 _, err := w.Write(([]byte((*(*(struct {
12531                         Channel string
12532                         Sender  string
12533                         Msg     string
12534                 }))(obj)).Sender))[:])
12535                 chk(err)
12536         }
12537         if len(([]byte((*(*(struct {
12538                 Channel string
12539                 Sender  string
12540                 Msg     string
12541         }))(obj)).Msg))) > math.MaxUint16 {
12542                 chk(ErrTooLong)
12543         }
12544         {
12545                 x := uint16(len(([]byte((*(*(struct {
12546                         Channel string
12547                         Sender  string
12548                         Msg     string
12549                 }))(obj)).Msg))))
12550                 write16(w, uint16(x))
12551         }
12552         {
12553                 _, err := w.Write(([]byte((*(*(struct {
12554                         Channel string
12555                         Sender  string
12556                         Msg     string
12557                 }))(obj)).Msg))[:])
12558                 chk(err)
12559         }
12560 }
12561
12562 func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
12563         var local215 []uint8
12564         var local216 uint16
12565         {
12566                 p := &local216
12567                 *p = read16(r)
12568         }
12569         (local215) = make([]uint8, local216)
12570         {
12571                 _, err := io.ReadFull(r, (local215)[:])
12572                 chk(err)
12573         }
12574         ((*(*(struct {
12575                 Channel string
12576                 Sender  string
12577                 Msg     string
12578         }))(obj)).Channel) = string(local215)
12579         var local217 []uint8
12580         var local218 uint16
12581         {
12582                 p := &local218
12583                 *p = read16(r)
12584         }
12585         (local217) = make([]uint8, local218)
12586         {
12587                 _, err := io.ReadFull(r, (local217)[:])
12588                 chk(err)
12589         }
12590         ((*(*(struct {
12591                 Channel string
12592                 Sender  string
12593                 Msg     string
12594         }))(obj)).Sender) = string(local217)
12595         var local219 []uint8
12596         var local220 uint16
12597         {
12598                 p := &local220
12599                 *p = read16(r)
12600         }
12601         (local219) = make([]uint8, local220)
12602         {
12603                 _, err := io.ReadFull(r, (local219)[:])
12604                 chk(err)
12605         }
12606         ((*(*(struct {
12607                 Channel string
12608                 Sender  string
12609                 Msg     string
12610         }))(obj)).Msg) = string(local219)
12611 }
12612
12613 func (obj *ToCltModChanSig) serialize(w io.Writer) {
12614         if err := pcall(func() {
12615                 ((*(*(struct {
12616                         Signal  ModChanSig
12617                         Channel string
12618                 }))(obj)).Signal).serialize(w)
12619         }); err != nil {
12620                 if err == io.EOF {
12621                         chk(io.EOF)
12622                 }
12623                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
12624         }
12625         if len(([]byte((*(*(struct {
12626                 Signal  ModChanSig
12627                 Channel string
12628         }))(obj)).Channel))) > math.MaxUint16 {
12629                 chk(ErrTooLong)
12630         }
12631         {
12632                 x := uint16(len(([]byte((*(*(struct {
12633                         Signal  ModChanSig
12634                         Channel string
12635                 }))(obj)).Channel))))
12636                 write16(w, uint16(x))
12637         }
12638         {
12639                 _, err := w.Write(([]byte((*(*(struct {
12640                         Signal  ModChanSig
12641                         Channel string
12642                 }))(obj)).Channel))[:])
12643                 chk(err)
12644         }
12645 }
12646
12647 func (obj *ToCltModChanSig) deserialize(r io.Reader) {
12648         if err := pcall(func() {
12649                 ((*(*(struct {
12650                         Signal  ModChanSig
12651                         Channel string
12652                 }))(obj)).Signal).deserialize(r)
12653         }); err != nil {
12654                 if err == io.EOF {
12655                         chk(io.EOF)
12656                 }
12657                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
12658         }
12659         var local221 []uint8
12660         var local222 uint16
12661         {
12662                 p := &local222
12663                 *p = read16(r)
12664         }
12665         (local221) = make([]uint8, local222)
12666         {
12667                 _, err := io.ReadFull(r, (local221)[:])
12668                 chk(err)
12669         }
12670         ((*(*(struct {
12671                 Signal  ModChanSig
12672                 Channel string
12673         }))(obj)).Channel) = string(local221)
12674 }
12675
12676 func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
12677         {
12678                 ow := w
12679                 w := new(bytes.Buffer)
12680                 {
12681                         x := (*(*(struct {
12682                                 //mt:lenhdr 32
12683                                 Changed map[[3]int16]*NodeMeta
12684                         }))(obj)).Changed
12685                         {
12686                                 w := zlib.NewWriter(w)
12687
12688                                 if x == nil {
12689                                         write8(w, 0)
12690                                 } else {
12691                                         write8(w, 2)
12692                                         if len(x) > math.MaxUint16 {
12693                                                 chk(ErrTooLong)
12694                                         }
12695                                         write16(w, uint16(len(x)))
12696                                         keys := make([][3]int16, 0, len(x))
12697                                         for key := range x {
12698                                                 keys = append(keys, key)
12699                                         }
12700                                         sort.Slice(keys, func(i, j int) bool {
12701                                                 p, q := keys[i], keys[j]
12702
12703                                                 for i := range p {
12704                                                         switch {
12705                                                         case p[i] < q[i]:
12706                                                                 return true
12707                                                         case p[i] > q[i]:
12708                                                                 return false
12709                                                         }
12710                                                 }
12711
12712                                                 return false
12713                                         })
12714                                         for _, key := range keys {
12715                                                 for _, n := range key {
12716                                                         write16(w, uint16(n))
12717                                                 }
12718                                                 chk(serialize(w, x[key]))
12719                                         }
12720                                 }
12721
12722                                 chk(w.Close())
12723                         }
12724
12725                 }
12726                 {
12727                         buf := w
12728                         w := ow
12729                         if len((buf.Bytes())) > math.MaxUint32 {
12730                                 chk(ErrTooLong)
12731                         }
12732                         {
12733                                 x := uint32(len((buf.Bytes())))
12734                                 write32(w, uint32(x))
12735                         }
12736                         {
12737                                 _, err := w.Write((buf.Bytes())[:])
12738                                 chk(err)
12739                         }
12740                 }
12741         }
12742 }
12743
12744 func (obj *ToCltNodeMetasChanged) deserialize(r io.Reader) {
12745         {
12746                 var n uint32
12747                 {
12748                         p := &n
12749                         *p = read32(r)
12750                 }
12751                 r := &io.LimitedReader{R: r, N: int64(n)}
12752                 {
12753                         p := &(*(*(struct {
12754                                 //mt:lenhdr 32
12755                                 Changed map[[3]int16]*NodeMeta
12756                         }))(obj)).Changed
12757                         {
12758                                 r, err := zlib.NewReader(byteReader{r})
12759                                 chk(err)
12760
12761                                 switch ver := read8(r); ver {
12762                                 case 0:
12763                                         *p = nil
12764                                 case 2:
12765                                         n := read16(r)
12766                                         *p = make(map[[3]int16]*NodeMeta, n)
12767                                         for ; n > 0; n-- {
12768                                                 var pos [3]int16
12769                                                 for i := range pos {
12770                                                         pos[i] = int16(read16(r))
12771                                                 }
12772                                                 nm := new(NodeMeta)
12773                                                 chk(deserialize(r, nm))
12774                                                 (*p)[pos] = nm
12775                                         }
12776                                 default:
12777                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
12778                                 }
12779
12780                                 chk(r.Close())
12781                         }
12782
12783                 }
12784                 if r.N > 0 {
12785                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
12786                 }
12787         }
12788 }
12789
12790 func (obj *ToCltSunParams) serialize(w io.Writer) {
12791         {
12792                 x := (*(*(struct {
12793                         Visible bool
12794                         Texture
12795                         ToneMap Texture
12796                         Rise    Texture
12797                         Rising  bool
12798                         Size    float32
12799                 }))(obj)).Visible
12800                 if x {
12801                         write8(w, 1)
12802                 } else {
12803                         write8(w, 0)
12804                 }
12805
12806         }
12807         if err := pcall(func() {
12808                 ((*(*(struct {
12809                         Visible bool
12810                         Texture
12811                         ToneMap Texture
12812                         Rise    Texture
12813                         Rising  bool
12814                         Size    float32
12815                 }))(obj)).Texture).serialize(w)
12816         }); err != nil {
12817                 if err == io.EOF {
12818                         chk(io.EOF)
12819                 }
12820                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12821         }
12822         if err := pcall(func() {
12823                 ((*(*(struct {
12824                         Visible bool
12825                         Texture
12826                         ToneMap Texture
12827                         Rise    Texture
12828                         Rising  bool
12829                         Size    float32
12830                 }))(obj)).ToneMap).serialize(w)
12831         }); err != nil {
12832                 if err == io.EOF {
12833                         chk(io.EOF)
12834                 }
12835                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12836         }
12837         if err := pcall(func() {
12838                 ((*(*(struct {
12839                         Visible bool
12840                         Texture
12841                         ToneMap Texture
12842                         Rise    Texture
12843                         Rising  bool
12844                         Size    float32
12845                 }))(obj)).Rise).serialize(w)
12846         }); err != nil {
12847                 if err == io.EOF {
12848                         chk(io.EOF)
12849                 }
12850                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12851         }
12852         {
12853                 x := (*(*(struct {
12854                         Visible bool
12855                         Texture
12856                         ToneMap Texture
12857                         Rise    Texture
12858                         Rising  bool
12859                         Size    float32
12860                 }))(obj)).Rising
12861                 if x {
12862                         write8(w, 1)
12863                 } else {
12864                         write8(w, 0)
12865                 }
12866
12867         }
12868         {
12869                 x := (*(*(struct {
12870                         Visible bool
12871                         Texture
12872                         ToneMap Texture
12873                         Rise    Texture
12874                         Rising  bool
12875                         Size    float32
12876                 }))(obj)).Size
12877                 write32(w, math.Float32bits(x))
12878         }
12879 }
12880
12881 func (obj *ToCltSunParams) deserialize(r io.Reader) {
12882         {
12883                 p := &(*(*(struct {
12884                         Visible bool
12885                         Texture
12886                         ToneMap Texture
12887                         Rise    Texture
12888                         Rising  bool
12889                         Size    float32
12890                 }))(obj)).Visible
12891                 switch n := read8(r); n {
12892                 case 0:
12893                         *p = false
12894                 case 1:
12895                         *p = true
12896                 default:
12897                         chk(fmt.Errorf("invalid bool: %d", n))
12898                 }
12899
12900         }
12901         if err := pcall(func() {
12902                 ((*(*(struct {
12903                         Visible bool
12904                         Texture
12905                         ToneMap Texture
12906                         Rise    Texture
12907                         Rising  bool
12908                         Size    float32
12909                 }))(obj)).Texture).deserialize(r)
12910         }); err != nil {
12911                 if err == io.EOF {
12912                         chk(io.EOF)
12913                 }
12914                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12915         }
12916         if err := pcall(func() {
12917                 ((*(*(struct {
12918                         Visible bool
12919                         Texture
12920                         ToneMap Texture
12921                         Rise    Texture
12922                         Rising  bool
12923                         Size    float32
12924                 }))(obj)).ToneMap).deserialize(r)
12925         }); err != nil {
12926                 if err == io.EOF {
12927                         chk(io.EOF)
12928                 }
12929                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12930         }
12931         if err := pcall(func() {
12932                 ((*(*(struct {
12933                         Visible bool
12934                         Texture
12935                         ToneMap Texture
12936                         Rise    Texture
12937                         Rising  bool
12938                         Size    float32
12939                 }))(obj)).Rise).deserialize(r)
12940         }); err != nil {
12941                 if err == io.EOF {
12942                         chk(io.EOF)
12943                 }
12944                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12945         }
12946         {
12947                 p := &(*(*(struct {
12948                         Visible bool
12949                         Texture
12950                         ToneMap Texture
12951                         Rise    Texture
12952                         Rising  bool
12953                         Size    float32
12954                 }))(obj)).Rising
12955                 switch n := read8(r); n {
12956                 case 0:
12957                         *p = false
12958                 case 1:
12959                         *p = true
12960                 default:
12961                         chk(fmt.Errorf("invalid bool: %d", n))
12962                 }
12963
12964         }
12965         {
12966                 p := &(*(*(struct {
12967                         Visible bool
12968                         Texture
12969                         ToneMap Texture
12970                         Rise    Texture
12971                         Rising  bool
12972                         Size    float32
12973                 }))(obj)).Size
12974                 *p = math.Float32frombits(read32(r))
12975         }
12976 }
12977
12978 func (obj *ToCltMoonParams) serialize(w io.Writer) {
12979         {
12980                 x := (*(*(struct {
12981                         Visible bool
12982                         Texture
12983                         ToneMap Texture
12984                         Size    float32
12985                 }))(obj)).Visible
12986                 if x {
12987                         write8(w, 1)
12988                 } else {
12989                         write8(w, 0)
12990                 }
12991
12992         }
12993         if err := pcall(func() {
12994                 ((*(*(struct {
12995                         Visible bool
12996                         Texture
12997                         ToneMap Texture
12998                         Size    float32
12999                 }))(obj)).Texture).serialize(w)
13000         }); err != nil {
13001                 if err == io.EOF {
13002                         chk(io.EOF)
13003                 }
13004                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13005         }
13006         if err := pcall(func() {
13007                 ((*(*(struct {
13008                         Visible bool
13009                         Texture
13010                         ToneMap Texture
13011                         Size    float32
13012                 }))(obj)).ToneMap).serialize(w)
13013         }); err != nil {
13014                 if err == io.EOF {
13015                         chk(io.EOF)
13016                 }
13017                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13018         }
13019         {
13020                 x := (*(*(struct {
13021                         Visible bool
13022                         Texture
13023                         ToneMap Texture
13024                         Size    float32
13025                 }))(obj)).Size
13026                 write32(w, math.Float32bits(x))
13027         }
13028 }
13029
13030 func (obj *ToCltMoonParams) deserialize(r io.Reader) {
13031         {
13032                 p := &(*(*(struct {
13033                         Visible bool
13034                         Texture
13035                         ToneMap Texture
13036                         Size    float32
13037                 }))(obj)).Visible
13038                 switch n := read8(r); n {
13039                 case 0:
13040                         *p = false
13041                 case 1:
13042                         *p = true
13043                 default:
13044                         chk(fmt.Errorf("invalid bool: %d", n))
13045                 }
13046
13047         }
13048         if err := pcall(func() {
13049                 ((*(*(struct {
13050                         Visible bool
13051                         Texture
13052                         ToneMap Texture
13053                         Size    float32
13054                 }))(obj)).Texture).deserialize(r)
13055         }); err != nil {
13056                 if err == io.EOF {
13057                         chk(io.EOF)
13058                 }
13059                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13060         }
13061         if err := pcall(func() {
13062                 ((*(*(struct {
13063                         Visible bool
13064                         Texture
13065                         ToneMap Texture
13066                         Size    float32
13067                 }))(obj)).ToneMap).deserialize(r)
13068         }); err != nil {
13069                 if err == io.EOF {
13070                         chk(io.EOF)
13071                 }
13072                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13073         }
13074         {
13075                 p := &(*(*(struct {
13076                         Visible bool
13077                         Texture
13078                         ToneMap Texture
13079                         Size    float32
13080                 }))(obj)).Size
13081                 *p = math.Float32frombits(read32(r))
13082         }
13083 }
13084
13085 func (obj *ToCltStarParams) serialize(w io.Writer) {
13086         {
13087                 x := (*(*(struct {
13088                         Visible bool
13089                         Count   uint32
13090                         Color   color.NRGBA
13091                         Size    float32
13092                 }))(obj)).Visible
13093                 if x {
13094                         write8(w, 1)
13095                 } else {
13096                         write8(w, 0)
13097                 }
13098
13099         }
13100         {
13101                 x := (*(*(struct {
13102                         Visible bool
13103                         Count   uint32
13104                         Color   color.NRGBA
13105                         Size    float32
13106                 }))(obj)).Count
13107                 write32(w, uint32(x))
13108         }
13109         {
13110                 x := (*(*(struct {
13111                         Visible bool
13112                         Count   uint32
13113                         Color   color.NRGBA
13114                         Size    float32
13115                 }))(obj)).Color
13116                 w.Write([]byte{x.A, x.R, x.G, x.B})
13117
13118         }
13119         {
13120                 x := (*(*(struct {
13121                         Visible bool
13122                         Count   uint32
13123                         Color   color.NRGBA
13124                         Size    float32
13125                 }))(obj)).Size
13126                 write32(w, math.Float32bits(x))
13127         }
13128 }
13129
13130 func (obj *ToCltStarParams) deserialize(r io.Reader) {
13131         {
13132                 p := &(*(*(struct {
13133                         Visible bool
13134                         Count   uint32
13135                         Color   color.NRGBA
13136                         Size    float32
13137                 }))(obj)).Visible
13138                 switch n := read8(r); n {
13139                 case 0:
13140                         *p = false
13141                 case 1:
13142                         *p = true
13143                 default:
13144                         chk(fmt.Errorf("invalid bool: %d", n))
13145                 }
13146
13147         }
13148         {
13149                 p := &(*(*(struct {
13150                         Visible bool
13151                         Count   uint32
13152                         Color   color.NRGBA
13153                         Size    float32
13154                 }))(obj)).Count
13155                 *p = read32(r)
13156         }
13157         {
13158                 p := &(*(*(struct {
13159                         Visible bool
13160                         Count   uint32
13161                         Color   color.NRGBA
13162                         Size    float32
13163                 }))(obj)).Color
13164                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13165
13166         }
13167         {
13168                 p := &(*(*(struct {
13169                         Visible bool
13170                         Count   uint32
13171                         Color   color.NRGBA
13172                         Size    float32
13173                 }))(obj)).Size
13174                 *p = math.Float32frombits(read32(r))
13175         }
13176 }
13177
13178 func (obj *ToCltSRPBytesSaltB) serialize(w io.Writer) {
13179         if len(((*(*(struct {
13180                 Salt, B []byte
13181         }))(obj)).Salt)) > math.MaxUint16 {
13182                 chk(ErrTooLong)
13183         }
13184         {
13185                 x := uint16(len(((*(*(struct {
13186                         Salt, B []byte
13187                 }))(obj)).Salt)))
13188                 write16(w, uint16(x))
13189         }
13190         {
13191                 _, err := w.Write(((*(*(struct {
13192                         Salt, B []byte
13193                 }))(obj)).Salt)[:])
13194                 chk(err)
13195         }
13196         if len(((*(*(struct {
13197                 Salt, B []byte
13198         }))(obj)).B)) > math.MaxUint16 {
13199                 chk(ErrTooLong)
13200         }
13201         {
13202                 x := uint16(len(((*(*(struct {
13203                         Salt, B []byte
13204                 }))(obj)).B)))
13205                 write16(w, uint16(x))
13206         }
13207         {
13208                 _, err := w.Write(((*(*(struct {
13209                         Salt, B []byte
13210                 }))(obj)).B)[:])
13211                 chk(err)
13212         }
13213 }
13214
13215 func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
13216         var local223 uint16
13217         {
13218                 p := &local223
13219                 *p = read16(r)
13220         }
13221         ((*(*(struct {
13222                 Salt, B []byte
13223         }))(obj)).Salt) = make([]byte, local223)
13224         {
13225                 _, err := io.ReadFull(r, ((*(*(struct {
13226                         Salt, B []byte
13227                 }))(obj)).Salt)[:])
13228                 chk(err)
13229         }
13230         var local224 uint16
13231         {
13232                 p := &local224
13233                 *p = read16(r)
13234         }
13235         ((*(*(struct {
13236                 Salt, B []byte
13237         }))(obj)).B) = make([]byte, local224)
13238         {
13239                 _, err := io.ReadFull(r, ((*(*(struct {
13240                         Salt, B []byte
13241                 }))(obj)).B)[:])
13242                 chk(err)
13243         }
13244 }
13245
13246 func (obj *ToCltFormspecPrepend) serialize(w io.Writer) {
13247         if len(([]byte((*(*(struct {
13248                 Prepend string
13249         }))(obj)).Prepend))) > math.MaxUint16 {
13250                 chk(ErrTooLong)
13251         }
13252         {
13253                 x := uint16(len(([]byte((*(*(struct {
13254                         Prepend string
13255                 }))(obj)).Prepend))))
13256                 write16(w, uint16(x))
13257         }
13258         {
13259                 _, err := w.Write(([]byte((*(*(struct {
13260                         Prepend string
13261                 }))(obj)).Prepend))[:])
13262                 chk(err)
13263         }
13264 }
13265
13266 func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
13267         var local225 []uint8
13268         var local226 uint16
13269         {
13270                 p := &local226
13271                 *p = read16(r)
13272         }
13273         (local225) = make([]uint8, local226)
13274         {
13275                 _, err := io.ReadFull(r, (local225)[:])
13276                 chk(err)
13277         }
13278         ((*(*(struct {
13279                 Prepend string
13280         }))(obj)).Prepend) = string(local225)
13281 }
13282
13283 func (obj *AOCmdProps) serialize(w io.Writer) {
13284         if err := pcall(func() {
13285                 ((*(*(struct {
13286                         Props AOProps
13287                 }))(obj)).Props).serialize(w)
13288         }); err != nil {
13289                 if err == io.EOF {
13290                         chk(io.EOF)
13291                 }
13292                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOProps", err))
13293         }
13294 }
13295
13296 func (obj *AOCmdProps) deserialize(r io.Reader) {
13297         if err := pcall(func() {
13298                 ((*(*(struct {
13299                         Props AOProps
13300                 }))(obj)).Props).deserialize(r)
13301         }); err != nil {
13302                 if err == io.EOF {
13303                         chk(io.EOF)
13304                 }
13305                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOProps", err))
13306         }
13307 }
13308
13309 func (obj *AOCmdPos) serialize(w io.Writer) {
13310         if err := pcall(func() {
13311                 ((*(*(struct {
13312                         Pos AOPos
13313                 }))(obj)).Pos).serialize(w)
13314         }); err != nil {
13315                 if err == io.EOF {
13316                         chk(io.EOF)
13317                 }
13318                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPos", err))
13319         }
13320 }
13321
13322 func (obj *AOCmdPos) deserialize(r io.Reader) {
13323         if err := pcall(func() {
13324                 ((*(*(struct {
13325                         Pos AOPos
13326                 }))(obj)).Pos).deserialize(r)
13327         }); err != nil {
13328                 if err == io.EOF {
13329                         chk(io.EOF)
13330                 }
13331                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPos", err))
13332         }
13333 }
13334
13335 func (obj *AOCmdTextureMod) serialize(w io.Writer) {
13336         if err := pcall(func() {
13337                 ((*(*(struct {
13338                         Mod Texture // suffix
13339                 }))(obj)).Mod).serialize(w)
13340         }); err != nil {
13341                 if err == io.EOF {
13342                         chk(io.EOF)
13343                 }
13344                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13345         }
13346 }
13347
13348 func (obj *AOCmdTextureMod) deserialize(r io.Reader) {
13349         if err := pcall(func() {
13350                 ((*(*(struct {
13351                         Mod Texture // suffix
13352                 }))(obj)).Mod).deserialize(r)
13353         }); err != nil {
13354                 if err == io.EOF {
13355                         chk(io.EOF)
13356                 }
13357                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13358         }
13359 }
13360
13361 func (obj *AOCmdSprite) serialize(w io.Writer) {
13362         if err := pcall(func() {
13363                 ((*(*(struct {
13364                         Sprite AOSprite
13365                 }))(obj)).Sprite).serialize(w)
13366         }); err != nil {
13367                 if err == io.EOF {
13368                         chk(io.EOF)
13369                 }
13370                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOSprite", err))
13371         }
13372 }
13373
13374 func (obj *AOCmdSprite) deserialize(r io.Reader) {
13375         if err := pcall(func() {
13376                 ((*(*(struct {
13377                         Sprite AOSprite
13378                 }))(obj)).Sprite).deserialize(r)
13379         }); err != nil {
13380                 if err == io.EOF {
13381                         chk(io.EOF)
13382                 }
13383                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOSprite", err))
13384         }
13385 }
13386
13387 func (obj *AOCmdHP) serialize(w io.Writer) {
13388         {
13389                 x := (*(*(struct {
13390                         HP uint16
13391                 }))(obj)).HP
13392                 write16(w, uint16(x))
13393         }
13394 }
13395
13396 func (obj *AOCmdHP) deserialize(r io.Reader) {
13397         {
13398                 p := &(*(*(struct {
13399                         HP uint16
13400                 }))(obj)).HP
13401                 *p = read16(r)
13402         }
13403 }
13404
13405 func (obj *AOCmdArmorGroups) serialize(w io.Writer) {
13406         if len(((*(*(struct {
13407                 Armor []Group
13408         }))(obj)).Armor)) > math.MaxUint16 {
13409                 chk(ErrTooLong)
13410         }
13411         {
13412                 x := uint16(len(((*(*(struct {
13413                         Armor []Group
13414                 }))(obj)).Armor)))
13415                 write16(w, uint16(x))
13416         }
13417         for local227 := range (*(*(struct {
13418                 Armor []Group
13419         }))(obj)).Armor {
13420                 if err := pcall(func() {
13421                         (((*(*(struct {
13422                                 Armor []Group
13423                         }))(obj)).Armor)[local227]).serialize(w)
13424                 }); err != nil {
13425                         if err == io.EOF {
13426                                 chk(io.EOF)
13427                         }
13428                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
13429                 }
13430         }
13431 }
13432
13433 func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
13434         var local228 uint16
13435         {
13436                 p := &local228
13437                 *p = read16(r)
13438         }
13439         ((*(*(struct {
13440                 Armor []Group
13441         }))(obj)).Armor) = make([]Group, local228)
13442         for local229 := range (*(*(struct {
13443                 Armor []Group
13444         }))(obj)).Armor {
13445                 if err := pcall(func() {
13446                         (((*(*(struct {
13447                                 Armor []Group
13448                         }))(obj)).Armor)[local229]).deserialize(r)
13449                 }); err != nil {
13450                         if err == io.EOF {
13451                                 chk(io.EOF)
13452                         }
13453                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
13454                 }
13455         }
13456 }
13457
13458 func (obj *AOCmdAnim) serialize(w io.Writer) {
13459         if err := pcall(func() {
13460                 ((*(*(struct {
13461                         Anim AOAnim
13462                 }))(obj)).Anim).serialize(w)
13463         }); err != nil {
13464                 if err == io.EOF {
13465                         chk(io.EOF)
13466                 }
13467                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAnim", err))
13468         }
13469 }
13470
13471 func (obj *AOCmdAnim) deserialize(r io.Reader) {
13472         if err := pcall(func() {
13473                 ((*(*(struct {
13474                         Anim AOAnim
13475                 }))(obj)).Anim).deserialize(r)
13476         }); err != nil {
13477                 if err == io.EOF {
13478                         chk(io.EOF)
13479                 }
13480                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAnim", err))
13481         }
13482 }
13483
13484 func (obj *AOCmdBonePos) serialize(w io.Writer) {
13485         if len(([]byte((*(*(struct {
13486                 Bone string
13487                 Pos  AOBonePos
13488         }))(obj)).Bone))) > math.MaxUint16 {
13489                 chk(ErrTooLong)
13490         }
13491         {
13492                 x := uint16(len(([]byte((*(*(struct {
13493                         Bone string
13494                         Pos  AOBonePos
13495                 }))(obj)).Bone))))
13496                 write16(w, uint16(x))
13497         }
13498         {
13499                 _, err := w.Write(([]byte((*(*(struct {
13500                         Bone string
13501                         Pos  AOBonePos
13502                 }))(obj)).Bone))[:])
13503                 chk(err)
13504         }
13505         if err := pcall(func() {
13506                 ((*(*(struct {
13507                         Bone string
13508                         Pos  AOBonePos
13509                 }))(obj)).Pos).serialize(w)
13510         }); err != nil {
13511                 if err == io.EOF {
13512                         chk(io.EOF)
13513                 }
13514                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOBonePos", err))
13515         }
13516 }
13517
13518 func (obj *AOCmdBonePos) deserialize(r io.Reader) {
13519         var local230 []uint8
13520         var local231 uint16
13521         {
13522                 p := &local231
13523                 *p = read16(r)
13524         }
13525         (local230) = make([]uint8, local231)
13526         {
13527                 _, err := io.ReadFull(r, (local230)[:])
13528                 chk(err)
13529         }
13530         ((*(*(struct {
13531                 Bone string
13532                 Pos  AOBonePos
13533         }))(obj)).Bone) = string(local230)
13534         if err := pcall(func() {
13535                 ((*(*(struct {
13536                         Bone string
13537                         Pos  AOBonePos
13538                 }))(obj)).Pos).deserialize(r)
13539         }); err != nil {
13540                 if err == io.EOF {
13541                         chk(io.EOF)
13542                 }
13543                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOBonePos", err))
13544         }
13545 }
13546
13547 func (obj *AOCmdAttach) serialize(w io.Writer) {
13548         if err := pcall(func() {
13549                 ((*(*(struct {
13550                         Attach AOAttach
13551                 }))(obj)).Attach).serialize(w)
13552         }); err != nil {
13553                 if err == io.EOF {
13554                         chk(io.EOF)
13555                 }
13556                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAttach", err))
13557         }
13558 }
13559
13560 func (obj *AOCmdAttach) deserialize(r io.Reader) {
13561         if err := pcall(func() {
13562                 ((*(*(struct {
13563                         Attach AOAttach
13564                 }))(obj)).Attach).deserialize(r)
13565         }); err != nil {
13566                 if err == io.EOF {
13567                         chk(io.EOF)
13568                 }
13569                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAttach", err))
13570         }
13571 }
13572
13573 func (obj *AOCmdPhysOverride) serialize(w io.Writer) {
13574         if err := pcall(func() {
13575                 ((*(*(struct {
13576                         Phys AOPhysOverride
13577                 }))(obj)).Phys).serialize(w)
13578         }); err != nil {
13579                 if err == io.EOF {
13580                         chk(io.EOF)
13581                 }
13582                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPhysOverride", err))
13583         }
13584 }
13585
13586 func (obj *AOCmdPhysOverride) deserialize(r io.Reader) {
13587         if err := pcall(func() {
13588                 ((*(*(struct {
13589                         Phys AOPhysOverride
13590                 }))(obj)).Phys).deserialize(r)
13591         }); err != nil {
13592                 if err == io.EOF {
13593                         chk(io.EOF)
13594                 }
13595                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPhysOverride", err))
13596         }
13597 }
13598
13599 func (obj *AOCmdSpawnInfant) serialize(w io.Writer) {
13600         if err := pcall(func() {
13601                 ((*(*(struct {
13602                         ID AOID
13603                 }))(obj)).ID).serialize(w)
13604         }); err != nil {
13605                 if err == io.EOF {
13606                         chk(io.EOF)
13607                 }
13608                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
13609         }
13610         {
13611                 local232 := genericCAO
13612                 if err := pcall(func() {
13613                         (local232).serialize(w)
13614                 }); err != nil {
13615                         if err == io.EOF {
13616                                 chk(io.EOF)
13617                         }
13618                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
13619                 }
13620         }
13621 }
13622
13623 func (obj *AOCmdSpawnInfant) deserialize(r io.Reader) {
13624         if err := pcall(func() {
13625                 ((*(*(struct {
13626                         ID AOID
13627                 }))(obj)).ID).deserialize(r)
13628         }); err != nil {
13629                 if err == io.EOF {
13630                         chk(io.EOF)
13631                 }
13632                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
13633         }
13634         {
13635                 var local233 aoType
13636                 local234 := genericCAO
13637                 if err := pcall(func() {
13638                         (local233).deserialize(r)
13639                 }); err != nil {
13640                         if err == io.EOF {
13641                                 chk(io.EOF)
13642                         }
13643                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
13644                 }
13645                 if local233 != local234 {
13646                         chk(fmt.Errorf("const %v: %v", "genericCAO", local233))
13647                 }
13648         }
13649 }
13650
13651 func (obj *AOCmdAnimSpeed) serialize(w io.Writer) {
13652         {
13653                 x := (*(*(struct {
13654                         Speed float32
13655                 }))(obj)).Speed
13656                 write32(w, math.Float32bits(x))
13657         }
13658 }
13659
13660 func (obj *AOCmdAnimSpeed) deserialize(r io.Reader) {
13661         {
13662                 p := &(*(*(struct {
13663                         Speed float32
13664                 }))(obj)).Speed
13665                 *p = math.Float32frombits(read32(r))
13666         }
13667 }
13668
13669 func (obj *NodeMeta) serialize(w io.Writer) {
13670         if len(((*(*(struct {
13671                 //mt:len32
13672                 Fields []NodeMetaField
13673
13674                 Inv Inv
13675         }))(obj)).Fields)) > math.MaxUint32 {
13676                 chk(ErrTooLong)
13677         }
13678         {
13679                 x := uint32(len(((*(*(struct {
13680                         //mt:len32
13681                         Fields []NodeMetaField
13682
13683                         Inv Inv
13684                 }))(obj)).Fields)))
13685                 write32(w, uint32(x))
13686         }
13687         for local235 := range (*(*(struct {
13688                 //mt:len32
13689                 Fields []NodeMetaField
13690
13691                 Inv Inv
13692         }))(obj)).Fields {
13693                 if err := pcall(func() {
13694                         (((*(*(struct {
13695                                 //mt:len32
13696                                 Fields []NodeMetaField
13697
13698                                 Inv Inv
13699                         }))(obj)).Fields)[local235]).serialize(w)
13700                 }); err != nil {
13701                         if err == io.EOF {
13702                                 chk(io.EOF)
13703                         }
13704                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeMetaField", err))
13705                 }
13706         }
13707         chk(((*(*(struct {
13708                 //mt:len32
13709                 Fields []NodeMetaField
13710
13711                 Inv Inv
13712         }))(obj)).Inv).Serialize(w))
13713 }
13714
13715 func (obj *NodeMeta) deserialize(r io.Reader) {
13716         var local236 uint32
13717         {
13718                 p := &local236
13719                 *p = read32(r)
13720         }
13721         ((*(*(struct {
13722                 //mt:len32
13723                 Fields []NodeMetaField
13724
13725                 Inv Inv
13726         }))(obj)).Fields) = make([]NodeMetaField, local236)
13727         for local237 := range (*(*(struct {
13728                 //mt:len32
13729                 Fields []NodeMetaField
13730
13731                 Inv Inv
13732         }))(obj)).Fields {
13733                 if err := pcall(func() {
13734                         (((*(*(struct {
13735                                 //mt:len32
13736                                 Fields []NodeMetaField
13737
13738                                 Inv Inv
13739                         }))(obj)).Fields)[local237]).deserialize(r)
13740                 }); err != nil {
13741                         if err == io.EOF {
13742                                 chk(io.EOF)
13743                         }
13744                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeMetaField", err))
13745                 }
13746         }
13747         chk(((*(*(struct {
13748                 //mt:len32
13749                 Fields []NodeMetaField
13750
13751                 Inv Inv
13752         }))(obj)).Inv).Deserialize(r))
13753 }
13754
13755 func (obj *MinimapMode) serialize(w io.Writer) {
13756         if err := pcall(func() {
13757                 ((*(*(struct {
13758                         Type  MinimapType
13759                         Label string
13760                         Size  uint16
13761                         Texture
13762                         Scale uint16
13763                 }))(obj)).Type).serialize(w)
13764         }); err != nil {
13765                 if err == io.EOF {
13766                         chk(io.EOF)
13767                 }
13768                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
13769         }
13770         if len(([]byte((*(*(struct {
13771                 Type  MinimapType
13772                 Label string
13773                 Size  uint16
13774                 Texture
13775                 Scale uint16
13776         }))(obj)).Label))) > math.MaxUint16 {
13777                 chk(ErrTooLong)
13778         }
13779         {
13780                 x := uint16(len(([]byte((*(*(struct {
13781                         Type  MinimapType
13782                         Label string
13783                         Size  uint16
13784                         Texture
13785                         Scale uint16
13786                 }))(obj)).Label))))
13787                 write16(w, uint16(x))
13788         }
13789         {
13790                 _, err := w.Write(([]byte((*(*(struct {
13791                         Type  MinimapType
13792                         Label string
13793                         Size  uint16
13794                         Texture
13795                         Scale uint16
13796                 }))(obj)).Label))[:])
13797                 chk(err)
13798         }
13799         {
13800                 x := (*(*(struct {
13801                         Type  MinimapType
13802                         Label string
13803                         Size  uint16
13804                         Texture
13805                         Scale uint16
13806                 }))(obj)).Size
13807                 write16(w, uint16(x))
13808         }
13809         if err := pcall(func() {
13810                 ((*(*(struct {
13811                         Type  MinimapType
13812                         Label string
13813                         Size  uint16
13814                         Texture
13815                         Scale uint16
13816                 }))(obj)).Texture).serialize(w)
13817         }); err != nil {
13818                 if err == io.EOF {
13819                         chk(io.EOF)
13820                 }
13821                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13822         }
13823         {
13824                 x := (*(*(struct {
13825                         Type  MinimapType
13826                         Label string
13827                         Size  uint16
13828                         Texture
13829                         Scale uint16
13830                 }))(obj)).Scale
13831                 write16(w, uint16(x))
13832         }
13833 }
13834
13835 func (obj *MinimapMode) deserialize(r io.Reader) {
13836         if err := pcall(func() {
13837                 ((*(*(struct {
13838                         Type  MinimapType
13839                         Label string
13840                         Size  uint16
13841                         Texture
13842                         Scale uint16
13843                 }))(obj)).Type).deserialize(r)
13844         }); err != nil {
13845                 if err == io.EOF {
13846                         chk(io.EOF)
13847                 }
13848                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
13849         }
13850         var local238 []uint8
13851         var local239 uint16
13852         {
13853                 p := &local239
13854                 *p = read16(r)
13855         }
13856         (local238) = make([]uint8, local239)
13857         {
13858                 _, err := io.ReadFull(r, (local238)[:])
13859                 chk(err)
13860         }
13861         ((*(*(struct {
13862                 Type  MinimapType
13863                 Label string
13864                 Size  uint16
13865                 Texture
13866                 Scale uint16
13867         }))(obj)).Label) = string(local238)
13868         {
13869                 p := &(*(*(struct {
13870                         Type  MinimapType
13871                         Label string
13872                         Size  uint16
13873                         Texture
13874                         Scale uint16
13875                 }))(obj)).Size
13876                 *p = read16(r)
13877         }
13878         if err := pcall(func() {
13879                 ((*(*(struct {
13880                         Type  MinimapType
13881                         Label string
13882                         Size  uint16
13883                         Texture
13884                         Scale uint16
13885                 }))(obj)).Texture).deserialize(r)
13886         }); err != nil {
13887                 if err == io.EOF {
13888                         chk(io.EOF)
13889                 }
13890                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13891         }
13892         {
13893                 p := &(*(*(struct {
13894                         Type  MinimapType
13895                         Label string
13896                         Size  uint16
13897                         Texture
13898                         Scale uint16
13899                 }))(obj)).Scale
13900                 *p = read16(r)
13901         }
13902 }
13903
13904 func (obj *NodeDef) serialize(w io.Writer) {
13905         if err := pcall(func() {
13906                 ((*(*(struct {
13907                         Param0 Content
13908
13909                         Name   string
13910                         Groups []Group
13911
13912                         P1Type   Param1Type
13913                         P2Type   Param2Type
13914                         DrawType DrawType
13915
13916                         Mesh  string
13917                         Scale float32
13918                         //mt:const uint8(6)
13919                         Tiles        [6]TileDef
13920                         OverlayTiles [6]TileDef
13921                         //mt:const uint8(6)
13922                         SpecialTiles [6]TileDef
13923
13924                         Color   color.NRGBA
13925                         Palette Texture
13926
13927                         Waving       WaveType
13928                         ConnectSides uint8
13929                         ConnectTo    []Content
13930                         InsideTint   color.NRGBA
13931                         Level        uint8 // Must be < 128.
13932
13933                         Translucent bool // Sunlight is scattered and becomes normal light.
13934                         Transparent bool // Sunlight isn't scattered.
13935                         LightSrc    uint8
13936
13937                         GndContent   bool
13938                         Collides     bool
13939                         Pointable    bool
13940                         Diggable     bool
13941                         Climbable    bool
13942                         Replaceable  bool
13943                         OnRightClick bool
13944
13945                         DmgPerSec int32
13946
13947                         LiquidType   LiquidType
13948                         FlowingAlt   string
13949                         SrcAlt       string
13950                         Viscosity    uint8 // 0-7
13951                         LiqRenewable bool
13952                         FlowRange    uint8
13953                         DrownDmg     uint8
13954                         Floodable    bool
13955
13956                         DrawBox, ColBox, SelBox NodeBox
13957
13958                         FootstepSnd, DiggingSnd, DugSnd SoundDef
13959
13960                         LegacyFaceDir bool
13961                         LegacyMounted bool
13962
13963                         DigPredict string
13964
13965                         MaxLvl uint8
13966
13967                         AlphaUse
13968                 }))(obj)).Param0).serialize(w)
13969         }); err != nil {
13970                 if err == io.EOF {
13971                         chk(io.EOF)
13972                 }
13973                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
13974         }
13975         {
13976                 ow := w
13977                 w := new(bytes.Buffer)
13978                 {
13979                         local240 := uint8(13)
13980                         {
13981                                 x := local240
13982                                 write8(w, uint8(x))
13983                         }
13984                 }
13985                 if len(([]byte((*(*(struct {
13986                         Param0 Content
13987
13988                         Name   string
13989                         Groups []Group
13990
13991                         P1Type   Param1Type
13992                         P2Type   Param2Type
13993                         DrawType DrawType
13994
13995                         Mesh  string
13996                         Scale float32
13997                         //mt:const uint8(6)
13998                         Tiles        [6]TileDef
13999                         OverlayTiles [6]TileDef
14000                         //mt:const uint8(6)
14001                         SpecialTiles [6]TileDef
14002
14003                         Color   color.NRGBA
14004                         Palette Texture
14005
14006                         Waving       WaveType
14007                         ConnectSides uint8
14008                         ConnectTo    []Content
14009                         InsideTint   color.NRGBA
14010                         Level        uint8 // Must be < 128.
14011
14012                         Translucent bool // Sunlight is scattered and becomes normal light.
14013                         Transparent bool // Sunlight isn't scattered.
14014                         LightSrc    uint8
14015
14016                         GndContent   bool
14017                         Collides     bool
14018                         Pointable    bool
14019                         Diggable     bool
14020                         Climbable    bool
14021                         Replaceable  bool
14022                         OnRightClick bool
14023
14024                         DmgPerSec int32
14025
14026                         LiquidType   LiquidType
14027                         FlowingAlt   string
14028                         SrcAlt       string
14029                         Viscosity    uint8 // 0-7
14030                         LiqRenewable bool
14031                         FlowRange    uint8
14032                         DrownDmg     uint8
14033                         Floodable    bool
14034
14035                         DrawBox, ColBox, SelBox NodeBox
14036
14037                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14038
14039                         LegacyFaceDir bool
14040                         LegacyMounted bool
14041
14042                         DigPredict string
14043
14044                         MaxLvl uint8
14045
14046                         AlphaUse
14047                 }))(obj)).Name))) > math.MaxUint16 {
14048                         chk(ErrTooLong)
14049                 }
14050                 {
14051                         x := uint16(len(([]byte((*(*(struct {
14052                                 Param0 Content
14053
14054                                 Name   string
14055                                 Groups []Group
14056
14057                                 P1Type   Param1Type
14058                                 P2Type   Param2Type
14059                                 DrawType DrawType
14060
14061                                 Mesh  string
14062                                 Scale float32
14063                                 //mt:const uint8(6)
14064                                 Tiles        [6]TileDef
14065                                 OverlayTiles [6]TileDef
14066                                 //mt:const uint8(6)
14067                                 SpecialTiles [6]TileDef
14068
14069                                 Color   color.NRGBA
14070                                 Palette Texture
14071
14072                                 Waving       WaveType
14073                                 ConnectSides uint8
14074                                 ConnectTo    []Content
14075                                 InsideTint   color.NRGBA
14076                                 Level        uint8 // Must be < 128.
14077
14078                                 Translucent bool // Sunlight is scattered and becomes normal light.
14079                                 Transparent bool // Sunlight isn't scattered.
14080                                 LightSrc    uint8
14081
14082                                 GndContent   bool
14083                                 Collides     bool
14084                                 Pointable    bool
14085                                 Diggable     bool
14086                                 Climbable    bool
14087                                 Replaceable  bool
14088                                 OnRightClick bool
14089
14090                                 DmgPerSec int32
14091
14092                                 LiquidType   LiquidType
14093                                 FlowingAlt   string
14094                                 SrcAlt       string
14095                                 Viscosity    uint8 // 0-7
14096                                 LiqRenewable bool
14097                                 FlowRange    uint8
14098                                 DrownDmg     uint8
14099                                 Floodable    bool
14100
14101                                 DrawBox, ColBox, SelBox NodeBox
14102
14103                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14104
14105                                 LegacyFaceDir bool
14106                                 LegacyMounted bool
14107
14108                                 DigPredict string
14109
14110                                 MaxLvl uint8
14111
14112                                 AlphaUse
14113                         }))(obj)).Name))))
14114                         write16(w, uint16(x))
14115                 }
14116                 {
14117                         _, err := w.Write(([]byte((*(*(struct {
14118                                 Param0 Content
14119
14120                                 Name   string
14121                                 Groups []Group
14122
14123                                 P1Type   Param1Type
14124                                 P2Type   Param2Type
14125                                 DrawType DrawType
14126
14127                                 Mesh  string
14128                                 Scale float32
14129                                 //mt:const uint8(6)
14130                                 Tiles        [6]TileDef
14131                                 OverlayTiles [6]TileDef
14132                                 //mt:const uint8(6)
14133                                 SpecialTiles [6]TileDef
14134
14135                                 Color   color.NRGBA
14136                                 Palette Texture
14137
14138                                 Waving       WaveType
14139                                 ConnectSides uint8
14140                                 ConnectTo    []Content
14141                                 InsideTint   color.NRGBA
14142                                 Level        uint8 // Must be < 128.
14143
14144                                 Translucent bool // Sunlight is scattered and becomes normal light.
14145                                 Transparent bool // Sunlight isn't scattered.
14146                                 LightSrc    uint8
14147
14148                                 GndContent   bool
14149                                 Collides     bool
14150                                 Pointable    bool
14151                                 Diggable     bool
14152                                 Climbable    bool
14153                                 Replaceable  bool
14154                                 OnRightClick bool
14155
14156                                 DmgPerSec int32
14157
14158                                 LiquidType   LiquidType
14159                                 FlowingAlt   string
14160                                 SrcAlt       string
14161                                 Viscosity    uint8 // 0-7
14162                                 LiqRenewable bool
14163                                 FlowRange    uint8
14164                                 DrownDmg     uint8
14165                                 Floodable    bool
14166
14167                                 DrawBox, ColBox, SelBox NodeBox
14168
14169                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14170
14171                                 LegacyFaceDir bool
14172                                 LegacyMounted bool
14173
14174                                 DigPredict string
14175
14176                                 MaxLvl uint8
14177
14178                                 AlphaUse
14179                         }))(obj)).Name))[:])
14180                         chk(err)
14181                 }
14182                 if len(((*(*(struct {
14183                         Param0 Content
14184
14185                         Name   string
14186                         Groups []Group
14187
14188                         P1Type   Param1Type
14189                         P2Type   Param2Type
14190                         DrawType DrawType
14191
14192                         Mesh  string
14193                         Scale float32
14194                         //mt:const uint8(6)
14195                         Tiles        [6]TileDef
14196                         OverlayTiles [6]TileDef
14197                         //mt:const uint8(6)
14198                         SpecialTiles [6]TileDef
14199
14200                         Color   color.NRGBA
14201                         Palette Texture
14202
14203                         Waving       WaveType
14204                         ConnectSides uint8
14205                         ConnectTo    []Content
14206                         InsideTint   color.NRGBA
14207                         Level        uint8 // Must be < 128.
14208
14209                         Translucent bool // Sunlight is scattered and becomes normal light.
14210                         Transparent bool // Sunlight isn't scattered.
14211                         LightSrc    uint8
14212
14213                         GndContent   bool
14214                         Collides     bool
14215                         Pointable    bool
14216                         Diggable     bool
14217                         Climbable    bool
14218                         Replaceable  bool
14219                         OnRightClick bool
14220
14221                         DmgPerSec int32
14222
14223                         LiquidType   LiquidType
14224                         FlowingAlt   string
14225                         SrcAlt       string
14226                         Viscosity    uint8 // 0-7
14227                         LiqRenewable bool
14228                         FlowRange    uint8
14229                         DrownDmg     uint8
14230                         Floodable    bool
14231
14232                         DrawBox, ColBox, SelBox NodeBox
14233
14234                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14235
14236                         LegacyFaceDir bool
14237                         LegacyMounted bool
14238
14239                         DigPredict string
14240
14241                         MaxLvl uint8
14242
14243                         AlphaUse
14244                 }))(obj)).Groups)) > math.MaxUint16 {
14245                         chk(ErrTooLong)
14246                 }
14247                 {
14248                         x := uint16(len(((*(*(struct {
14249                                 Param0 Content
14250
14251                                 Name   string
14252                                 Groups []Group
14253
14254                                 P1Type   Param1Type
14255                                 P2Type   Param2Type
14256                                 DrawType DrawType
14257
14258                                 Mesh  string
14259                                 Scale float32
14260                                 //mt:const uint8(6)
14261                                 Tiles        [6]TileDef
14262                                 OverlayTiles [6]TileDef
14263                                 //mt:const uint8(6)
14264                                 SpecialTiles [6]TileDef
14265
14266                                 Color   color.NRGBA
14267                                 Palette Texture
14268
14269                                 Waving       WaveType
14270                                 ConnectSides uint8
14271                                 ConnectTo    []Content
14272                                 InsideTint   color.NRGBA
14273                                 Level        uint8 // Must be < 128.
14274
14275                                 Translucent bool // Sunlight is scattered and becomes normal light.
14276                                 Transparent bool // Sunlight isn't scattered.
14277                                 LightSrc    uint8
14278
14279                                 GndContent   bool
14280                                 Collides     bool
14281                                 Pointable    bool
14282                                 Diggable     bool
14283                                 Climbable    bool
14284                                 Replaceable  bool
14285                                 OnRightClick bool
14286
14287                                 DmgPerSec int32
14288
14289                                 LiquidType   LiquidType
14290                                 FlowingAlt   string
14291                                 SrcAlt       string
14292                                 Viscosity    uint8 // 0-7
14293                                 LiqRenewable bool
14294                                 FlowRange    uint8
14295                                 DrownDmg     uint8
14296                                 Floodable    bool
14297
14298                                 DrawBox, ColBox, SelBox NodeBox
14299
14300                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14301
14302                                 LegacyFaceDir bool
14303                                 LegacyMounted bool
14304
14305                                 DigPredict string
14306
14307                                 MaxLvl uint8
14308
14309                                 AlphaUse
14310                         }))(obj)).Groups)))
14311                         write16(w, uint16(x))
14312                 }
14313                 for local241 := range (*(*(struct {
14314                         Param0 Content
14315
14316                         Name   string
14317                         Groups []Group
14318
14319                         P1Type   Param1Type
14320                         P2Type   Param2Type
14321                         DrawType DrawType
14322
14323                         Mesh  string
14324                         Scale float32
14325                         //mt:const uint8(6)
14326                         Tiles        [6]TileDef
14327                         OverlayTiles [6]TileDef
14328                         //mt:const uint8(6)
14329                         SpecialTiles [6]TileDef
14330
14331                         Color   color.NRGBA
14332                         Palette Texture
14333
14334                         Waving       WaveType
14335                         ConnectSides uint8
14336                         ConnectTo    []Content
14337                         InsideTint   color.NRGBA
14338                         Level        uint8 // Must be < 128.
14339
14340                         Translucent bool // Sunlight is scattered and becomes normal light.
14341                         Transparent bool // Sunlight isn't scattered.
14342                         LightSrc    uint8
14343
14344                         GndContent   bool
14345                         Collides     bool
14346                         Pointable    bool
14347                         Diggable     bool
14348                         Climbable    bool
14349                         Replaceable  bool
14350                         OnRightClick bool
14351
14352                         DmgPerSec int32
14353
14354                         LiquidType   LiquidType
14355                         FlowingAlt   string
14356                         SrcAlt       string
14357                         Viscosity    uint8 // 0-7
14358                         LiqRenewable bool
14359                         FlowRange    uint8
14360                         DrownDmg     uint8
14361                         Floodable    bool
14362
14363                         DrawBox, ColBox, SelBox NodeBox
14364
14365                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14366
14367                         LegacyFaceDir bool
14368                         LegacyMounted bool
14369
14370                         DigPredict string
14371
14372                         MaxLvl uint8
14373
14374                         AlphaUse
14375                 }))(obj)).Groups {
14376                         if err := pcall(func() {
14377                                 (((*(*(struct {
14378                                         Param0 Content
14379
14380                                         Name   string
14381                                         Groups []Group
14382
14383                                         P1Type   Param1Type
14384                                         P2Type   Param2Type
14385                                         DrawType DrawType
14386
14387                                         Mesh  string
14388                                         Scale float32
14389                                         //mt:const uint8(6)
14390                                         Tiles        [6]TileDef
14391                                         OverlayTiles [6]TileDef
14392                                         //mt:const uint8(6)
14393                                         SpecialTiles [6]TileDef
14394
14395                                         Color   color.NRGBA
14396                                         Palette Texture
14397
14398                                         Waving       WaveType
14399                                         ConnectSides uint8
14400                                         ConnectTo    []Content
14401                                         InsideTint   color.NRGBA
14402                                         Level        uint8 // Must be < 128.
14403
14404                                         Translucent bool // Sunlight is scattered and becomes normal light.
14405                                         Transparent bool // Sunlight isn't scattered.
14406                                         LightSrc    uint8
14407
14408                                         GndContent   bool
14409                                         Collides     bool
14410                                         Pointable    bool
14411                                         Diggable     bool
14412                                         Climbable    bool
14413                                         Replaceable  bool
14414                                         OnRightClick bool
14415
14416                                         DmgPerSec int32
14417
14418                                         LiquidType   LiquidType
14419                                         FlowingAlt   string
14420                                         SrcAlt       string
14421                                         Viscosity    uint8 // 0-7
14422                                         LiqRenewable bool
14423                                         FlowRange    uint8
14424                                         DrownDmg     uint8
14425                                         Floodable    bool
14426
14427                                         DrawBox, ColBox, SelBox NodeBox
14428
14429                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14430
14431                                         LegacyFaceDir bool
14432                                         LegacyMounted bool
14433
14434                                         DigPredict string
14435
14436                                         MaxLvl uint8
14437
14438                                         AlphaUse
14439                                 }))(obj)).Groups)[local241]).serialize(w)
14440                         }); err != nil {
14441                                 if err == io.EOF {
14442                                         chk(io.EOF)
14443                                 }
14444                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
14445                         }
14446                 }
14447                 if err := pcall(func() {
14448                         ((*(*(struct {
14449                                 Param0 Content
14450
14451                                 Name   string
14452                                 Groups []Group
14453
14454                                 P1Type   Param1Type
14455                                 P2Type   Param2Type
14456                                 DrawType DrawType
14457
14458                                 Mesh  string
14459                                 Scale float32
14460                                 //mt:const uint8(6)
14461                                 Tiles        [6]TileDef
14462                                 OverlayTiles [6]TileDef
14463                                 //mt:const uint8(6)
14464                                 SpecialTiles [6]TileDef
14465
14466                                 Color   color.NRGBA
14467                                 Palette Texture
14468
14469                                 Waving       WaveType
14470                                 ConnectSides uint8
14471                                 ConnectTo    []Content
14472                                 InsideTint   color.NRGBA
14473                                 Level        uint8 // Must be < 128.
14474
14475                                 Translucent bool // Sunlight is scattered and becomes normal light.
14476                                 Transparent bool // Sunlight isn't scattered.
14477                                 LightSrc    uint8
14478
14479                                 GndContent   bool
14480                                 Collides     bool
14481                                 Pointable    bool
14482                                 Diggable     bool
14483                                 Climbable    bool
14484                                 Replaceable  bool
14485                                 OnRightClick bool
14486
14487                                 DmgPerSec int32
14488
14489                                 LiquidType   LiquidType
14490                                 FlowingAlt   string
14491                                 SrcAlt       string
14492                                 Viscosity    uint8 // 0-7
14493                                 LiqRenewable bool
14494                                 FlowRange    uint8
14495                                 DrownDmg     uint8
14496                                 Floodable    bool
14497
14498                                 DrawBox, ColBox, SelBox NodeBox
14499
14500                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14501
14502                                 LegacyFaceDir bool
14503                                 LegacyMounted bool
14504
14505                                 DigPredict string
14506
14507                                 MaxLvl uint8
14508
14509                                 AlphaUse
14510                         }))(obj)).P1Type).serialize(w)
14511                 }); err != nil {
14512                         if err == io.EOF {
14513                                 chk(io.EOF)
14514                         }
14515                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param1Type", err))
14516                 }
14517                 if err := pcall(func() {
14518                         ((*(*(struct {
14519                                 Param0 Content
14520
14521                                 Name   string
14522                                 Groups []Group
14523
14524                                 P1Type   Param1Type
14525                                 P2Type   Param2Type
14526                                 DrawType DrawType
14527
14528                                 Mesh  string
14529                                 Scale float32
14530                                 //mt:const uint8(6)
14531                                 Tiles        [6]TileDef
14532                                 OverlayTiles [6]TileDef
14533                                 //mt:const uint8(6)
14534                                 SpecialTiles [6]TileDef
14535
14536                                 Color   color.NRGBA
14537                                 Palette Texture
14538
14539                                 Waving       WaveType
14540                                 ConnectSides uint8
14541                                 ConnectTo    []Content
14542                                 InsideTint   color.NRGBA
14543                                 Level        uint8 // Must be < 128.
14544
14545                                 Translucent bool // Sunlight is scattered and becomes normal light.
14546                                 Transparent bool // Sunlight isn't scattered.
14547                                 LightSrc    uint8
14548
14549                                 GndContent   bool
14550                                 Collides     bool
14551                                 Pointable    bool
14552                                 Diggable     bool
14553                                 Climbable    bool
14554                                 Replaceable  bool
14555                                 OnRightClick bool
14556
14557                                 DmgPerSec int32
14558
14559                                 LiquidType   LiquidType
14560                                 FlowingAlt   string
14561                                 SrcAlt       string
14562                                 Viscosity    uint8 // 0-7
14563                                 LiqRenewable bool
14564                                 FlowRange    uint8
14565                                 DrownDmg     uint8
14566                                 Floodable    bool
14567
14568                                 DrawBox, ColBox, SelBox NodeBox
14569
14570                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14571
14572                                 LegacyFaceDir bool
14573                                 LegacyMounted bool
14574
14575                                 DigPredict string
14576
14577                                 MaxLvl uint8
14578
14579                                 AlphaUse
14580                         }))(obj)).P2Type).serialize(w)
14581                 }); err != nil {
14582                         if err == io.EOF {
14583                                 chk(io.EOF)
14584                         }
14585                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param2Type", err))
14586                 }
14587                 if err := pcall(func() {
14588                         ((*(*(struct {
14589                                 Param0 Content
14590
14591                                 Name   string
14592                                 Groups []Group
14593
14594                                 P1Type   Param1Type
14595                                 P2Type   Param2Type
14596                                 DrawType DrawType
14597
14598                                 Mesh  string
14599                                 Scale float32
14600                                 //mt:const uint8(6)
14601                                 Tiles        [6]TileDef
14602                                 OverlayTiles [6]TileDef
14603                                 //mt:const uint8(6)
14604                                 SpecialTiles [6]TileDef
14605
14606                                 Color   color.NRGBA
14607                                 Palette Texture
14608
14609                                 Waving       WaveType
14610                                 ConnectSides uint8
14611                                 ConnectTo    []Content
14612                                 InsideTint   color.NRGBA
14613                                 Level        uint8 // Must be < 128.
14614
14615                                 Translucent bool // Sunlight is scattered and becomes normal light.
14616                                 Transparent bool // Sunlight isn't scattered.
14617                                 LightSrc    uint8
14618
14619                                 GndContent   bool
14620                                 Collides     bool
14621                                 Pointable    bool
14622                                 Diggable     bool
14623                                 Climbable    bool
14624                                 Replaceable  bool
14625                                 OnRightClick bool
14626
14627                                 DmgPerSec int32
14628
14629                                 LiquidType   LiquidType
14630                                 FlowingAlt   string
14631                                 SrcAlt       string
14632                                 Viscosity    uint8 // 0-7
14633                                 LiqRenewable bool
14634                                 FlowRange    uint8
14635                                 DrownDmg     uint8
14636                                 Floodable    bool
14637
14638                                 DrawBox, ColBox, SelBox NodeBox
14639
14640                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14641
14642                                 LegacyFaceDir bool
14643                                 LegacyMounted bool
14644
14645                                 DigPredict string
14646
14647                                 MaxLvl uint8
14648
14649                                 AlphaUse
14650                         }))(obj)).DrawType).serialize(w)
14651                 }); err != nil {
14652                         if err == io.EOF {
14653                                 chk(io.EOF)
14654                         }
14655                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
14656                 }
14657                 if len(([]byte((*(*(struct {
14658                         Param0 Content
14659
14660                         Name   string
14661                         Groups []Group
14662
14663                         P1Type   Param1Type
14664                         P2Type   Param2Type
14665                         DrawType DrawType
14666
14667                         Mesh  string
14668                         Scale float32
14669                         //mt:const uint8(6)
14670                         Tiles        [6]TileDef
14671                         OverlayTiles [6]TileDef
14672                         //mt:const uint8(6)
14673                         SpecialTiles [6]TileDef
14674
14675                         Color   color.NRGBA
14676                         Palette Texture
14677
14678                         Waving       WaveType
14679                         ConnectSides uint8
14680                         ConnectTo    []Content
14681                         InsideTint   color.NRGBA
14682                         Level        uint8 // Must be < 128.
14683
14684                         Translucent bool // Sunlight is scattered and becomes normal light.
14685                         Transparent bool // Sunlight isn't scattered.
14686                         LightSrc    uint8
14687
14688                         GndContent   bool
14689                         Collides     bool
14690                         Pointable    bool
14691                         Diggable     bool
14692                         Climbable    bool
14693                         Replaceable  bool
14694                         OnRightClick bool
14695
14696                         DmgPerSec int32
14697
14698                         LiquidType   LiquidType
14699                         FlowingAlt   string
14700                         SrcAlt       string
14701                         Viscosity    uint8 // 0-7
14702                         LiqRenewable bool
14703                         FlowRange    uint8
14704                         DrownDmg     uint8
14705                         Floodable    bool
14706
14707                         DrawBox, ColBox, SelBox NodeBox
14708
14709                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14710
14711                         LegacyFaceDir bool
14712                         LegacyMounted bool
14713
14714                         DigPredict string
14715
14716                         MaxLvl uint8
14717
14718                         AlphaUse
14719                 }))(obj)).Mesh))) > math.MaxUint16 {
14720                         chk(ErrTooLong)
14721                 }
14722                 {
14723                         x := uint16(len(([]byte((*(*(struct {
14724                                 Param0 Content
14725
14726                                 Name   string
14727                                 Groups []Group
14728
14729                                 P1Type   Param1Type
14730                                 P2Type   Param2Type
14731                                 DrawType DrawType
14732
14733                                 Mesh  string
14734                                 Scale float32
14735                                 //mt:const uint8(6)
14736                                 Tiles        [6]TileDef
14737                                 OverlayTiles [6]TileDef
14738                                 //mt:const uint8(6)
14739                                 SpecialTiles [6]TileDef
14740
14741                                 Color   color.NRGBA
14742                                 Palette Texture
14743
14744                                 Waving       WaveType
14745                                 ConnectSides uint8
14746                                 ConnectTo    []Content
14747                                 InsideTint   color.NRGBA
14748                                 Level        uint8 // Must be < 128.
14749
14750                                 Translucent bool // Sunlight is scattered and becomes normal light.
14751                                 Transparent bool // Sunlight isn't scattered.
14752                                 LightSrc    uint8
14753
14754                                 GndContent   bool
14755                                 Collides     bool
14756                                 Pointable    bool
14757                                 Diggable     bool
14758                                 Climbable    bool
14759                                 Replaceable  bool
14760                                 OnRightClick bool
14761
14762                                 DmgPerSec int32
14763
14764                                 LiquidType   LiquidType
14765                                 FlowingAlt   string
14766                                 SrcAlt       string
14767                                 Viscosity    uint8 // 0-7
14768                                 LiqRenewable bool
14769                                 FlowRange    uint8
14770                                 DrownDmg     uint8
14771                                 Floodable    bool
14772
14773                                 DrawBox, ColBox, SelBox NodeBox
14774
14775                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14776
14777                                 LegacyFaceDir bool
14778                                 LegacyMounted bool
14779
14780                                 DigPredict string
14781
14782                                 MaxLvl uint8
14783
14784                                 AlphaUse
14785                         }))(obj)).Mesh))))
14786                         write16(w, uint16(x))
14787                 }
14788                 {
14789                         _, err := w.Write(([]byte((*(*(struct {
14790                                 Param0 Content
14791
14792                                 Name   string
14793                                 Groups []Group
14794
14795                                 P1Type   Param1Type
14796                                 P2Type   Param2Type
14797                                 DrawType DrawType
14798
14799                                 Mesh  string
14800                                 Scale float32
14801                                 //mt:const uint8(6)
14802                                 Tiles        [6]TileDef
14803                                 OverlayTiles [6]TileDef
14804                                 //mt:const uint8(6)
14805                                 SpecialTiles [6]TileDef
14806
14807                                 Color   color.NRGBA
14808                                 Palette Texture
14809
14810                                 Waving       WaveType
14811                                 ConnectSides uint8
14812                                 ConnectTo    []Content
14813                                 InsideTint   color.NRGBA
14814                                 Level        uint8 // Must be < 128.
14815
14816                                 Translucent bool // Sunlight is scattered and becomes normal light.
14817                                 Transparent bool // Sunlight isn't scattered.
14818                                 LightSrc    uint8
14819
14820                                 GndContent   bool
14821                                 Collides     bool
14822                                 Pointable    bool
14823                                 Diggable     bool
14824                                 Climbable    bool
14825                                 Replaceable  bool
14826                                 OnRightClick bool
14827
14828                                 DmgPerSec int32
14829
14830                                 LiquidType   LiquidType
14831                                 FlowingAlt   string
14832                                 SrcAlt       string
14833                                 Viscosity    uint8 // 0-7
14834                                 LiqRenewable bool
14835                                 FlowRange    uint8
14836                                 DrownDmg     uint8
14837                                 Floodable    bool
14838
14839                                 DrawBox, ColBox, SelBox NodeBox
14840
14841                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14842
14843                                 LegacyFaceDir bool
14844                                 LegacyMounted bool
14845
14846                                 DigPredict string
14847
14848                                 MaxLvl uint8
14849
14850                                 AlphaUse
14851                         }))(obj)).Mesh))[:])
14852                         chk(err)
14853                 }
14854                 {
14855                         x := (*(*(struct {
14856                                 Param0 Content
14857
14858                                 Name   string
14859                                 Groups []Group
14860
14861                                 P1Type   Param1Type
14862                                 P2Type   Param2Type
14863                                 DrawType DrawType
14864
14865                                 Mesh  string
14866                                 Scale float32
14867                                 //mt:const uint8(6)
14868                                 Tiles        [6]TileDef
14869                                 OverlayTiles [6]TileDef
14870                                 //mt:const uint8(6)
14871                                 SpecialTiles [6]TileDef
14872
14873                                 Color   color.NRGBA
14874                                 Palette Texture
14875
14876                                 Waving       WaveType
14877                                 ConnectSides uint8
14878                                 ConnectTo    []Content
14879                                 InsideTint   color.NRGBA
14880                                 Level        uint8 // Must be < 128.
14881
14882                                 Translucent bool // Sunlight is scattered and becomes normal light.
14883                                 Transparent bool // Sunlight isn't scattered.
14884                                 LightSrc    uint8
14885
14886                                 GndContent   bool
14887                                 Collides     bool
14888                                 Pointable    bool
14889                                 Diggable     bool
14890                                 Climbable    bool
14891                                 Replaceable  bool
14892                                 OnRightClick bool
14893
14894                                 DmgPerSec int32
14895
14896                                 LiquidType   LiquidType
14897                                 FlowingAlt   string
14898                                 SrcAlt       string
14899                                 Viscosity    uint8 // 0-7
14900                                 LiqRenewable bool
14901                                 FlowRange    uint8
14902                                 DrownDmg     uint8
14903                                 Floodable    bool
14904
14905                                 DrawBox, ColBox, SelBox NodeBox
14906
14907                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14908
14909                                 LegacyFaceDir bool
14910                                 LegacyMounted bool
14911
14912                                 DigPredict string
14913
14914                                 MaxLvl uint8
14915
14916                                 AlphaUse
14917                         }))(obj)).Scale
14918                         write32(w, math.Float32bits(x))
14919                 }
14920                 {
14921                         local242 := uint8(6)
14922                         {
14923                                 x := local242
14924                                 write8(w, uint8(x))
14925                         }
14926                 }
14927                 for local243 := range (*(*(struct {
14928                         Param0 Content
14929
14930                         Name   string
14931                         Groups []Group
14932
14933                         P1Type   Param1Type
14934                         P2Type   Param2Type
14935                         DrawType DrawType
14936
14937                         Mesh  string
14938                         Scale float32
14939                         //mt:const uint8(6)
14940                         Tiles        [6]TileDef
14941                         OverlayTiles [6]TileDef
14942                         //mt:const uint8(6)
14943                         SpecialTiles [6]TileDef
14944
14945                         Color   color.NRGBA
14946                         Palette Texture
14947
14948                         Waving       WaveType
14949                         ConnectSides uint8
14950                         ConnectTo    []Content
14951                         InsideTint   color.NRGBA
14952                         Level        uint8 // Must be < 128.
14953
14954                         Translucent bool // Sunlight is scattered and becomes normal light.
14955                         Transparent bool // Sunlight isn't scattered.
14956                         LightSrc    uint8
14957
14958                         GndContent   bool
14959                         Collides     bool
14960                         Pointable    bool
14961                         Diggable     bool
14962                         Climbable    bool
14963                         Replaceable  bool
14964                         OnRightClick bool
14965
14966                         DmgPerSec int32
14967
14968                         LiquidType   LiquidType
14969                         FlowingAlt   string
14970                         SrcAlt       string
14971                         Viscosity    uint8 // 0-7
14972                         LiqRenewable bool
14973                         FlowRange    uint8
14974                         DrownDmg     uint8
14975                         Floodable    bool
14976
14977                         DrawBox, ColBox, SelBox NodeBox
14978
14979                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14980
14981                         LegacyFaceDir bool
14982                         LegacyMounted bool
14983
14984                         DigPredict string
14985
14986                         MaxLvl uint8
14987
14988                         AlphaUse
14989                 }))(obj)).Tiles {
14990                         if err := pcall(func() {
14991                                 (((*(*(struct {
14992                                         Param0 Content
14993
14994                                         Name   string
14995                                         Groups []Group
14996
14997                                         P1Type   Param1Type
14998                                         P2Type   Param2Type
14999                                         DrawType DrawType
15000
15001                                         Mesh  string
15002                                         Scale float32
15003                                         //mt:const uint8(6)
15004                                         Tiles        [6]TileDef
15005                                         OverlayTiles [6]TileDef
15006                                         //mt:const uint8(6)
15007                                         SpecialTiles [6]TileDef
15008
15009                                         Color   color.NRGBA
15010                                         Palette Texture
15011
15012                                         Waving       WaveType
15013                                         ConnectSides uint8
15014                                         ConnectTo    []Content
15015                                         InsideTint   color.NRGBA
15016                                         Level        uint8 // Must be < 128.
15017
15018                                         Translucent bool // Sunlight is scattered and becomes normal light.
15019                                         Transparent bool // Sunlight isn't scattered.
15020                                         LightSrc    uint8
15021
15022                                         GndContent   bool
15023                                         Collides     bool
15024                                         Pointable    bool
15025                                         Diggable     bool
15026                                         Climbable    bool
15027                                         Replaceable  bool
15028                                         OnRightClick bool
15029
15030                                         DmgPerSec int32
15031
15032                                         LiquidType   LiquidType
15033                                         FlowingAlt   string
15034                                         SrcAlt       string
15035                                         Viscosity    uint8 // 0-7
15036                                         LiqRenewable bool
15037                                         FlowRange    uint8
15038                                         DrownDmg     uint8
15039                                         Floodable    bool
15040
15041                                         DrawBox, ColBox, SelBox NodeBox
15042
15043                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15044
15045                                         LegacyFaceDir bool
15046                                         LegacyMounted bool
15047
15048                                         DigPredict string
15049
15050                                         MaxLvl uint8
15051
15052                                         AlphaUse
15053                                 }))(obj)).Tiles)[local243]).serialize(w)
15054                         }); err != nil {
15055                                 if err == io.EOF {
15056                                         chk(io.EOF)
15057                                 }
15058                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
15059                         }
15060                 }
15061                 for local244 := range (*(*(struct {
15062                         Param0 Content
15063
15064                         Name   string
15065                         Groups []Group
15066
15067                         P1Type   Param1Type
15068                         P2Type   Param2Type
15069                         DrawType DrawType
15070
15071                         Mesh  string
15072                         Scale float32
15073                         //mt:const uint8(6)
15074                         Tiles        [6]TileDef
15075                         OverlayTiles [6]TileDef
15076                         //mt:const uint8(6)
15077                         SpecialTiles [6]TileDef
15078
15079                         Color   color.NRGBA
15080                         Palette Texture
15081
15082                         Waving       WaveType
15083                         ConnectSides uint8
15084                         ConnectTo    []Content
15085                         InsideTint   color.NRGBA
15086                         Level        uint8 // Must be < 128.
15087
15088                         Translucent bool // Sunlight is scattered and becomes normal light.
15089                         Transparent bool // Sunlight isn't scattered.
15090                         LightSrc    uint8
15091
15092                         GndContent   bool
15093                         Collides     bool
15094                         Pointable    bool
15095                         Diggable     bool
15096                         Climbable    bool
15097                         Replaceable  bool
15098                         OnRightClick bool
15099
15100                         DmgPerSec int32
15101
15102                         LiquidType   LiquidType
15103                         FlowingAlt   string
15104                         SrcAlt       string
15105                         Viscosity    uint8 // 0-7
15106                         LiqRenewable bool
15107                         FlowRange    uint8
15108                         DrownDmg     uint8
15109                         Floodable    bool
15110
15111                         DrawBox, ColBox, SelBox NodeBox
15112
15113                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15114
15115                         LegacyFaceDir bool
15116                         LegacyMounted bool
15117
15118                         DigPredict string
15119
15120                         MaxLvl uint8
15121
15122                         AlphaUse
15123                 }))(obj)).OverlayTiles {
15124                         if err := pcall(func() {
15125                                 (((*(*(struct {
15126                                         Param0 Content
15127
15128                                         Name   string
15129                                         Groups []Group
15130
15131                                         P1Type   Param1Type
15132                                         P2Type   Param2Type
15133                                         DrawType DrawType
15134
15135                                         Mesh  string
15136                                         Scale float32
15137                                         //mt:const uint8(6)
15138                                         Tiles        [6]TileDef
15139                                         OverlayTiles [6]TileDef
15140                                         //mt:const uint8(6)
15141                                         SpecialTiles [6]TileDef
15142
15143                                         Color   color.NRGBA
15144                                         Palette Texture
15145
15146                                         Waving       WaveType
15147                                         ConnectSides uint8
15148                                         ConnectTo    []Content
15149                                         InsideTint   color.NRGBA
15150                                         Level        uint8 // Must be < 128.
15151
15152                                         Translucent bool // Sunlight is scattered and becomes normal light.
15153                                         Transparent bool // Sunlight isn't scattered.
15154                                         LightSrc    uint8
15155
15156                                         GndContent   bool
15157                                         Collides     bool
15158                                         Pointable    bool
15159                                         Diggable     bool
15160                                         Climbable    bool
15161                                         Replaceable  bool
15162                                         OnRightClick bool
15163
15164                                         DmgPerSec int32
15165
15166                                         LiquidType   LiquidType
15167                                         FlowingAlt   string
15168                                         SrcAlt       string
15169                                         Viscosity    uint8 // 0-7
15170                                         LiqRenewable bool
15171                                         FlowRange    uint8
15172                                         DrownDmg     uint8
15173                                         Floodable    bool
15174
15175                                         DrawBox, ColBox, SelBox NodeBox
15176
15177                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15178
15179                                         LegacyFaceDir bool
15180                                         LegacyMounted bool
15181
15182                                         DigPredict string
15183
15184                                         MaxLvl uint8
15185
15186                                         AlphaUse
15187                                 }))(obj)).OverlayTiles)[local244]).serialize(w)
15188                         }); err != nil {
15189                                 if err == io.EOF {
15190                                         chk(io.EOF)
15191                                 }
15192                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
15193                         }
15194                 }
15195                 {
15196                         local245 := uint8(6)
15197                         {
15198                                 x := local245
15199                                 write8(w, uint8(x))
15200                         }
15201                 }
15202                 for local246 := range (*(*(struct {
15203                         Param0 Content
15204
15205                         Name   string
15206                         Groups []Group
15207
15208                         P1Type   Param1Type
15209                         P2Type   Param2Type
15210                         DrawType DrawType
15211
15212                         Mesh  string
15213                         Scale float32
15214                         //mt:const uint8(6)
15215                         Tiles        [6]TileDef
15216                         OverlayTiles [6]TileDef
15217                         //mt:const uint8(6)
15218                         SpecialTiles [6]TileDef
15219
15220                         Color   color.NRGBA
15221                         Palette Texture
15222
15223                         Waving       WaveType
15224                         ConnectSides uint8
15225                         ConnectTo    []Content
15226                         InsideTint   color.NRGBA
15227                         Level        uint8 // Must be < 128.
15228
15229                         Translucent bool // Sunlight is scattered and becomes normal light.
15230                         Transparent bool // Sunlight isn't scattered.
15231                         LightSrc    uint8
15232
15233                         GndContent   bool
15234                         Collides     bool
15235                         Pointable    bool
15236                         Diggable     bool
15237                         Climbable    bool
15238                         Replaceable  bool
15239                         OnRightClick bool
15240
15241                         DmgPerSec int32
15242
15243                         LiquidType   LiquidType
15244                         FlowingAlt   string
15245                         SrcAlt       string
15246                         Viscosity    uint8 // 0-7
15247                         LiqRenewable bool
15248                         FlowRange    uint8
15249                         DrownDmg     uint8
15250                         Floodable    bool
15251
15252                         DrawBox, ColBox, SelBox NodeBox
15253
15254                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15255
15256                         LegacyFaceDir bool
15257                         LegacyMounted bool
15258
15259                         DigPredict string
15260
15261                         MaxLvl uint8
15262
15263                         AlphaUse
15264                 }))(obj)).SpecialTiles {
15265                         if err := pcall(func() {
15266                                 (((*(*(struct {
15267                                         Param0 Content
15268
15269                                         Name   string
15270                                         Groups []Group
15271
15272                                         P1Type   Param1Type
15273                                         P2Type   Param2Type
15274                                         DrawType DrawType
15275
15276                                         Mesh  string
15277                                         Scale float32
15278                                         //mt:const uint8(6)
15279                                         Tiles        [6]TileDef
15280                                         OverlayTiles [6]TileDef
15281                                         //mt:const uint8(6)
15282                                         SpecialTiles [6]TileDef
15283
15284                                         Color   color.NRGBA
15285                                         Palette Texture
15286
15287                                         Waving       WaveType
15288                                         ConnectSides uint8
15289                                         ConnectTo    []Content
15290                                         InsideTint   color.NRGBA
15291                                         Level        uint8 // Must be < 128.
15292
15293                                         Translucent bool // Sunlight is scattered and becomes normal light.
15294                                         Transparent bool // Sunlight isn't scattered.
15295                                         LightSrc    uint8
15296
15297                                         GndContent   bool
15298                                         Collides     bool
15299                                         Pointable    bool
15300                                         Diggable     bool
15301                                         Climbable    bool
15302                                         Replaceable  bool
15303                                         OnRightClick bool
15304
15305                                         DmgPerSec int32
15306
15307                                         LiquidType   LiquidType
15308                                         FlowingAlt   string
15309                                         SrcAlt       string
15310                                         Viscosity    uint8 // 0-7
15311                                         LiqRenewable bool
15312                                         FlowRange    uint8
15313                                         DrownDmg     uint8
15314                                         Floodable    bool
15315
15316                                         DrawBox, ColBox, SelBox NodeBox
15317
15318                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15319
15320                                         LegacyFaceDir bool
15321                                         LegacyMounted bool
15322
15323                                         DigPredict string
15324
15325                                         MaxLvl uint8
15326
15327                                         AlphaUse
15328                                 }))(obj)).SpecialTiles)[local246]).serialize(w)
15329                         }); err != nil {
15330                                 if err == io.EOF {
15331                                         chk(io.EOF)
15332                                 }
15333                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
15334                         }
15335                 }
15336                 {
15337                         x := (*(*(struct {
15338                                 Param0 Content
15339
15340                                 Name   string
15341                                 Groups []Group
15342
15343                                 P1Type   Param1Type
15344                                 P2Type   Param2Type
15345                                 DrawType DrawType
15346
15347                                 Mesh  string
15348                                 Scale float32
15349                                 //mt:const uint8(6)
15350                                 Tiles        [6]TileDef
15351                                 OverlayTiles [6]TileDef
15352                                 //mt:const uint8(6)
15353                                 SpecialTiles [6]TileDef
15354
15355                                 Color   color.NRGBA
15356                                 Palette Texture
15357
15358                                 Waving       WaveType
15359                                 ConnectSides uint8
15360                                 ConnectTo    []Content
15361                                 InsideTint   color.NRGBA
15362                                 Level        uint8 // Must be < 128.
15363
15364                                 Translucent bool // Sunlight is scattered and becomes normal light.
15365                                 Transparent bool // Sunlight isn't scattered.
15366                                 LightSrc    uint8
15367
15368                                 GndContent   bool
15369                                 Collides     bool
15370                                 Pointable    bool
15371                                 Diggable     bool
15372                                 Climbable    bool
15373                                 Replaceable  bool
15374                                 OnRightClick bool
15375
15376                                 DmgPerSec int32
15377
15378                                 LiquidType   LiquidType
15379                                 FlowingAlt   string
15380                                 SrcAlt       string
15381                                 Viscosity    uint8 // 0-7
15382                                 LiqRenewable bool
15383                                 FlowRange    uint8
15384                                 DrownDmg     uint8
15385                                 Floodable    bool
15386
15387                                 DrawBox, ColBox, SelBox NodeBox
15388
15389                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15390
15391                                 LegacyFaceDir bool
15392                                 LegacyMounted bool
15393
15394                                 DigPredict string
15395
15396                                 MaxLvl uint8
15397
15398                                 AlphaUse
15399                         }))(obj)).Color
15400                         w.Write([]byte{x.A, x.R, x.G, x.B})
15401
15402                 }
15403                 if err := pcall(func() {
15404                         ((*(*(struct {
15405                                 Param0 Content
15406
15407                                 Name   string
15408                                 Groups []Group
15409
15410                                 P1Type   Param1Type
15411                                 P2Type   Param2Type
15412                                 DrawType DrawType
15413
15414                                 Mesh  string
15415                                 Scale float32
15416                                 //mt:const uint8(6)
15417                                 Tiles        [6]TileDef
15418                                 OverlayTiles [6]TileDef
15419                                 //mt:const uint8(6)
15420                                 SpecialTiles [6]TileDef
15421
15422                                 Color   color.NRGBA
15423                                 Palette Texture
15424
15425                                 Waving       WaveType
15426                                 ConnectSides uint8
15427                                 ConnectTo    []Content
15428                                 InsideTint   color.NRGBA
15429                                 Level        uint8 // Must be < 128.
15430
15431                                 Translucent bool // Sunlight is scattered and becomes normal light.
15432                                 Transparent bool // Sunlight isn't scattered.
15433                                 LightSrc    uint8
15434
15435                                 GndContent   bool
15436                                 Collides     bool
15437                                 Pointable    bool
15438                                 Diggable     bool
15439                                 Climbable    bool
15440                                 Replaceable  bool
15441                                 OnRightClick bool
15442
15443                                 DmgPerSec int32
15444
15445                                 LiquidType   LiquidType
15446                                 FlowingAlt   string
15447                                 SrcAlt       string
15448                                 Viscosity    uint8 // 0-7
15449                                 LiqRenewable bool
15450                                 FlowRange    uint8
15451                                 DrownDmg     uint8
15452                                 Floodable    bool
15453
15454                                 DrawBox, ColBox, SelBox NodeBox
15455
15456                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15457
15458                                 LegacyFaceDir bool
15459                                 LegacyMounted bool
15460
15461                                 DigPredict string
15462
15463                                 MaxLvl uint8
15464
15465                                 AlphaUse
15466                         }))(obj)).Palette).serialize(w)
15467                 }); err != nil {
15468                         if err == io.EOF {
15469                                 chk(io.EOF)
15470                         }
15471                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
15472                 }
15473                 if err := pcall(func() {
15474                         ((*(*(struct {
15475                                 Param0 Content
15476
15477                                 Name   string
15478                                 Groups []Group
15479
15480                                 P1Type   Param1Type
15481                                 P2Type   Param2Type
15482                                 DrawType DrawType
15483
15484                                 Mesh  string
15485                                 Scale float32
15486                                 //mt:const uint8(6)
15487                                 Tiles        [6]TileDef
15488                                 OverlayTiles [6]TileDef
15489                                 //mt:const uint8(6)
15490                                 SpecialTiles [6]TileDef
15491
15492                                 Color   color.NRGBA
15493                                 Palette Texture
15494
15495                                 Waving       WaveType
15496                                 ConnectSides uint8
15497                                 ConnectTo    []Content
15498                                 InsideTint   color.NRGBA
15499                                 Level        uint8 // Must be < 128.
15500
15501                                 Translucent bool // Sunlight is scattered and becomes normal light.
15502                                 Transparent bool // Sunlight isn't scattered.
15503                                 LightSrc    uint8
15504
15505                                 GndContent   bool
15506                                 Collides     bool
15507                                 Pointable    bool
15508                                 Diggable     bool
15509                                 Climbable    bool
15510                                 Replaceable  bool
15511                                 OnRightClick bool
15512
15513                                 DmgPerSec int32
15514
15515                                 LiquidType   LiquidType
15516                                 FlowingAlt   string
15517                                 SrcAlt       string
15518                                 Viscosity    uint8 // 0-7
15519                                 LiqRenewable bool
15520                                 FlowRange    uint8
15521                                 DrownDmg     uint8
15522                                 Floodable    bool
15523
15524                                 DrawBox, ColBox, SelBox NodeBox
15525
15526                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15527
15528                                 LegacyFaceDir bool
15529                                 LegacyMounted bool
15530
15531                                 DigPredict string
15532
15533                                 MaxLvl uint8
15534
15535                                 AlphaUse
15536                         }))(obj)).Waving).serialize(w)
15537                 }); err != nil {
15538                         if err == io.EOF {
15539                                 chk(io.EOF)
15540                         }
15541                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.WaveType", err))
15542                 }
15543                 {
15544                         x := (*(*(struct {
15545                                 Param0 Content
15546
15547                                 Name   string
15548                                 Groups []Group
15549
15550                                 P1Type   Param1Type
15551                                 P2Type   Param2Type
15552                                 DrawType DrawType
15553
15554                                 Mesh  string
15555                                 Scale float32
15556                                 //mt:const uint8(6)
15557                                 Tiles        [6]TileDef
15558                                 OverlayTiles [6]TileDef
15559                                 //mt:const uint8(6)
15560                                 SpecialTiles [6]TileDef
15561
15562                                 Color   color.NRGBA
15563                                 Palette Texture
15564
15565                                 Waving       WaveType
15566                                 ConnectSides uint8
15567                                 ConnectTo    []Content
15568                                 InsideTint   color.NRGBA
15569                                 Level        uint8 // Must be < 128.
15570
15571                                 Translucent bool // Sunlight is scattered and becomes normal light.
15572                                 Transparent bool // Sunlight isn't scattered.
15573                                 LightSrc    uint8
15574
15575                                 GndContent   bool
15576                                 Collides     bool
15577                                 Pointable    bool
15578                                 Diggable     bool
15579                                 Climbable    bool
15580                                 Replaceable  bool
15581                                 OnRightClick bool
15582
15583                                 DmgPerSec int32
15584
15585                                 LiquidType   LiquidType
15586                                 FlowingAlt   string
15587                                 SrcAlt       string
15588                                 Viscosity    uint8 // 0-7
15589                                 LiqRenewable bool
15590                                 FlowRange    uint8
15591                                 DrownDmg     uint8
15592                                 Floodable    bool
15593
15594                                 DrawBox, ColBox, SelBox NodeBox
15595
15596                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15597
15598                                 LegacyFaceDir bool
15599                                 LegacyMounted bool
15600
15601                                 DigPredict string
15602
15603                                 MaxLvl uint8
15604
15605                                 AlphaUse
15606                         }))(obj)).ConnectSides
15607                         write8(w, uint8(x))
15608                 }
15609                 if len(((*(*(struct {
15610                         Param0 Content
15611
15612                         Name   string
15613                         Groups []Group
15614
15615                         P1Type   Param1Type
15616                         P2Type   Param2Type
15617                         DrawType DrawType
15618
15619                         Mesh  string
15620                         Scale float32
15621                         //mt:const uint8(6)
15622                         Tiles        [6]TileDef
15623                         OverlayTiles [6]TileDef
15624                         //mt:const uint8(6)
15625                         SpecialTiles [6]TileDef
15626
15627                         Color   color.NRGBA
15628                         Palette Texture
15629
15630                         Waving       WaveType
15631                         ConnectSides uint8
15632                         ConnectTo    []Content
15633                         InsideTint   color.NRGBA
15634                         Level        uint8 // Must be < 128.
15635
15636                         Translucent bool // Sunlight is scattered and becomes normal light.
15637                         Transparent bool // Sunlight isn't scattered.
15638                         LightSrc    uint8
15639
15640                         GndContent   bool
15641                         Collides     bool
15642                         Pointable    bool
15643                         Diggable     bool
15644                         Climbable    bool
15645                         Replaceable  bool
15646                         OnRightClick bool
15647
15648                         DmgPerSec int32
15649
15650                         LiquidType   LiquidType
15651                         FlowingAlt   string
15652                         SrcAlt       string
15653                         Viscosity    uint8 // 0-7
15654                         LiqRenewable bool
15655                         FlowRange    uint8
15656                         DrownDmg     uint8
15657                         Floodable    bool
15658
15659                         DrawBox, ColBox, SelBox NodeBox
15660
15661                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15662
15663                         LegacyFaceDir bool
15664                         LegacyMounted bool
15665
15666                         DigPredict string
15667
15668                         MaxLvl uint8
15669
15670                         AlphaUse
15671                 }))(obj)).ConnectTo)) > math.MaxUint16 {
15672                         chk(ErrTooLong)
15673                 }
15674                 {
15675                         x := uint16(len(((*(*(struct {
15676                                 Param0 Content
15677
15678                                 Name   string
15679                                 Groups []Group
15680
15681                                 P1Type   Param1Type
15682                                 P2Type   Param2Type
15683                                 DrawType DrawType
15684
15685                                 Mesh  string
15686                                 Scale float32
15687                                 //mt:const uint8(6)
15688                                 Tiles        [6]TileDef
15689                                 OverlayTiles [6]TileDef
15690                                 //mt:const uint8(6)
15691                                 SpecialTiles [6]TileDef
15692
15693                                 Color   color.NRGBA
15694                                 Palette Texture
15695
15696                                 Waving       WaveType
15697                                 ConnectSides uint8
15698                                 ConnectTo    []Content
15699                                 InsideTint   color.NRGBA
15700                                 Level        uint8 // Must be < 128.
15701
15702                                 Translucent bool // Sunlight is scattered and becomes normal light.
15703                                 Transparent bool // Sunlight isn't scattered.
15704                                 LightSrc    uint8
15705
15706                                 GndContent   bool
15707                                 Collides     bool
15708                                 Pointable    bool
15709                                 Diggable     bool
15710                                 Climbable    bool
15711                                 Replaceable  bool
15712                                 OnRightClick bool
15713
15714                                 DmgPerSec int32
15715
15716                                 LiquidType   LiquidType
15717                                 FlowingAlt   string
15718                                 SrcAlt       string
15719                                 Viscosity    uint8 // 0-7
15720                                 LiqRenewable bool
15721                                 FlowRange    uint8
15722                                 DrownDmg     uint8
15723                                 Floodable    bool
15724
15725                                 DrawBox, ColBox, SelBox NodeBox
15726
15727                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15728
15729                                 LegacyFaceDir bool
15730                                 LegacyMounted bool
15731
15732                                 DigPredict string
15733
15734                                 MaxLvl uint8
15735
15736                                 AlphaUse
15737                         }))(obj)).ConnectTo)))
15738                         write16(w, uint16(x))
15739                 }
15740                 for local247 := range (*(*(struct {
15741                         Param0 Content
15742
15743                         Name   string
15744                         Groups []Group
15745
15746                         P1Type   Param1Type
15747                         P2Type   Param2Type
15748                         DrawType DrawType
15749
15750                         Mesh  string
15751                         Scale float32
15752                         //mt:const uint8(6)
15753                         Tiles        [6]TileDef
15754                         OverlayTiles [6]TileDef
15755                         //mt:const uint8(6)
15756                         SpecialTiles [6]TileDef
15757
15758                         Color   color.NRGBA
15759                         Palette Texture
15760
15761                         Waving       WaveType
15762                         ConnectSides uint8
15763                         ConnectTo    []Content
15764                         InsideTint   color.NRGBA
15765                         Level        uint8 // Must be < 128.
15766
15767                         Translucent bool // Sunlight is scattered and becomes normal light.
15768                         Transparent bool // Sunlight isn't scattered.
15769                         LightSrc    uint8
15770
15771                         GndContent   bool
15772                         Collides     bool
15773                         Pointable    bool
15774                         Diggable     bool
15775                         Climbable    bool
15776                         Replaceable  bool
15777                         OnRightClick bool
15778
15779                         DmgPerSec int32
15780
15781                         LiquidType   LiquidType
15782                         FlowingAlt   string
15783                         SrcAlt       string
15784                         Viscosity    uint8 // 0-7
15785                         LiqRenewable bool
15786                         FlowRange    uint8
15787                         DrownDmg     uint8
15788                         Floodable    bool
15789
15790                         DrawBox, ColBox, SelBox NodeBox
15791
15792                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15793
15794                         LegacyFaceDir bool
15795                         LegacyMounted bool
15796
15797                         DigPredict string
15798
15799                         MaxLvl uint8
15800
15801                         AlphaUse
15802                 }))(obj)).ConnectTo {
15803                         if err := pcall(func() {
15804                                 (((*(*(struct {
15805                                         Param0 Content
15806
15807                                         Name   string
15808                                         Groups []Group
15809
15810                                         P1Type   Param1Type
15811                                         P2Type   Param2Type
15812                                         DrawType DrawType
15813
15814                                         Mesh  string
15815                                         Scale float32
15816                                         //mt:const uint8(6)
15817                                         Tiles        [6]TileDef
15818                                         OverlayTiles [6]TileDef
15819                                         //mt:const uint8(6)
15820                                         SpecialTiles [6]TileDef
15821
15822                                         Color   color.NRGBA
15823                                         Palette Texture
15824
15825                                         Waving       WaveType
15826                                         ConnectSides uint8
15827                                         ConnectTo    []Content
15828                                         InsideTint   color.NRGBA
15829                                         Level        uint8 // Must be < 128.
15830
15831                                         Translucent bool // Sunlight is scattered and becomes normal light.
15832                                         Transparent bool // Sunlight isn't scattered.
15833                                         LightSrc    uint8
15834
15835                                         GndContent   bool
15836                                         Collides     bool
15837                                         Pointable    bool
15838                                         Diggable     bool
15839                                         Climbable    bool
15840                                         Replaceable  bool
15841                                         OnRightClick bool
15842
15843                                         DmgPerSec int32
15844
15845                                         LiquidType   LiquidType
15846                                         FlowingAlt   string
15847                                         SrcAlt       string
15848                                         Viscosity    uint8 // 0-7
15849                                         LiqRenewable bool
15850                                         FlowRange    uint8
15851                                         DrownDmg     uint8
15852                                         Floodable    bool
15853
15854                                         DrawBox, ColBox, SelBox NodeBox
15855
15856                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15857
15858                                         LegacyFaceDir bool
15859                                         LegacyMounted bool
15860
15861                                         DigPredict string
15862
15863                                         MaxLvl uint8
15864
15865                                         AlphaUse
15866                                 }))(obj)).ConnectTo)[local247]).serialize(w)
15867                         }); err != nil {
15868                                 if err == io.EOF {
15869                                         chk(io.EOF)
15870                                 }
15871                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
15872                         }
15873                 }
15874                 {
15875                         x := (*(*(struct {
15876                                 Param0 Content
15877
15878                                 Name   string
15879                                 Groups []Group
15880
15881                                 P1Type   Param1Type
15882                                 P2Type   Param2Type
15883                                 DrawType DrawType
15884
15885                                 Mesh  string
15886                                 Scale float32
15887                                 //mt:const uint8(6)
15888                                 Tiles        [6]TileDef
15889                                 OverlayTiles [6]TileDef
15890                                 //mt:const uint8(6)
15891                                 SpecialTiles [6]TileDef
15892
15893                                 Color   color.NRGBA
15894                                 Palette Texture
15895
15896                                 Waving       WaveType
15897                                 ConnectSides uint8
15898                                 ConnectTo    []Content
15899                                 InsideTint   color.NRGBA
15900                                 Level        uint8 // Must be < 128.
15901
15902                                 Translucent bool // Sunlight is scattered and becomes normal light.
15903                                 Transparent bool // Sunlight isn't scattered.
15904                                 LightSrc    uint8
15905
15906                                 GndContent   bool
15907                                 Collides     bool
15908                                 Pointable    bool
15909                                 Diggable     bool
15910                                 Climbable    bool
15911                                 Replaceable  bool
15912                                 OnRightClick bool
15913
15914                                 DmgPerSec int32
15915
15916                                 LiquidType   LiquidType
15917                                 FlowingAlt   string
15918                                 SrcAlt       string
15919                                 Viscosity    uint8 // 0-7
15920                                 LiqRenewable bool
15921                                 FlowRange    uint8
15922                                 DrownDmg     uint8
15923                                 Floodable    bool
15924
15925                                 DrawBox, ColBox, SelBox NodeBox
15926
15927                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15928
15929                                 LegacyFaceDir bool
15930                                 LegacyMounted bool
15931
15932                                 DigPredict string
15933
15934                                 MaxLvl uint8
15935
15936                                 AlphaUse
15937                         }))(obj)).InsideTint
15938                         w.Write([]byte{x.A, x.R, x.G, x.B})
15939
15940                 }
15941                 {
15942                         x := (*(*(struct {
15943                                 Param0 Content
15944
15945                                 Name   string
15946                                 Groups []Group
15947
15948                                 P1Type   Param1Type
15949                                 P2Type   Param2Type
15950                                 DrawType DrawType
15951
15952                                 Mesh  string
15953                                 Scale float32
15954                                 //mt:const uint8(6)
15955                                 Tiles        [6]TileDef
15956                                 OverlayTiles [6]TileDef
15957                                 //mt:const uint8(6)
15958                                 SpecialTiles [6]TileDef
15959
15960                                 Color   color.NRGBA
15961                                 Palette Texture
15962
15963                                 Waving       WaveType
15964                                 ConnectSides uint8
15965                                 ConnectTo    []Content
15966                                 InsideTint   color.NRGBA
15967                                 Level        uint8 // Must be < 128.
15968
15969                                 Translucent bool // Sunlight is scattered and becomes normal light.
15970                                 Transparent bool // Sunlight isn't scattered.
15971                                 LightSrc    uint8
15972
15973                                 GndContent   bool
15974                                 Collides     bool
15975                                 Pointable    bool
15976                                 Diggable     bool
15977                                 Climbable    bool
15978                                 Replaceable  bool
15979                                 OnRightClick bool
15980
15981                                 DmgPerSec int32
15982
15983                                 LiquidType   LiquidType
15984                                 FlowingAlt   string
15985                                 SrcAlt       string
15986                                 Viscosity    uint8 // 0-7
15987                                 LiqRenewable bool
15988                                 FlowRange    uint8
15989                                 DrownDmg     uint8
15990                                 Floodable    bool
15991
15992                                 DrawBox, ColBox, SelBox NodeBox
15993
15994                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15995
15996                                 LegacyFaceDir bool
15997                                 LegacyMounted bool
15998
15999                                 DigPredict string
16000
16001                                 MaxLvl uint8
16002
16003                                 AlphaUse
16004                         }))(obj)).Level
16005                         write8(w, uint8(x))
16006                 }
16007                 {
16008                         x := (*(*(struct {
16009                                 Param0 Content
16010
16011                                 Name   string
16012                                 Groups []Group
16013
16014                                 P1Type   Param1Type
16015                                 P2Type   Param2Type
16016                                 DrawType DrawType
16017
16018                                 Mesh  string
16019                                 Scale float32
16020                                 //mt:const uint8(6)
16021                                 Tiles        [6]TileDef
16022                                 OverlayTiles [6]TileDef
16023                                 //mt:const uint8(6)
16024                                 SpecialTiles [6]TileDef
16025
16026                                 Color   color.NRGBA
16027                                 Palette Texture
16028
16029                                 Waving       WaveType
16030                                 ConnectSides uint8
16031                                 ConnectTo    []Content
16032                                 InsideTint   color.NRGBA
16033                                 Level        uint8 // Must be < 128.
16034
16035                                 Translucent bool // Sunlight is scattered and becomes normal light.
16036                                 Transparent bool // Sunlight isn't scattered.
16037                                 LightSrc    uint8
16038
16039                                 GndContent   bool
16040                                 Collides     bool
16041                                 Pointable    bool
16042                                 Diggable     bool
16043                                 Climbable    bool
16044                                 Replaceable  bool
16045                                 OnRightClick bool
16046
16047                                 DmgPerSec int32
16048
16049                                 LiquidType   LiquidType
16050                                 FlowingAlt   string
16051                                 SrcAlt       string
16052                                 Viscosity    uint8 // 0-7
16053                                 LiqRenewable bool
16054                                 FlowRange    uint8
16055                                 DrownDmg     uint8
16056                                 Floodable    bool
16057
16058                                 DrawBox, ColBox, SelBox NodeBox
16059
16060                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16061
16062                                 LegacyFaceDir bool
16063                                 LegacyMounted bool
16064
16065                                 DigPredict string
16066
16067                                 MaxLvl uint8
16068
16069                                 AlphaUse
16070                         }))(obj)).Translucent
16071                         if x {
16072                                 write8(w, 1)
16073                         } else {
16074                                 write8(w, 0)
16075                         }
16076
16077                 }
16078                 {
16079                         x := (*(*(struct {
16080                                 Param0 Content
16081
16082                                 Name   string
16083                                 Groups []Group
16084
16085                                 P1Type   Param1Type
16086                                 P2Type   Param2Type
16087                                 DrawType DrawType
16088
16089                                 Mesh  string
16090                                 Scale float32
16091                                 //mt:const uint8(6)
16092                                 Tiles        [6]TileDef
16093                                 OverlayTiles [6]TileDef
16094                                 //mt:const uint8(6)
16095                                 SpecialTiles [6]TileDef
16096
16097                                 Color   color.NRGBA
16098                                 Palette Texture
16099
16100                                 Waving       WaveType
16101                                 ConnectSides uint8
16102                                 ConnectTo    []Content
16103                                 InsideTint   color.NRGBA
16104                                 Level        uint8 // Must be < 128.
16105
16106                                 Translucent bool // Sunlight is scattered and becomes normal light.
16107                                 Transparent bool // Sunlight isn't scattered.
16108                                 LightSrc    uint8
16109
16110                                 GndContent   bool
16111                                 Collides     bool
16112                                 Pointable    bool
16113                                 Diggable     bool
16114                                 Climbable    bool
16115                                 Replaceable  bool
16116                                 OnRightClick bool
16117
16118                                 DmgPerSec int32
16119
16120                                 LiquidType   LiquidType
16121                                 FlowingAlt   string
16122                                 SrcAlt       string
16123                                 Viscosity    uint8 // 0-7
16124                                 LiqRenewable bool
16125                                 FlowRange    uint8
16126                                 DrownDmg     uint8
16127                                 Floodable    bool
16128
16129                                 DrawBox, ColBox, SelBox NodeBox
16130
16131                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16132
16133                                 LegacyFaceDir bool
16134                                 LegacyMounted bool
16135
16136                                 DigPredict string
16137
16138                                 MaxLvl uint8
16139
16140                                 AlphaUse
16141                         }))(obj)).Transparent
16142                         if x {
16143                                 write8(w, 1)
16144                         } else {
16145                                 write8(w, 0)
16146                         }
16147
16148                 }
16149                 {
16150                         x := (*(*(struct {
16151                                 Param0 Content
16152
16153                                 Name   string
16154                                 Groups []Group
16155
16156                                 P1Type   Param1Type
16157                                 P2Type   Param2Type
16158                                 DrawType DrawType
16159
16160                                 Mesh  string
16161                                 Scale float32
16162                                 //mt:const uint8(6)
16163                                 Tiles        [6]TileDef
16164                                 OverlayTiles [6]TileDef
16165                                 //mt:const uint8(6)
16166                                 SpecialTiles [6]TileDef
16167
16168                                 Color   color.NRGBA
16169                                 Palette Texture
16170
16171                                 Waving       WaveType
16172                                 ConnectSides uint8
16173                                 ConnectTo    []Content
16174                                 InsideTint   color.NRGBA
16175                                 Level        uint8 // Must be < 128.
16176
16177                                 Translucent bool // Sunlight is scattered and becomes normal light.
16178                                 Transparent bool // Sunlight isn't scattered.
16179                                 LightSrc    uint8
16180
16181                                 GndContent   bool
16182                                 Collides     bool
16183                                 Pointable    bool
16184                                 Diggable     bool
16185                                 Climbable    bool
16186                                 Replaceable  bool
16187                                 OnRightClick bool
16188
16189                                 DmgPerSec int32
16190
16191                                 LiquidType   LiquidType
16192                                 FlowingAlt   string
16193                                 SrcAlt       string
16194                                 Viscosity    uint8 // 0-7
16195                                 LiqRenewable bool
16196                                 FlowRange    uint8
16197                                 DrownDmg     uint8
16198                                 Floodable    bool
16199
16200                                 DrawBox, ColBox, SelBox NodeBox
16201
16202                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16203
16204                                 LegacyFaceDir bool
16205                                 LegacyMounted bool
16206
16207                                 DigPredict string
16208
16209                                 MaxLvl uint8
16210
16211                                 AlphaUse
16212                         }))(obj)).LightSrc
16213                         write8(w, uint8(x))
16214                 }
16215                 {
16216                         x := (*(*(struct {
16217                                 Param0 Content
16218
16219                                 Name   string
16220                                 Groups []Group
16221
16222                                 P1Type   Param1Type
16223                                 P2Type   Param2Type
16224                                 DrawType DrawType
16225
16226                                 Mesh  string
16227                                 Scale float32
16228                                 //mt:const uint8(6)
16229                                 Tiles        [6]TileDef
16230                                 OverlayTiles [6]TileDef
16231                                 //mt:const uint8(6)
16232                                 SpecialTiles [6]TileDef
16233
16234                                 Color   color.NRGBA
16235                                 Palette Texture
16236
16237                                 Waving       WaveType
16238                                 ConnectSides uint8
16239                                 ConnectTo    []Content
16240                                 InsideTint   color.NRGBA
16241                                 Level        uint8 // Must be < 128.
16242
16243                                 Translucent bool // Sunlight is scattered and becomes normal light.
16244                                 Transparent bool // Sunlight isn't scattered.
16245                                 LightSrc    uint8
16246
16247                                 GndContent   bool
16248                                 Collides     bool
16249                                 Pointable    bool
16250                                 Diggable     bool
16251                                 Climbable    bool
16252                                 Replaceable  bool
16253                                 OnRightClick bool
16254
16255                                 DmgPerSec int32
16256
16257                                 LiquidType   LiquidType
16258                                 FlowingAlt   string
16259                                 SrcAlt       string
16260                                 Viscosity    uint8 // 0-7
16261                                 LiqRenewable bool
16262                                 FlowRange    uint8
16263                                 DrownDmg     uint8
16264                                 Floodable    bool
16265
16266                                 DrawBox, ColBox, SelBox NodeBox
16267
16268                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16269
16270                                 LegacyFaceDir bool
16271                                 LegacyMounted bool
16272
16273                                 DigPredict string
16274
16275                                 MaxLvl uint8
16276
16277                                 AlphaUse
16278                         }))(obj)).GndContent
16279                         if x {
16280                                 write8(w, 1)
16281                         } else {
16282                                 write8(w, 0)
16283                         }
16284
16285                 }
16286                 {
16287                         x := (*(*(struct {
16288                                 Param0 Content
16289
16290                                 Name   string
16291                                 Groups []Group
16292
16293                                 P1Type   Param1Type
16294                                 P2Type   Param2Type
16295                                 DrawType DrawType
16296
16297                                 Mesh  string
16298                                 Scale float32
16299                                 //mt:const uint8(6)
16300                                 Tiles        [6]TileDef
16301                                 OverlayTiles [6]TileDef
16302                                 //mt:const uint8(6)
16303                                 SpecialTiles [6]TileDef
16304
16305                                 Color   color.NRGBA
16306                                 Palette Texture
16307
16308                                 Waving       WaveType
16309                                 ConnectSides uint8
16310                                 ConnectTo    []Content
16311                                 InsideTint   color.NRGBA
16312                                 Level        uint8 // Must be < 128.
16313
16314                                 Translucent bool // Sunlight is scattered and becomes normal light.
16315                                 Transparent bool // Sunlight isn't scattered.
16316                                 LightSrc    uint8
16317
16318                                 GndContent   bool
16319                                 Collides     bool
16320                                 Pointable    bool
16321                                 Diggable     bool
16322                                 Climbable    bool
16323                                 Replaceable  bool
16324                                 OnRightClick bool
16325
16326                                 DmgPerSec int32
16327
16328                                 LiquidType   LiquidType
16329                                 FlowingAlt   string
16330                                 SrcAlt       string
16331                                 Viscosity    uint8 // 0-7
16332                                 LiqRenewable bool
16333                                 FlowRange    uint8
16334                                 DrownDmg     uint8
16335                                 Floodable    bool
16336
16337                                 DrawBox, ColBox, SelBox NodeBox
16338
16339                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16340
16341                                 LegacyFaceDir bool
16342                                 LegacyMounted bool
16343
16344                                 DigPredict string
16345
16346                                 MaxLvl uint8
16347
16348                                 AlphaUse
16349                         }))(obj)).Collides
16350                         if x {
16351                                 write8(w, 1)
16352                         } else {
16353                                 write8(w, 0)
16354                         }
16355
16356                 }
16357                 {
16358                         x := (*(*(struct {
16359                                 Param0 Content
16360
16361                                 Name   string
16362                                 Groups []Group
16363
16364                                 P1Type   Param1Type
16365                                 P2Type   Param2Type
16366                                 DrawType DrawType
16367
16368                                 Mesh  string
16369                                 Scale float32
16370                                 //mt:const uint8(6)
16371                                 Tiles        [6]TileDef
16372                                 OverlayTiles [6]TileDef
16373                                 //mt:const uint8(6)
16374                                 SpecialTiles [6]TileDef
16375
16376                                 Color   color.NRGBA
16377                                 Palette Texture
16378
16379                                 Waving       WaveType
16380                                 ConnectSides uint8
16381                                 ConnectTo    []Content
16382                                 InsideTint   color.NRGBA
16383                                 Level        uint8 // Must be < 128.
16384
16385                                 Translucent bool // Sunlight is scattered and becomes normal light.
16386                                 Transparent bool // Sunlight isn't scattered.
16387                                 LightSrc    uint8
16388
16389                                 GndContent   bool
16390                                 Collides     bool
16391                                 Pointable    bool
16392                                 Diggable     bool
16393                                 Climbable    bool
16394                                 Replaceable  bool
16395                                 OnRightClick bool
16396
16397                                 DmgPerSec int32
16398
16399                                 LiquidType   LiquidType
16400                                 FlowingAlt   string
16401                                 SrcAlt       string
16402                                 Viscosity    uint8 // 0-7
16403                                 LiqRenewable bool
16404                                 FlowRange    uint8
16405                                 DrownDmg     uint8
16406                                 Floodable    bool
16407
16408                                 DrawBox, ColBox, SelBox NodeBox
16409
16410                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16411
16412                                 LegacyFaceDir bool
16413                                 LegacyMounted bool
16414
16415                                 DigPredict string
16416
16417                                 MaxLvl uint8
16418
16419                                 AlphaUse
16420                         }))(obj)).Pointable
16421                         if x {
16422                                 write8(w, 1)
16423                         } else {
16424                                 write8(w, 0)
16425                         }
16426
16427                 }
16428                 {
16429                         x := (*(*(struct {
16430                                 Param0 Content
16431
16432                                 Name   string
16433                                 Groups []Group
16434
16435                                 P1Type   Param1Type
16436                                 P2Type   Param2Type
16437                                 DrawType DrawType
16438
16439                                 Mesh  string
16440                                 Scale float32
16441                                 //mt:const uint8(6)
16442                                 Tiles        [6]TileDef
16443                                 OverlayTiles [6]TileDef
16444                                 //mt:const uint8(6)
16445                                 SpecialTiles [6]TileDef
16446
16447                                 Color   color.NRGBA
16448                                 Palette Texture
16449
16450                                 Waving       WaveType
16451                                 ConnectSides uint8
16452                                 ConnectTo    []Content
16453                                 InsideTint   color.NRGBA
16454                                 Level        uint8 // Must be < 128.
16455
16456                                 Translucent bool // Sunlight is scattered and becomes normal light.
16457                                 Transparent bool // Sunlight isn't scattered.
16458                                 LightSrc    uint8
16459
16460                                 GndContent   bool
16461                                 Collides     bool
16462                                 Pointable    bool
16463                                 Diggable     bool
16464                                 Climbable    bool
16465                                 Replaceable  bool
16466                                 OnRightClick bool
16467
16468                                 DmgPerSec int32
16469
16470                                 LiquidType   LiquidType
16471                                 FlowingAlt   string
16472                                 SrcAlt       string
16473                                 Viscosity    uint8 // 0-7
16474                                 LiqRenewable bool
16475                                 FlowRange    uint8
16476                                 DrownDmg     uint8
16477                                 Floodable    bool
16478
16479                                 DrawBox, ColBox, SelBox NodeBox
16480
16481                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16482
16483                                 LegacyFaceDir bool
16484                                 LegacyMounted bool
16485
16486                                 DigPredict string
16487
16488                                 MaxLvl uint8
16489
16490                                 AlphaUse
16491                         }))(obj)).Diggable
16492                         if x {
16493                                 write8(w, 1)
16494                         } else {
16495                                 write8(w, 0)
16496                         }
16497
16498                 }
16499                 {
16500                         x := (*(*(struct {
16501                                 Param0 Content
16502
16503                                 Name   string
16504                                 Groups []Group
16505
16506                                 P1Type   Param1Type
16507                                 P2Type   Param2Type
16508                                 DrawType DrawType
16509
16510                                 Mesh  string
16511                                 Scale float32
16512                                 //mt:const uint8(6)
16513                                 Tiles        [6]TileDef
16514                                 OverlayTiles [6]TileDef
16515                                 //mt:const uint8(6)
16516                                 SpecialTiles [6]TileDef
16517
16518                                 Color   color.NRGBA
16519                                 Palette Texture
16520
16521                                 Waving       WaveType
16522                                 ConnectSides uint8
16523                                 ConnectTo    []Content
16524                                 InsideTint   color.NRGBA
16525                                 Level        uint8 // Must be < 128.
16526
16527                                 Translucent bool // Sunlight is scattered and becomes normal light.
16528                                 Transparent bool // Sunlight isn't scattered.
16529                                 LightSrc    uint8
16530
16531                                 GndContent   bool
16532                                 Collides     bool
16533                                 Pointable    bool
16534                                 Diggable     bool
16535                                 Climbable    bool
16536                                 Replaceable  bool
16537                                 OnRightClick bool
16538
16539                                 DmgPerSec int32
16540
16541                                 LiquidType   LiquidType
16542                                 FlowingAlt   string
16543                                 SrcAlt       string
16544                                 Viscosity    uint8 // 0-7
16545                                 LiqRenewable bool
16546                                 FlowRange    uint8
16547                                 DrownDmg     uint8
16548                                 Floodable    bool
16549
16550                                 DrawBox, ColBox, SelBox NodeBox
16551
16552                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16553
16554                                 LegacyFaceDir bool
16555                                 LegacyMounted bool
16556
16557                                 DigPredict string
16558
16559                                 MaxLvl uint8
16560
16561                                 AlphaUse
16562                         }))(obj)).Climbable
16563                         if x {
16564                                 write8(w, 1)
16565                         } else {
16566                                 write8(w, 0)
16567                         }
16568
16569                 }
16570                 {
16571                         x := (*(*(struct {
16572                                 Param0 Content
16573
16574                                 Name   string
16575                                 Groups []Group
16576
16577                                 P1Type   Param1Type
16578                                 P2Type   Param2Type
16579                                 DrawType DrawType
16580
16581                                 Mesh  string
16582                                 Scale float32
16583                                 //mt:const uint8(6)
16584                                 Tiles        [6]TileDef
16585                                 OverlayTiles [6]TileDef
16586                                 //mt:const uint8(6)
16587                                 SpecialTiles [6]TileDef
16588
16589                                 Color   color.NRGBA
16590                                 Palette Texture
16591
16592                                 Waving       WaveType
16593                                 ConnectSides uint8
16594                                 ConnectTo    []Content
16595                                 InsideTint   color.NRGBA
16596                                 Level        uint8 // Must be < 128.
16597
16598                                 Translucent bool // Sunlight is scattered and becomes normal light.
16599                                 Transparent bool // Sunlight isn't scattered.
16600                                 LightSrc    uint8
16601
16602                                 GndContent   bool
16603                                 Collides     bool
16604                                 Pointable    bool
16605                                 Diggable     bool
16606                                 Climbable    bool
16607                                 Replaceable  bool
16608                                 OnRightClick bool
16609
16610                                 DmgPerSec int32
16611
16612                                 LiquidType   LiquidType
16613                                 FlowingAlt   string
16614                                 SrcAlt       string
16615                                 Viscosity    uint8 // 0-7
16616                                 LiqRenewable bool
16617                                 FlowRange    uint8
16618                                 DrownDmg     uint8
16619                                 Floodable    bool
16620
16621                                 DrawBox, ColBox, SelBox NodeBox
16622
16623                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16624
16625                                 LegacyFaceDir bool
16626                                 LegacyMounted bool
16627
16628                                 DigPredict string
16629
16630                                 MaxLvl uint8
16631
16632                                 AlphaUse
16633                         }))(obj)).Replaceable
16634                         if x {
16635                                 write8(w, 1)
16636                         } else {
16637                                 write8(w, 0)
16638                         }
16639
16640                 }
16641                 {
16642                         x := (*(*(struct {
16643                                 Param0 Content
16644
16645                                 Name   string
16646                                 Groups []Group
16647
16648                                 P1Type   Param1Type
16649                                 P2Type   Param2Type
16650                                 DrawType DrawType
16651
16652                                 Mesh  string
16653                                 Scale float32
16654                                 //mt:const uint8(6)
16655                                 Tiles        [6]TileDef
16656                                 OverlayTiles [6]TileDef
16657                                 //mt:const uint8(6)
16658                                 SpecialTiles [6]TileDef
16659
16660                                 Color   color.NRGBA
16661                                 Palette Texture
16662
16663                                 Waving       WaveType
16664                                 ConnectSides uint8
16665                                 ConnectTo    []Content
16666                                 InsideTint   color.NRGBA
16667                                 Level        uint8 // Must be < 128.
16668
16669                                 Translucent bool // Sunlight is scattered and becomes normal light.
16670                                 Transparent bool // Sunlight isn't scattered.
16671                                 LightSrc    uint8
16672
16673                                 GndContent   bool
16674                                 Collides     bool
16675                                 Pointable    bool
16676                                 Diggable     bool
16677                                 Climbable    bool
16678                                 Replaceable  bool
16679                                 OnRightClick bool
16680
16681                                 DmgPerSec int32
16682
16683                                 LiquidType   LiquidType
16684                                 FlowingAlt   string
16685                                 SrcAlt       string
16686                                 Viscosity    uint8 // 0-7
16687                                 LiqRenewable bool
16688                                 FlowRange    uint8
16689                                 DrownDmg     uint8
16690                                 Floodable    bool
16691
16692                                 DrawBox, ColBox, SelBox NodeBox
16693
16694                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16695
16696                                 LegacyFaceDir bool
16697                                 LegacyMounted bool
16698
16699                                 DigPredict string
16700
16701                                 MaxLvl uint8
16702
16703                                 AlphaUse
16704                         }))(obj)).OnRightClick
16705                         if x {
16706                                 write8(w, 1)
16707                         } else {
16708                                 write8(w, 0)
16709                         }
16710
16711                 }
16712                 {
16713                         x := (*(*(struct {
16714                                 Param0 Content
16715
16716                                 Name   string
16717                                 Groups []Group
16718
16719                                 P1Type   Param1Type
16720                                 P2Type   Param2Type
16721                                 DrawType DrawType
16722
16723                                 Mesh  string
16724                                 Scale float32
16725                                 //mt:const uint8(6)
16726                                 Tiles        [6]TileDef
16727                                 OverlayTiles [6]TileDef
16728                                 //mt:const uint8(6)
16729                                 SpecialTiles [6]TileDef
16730
16731                                 Color   color.NRGBA
16732                                 Palette Texture
16733
16734                                 Waving       WaveType
16735                                 ConnectSides uint8
16736                                 ConnectTo    []Content
16737                                 InsideTint   color.NRGBA
16738                                 Level        uint8 // Must be < 128.
16739
16740                                 Translucent bool // Sunlight is scattered and becomes normal light.
16741                                 Transparent bool // Sunlight isn't scattered.
16742                                 LightSrc    uint8
16743
16744                                 GndContent   bool
16745                                 Collides     bool
16746                                 Pointable    bool
16747                                 Diggable     bool
16748                                 Climbable    bool
16749                                 Replaceable  bool
16750                                 OnRightClick bool
16751
16752                                 DmgPerSec int32
16753
16754                                 LiquidType   LiquidType
16755                                 FlowingAlt   string
16756                                 SrcAlt       string
16757                                 Viscosity    uint8 // 0-7
16758                                 LiqRenewable bool
16759                                 FlowRange    uint8
16760                                 DrownDmg     uint8
16761                                 Floodable    bool
16762
16763                                 DrawBox, ColBox, SelBox NodeBox
16764
16765                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16766
16767                                 LegacyFaceDir bool
16768                                 LegacyMounted bool
16769
16770                                 DigPredict string
16771
16772                                 MaxLvl uint8
16773
16774                                 AlphaUse
16775                         }))(obj)).DmgPerSec
16776                         write32(w, uint32(x))
16777                 }
16778                 if err := pcall(func() {
16779                         ((*(*(struct {
16780                                 Param0 Content
16781
16782                                 Name   string
16783                                 Groups []Group
16784
16785                                 P1Type   Param1Type
16786                                 P2Type   Param2Type
16787                                 DrawType DrawType
16788
16789                                 Mesh  string
16790                                 Scale float32
16791                                 //mt:const uint8(6)
16792                                 Tiles        [6]TileDef
16793                                 OverlayTiles [6]TileDef
16794                                 //mt:const uint8(6)
16795                                 SpecialTiles [6]TileDef
16796
16797                                 Color   color.NRGBA
16798                                 Palette Texture
16799
16800                                 Waving       WaveType
16801                                 ConnectSides uint8
16802                                 ConnectTo    []Content
16803                                 InsideTint   color.NRGBA
16804                                 Level        uint8 // Must be < 128.
16805
16806                                 Translucent bool // Sunlight is scattered and becomes normal light.
16807                                 Transparent bool // Sunlight isn't scattered.
16808                                 LightSrc    uint8
16809
16810                                 GndContent   bool
16811                                 Collides     bool
16812                                 Pointable    bool
16813                                 Diggable     bool
16814                                 Climbable    bool
16815                                 Replaceable  bool
16816                                 OnRightClick bool
16817
16818                                 DmgPerSec int32
16819
16820                                 LiquidType   LiquidType
16821                                 FlowingAlt   string
16822                                 SrcAlt       string
16823                                 Viscosity    uint8 // 0-7
16824                                 LiqRenewable bool
16825                                 FlowRange    uint8
16826                                 DrownDmg     uint8
16827                                 Floodable    bool
16828
16829                                 DrawBox, ColBox, SelBox NodeBox
16830
16831                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16832
16833                                 LegacyFaceDir bool
16834                                 LegacyMounted bool
16835
16836                                 DigPredict string
16837
16838                                 MaxLvl uint8
16839
16840                                 AlphaUse
16841                         }))(obj)).LiquidType).serialize(w)
16842                 }); err != nil {
16843                         if err == io.EOF {
16844                                 chk(io.EOF)
16845                         }
16846                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
16847                 }
16848                 if len(([]byte((*(*(struct {
16849                         Param0 Content
16850
16851                         Name   string
16852                         Groups []Group
16853
16854                         P1Type   Param1Type
16855                         P2Type   Param2Type
16856                         DrawType DrawType
16857
16858                         Mesh  string
16859                         Scale float32
16860                         //mt:const uint8(6)
16861                         Tiles        [6]TileDef
16862                         OverlayTiles [6]TileDef
16863                         //mt:const uint8(6)
16864                         SpecialTiles [6]TileDef
16865
16866                         Color   color.NRGBA
16867                         Palette Texture
16868
16869                         Waving       WaveType
16870                         ConnectSides uint8
16871                         ConnectTo    []Content
16872                         InsideTint   color.NRGBA
16873                         Level        uint8 // Must be < 128.
16874
16875                         Translucent bool // Sunlight is scattered and becomes normal light.
16876                         Transparent bool // Sunlight isn't scattered.
16877                         LightSrc    uint8
16878
16879                         GndContent   bool
16880                         Collides     bool
16881                         Pointable    bool
16882                         Diggable     bool
16883                         Climbable    bool
16884                         Replaceable  bool
16885                         OnRightClick bool
16886
16887                         DmgPerSec int32
16888
16889                         LiquidType   LiquidType
16890                         FlowingAlt   string
16891                         SrcAlt       string
16892                         Viscosity    uint8 // 0-7
16893                         LiqRenewable bool
16894                         FlowRange    uint8
16895                         DrownDmg     uint8
16896                         Floodable    bool
16897
16898                         DrawBox, ColBox, SelBox NodeBox
16899
16900                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16901
16902                         LegacyFaceDir bool
16903                         LegacyMounted bool
16904
16905                         DigPredict string
16906
16907                         MaxLvl uint8
16908
16909                         AlphaUse
16910                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
16911                         chk(ErrTooLong)
16912                 }
16913                 {
16914                         x := uint16(len(([]byte((*(*(struct {
16915                                 Param0 Content
16916
16917                                 Name   string
16918                                 Groups []Group
16919
16920                                 P1Type   Param1Type
16921                                 P2Type   Param2Type
16922                                 DrawType DrawType
16923
16924                                 Mesh  string
16925                                 Scale float32
16926                                 //mt:const uint8(6)
16927                                 Tiles        [6]TileDef
16928                                 OverlayTiles [6]TileDef
16929                                 //mt:const uint8(6)
16930                                 SpecialTiles [6]TileDef
16931
16932                                 Color   color.NRGBA
16933                                 Palette Texture
16934
16935                                 Waving       WaveType
16936                                 ConnectSides uint8
16937                                 ConnectTo    []Content
16938                                 InsideTint   color.NRGBA
16939                                 Level        uint8 // Must be < 128.
16940
16941                                 Translucent bool // Sunlight is scattered and becomes normal light.
16942                                 Transparent bool // Sunlight isn't scattered.
16943                                 LightSrc    uint8
16944
16945                                 GndContent   bool
16946                                 Collides     bool
16947                                 Pointable    bool
16948                                 Diggable     bool
16949                                 Climbable    bool
16950                                 Replaceable  bool
16951                                 OnRightClick bool
16952
16953                                 DmgPerSec int32
16954
16955                                 LiquidType   LiquidType
16956                                 FlowingAlt   string
16957                                 SrcAlt       string
16958                                 Viscosity    uint8 // 0-7
16959                                 LiqRenewable bool
16960                                 FlowRange    uint8
16961                                 DrownDmg     uint8
16962                                 Floodable    bool
16963
16964                                 DrawBox, ColBox, SelBox NodeBox
16965
16966                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16967
16968                                 LegacyFaceDir bool
16969                                 LegacyMounted bool
16970
16971                                 DigPredict string
16972
16973                                 MaxLvl uint8
16974
16975                                 AlphaUse
16976                         }))(obj)).FlowingAlt))))
16977                         write16(w, uint16(x))
16978                 }
16979                 {
16980                         _, err := w.Write(([]byte((*(*(struct {
16981                                 Param0 Content
16982
16983                                 Name   string
16984                                 Groups []Group
16985
16986                                 P1Type   Param1Type
16987                                 P2Type   Param2Type
16988                                 DrawType DrawType
16989
16990                                 Mesh  string
16991                                 Scale float32
16992                                 //mt:const uint8(6)
16993                                 Tiles        [6]TileDef
16994                                 OverlayTiles [6]TileDef
16995                                 //mt:const uint8(6)
16996                                 SpecialTiles [6]TileDef
16997
16998                                 Color   color.NRGBA
16999                                 Palette Texture
17000
17001                                 Waving       WaveType
17002                                 ConnectSides uint8
17003                                 ConnectTo    []Content
17004                                 InsideTint   color.NRGBA
17005                                 Level        uint8 // Must be < 128.
17006
17007                                 Translucent bool // Sunlight is scattered and becomes normal light.
17008                                 Transparent bool // Sunlight isn't scattered.
17009                                 LightSrc    uint8
17010
17011                                 GndContent   bool
17012                                 Collides     bool
17013                                 Pointable    bool
17014                                 Diggable     bool
17015                                 Climbable    bool
17016                                 Replaceable  bool
17017                                 OnRightClick bool
17018
17019                                 DmgPerSec int32
17020
17021                                 LiquidType   LiquidType
17022                                 FlowingAlt   string
17023                                 SrcAlt       string
17024                                 Viscosity    uint8 // 0-7
17025                                 LiqRenewable bool
17026                                 FlowRange    uint8
17027                                 DrownDmg     uint8
17028                                 Floodable    bool
17029
17030                                 DrawBox, ColBox, SelBox NodeBox
17031
17032                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17033
17034                                 LegacyFaceDir bool
17035                                 LegacyMounted bool
17036
17037                                 DigPredict string
17038
17039                                 MaxLvl uint8
17040
17041                                 AlphaUse
17042                         }))(obj)).FlowingAlt))[:])
17043                         chk(err)
17044                 }
17045                 if len(([]byte((*(*(struct {
17046                         Param0 Content
17047
17048                         Name   string
17049                         Groups []Group
17050
17051                         P1Type   Param1Type
17052                         P2Type   Param2Type
17053                         DrawType DrawType
17054
17055                         Mesh  string
17056                         Scale float32
17057                         //mt:const uint8(6)
17058                         Tiles        [6]TileDef
17059                         OverlayTiles [6]TileDef
17060                         //mt:const uint8(6)
17061                         SpecialTiles [6]TileDef
17062
17063                         Color   color.NRGBA
17064                         Palette Texture
17065
17066                         Waving       WaveType
17067                         ConnectSides uint8
17068                         ConnectTo    []Content
17069                         InsideTint   color.NRGBA
17070                         Level        uint8 // Must be < 128.
17071
17072                         Translucent bool // Sunlight is scattered and becomes normal light.
17073                         Transparent bool // Sunlight isn't scattered.
17074                         LightSrc    uint8
17075
17076                         GndContent   bool
17077                         Collides     bool
17078                         Pointable    bool
17079                         Diggable     bool
17080                         Climbable    bool
17081                         Replaceable  bool
17082                         OnRightClick bool
17083
17084                         DmgPerSec int32
17085
17086                         LiquidType   LiquidType
17087                         FlowingAlt   string
17088                         SrcAlt       string
17089                         Viscosity    uint8 // 0-7
17090                         LiqRenewable bool
17091                         FlowRange    uint8
17092                         DrownDmg     uint8
17093                         Floodable    bool
17094
17095                         DrawBox, ColBox, SelBox NodeBox
17096
17097                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17098
17099                         LegacyFaceDir bool
17100                         LegacyMounted bool
17101
17102                         DigPredict string
17103
17104                         MaxLvl uint8
17105
17106                         AlphaUse
17107                 }))(obj)).SrcAlt))) > math.MaxUint16 {
17108                         chk(ErrTooLong)
17109                 }
17110                 {
17111                         x := uint16(len(([]byte((*(*(struct {
17112                                 Param0 Content
17113
17114                                 Name   string
17115                                 Groups []Group
17116
17117                                 P1Type   Param1Type
17118                                 P2Type   Param2Type
17119                                 DrawType DrawType
17120
17121                                 Mesh  string
17122                                 Scale float32
17123                                 //mt:const uint8(6)
17124                                 Tiles        [6]TileDef
17125                                 OverlayTiles [6]TileDef
17126                                 //mt:const uint8(6)
17127                                 SpecialTiles [6]TileDef
17128
17129                                 Color   color.NRGBA
17130                                 Palette Texture
17131
17132                                 Waving       WaveType
17133                                 ConnectSides uint8
17134                                 ConnectTo    []Content
17135                                 InsideTint   color.NRGBA
17136                                 Level        uint8 // Must be < 128.
17137
17138                                 Translucent bool // Sunlight is scattered and becomes normal light.
17139                                 Transparent bool // Sunlight isn't scattered.
17140                                 LightSrc    uint8
17141
17142                                 GndContent   bool
17143                                 Collides     bool
17144                                 Pointable    bool
17145                                 Diggable     bool
17146                                 Climbable    bool
17147                                 Replaceable  bool
17148                                 OnRightClick bool
17149
17150                                 DmgPerSec int32
17151
17152                                 LiquidType   LiquidType
17153                                 FlowingAlt   string
17154                                 SrcAlt       string
17155                                 Viscosity    uint8 // 0-7
17156                                 LiqRenewable bool
17157                                 FlowRange    uint8
17158                                 DrownDmg     uint8
17159                                 Floodable    bool
17160
17161                                 DrawBox, ColBox, SelBox NodeBox
17162
17163                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17164
17165                                 LegacyFaceDir bool
17166                                 LegacyMounted bool
17167
17168                                 DigPredict string
17169
17170                                 MaxLvl uint8
17171
17172                                 AlphaUse
17173                         }))(obj)).SrcAlt))))
17174                         write16(w, uint16(x))
17175                 }
17176                 {
17177                         _, err := w.Write(([]byte((*(*(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)).SrcAlt))[:])
17240                         chk(err)
17241                 }
17242                 {
17243                         x := (*(*(struct {
17244                                 Param0 Content
17245
17246                                 Name   string
17247                                 Groups []Group
17248
17249                                 P1Type   Param1Type
17250                                 P2Type   Param2Type
17251                                 DrawType DrawType
17252
17253                                 Mesh  string
17254                                 Scale float32
17255                                 //mt:const uint8(6)
17256                                 Tiles        [6]TileDef
17257                                 OverlayTiles [6]TileDef
17258                                 //mt:const uint8(6)
17259                                 SpecialTiles [6]TileDef
17260
17261                                 Color   color.NRGBA
17262                                 Palette Texture
17263
17264                                 Waving       WaveType
17265                                 ConnectSides uint8
17266                                 ConnectTo    []Content
17267                                 InsideTint   color.NRGBA
17268                                 Level        uint8 // Must be < 128.
17269
17270                                 Translucent bool // Sunlight is scattered and becomes normal light.
17271                                 Transparent bool // Sunlight isn't scattered.
17272                                 LightSrc    uint8
17273
17274                                 GndContent   bool
17275                                 Collides     bool
17276                                 Pointable    bool
17277                                 Diggable     bool
17278                                 Climbable    bool
17279                                 Replaceable  bool
17280                                 OnRightClick bool
17281
17282                                 DmgPerSec int32
17283
17284                                 LiquidType   LiquidType
17285                                 FlowingAlt   string
17286                                 SrcAlt       string
17287                                 Viscosity    uint8 // 0-7
17288                                 LiqRenewable bool
17289                                 FlowRange    uint8
17290                                 DrownDmg     uint8
17291                                 Floodable    bool
17292
17293                                 DrawBox, ColBox, SelBox NodeBox
17294
17295                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17296
17297                                 LegacyFaceDir bool
17298                                 LegacyMounted bool
17299
17300                                 DigPredict string
17301
17302                                 MaxLvl uint8
17303
17304                                 AlphaUse
17305                         }))(obj)).Viscosity
17306                         write8(w, uint8(x))
17307                 }
17308                 {
17309                         x := (*(*(struct {
17310                                 Param0 Content
17311
17312                                 Name   string
17313                                 Groups []Group
17314
17315                                 P1Type   Param1Type
17316                                 P2Type   Param2Type
17317                                 DrawType DrawType
17318
17319                                 Mesh  string
17320                                 Scale float32
17321                                 //mt:const uint8(6)
17322                                 Tiles        [6]TileDef
17323                                 OverlayTiles [6]TileDef
17324                                 //mt:const uint8(6)
17325                                 SpecialTiles [6]TileDef
17326
17327                                 Color   color.NRGBA
17328                                 Palette Texture
17329
17330                                 Waving       WaveType
17331                                 ConnectSides uint8
17332                                 ConnectTo    []Content
17333                                 InsideTint   color.NRGBA
17334                                 Level        uint8 // Must be < 128.
17335
17336                                 Translucent bool // Sunlight is scattered and becomes normal light.
17337                                 Transparent bool // Sunlight isn't scattered.
17338                                 LightSrc    uint8
17339
17340                                 GndContent   bool
17341                                 Collides     bool
17342                                 Pointable    bool
17343                                 Diggable     bool
17344                                 Climbable    bool
17345                                 Replaceable  bool
17346                                 OnRightClick bool
17347
17348                                 DmgPerSec int32
17349
17350                                 LiquidType   LiquidType
17351                                 FlowingAlt   string
17352                                 SrcAlt       string
17353                                 Viscosity    uint8 // 0-7
17354                                 LiqRenewable bool
17355                                 FlowRange    uint8
17356                                 DrownDmg     uint8
17357                                 Floodable    bool
17358
17359                                 DrawBox, ColBox, SelBox NodeBox
17360
17361                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17362
17363                                 LegacyFaceDir bool
17364                                 LegacyMounted bool
17365
17366                                 DigPredict string
17367
17368                                 MaxLvl uint8
17369
17370                                 AlphaUse
17371                         }))(obj)).LiqRenewable
17372                         if x {
17373                                 write8(w, 1)
17374                         } else {
17375                                 write8(w, 0)
17376                         }
17377
17378                 }
17379                 {
17380                         x := (*(*(struct {
17381                                 Param0 Content
17382
17383                                 Name   string
17384                                 Groups []Group
17385
17386                                 P1Type   Param1Type
17387                                 P2Type   Param2Type
17388                                 DrawType DrawType
17389
17390                                 Mesh  string
17391                                 Scale float32
17392                                 //mt:const uint8(6)
17393                                 Tiles        [6]TileDef
17394                                 OverlayTiles [6]TileDef
17395                                 //mt:const uint8(6)
17396                                 SpecialTiles [6]TileDef
17397
17398                                 Color   color.NRGBA
17399                                 Palette Texture
17400
17401                                 Waving       WaveType
17402                                 ConnectSides uint8
17403                                 ConnectTo    []Content
17404                                 InsideTint   color.NRGBA
17405                                 Level        uint8 // Must be < 128.
17406
17407                                 Translucent bool // Sunlight is scattered and becomes normal light.
17408                                 Transparent bool // Sunlight isn't scattered.
17409                                 LightSrc    uint8
17410
17411                                 GndContent   bool
17412                                 Collides     bool
17413                                 Pointable    bool
17414                                 Diggable     bool
17415                                 Climbable    bool
17416                                 Replaceable  bool
17417                                 OnRightClick bool
17418
17419                                 DmgPerSec int32
17420
17421                                 LiquidType   LiquidType
17422                                 FlowingAlt   string
17423                                 SrcAlt       string
17424                                 Viscosity    uint8 // 0-7
17425                                 LiqRenewable bool
17426                                 FlowRange    uint8
17427                                 DrownDmg     uint8
17428                                 Floodable    bool
17429
17430                                 DrawBox, ColBox, SelBox NodeBox
17431
17432                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17433
17434                                 LegacyFaceDir bool
17435                                 LegacyMounted bool
17436
17437                                 DigPredict string
17438
17439                                 MaxLvl uint8
17440
17441                                 AlphaUse
17442                         }))(obj)).FlowRange
17443                         write8(w, uint8(x))
17444                 }
17445                 {
17446                         x := (*(*(struct {
17447                                 Param0 Content
17448
17449                                 Name   string
17450                                 Groups []Group
17451
17452                                 P1Type   Param1Type
17453                                 P2Type   Param2Type
17454                                 DrawType DrawType
17455
17456                                 Mesh  string
17457                                 Scale float32
17458                                 //mt:const uint8(6)
17459                                 Tiles        [6]TileDef
17460                                 OverlayTiles [6]TileDef
17461                                 //mt:const uint8(6)
17462                                 SpecialTiles [6]TileDef
17463
17464                                 Color   color.NRGBA
17465                                 Palette Texture
17466
17467                                 Waving       WaveType
17468                                 ConnectSides uint8
17469                                 ConnectTo    []Content
17470                                 InsideTint   color.NRGBA
17471                                 Level        uint8 // Must be < 128.
17472
17473                                 Translucent bool // Sunlight is scattered and becomes normal light.
17474                                 Transparent bool // Sunlight isn't scattered.
17475                                 LightSrc    uint8
17476
17477                                 GndContent   bool
17478                                 Collides     bool
17479                                 Pointable    bool
17480                                 Diggable     bool
17481                                 Climbable    bool
17482                                 Replaceable  bool
17483                                 OnRightClick bool
17484
17485                                 DmgPerSec int32
17486
17487                                 LiquidType   LiquidType
17488                                 FlowingAlt   string
17489                                 SrcAlt       string
17490                                 Viscosity    uint8 // 0-7
17491                                 LiqRenewable bool
17492                                 FlowRange    uint8
17493                                 DrownDmg     uint8
17494                                 Floodable    bool
17495
17496                                 DrawBox, ColBox, SelBox NodeBox
17497
17498                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17499
17500                                 LegacyFaceDir bool
17501                                 LegacyMounted bool
17502
17503                                 DigPredict string
17504
17505                                 MaxLvl uint8
17506
17507                                 AlphaUse
17508                         }))(obj)).DrownDmg
17509                         write8(w, uint8(x))
17510                 }
17511                 {
17512                         x := (*(*(struct {
17513                                 Param0 Content
17514
17515                                 Name   string
17516                                 Groups []Group
17517
17518                                 P1Type   Param1Type
17519                                 P2Type   Param2Type
17520                                 DrawType DrawType
17521
17522                                 Mesh  string
17523                                 Scale float32
17524                                 //mt:const uint8(6)
17525                                 Tiles        [6]TileDef
17526                                 OverlayTiles [6]TileDef
17527                                 //mt:const uint8(6)
17528                                 SpecialTiles [6]TileDef
17529
17530                                 Color   color.NRGBA
17531                                 Palette Texture
17532
17533                                 Waving       WaveType
17534                                 ConnectSides uint8
17535                                 ConnectTo    []Content
17536                                 InsideTint   color.NRGBA
17537                                 Level        uint8 // Must be < 128.
17538
17539                                 Translucent bool // Sunlight is scattered and becomes normal light.
17540                                 Transparent bool // Sunlight isn't scattered.
17541                                 LightSrc    uint8
17542
17543                                 GndContent   bool
17544                                 Collides     bool
17545                                 Pointable    bool
17546                                 Diggable     bool
17547                                 Climbable    bool
17548                                 Replaceable  bool
17549                                 OnRightClick bool
17550
17551                                 DmgPerSec int32
17552
17553                                 LiquidType   LiquidType
17554                                 FlowingAlt   string
17555                                 SrcAlt       string
17556                                 Viscosity    uint8 // 0-7
17557                                 LiqRenewable bool
17558                                 FlowRange    uint8
17559                                 DrownDmg     uint8
17560                                 Floodable    bool
17561
17562                                 DrawBox, ColBox, SelBox NodeBox
17563
17564                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17565
17566                                 LegacyFaceDir bool
17567                                 LegacyMounted bool
17568
17569                                 DigPredict string
17570
17571                                 MaxLvl uint8
17572
17573                                 AlphaUse
17574                         }))(obj)).Floodable
17575                         if x {
17576                                 write8(w, 1)
17577                         } else {
17578                                 write8(w, 0)
17579                         }
17580
17581                 }
17582                 if err := pcall(func() {
17583                         ((*(*(struct {
17584                                 Param0 Content
17585
17586                                 Name   string
17587                                 Groups []Group
17588
17589                                 P1Type   Param1Type
17590                                 P2Type   Param2Type
17591                                 DrawType DrawType
17592
17593                                 Mesh  string
17594                                 Scale float32
17595                                 //mt:const uint8(6)
17596                                 Tiles        [6]TileDef
17597                                 OverlayTiles [6]TileDef
17598                                 //mt:const uint8(6)
17599                                 SpecialTiles [6]TileDef
17600
17601                                 Color   color.NRGBA
17602                                 Palette Texture
17603
17604                                 Waving       WaveType
17605                                 ConnectSides uint8
17606                                 ConnectTo    []Content
17607                                 InsideTint   color.NRGBA
17608                                 Level        uint8 // Must be < 128.
17609
17610                                 Translucent bool // Sunlight is scattered and becomes normal light.
17611                                 Transparent bool // Sunlight isn't scattered.
17612                                 LightSrc    uint8
17613
17614                                 GndContent   bool
17615                                 Collides     bool
17616                                 Pointable    bool
17617                                 Diggable     bool
17618                                 Climbable    bool
17619                                 Replaceable  bool
17620                                 OnRightClick bool
17621
17622                                 DmgPerSec int32
17623
17624                                 LiquidType   LiquidType
17625                                 FlowingAlt   string
17626                                 SrcAlt       string
17627                                 Viscosity    uint8 // 0-7
17628                                 LiqRenewable bool
17629                                 FlowRange    uint8
17630                                 DrownDmg     uint8
17631                                 Floodable    bool
17632
17633                                 DrawBox, ColBox, SelBox NodeBox
17634
17635                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17636
17637                                 LegacyFaceDir bool
17638                                 LegacyMounted bool
17639
17640                                 DigPredict string
17641
17642                                 MaxLvl uint8
17643
17644                                 AlphaUse
17645                         }))(obj)).DrawBox).serialize(w)
17646                 }); err != nil {
17647                         if err == io.EOF {
17648                                 chk(io.EOF)
17649                         }
17650                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17651                 }
17652                 if err := pcall(func() {
17653                         ((*(*(struct {
17654                                 Param0 Content
17655
17656                                 Name   string
17657                                 Groups []Group
17658
17659                                 P1Type   Param1Type
17660                                 P2Type   Param2Type
17661                                 DrawType DrawType
17662
17663                                 Mesh  string
17664                                 Scale float32
17665                                 //mt:const uint8(6)
17666                                 Tiles        [6]TileDef
17667                                 OverlayTiles [6]TileDef
17668                                 //mt:const uint8(6)
17669                                 SpecialTiles [6]TileDef
17670
17671                                 Color   color.NRGBA
17672                                 Palette Texture
17673
17674                                 Waving       WaveType
17675                                 ConnectSides uint8
17676                                 ConnectTo    []Content
17677                                 InsideTint   color.NRGBA
17678                                 Level        uint8 // Must be < 128.
17679
17680                                 Translucent bool // Sunlight is scattered and becomes normal light.
17681                                 Transparent bool // Sunlight isn't scattered.
17682                                 LightSrc    uint8
17683
17684                                 GndContent   bool
17685                                 Collides     bool
17686                                 Pointable    bool
17687                                 Diggable     bool
17688                                 Climbable    bool
17689                                 Replaceable  bool
17690                                 OnRightClick bool
17691
17692                                 DmgPerSec int32
17693
17694                                 LiquidType   LiquidType
17695                                 FlowingAlt   string
17696                                 SrcAlt       string
17697                                 Viscosity    uint8 // 0-7
17698                                 LiqRenewable bool
17699                                 FlowRange    uint8
17700                                 DrownDmg     uint8
17701                                 Floodable    bool
17702
17703                                 DrawBox, ColBox, SelBox NodeBox
17704
17705                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17706
17707                                 LegacyFaceDir bool
17708                                 LegacyMounted bool
17709
17710                                 DigPredict string
17711
17712                                 MaxLvl uint8
17713
17714                                 AlphaUse
17715                         }))(obj)).ColBox).serialize(w)
17716                 }); err != nil {
17717                         if err == io.EOF {
17718                                 chk(io.EOF)
17719                         }
17720                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17721                 }
17722                 if err := pcall(func() {
17723                         ((*(*(struct {
17724                                 Param0 Content
17725
17726                                 Name   string
17727                                 Groups []Group
17728
17729                                 P1Type   Param1Type
17730                                 P2Type   Param2Type
17731                                 DrawType DrawType
17732
17733                                 Mesh  string
17734                                 Scale float32
17735                                 //mt:const uint8(6)
17736                                 Tiles        [6]TileDef
17737                                 OverlayTiles [6]TileDef
17738                                 //mt:const uint8(6)
17739                                 SpecialTiles [6]TileDef
17740
17741                                 Color   color.NRGBA
17742                                 Palette Texture
17743
17744                                 Waving       WaveType
17745                                 ConnectSides uint8
17746                                 ConnectTo    []Content
17747                                 InsideTint   color.NRGBA
17748                                 Level        uint8 // Must be < 128.
17749
17750                                 Translucent bool // Sunlight is scattered and becomes normal light.
17751                                 Transparent bool // Sunlight isn't scattered.
17752                                 LightSrc    uint8
17753
17754                                 GndContent   bool
17755                                 Collides     bool
17756                                 Pointable    bool
17757                                 Diggable     bool
17758                                 Climbable    bool
17759                                 Replaceable  bool
17760                                 OnRightClick bool
17761
17762                                 DmgPerSec int32
17763
17764                                 LiquidType   LiquidType
17765                                 FlowingAlt   string
17766                                 SrcAlt       string
17767                                 Viscosity    uint8 // 0-7
17768                                 LiqRenewable bool
17769                                 FlowRange    uint8
17770                                 DrownDmg     uint8
17771                                 Floodable    bool
17772
17773                                 DrawBox, ColBox, SelBox NodeBox
17774
17775                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17776
17777                                 LegacyFaceDir bool
17778                                 LegacyMounted bool
17779
17780                                 DigPredict string
17781
17782                                 MaxLvl uint8
17783
17784                                 AlphaUse
17785                         }))(obj)).SelBox).serialize(w)
17786                 }); err != nil {
17787                         if err == io.EOF {
17788                                 chk(io.EOF)
17789                         }
17790                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17791                 }
17792                 if err := pcall(func() {
17793                         ((*(*(struct {
17794                                 Param0 Content
17795
17796                                 Name   string
17797                                 Groups []Group
17798
17799                                 P1Type   Param1Type
17800                                 P2Type   Param2Type
17801                                 DrawType DrawType
17802
17803                                 Mesh  string
17804                                 Scale float32
17805                                 //mt:const uint8(6)
17806                                 Tiles        [6]TileDef
17807                                 OverlayTiles [6]TileDef
17808                                 //mt:const uint8(6)
17809                                 SpecialTiles [6]TileDef
17810
17811                                 Color   color.NRGBA
17812                                 Palette Texture
17813
17814                                 Waving       WaveType
17815                                 ConnectSides uint8
17816                                 ConnectTo    []Content
17817                                 InsideTint   color.NRGBA
17818                                 Level        uint8 // Must be < 128.
17819
17820                                 Translucent bool // Sunlight is scattered and becomes normal light.
17821                                 Transparent bool // Sunlight isn't scattered.
17822                                 LightSrc    uint8
17823
17824                                 GndContent   bool
17825                                 Collides     bool
17826                                 Pointable    bool
17827                                 Diggable     bool
17828                                 Climbable    bool
17829                                 Replaceable  bool
17830                                 OnRightClick bool
17831
17832                                 DmgPerSec int32
17833
17834                                 LiquidType   LiquidType
17835                                 FlowingAlt   string
17836                                 SrcAlt       string
17837                                 Viscosity    uint8 // 0-7
17838                                 LiqRenewable bool
17839                                 FlowRange    uint8
17840                                 DrownDmg     uint8
17841                                 Floodable    bool
17842
17843                                 DrawBox, ColBox, SelBox NodeBox
17844
17845                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17846
17847                                 LegacyFaceDir bool
17848                                 LegacyMounted bool
17849
17850                                 DigPredict string
17851
17852                                 MaxLvl uint8
17853
17854                                 AlphaUse
17855                         }))(obj)).FootstepSnd).serialize(w)
17856                 }); err != nil {
17857                         if err == io.EOF {
17858                                 chk(io.EOF)
17859                         }
17860                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
17861                 }
17862                 if err := pcall(func() {
17863                         ((*(*(struct {
17864                                 Param0 Content
17865
17866                                 Name   string
17867                                 Groups []Group
17868
17869                                 P1Type   Param1Type
17870                                 P2Type   Param2Type
17871                                 DrawType DrawType
17872
17873                                 Mesh  string
17874                                 Scale float32
17875                                 //mt:const uint8(6)
17876                                 Tiles        [6]TileDef
17877                                 OverlayTiles [6]TileDef
17878                                 //mt:const uint8(6)
17879                                 SpecialTiles [6]TileDef
17880
17881                                 Color   color.NRGBA
17882                                 Palette Texture
17883
17884                                 Waving       WaveType
17885                                 ConnectSides uint8
17886                                 ConnectTo    []Content
17887                                 InsideTint   color.NRGBA
17888                                 Level        uint8 // Must be < 128.
17889
17890                                 Translucent bool // Sunlight is scattered and becomes normal light.
17891                                 Transparent bool // Sunlight isn't scattered.
17892                                 LightSrc    uint8
17893
17894                                 GndContent   bool
17895                                 Collides     bool
17896                                 Pointable    bool
17897                                 Diggable     bool
17898                                 Climbable    bool
17899                                 Replaceable  bool
17900                                 OnRightClick bool
17901
17902                                 DmgPerSec int32
17903
17904                                 LiquidType   LiquidType
17905                                 FlowingAlt   string
17906                                 SrcAlt       string
17907                                 Viscosity    uint8 // 0-7
17908                                 LiqRenewable bool
17909                                 FlowRange    uint8
17910                                 DrownDmg     uint8
17911                                 Floodable    bool
17912
17913                                 DrawBox, ColBox, SelBox NodeBox
17914
17915                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17916
17917                                 LegacyFaceDir bool
17918                                 LegacyMounted bool
17919
17920                                 DigPredict string
17921
17922                                 MaxLvl uint8
17923
17924                                 AlphaUse
17925                         }))(obj)).DiggingSnd).serialize(w)
17926                 }); err != nil {
17927                         if err == io.EOF {
17928                                 chk(io.EOF)
17929                         }
17930                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
17931                 }
17932                 if err := pcall(func() {
17933                         ((*(*(struct {
17934                                 Param0 Content
17935
17936                                 Name   string
17937                                 Groups []Group
17938
17939                                 P1Type   Param1Type
17940                                 P2Type   Param2Type
17941                                 DrawType DrawType
17942
17943                                 Mesh  string
17944                                 Scale float32
17945                                 //mt:const uint8(6)
17946                                 Tiles        [6]TileDef
17947                                 OverlayTiles [6]TileDef
17948                                 //mt:const uint8(6)
17949                                 SpecialTiles [6]TileDef
17950
17951                                 Color   color.NRGBA
17952                                 Palette Texture
17953
17954                                 Waving       WaveType
17955                                 ConnectSides uint8
17956                                 ConnectTo    []Content
17957                                 InsideTint   color.NRGBA
17958                                 Level        uint8 // Must be < 128.
17959
17960                                 Translucent bool // Sunlight is scattered and becomes normal light.
17961                                 Transparent bool // Sunlight isn't scattered.
17962                                 LightSrc    uint8
17963
17964                                 GndContent   bool
17965                                 Collides     bool
17966                                 Pointable    bool
17967                                 Diggable     bool
17968                                 Climbable    bool
17969                                 Replaceable  bool
17970                                 OnRightClick bool
17971
17972                                 DmgPerSec int32
17973
17974                                 LiquidType   LiquidType
17975                                 FlowingAlt   string
17976                                 SrcAlt       string
17977                                 Viscosity    uint8 // 0-7
17978                                 LiqRenewable bool
17979                                 FlowRange    uint8
17980                                 DrownDmg     uint8
17981                                 Floodable    bool
17982
17983                                 DrawBox, ColBox, SelBox NodeBox
17984
17985                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17986
17987                                 LegacyFaceDir bool
17988                                 LegacyMounted bool
17989
17990                                 DigPredict string
17991
17992                                 MaxLvl uint8
17993
17994                                 AlphaUse
17995                         }))(obj)).DugSnd).serialize(w)
17996                 }); err != nil {
17997                         if err == io.EOF {
17998                                 chk(io.EOF)
17999                         }
18000                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
18001                 }
18002                 {
18003                         x := (*(*(struct {
18004                                 Param0 Content
18005
18006                                 Name   string
18007                                 Groups []Group
18008
18009                                 P1Type   Param1Type
18010                                 P2Type   Param2Type
18011                                 DrawType DrawType
18012
18013                                 Mesh  string
18014                                 Scale float32
18015                                 //mt:const uint8(6)
18016                                 Tiles        [6]TileDef
18017                                 OverlayTiles [6]TileDef
18018                                 //mt:const uint8(6)
18019                                 SpecialTiles [6]TileDef
18020
18021                                 Color   color.NRGBA
18022                                 Palette Texture
18023
18024                                 Waving       WaveType
18025                                 ConnectSides uint8
18026                                 ConnectTo    []Content
18027                                 InsideTint   color.NRGBA
18028                                 Level        uint8 // Must be < 128.
18029
18030                                 Translucent bool // Sunlight is scattered and becomes normal light.
18031                                 Transparent bool // Sunlight isn't scattered.
18032                                 LightSrc    uint8
18033
18034                                 GndContent   bool
18035                                 Collides     bool
18036                                 Pointable    bool
18037                                 Diggable     bool
18038                                 Climbable    bool
18039                                 Replaceable  bool
18040                                 OnRightClick bool
18041
18042                                 DmgPerSec int32
18043
18044                                 LiquidType   LiquidType
18045                                 FlowingAlt   string
18046                                 SrcAlt       string
18047                                 Viscosity    uint8 // 0-7
18048                                 LiqRenewable bool
18049                                 FlowRange    uint8
18050                                 DrownDmg     uint8
18051                                 Floodable    bool
18052
18053                                 DrawBox, ColBox, SelBox NodeBox
18054
18055                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18056
18057                                 LegacyFaceDir bool
18058                                 LegacyMounted bool
18059
18060                                 DigPredict string
18061
18062                                 MaxLvl uint8
18063
18064                                 AlphaUse
18065                         }))(obj)).LegacyFaceDir
18066                         if x {
18067                                 write8(w, 1)
18068                         } else {
18069                                 write8(w, 0)
18070                         }
18071
18072                 }
18073                 {
18074                         x := (*(*(struct {
18075                                 Param0 Content
18076
18077                                 Name   string
18078                                 Groups []Group
18079
18080                                 P1Type   Param1Type
18081                                 P2Type   Param2Type
18082                                 DrawType DrawType
18083
18084                                 Mesh  string
18085                                 Scale float32
18086                                 //mt:const uint8(6)
18087                                 Tiles        [6]TileDef
18088                                 OverlayTiles [6]TileDef
18089                                 //mt:const uint8(6)
18090                                 SpecialTiles [6]TileDef
18091
18092                                 Color   color.NRGBA
18093                                 Palette Texture
18094
18095                                 Waving       WaveType
18096                                 ConnectSides uint8
18097                                 ConnectTo    []Content
18098                                 InsideTint   color.NRGBA
18099                                 Level        uint8 // Must be < 128.
18100
18101                                 Translucent bool // Sunlight is scattered and becomes normal light.
18102                                 Transparent bool // Sunlight isn't scattered.
18103                                 LightSrc    uint8
18104
18105                                 GndContent   bool
18106                                 Collides     bool
18107                                 Pointable    bool
18108                                 Diggable     bool
18109                                 Climbable    bool
18110                                 Replaceable  bool
18111                                 OnRightClick bool
18112
18113                                 DmgPerSec int32
18114
18115                                 LiquidType   LiquidType
18116                                 FlowingAlt   string
18117                                 SrcAlt       string
18118                                 Viscosity    uint8 // 0-7
18119                                 LiqRenewable bool
18120                                 FlowRange    uint8
18121                                 DrownDmg     uint8
18122                                 Floodable    bool
18123
18124                                 DrawBox, ColBox, SelBox NodeBox
18125
18126                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18127
18128                                 LegacyFaceDir bool
18129                                 LegacyMounted bool
18130
18131                                 DigPredict string
18132
18133                                 MaxLvl uint8
18134
18135                                 AlphaUse
18136                         }))(obj)).LegacyMounted
18137                         if x {
18138                                 write8(w, 1)
18139                         } else {
18140                                 write8(w, 0)
18141                         }
18142
18143                 }
18144                 if len(([]byte((*(*(struct {
18145                         Param0 Content
18146
18147                         Name   string
18148                         Groups []Group
18149
18150                         P1Type   Param1Type
18151                         P2Type   Param2Type
18152                         DrawType DrawType
18153
18154                         Mesh  string
18155                         Scale float32
18156                         //mt:const uint8(6)
18157                         Tiles        [6]TileDef
18158                         OverlayTiles [6]TileDef
18159                         //mt:const uint8(6)
18160                         SpecialTiles [6]TileDef
18161
18162                         Color   color.NRGBA
18163                         Palette Texture
18164
18165                         Waving       WaveType
18166                         ConnectSides uint8
18167                         ConnectTo    []Content
18168                         InsideTint   color.NRGBA
18169                         Level        uint8 // Must be < 128.
18170
18171                         Translucent bool // Sunlight is scattered and becomes normal light.
18172                         Transparent bool // Sunlight isn't scattered.
18173                         LightSrc    uint8
18174
18175                         GndContent   bool
18176                         Collides     bool
18177                         Pointable    bool
18178                         Diggable     bool
18179                         Climbable    bool
18180                         Replaceable  bool
18181                         OnRightClick bool
18182
18183                         DmgPerSec int32
18184
18185                         LiquidType   LiquidType
18186                         FlowingAlt   string
18187                         SrcAlt       string
18188                         Viscosity    uint8 // 0-7
18189                         LiqRenewable bool
18190                         FlowRange    uint8
18191                         DrownDmg     uint8
18192                         Floodable    bool
18193
18194                         DrawBox, ColBox, SelBox NodeBox
18195
18196                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18197
18198                         LegacyFaceDir bool
18199                         LegacyMounted bool
18200
18201                         DigPredict string
18202
18203                         MaxLvl uint8
18204
18205                         AlphaUse
18206                 }))(obj)).DigPredict))) > math.MaxUint16 {
18207                         chk(ErrTooLong)
18208                 }
18209                 {
18210                         x := uint16(len(([]byte((*(*(struct {
18211                                 Param0 Content
18212
18213                                 Name   string
18214                                 Groups []Group
18215
18216                                 P1Type   Param1Type
18217                                 P2Type   Param2Type
18218                                 DrawType DrawType
18219
18220                                 Mesh  string
18221                                 Scale float32
18222                                 //mt:const uint8(6)
18223                                 Tiles        [6]TileDef
18224                                 OverlayTiles [6]TileDef
18225                                 //mt:const uint8(6)
18226                                 SpecialTiles [6]TileDef
18227
18228                                 Color   color.NRGBA
18229                                 Palette Texture
18230
18231                                 Waving       WaveType
18232                                 ConnectSides uint8
18233                                 ConnectTo    []Content
18234                                 InsideTint   color.NRGBA
18235                                 Level        uint8 // Must be < 128.
18236
18237                                 Translucent bool // Sunlight is scattered and becomes normal light.
18238                                 Transparent bool // Sunlight isn't scattered.
18239                                 LightSrc    uint8
18240
18241                                 GndContent   bool
18242                                 Collides     bool
18243                                 Pointable    bool
18244                                 Diggable     bool
18245                                 Climbable    bool
18246                                 Replaceable  bool
18247                                 OnRightClick bool
18248
18249                                 DmgPerSec int32
18250
18251                                 LiquidType   LiquidType
18252                                 FlowingAlt   string
18253                                 SrcAlt       string
18254                                 Viscosity    uint8 // 0-7
18255                                 LiqRenewable bool
18256                                 FlowRange    uint8
18257                                 DrownDmg     uint8
18258                                 Floodable    bool
18259
18260                                 DrawBox, ColBox, SelBox NodeBox
18261
18262                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18263
18264                                 LegacyFaceDir bool
18265                                 LegacyMounted bool
18266
18267                                 DigPredict string
18268
18269                                 MaxLvl uint8
18270
18271                                 AlphaUse
18272                         }))(obj)).DigPredict))))
18273                         write16(w, uint16(x))
18274                 }
18275                 {
18276                         _, err := w.Write(([]byte((*(*(struct {
18277                                 Param0 Content
18278
18279                                 Name   string
18280                                 Groups []Group
18281
18282                                 P1Type   Param1Type
18283                                 P2Type   Param2Type
18284                                 DrawType DrawType
18285
18286                                 Mesh  string
18287                                 Scale float32
18288                                 //mt:const uint8(6)
18289                                 Tiles        [6]TileDef
18290                                 OverlayTiles [6]TileDef
18291                                 //mt:const uint8(6)
18292                                 SpecialTiles [6]TileDef
18293
18294                                 Color   color.NRGBA
18295                                 Palette Texture
18296
18297                                 Waving       WaveType
18298                                 ConnectSides uint8
18299                                 ConnectTo    []Content
18300                                 InsideTint   color.NRGBA
18301                                 Level        uint8 // Must be < 128.
18302
18303                                 Translucent bool // Sunlight is scattered and becomes normal light.
18304                                 Transparent bool // Sunlight isn't scattered.
18305                                 LightSrc    uint8
18306
18307                                 GndContent   bool
18308                                 Collides     bool
18309                                 Pointable    bool
18310                                 Diggable     bool
18311                                 Climbable    bool
18312                                 Replaceable  bool
18313                                 OnRightClick bool
18314
18315                                 DmgPerSec int32
18316
18317                                 LiquidType   LiquidType
18318                                 FlowingAlt   string
18319                                 SrcAlt       string
18320                                 Viscosity    uint8 // 0-7
18321                                 LiqRenewable bool
18322                                 FlowRange    uint8
18323                                 DrownDmg     uint8
18324                                 Floodable    bool
18325
18326                                 DrawBox, ColBox, SelBox NodeBox
18327
18328                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18329
18330                                 LegacyFaceDir bool
18331                                 LegacyMounted bool
18332
18333                                 DigPredict string
18334
18335                                 MaxLvl uint8
18336
18337                                 AlphaUse
18338                         }))(obj)).DigPredict))[:])
18339                         chk(err)
18340                 }
18341                 {
18342                         x := (*(*(struct {
18343                                 Param0 Content
18344
18345                                 Name   string
18346                                 Groups []Group
18347
18348                                 P1Type   Param1Type
18349                                 P2Type   Param2Type
18350                                 DrawType DrawType
18351
18352                                 Mesh  string
18353                                 Scale float32
18354                                 //mt:const uint8(6)
18355                                 Tiles        [6]TileDef
18356                                 OverlayTiles [6]TileDef
18357                                 //mt:const uint8(6)
18358                                 SpecialTiles [6]TileDef
18359
18360                                 Color   color.NRGBA
18361                                 Palette Texture
18362
18363                                 Waving       WaveType
18364                                 ConnectSides uint8
18365                                 ConnectTo    []Content
18366                                 InsideTint   color.NRGBA
18367                                 Level        uint8 // Must be < 128.
18368
18369                                 Translucent bool // Sunlight is scattered and becomes normal light.
18370                                 Transparent bool // Sunlight isn't scattered.
18371                                 LightSrc    uint8
18372
18373                                 GndContent   bool
18374                                 Collides     bool
18375                                 Pointable    bool
18376                                 Diggable     bool
18377                                 Climbable    bool
18378                                 Replaceable  bool
18379                                 OnRightClick bool
18380
18381                                 DmgPerSec int32
18382
18383                                 LiquidType   LiquidType
18384                                 FlowingAlt   string
18385                                 SrcAlt       string
18386                                 Viscosity    uint8 // 0-7
18387                                 LiqRenewable bool
18388                                 FlowRange    uint8
18389                                 DrownDmg     uint8
18390                                 Floodable    bool
18391
18392                                 DrawBox, ColBox, SelBox NodeBox
18393
18394                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18395
18396                                 LegacyFaceDir bool
18397                                 LegacyMounted bool
18398
18399                                 DigPredict string
18400
18401                                 MaxLvl uint8
18402
18403                                 AlphaUse
18404                         }))(obj)).MaxLvl
18405                         write8(w, uint8(x))
18406                 }
18407                 if err := pcall(func() {
18408                         ((*(*(struct {
18409                                 Param0 Content
18410
18411                                 Name   string
18412                                 Groups []Group
18413
18414                                 P1Type   Param1Type
18415                                 P2Type   Param2Type
18416                                 DrawType DrawType
18417
18418                                 Mesh  string
18419                                 Scale float32
18420                                 //mt:const uint8(6)
18421                                 Tiles        [6]TileDef
18422                                 OverlayTiles [6]TileDef
18423                                 //mt:const uint8(6)
18424                                 SpecialTiles [6]TileDef
18425
18426                                 Color   color.NRGBA
18427                                 Palette Texture
18428
18429                                 Waving       WaveType
18430                                 ConnectSides uint8
18431                                 ConnectTo    []Content
18432                                 InsideTint   color.NRGBA
18433                                 Level        uint8 // Must be < 128.
18434
18435                                 Translucent bool // Sunlight is scattered and becomes normal light.
18436                                 Transparent bool // Sunlight isn't scattered.
18437                                 LightSrc    uint8
18438
18439                                 GndContent   bool
18440                                 Collides     bool
18441                                 Pointable    bool
18442                                 Diggable     bool
18443                                 Climbable    bool
18444                                 Replaceable  bool
18445                                 OnRightClick bool
18446
18447                                 DmgPerSec int32
18448
18449                                 LiquidType   LiquidType
18450                                 FlowingAlt   string
18451                                 SrcAlt       string
18452                                 Viscosity    uint8 // 0-7
18453                                 LiqRenewable bool
18454                                 FlowRange    uint8
18455                                 DrownDmg     uint8
18456                                 Floodable    bool
18457
18458                                 DrawBox, ColBox, SelBox NodeBox
18459
18460                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18461
18462                                 LegacyFaceDir bool
18463                                 LegacyMounted bool
18464
18465                                 DigPredict string
18466
18467                                 MaxLvl uint8
18468
18469                                 AlphaUse
18470                         }))(obj)).AlphaUse).serialize(w)
18471                 }); err != nil {
18472                         if err == io.EOF {
18473                                 chk(io.EOF)
18474                         }
18475                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlphaUse", err))
18476                 }
18477                 {
18478                         buf := w
18479                         w := ow
18480                         if len((buf.Bytes())) > math.MaxUint16 {
18481                                 chk(ErrTooLong)
18482                         }
18483                         {
18484                                 x := uint16(len((buf.Bytes())))
18485                                 write16(w, uint16(x))
18486                         }
18487                         {
18488                                 _, err := w.Write((buf.Bytes())[:])
18489                                 chk(err)
18490                         }
18491                 }
18492         }
18493 }
18494
18495 func (obj *NodeDef) deserialize(r io.Reader) {
18496         if err := pcall(func() {
18497                 ((*(*(struct {
18498                         Param0 Content
18499
18500                         Name   string
18501                         Groups []Group
18502
18503                         P1Type   Param1Type
18504                         P2Type   Param2Type
18505                         DrawType DrawType
18506
18507                         Mesh  string
18508                         Scale float32
18509                         //mt:const uint8(6)
18510                         Tiles        [6]TileDef
18511                         OverlayTiles [6]TileDef
18512                         //mt:const uint8(6)
18513                         SpecialTiles [6]TileDef
18514
18515                         Color   color.NRGBA
18516                         Palette Texture
18517
18518                         Waving       WaveType
18519                         ConnectSides uint8
18520                         ConnectTo    []Content
18521                         InsideTint   color.NRGBA
18522                         Level        uint8 // Must be < 128.
18523
18524                         Translucent bool // Sunlight is scattered and becomes normal light.
18525                         Transparent bool // Sunlight isn't scattered.
18526                         LightSrc    uint8
18527
18528                         GndContent   bool
18529                         Collides     bool
18530                         Pointable    bool
18531                         Diggable     bool
18532                         Climbable    bool
18533                         Replaceable  bool
18534                         OnRightClick bool
18535
18536                         DmgPerSec int32
18537
18538                         LiquidType   LiquidType
18539                         FlowingAlt   string
18540                         SrcAlt       string
18541                         Viscosity    uint8 // 0-7
18542                         LiqRenewable bool
18543                         FlowRange    uint8
18544                         DrownDmg     uint8
18545                         Floodable    bool
18546
18547                         DrawBox, ColBox, SelBox NodeBox
18548
18549                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18550
18551                         LegacyFaceDir bool
18552                         LegacyMounted bool
18553
18554                         DigPredict string
18555
18556                         MaxLvl uint8
18557
18558                         AlphaUse
18559                 }))(obj)).Param0).deserialize(r)
18560         }); err != nil {
18561                 if err == io.EOF {
18562                         chk(io.EOF)
18563                 }
18564                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
18565         }
18566         {
18567                 var n uint16
18568                 {
18569                         p := &n
18570                         *p = read16(r)
18571                 }
18572                 r := &io.LimitedReader{R: r, N: int64(n)}
18573                 {
18574                         var local248 uint8
18575                         local249 := uint8(13)
18576                         {
18577                                 p := &local248
18578                                 *p = read8(r)
18579                         }
18580                         if local248 != local249 {
18581                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local248))
18582                         }
18583                 }
18584                 var local250 []uint8
18585                 var local251 uint16
18586                 {
18587                         p := &local251
18588                         *p = read16(r)
18589                 }
18590                 (local250) = make([]uint8, local251)
18591                 {
18592                         _, err := io.ReadFull(r, (local250)[:])
18593                         chk(err)
18594                 }
18595                 ((*(*(struct {
18596                         Param0 Content
18597
18598                         Name   string
18599                         Groups []Group
18600
18601                         P1Type   Param1Type
18602                         P2Type   Param2Type
18603                         DrawType DrawType
18604
18605                         Mesh  string
18606                         Scale float32
18607                         //mt:const uint8(6)
18608                         Tiles        [6]TileDef
18609                         OverlayTiles [6]TileDef
18610                         //mt:const uint8(6)
18611                         SpecialTiles [6]TileDef
18612
18613                         Color   color.NRGBA
18614                         Palette Texture
18615
18616                         Waving       WaveType
18617                         ConnectSides uint8
18618                         ConnectTo    []Content
18619                         InsideTint   color.NRGBA
18620                         Level        uint8 // Must be < 128.
18621
18622                         Translucent bool // Sunlight is scattered and becomes normal light.
18623                         Transparent bool // Sunlight isn't scattered.
18624                         LightSrc    uint8
18625
18626                         GndContent   bool
18627                         Collides     bool
18628                         Pointable    bool
18629                         Diggable     bool
18630                         Climbable    bool
18631                         Replaceable  bool
18632                         OnRightClick bool
18633
18634                         DmgPerSec int32
18635
18636                         LiquidType   LiquidType
18637                         FlowingAlt   string
18638                         SrcAlt       string
18639                         Viscosity    uint8 // 0-7
18640                         LiqRenewable bool
18641                         FlowRange    uint8
18642                         DrownDmg     uint8
18643                         Floodable    bool
18644
18645                         DrawBox, ColBox, SelBox NodeBox
18646
18647                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18648
18649                         LegacyFaceDir bool
18650                         LegacyMounted bool
18651
18652                         DigPredict string
18653
18654                         MaxLvl uint8
18655
18656                         AlphaUse
18657                 }))(obj)).Name) = string(local250)
18658                 var local252 uint16
18659                 {
18660                         p := &local252
18661                         *p = read16(r)
18662                 }
18663                 ((*(*(struct {
18664                         Param0 Content
18665
18666                         Name   string
18667                         Groups []Group
18668
18669                         P1Type   Param1Type
18670                         P2Type   Param2Type
18671                         DrawType DrawType
18672
18673                         Mesh  string
18674                         Scale float32
18675                         //mt:const uint8(6)
18676                         Tiles        [6]TileDef
18677                         OverlayTiles [6]TileDef
18678                         //mt:const uint8(6)
18679                         SpecialTiles [6]TileDef
18680
18681                         Color   color.NRGBA
18682                         Palette Texture
18683
18684                         Waving       WaveType
18685                         ConnectSides uint8
18686                         ConnectTo    []Content
18687                         InsideTint   color.NRGBA
18688                         Level        uint8 // Must be < 128.
18689
18690                         Translucent bool // Sunlight is scattered and becomes normal light.
18691                         Transparent bool // Sunlight isn't scattered.
18692                         LightSrc    uint8
18693
18694                         GndContent   bool
18695                         Collides     bool
18696                         Pointable    bool
18697                         Diggable     bool
18698                         Climbable    bool
18699                         Replaceable  bool
18700                         OnRightClick bool
18701
18702                         DmgPerSec int32
18703
18704                         LiquidType   LiquidType
18705                         FlowingAlt   string
18706                         SrcAlt       string
18707                         Viscosity    uint8 // 0-7
18708                         LiqRenewable bool
18709                         FlowRange    uint8
18710                         DrownDmg     uint8
18711                         Floodable    bool
18712
18713                         DrawBox, ColBox, SelBox NodeBox
18714
18715                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18716
18717                         LegacyFaceDir bool
18718                         LegacyMounted bool
18719
18720                         DigPredict string
18721
18722                         MaxLvl uint8
18723
18724                         AlphaUse
18725                 }))(obj)).Groups) = make([]Group, local252)
18726                 for local253 := range (*(*(struct {
18727                         Param0 Content
18728
18729                         Name   string
18730                         Groups []Group
18731
18732                         P1Type   Param1Type
18733                         P2Type   Param2Type
18734                         DrawType DrawType
18735
18736                         Mesh  string
18737                         Scale float32
18738                         //mt:const uint8(6)
18739                         Tiles        [6]TileDef
18740                         OverlayTiles [6]TileDef
18741                         //mt:const uint8(6)
18742                         SpecialTiles [6]TileDef
18743
18744                         Color   color.NRGBA
18745                         Palette Texture
18746
18747                         Waving       WaveType
18748                         ConnectSides uint8
18749                         ConnectTo    []Content
18750                         InsideTint   color.NRGBA
18751                         Level        uint8 // Must be < 128.
18752
18753                         Translucent bool // Sunlight is scattered and becomes normal light.
18754                         Transparent bool // Sunlight isn't scattered.
18755                         LightSrc    uint8
18756
18757                         GndContent   bool
18758                         Collides     bool
18759                         Pointable    bool
18760                         Diggable     bool
18761                         Climbable    bool
18762                         Replaceable  bool
18763                         OnRightClick bool
18764
18765                         DmgPerSec int32
18766
18767                         LiquidType   LiquidType
18768                         FlowingAlt   string
18769                         SrcAlt       string
18770                         Viscosity    uint8 // 0-7
18771                         LiqRenewable bool
18772                         FlowRange    uint8
18773                         DrownDmg     uint8
18774                         Floodable    bool
18775
18776                         DrawBox, ColBox, SelBox NodeBox
18777
18778                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18779
18780                         LegacyFaceDir bool
18781                         LegacyMounted bool
18782
18783                         DigPredict string
18784
18785                         MaxLvl uint8
18786
18787                         AlphaUse
18788                 }))(obj)).Groups {
18789                         if err := pcall(func() {
18790                                 (((*(*(struct {
18791                                         Param0 Content
18792
18793                                         Name   string
18794                                         Groups []Group
18795
18796                                         P1Type   Param1Type
18797                                         P2Type   Param2Type
18798                                         DrawType DrawType
18799
18800                                         Mesh  string
18801                                         Scale float32
18802                                         //mt:const uint8(6)
18803                                         Tiles        [6]TileDef
18804                                         OverlayTiles [6]TileDef
18805                                         //mt:const uint8(6)
18806                                         SpecialTiles [6]TileDef
18807
18808                                         Color   color.NRGBA
18809                                         Palette Texture
18810
18811                                         Waving       WaveType
18812                                         ConnectSides uint8
18813                                         ConnectTo    []Content
18814                                         InsideTint   color.NRGBA
18815                                         Level        uint8 // Must be < 128.
18816
18817                                         Translucent bool // Sunlight is scattered and becomes normal light.
18818                                         Transparent bool // Sunlight isn't scattered.
18819                                         LightSrc    uint8
18820
18821                                         GndContent   bool
18822                                         Collides     bool
18823                                         Pointable    bool
18824                                         Diggable     bool
18825                                         Climbable    bool
18826                                         Replaceable  bool
18827                                         OnRightClick bool
18828
18829                                         DmgPerSec int32
18830
18831                                         LiquidType   LiquidType
18832                                         FlowingAlt   string
18833                                         SrcAlt       string
18834                                         Viscosity    uint8 // 0-7
18835                                         LiqRenewable bool
18836                                         FlowRange    uint8
18837                                         DrownDmg     uint8
18838                                         Floodable    bool
18839
18840                                         DrawBox, ColBox, SelBox NodeBox
18841
18842                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18843
18844                                         LegacyFaceDir bool
18845                                         LegacyMounted bool
18846
18847                                         DigPredict string
18848
18849                                         MaxLvl uint8
18850
18851                                         AlphaUse
18852                                 }))(obj)).Groups)[local253]).deserialize(r)
18853                         }); err != nil {
18854                                 if err == io.EOF {
18855                                         chk(io.EOF)
18856                                 }
18857                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
18858                         }
18859                 }
18860                 if err := pcall(func() {
18861                         ((*(*(struct {
18862                                 Param0 Content
18863
18864                                 Name   string
18865                                 Groups []Group
18866
18867                                 P1Type   Param1Type
18868                                 P2Type   Param2Type
18869                                 DrawType DrawType
18870
18871                                 Mesh  string
18872                                 Scale float32
18873                                 //mt:const uint8(6)
18874                                 Tiles        [6]TileDef
18875                                 OverlayTiles [6]TileDef
18876                                 //mt:const uint8(6)
18877                                 SpecialTiles [6]TileDef
18878
18879                                 Color   color.NRGBA
18880                                 Palette Texture
18881
18882                                 Waving       WaveType
18883                                 ConnectSides uint8
18884                                 ConnectTo    []Content
18885                                 InsideTint   color.NRGBA
18886                                 Level        uint8 // Must be < 128.
18887
18888                                 Translucent bool // Sunlight is scattered and becomes normal light.
18889                                 Transparent bool // Sunlight isn't scattered.
18890                                 LightSrc    uint8
18891
18892                                 GndContent   bool
18893                                 Collides     bool
18894                                 Pointable    bool
18895                                 Diggable     bool
18896                                 Climbable    bool
18897                                 Replaceable  bool
18898                                 OnRightClick bool
18899
18900                                 DmgPerSec int32
18901
18902                                 LiquidType   LiquidType
18903                                 FlowingAlt   string
18904                                 SrcAlt       string
18905                                 Viscosity    uint8 // 0-7
18906                                 LiqRenewable bool
18907                                 FlowRange    uint8
18908                                 DrownDmg     uint8
18909                                 Floodable    bool
18910
18911                                 DrawBox, ColBox, SelBox NodeBox
18912
18913                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18914
18915                                 LegacyFaceDir bool
18916                                 LegacyMounted bool
18917
18918                                 DigPredict string
18919
18920                                 MaxLvl uint8
18921
18922                                 AlphaUse
18923                         }))(obj)).P1Type).deserialize(r)
18924                 }); err != nil {
18925                         if err == io.EOF {
18926                                 chk(io.EOF)
18927                         }
18928                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param1Type", err))
18929                 }
18930                 if err := pcall(func() {
18931                         ((*(*(struct {
18932                                 Param0 Content
18933
18934                                 Name   string
18935                                 Groups []Group
18936
18937                                 P1Type   Param1Type
18938                                 P2Type   Param2Type
18939                                 DrawType DrawType
18940
18941                                 Mesh  string
18942                                 Scale float32
18943                                 //mt:const uint8(6)
18944                                 Tiles        [6]TileDef
18945                                 OverlayTiles [6]TileDef
18946                                 //mt:const uint8(6)
18947                                 SpecialTiles [6]TileDef
18948
18949                                 Color   color.NRGBA
18950                                 Palette Texture
18951
18952                                 Waving       WaveType
18953                                 ConnectSides uint8
18954                                 ConnectTo    []Content
18955                                 InsideTint   color.NRGBA
18956                                 Level        uint8 // Must be < 128.
18957
18958                                 Translucent bool // Sunlight is scattered and becomes normal light.
18959                                 Transparent bool // Sunlight isn't scattered.
18960                                 LightSrc    uint8
18961
18962                                 GndContent   bool
18963                                 Collides     bool
18964                                 Pointable    bool
18965                                 Diggable     bool
18966                                 Climbable    bool
18967                                 Replaceable  bool
18968                                 OnRightClick bool
18969
18970                                 DmgPerSec int32
18971
18972                                 LiquidType   LiquidType
18973                                 FlowingAlt   string
18974                                 SrcAlt       string
18975                                 Viscosity    uint8 // 0-7
18976                                 LiqRenewable bool
18977                                 FlowRange    uint8
18978                                 DrownDmg     uint8
18979                                 Floodable    bool
18980
18981                                 DrawBox, ColBox, SelBox NodeBox
18982
18983                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18984
18985                                 LegacyFaceDir bool
18986                                 LegacyMounted bool
18987
18988                                 DigPredict string
18989
18990                                 MaxLvl uint8
18991
18992                                 AlphaUse
18993                         }))(obj)).P2Type).deserialize(r)
18994                 }); err != nil {
18995                         if err == io.EOF {
18996                                 chk(io.EOF)
18997                         }
18998                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param2Type", err))
18999                 }
19000                 if err := pcall(func() {
19001                         ((*(*(struct {
19002                                 Param0 Content
19003
19004                                 Name   string
19005                                 Groups []Group
19006
19007                                 P1Type   Param1Type
19008                                 P2Type   Param2Type
19009                                 DrawType DrawType
19010
19011                                 Mesh  string
19012                                 Scale float32
19013                                 //mt:const uint8(6)
19014                                 Tiles        [6]TileDef
19015                                 OverlayTiles [6]TileDef
19016                                 //mt:const uint8(6)
19017                                 SpecialTiles [6]TileDef
19018
19019                                 Color   color.NRGBA
19020                                 Palette Texture
19021
19022                                 Waving       WaveType
19023                                 ConnectSides uint8
19024                                 ConnectTo    []Content
19025                                 InsideTint   color.NRGBA
19026                                 Level        uint8 // Must be < 128.
19027
19028                                 Translucent bool // Sunlight is scattered and becomes normal light.
19029                                 Transparent bool // Sunlight isn't scattered.
19030                                 LightSrc    uint8
19031
19032                                 GndContent   bool
19033                                 Collides     bool
19034                                 Pointable    bool
19035                                 Diggable     bool
19036                                 Climbable    bool
19037                                 Replaceable  bool
19038                                 OnRightClick bool
19039
19040                                 DmgPerSec int32
19041
19042                                 LiquidType   LiquidType
19043                                 FlowingAlt   string
19044                                 SrcAlt       string
19045                                 Viscosity    uint8 // 0-7
19046                                 LiqRenewable bool
19047                                 FlowRange    uint8
19048                                 DrownDmg     uint8
19049                                 Floodable    bool
19050
19051                                 DrawBox, ColBox, SelBox NodeBox
19052
19053                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19054
19055                                 LegacyFaceDir bool
19056                                 LegacyMounted bool
19057
19058                                 DigPredict string
19059
19060                                 MaxLvl uint8
19061
19062                                 AlphaUse
19063                         }))(obj)).DrawType).deserialize(r)
19064                 }); err != nil {
19065                         if err == io.EOF {
19066                                 chk(io.EOF)
19067                         }
19068                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
19069                 }
19070                 var local254 []uint8
19071                 var local255 uint16
19072                 {
19073                         p := &local255
19074                         *p = read16(r)
19075                 }
19076                 (local254) = make([]uint8, local255)
19077                 {
19078                         _, err := io.ReadFull(r, (local254)[:])
19079                         chk(err)
19080                 }
19081                 ((*(*(struct {
19082                         Param0 Content
19083
19084                         Name   string
19085                         Groups []Group
19086
19087                         P1Type   Param1Type
19088                         P2Type   Param2Type
19089                         DrawType DrawType
19090
19091                         Mesh  string
19092                         Scale float32
19093                         //mt:const uint8(6)
19094                         Tiles        [6]TileDef
19095                         OverlayTiles [6]TileDef
19096                         //mt:const uint8(6)
19097                         SpecialTiles [6]TileDef
19098
19099                         Color   color.NRGBA
19100                         Palette Texture
19101
19102                         Waving       WaveType
19103                         ConnectSides uint8
19104                         ConnectTo    []Content
19105                         InsideTint   color.NRGBA
19106                         Level        uint8 // Must be < 128.
19107
19108                         Translucent bool // Sunlight is scattered and becomes normal light.
19109                         Transparent bool // Sunlight isn't scattered.
19110                         LightSrc    uint8
19111
19112                         GndContent   bool
19113                         Collides     bool
19114                         Pointable    bool
19115                         Diggable     bool
19116                         Climbable    bool
19117                         Replaceable  bool
19118                         OnRightClick bool
19119
19120                         DmgPerSec int32
19121
19122                         LiquidType   LiquidType
19123                         FlowingAlt   string
19124                         SrcAlt       string
19125                         Viscosity    uint8 // 0-7
19126                         LiqRenewable bool
19127                         FlowRange    uint8
19128                         DrownDmg     uint8
19129                         Floodable    bool
19130
19131                         DrawBox, ColBox, SelBox NodeBox
19132
19133                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19134
19135                         LegacyFaceDir bool
19136                         LegacyMounted bool
19137
19138                         DigPredict string
19139
19140                         MaxLvl uint8
19141
19142                         AlphaUse
19143                 }))(obj)).Mesh) = string(local254)
19144                 {
19145                         p := &(*(*(struct {
19146                                 Param0 Content
19147
19148                                 Name   string
19149                                 Groups []Group
19150
19151                                 P1Type   Param1Type
19152                                 P2Type   Param2Type
19153                                 DrawType DrawType
19154
19155                                 Mesh  string
19156                                 Scale float32
19157                                 //mt:const uint8(6)
19158                                 Tiles        [6]TileDef
19159                                 OverlayTiles [6]TileDef
19160                                 //mt:const uint8(6)
19161                                 SpecialTiles [6]TileDef
19162
19163                                 Color   color.NRGBA
19164                                 Palette Texture
19165
19166                                 Waving       WaveType
19167                                 ConnectSides uint8
19168                                 ConnectTo    []Content
19169                                 InsideTint   color.NRGBA
19170                                 Level        uint8 // Must be < 128.
19171
19172                                 Translucent bool // Sunlight is scattered and becomes normal light.
19173                                 Transparent bool // Sunlight isn't scattered.
19174                                 LightSrc    uint8
19175
19176                                 GndContent   bool
19177                                 Collides     bool
19178                                 Pointable    bool
19179                                 Diggable     bool
19180                                 Climbable    bool
19181                                 Replaceable  bool
19182                                 OnRightClick bool
19183
19184                                 DmgPerSec int32
19185
19186                                 LiquidType   LiquidType
19187                                 FlowingAlt   string
19188                                 SrcAlt       string
19189                                 Viscosity    uint8 // 0-7
19190                                 LiqRenewable bool
19191                                 FlowRange    uint8
19192                                 DrownDmg     uint8
19193                                 Floodable    bool
19194
19195                                 DrawBox, ColBox, SelBox NodeBox
19196
19197                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19198
19199                                 LegacyFaceDir bool
19200                                 LegacyMounted bool
19201
19202                                 DigPredict string
19203
19204                                 MaxLvl uint8
19205
19206                                 AlphaUse
19207                         }))(obj)).Scale
19208                         *p = math.Float32frombits(read32(r))
19209                 }
19210                 {
19211                         var local256 uint8
19212                         local257 := uint8(6)
19213                         {
19214                                 p := &local256
19215                                 *p = read8(r)
19216                         }
19217                         if local256 != local257 {
19218                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local256))
19219                         }
19220                 }
19221                 for local258 := range (*(*(struct {
19222                         Param0 Content
19223
19224                         Name   string
19225                         Groups []Group
19226
19227                         P1Type   Param1Type
19228                         P2Type   Param2Type
19229                         DrawType DrawType
19230
19231                         Mesh  string
19232                         Scale float32
19233                         //mt:const uint8(6)
19234                         Tiles        [6]TileDef
19235                         OverlayTiles [6]TileDef
19236                         //mt:const uint8(6)
19237                         SpecialTiles [6]TileDef
19238
19239                         Color   color.NRGBA
19240                         Palette Texture
19241
19242                         Waving       WaveType
19243                         ConnectSides uint8
19244                         ConnectTo    []Content
19245                         InsideTint   color.NRGBA
19246                         Level        uint8 // Must be < 128.
19247
19248                         Translucent bool // Sunlight is scattered and becomes normal light.
19249                         Transparent bool // Sunlight isn't scattered.
19250                         LightSrc    uint8
19251
19252                         GndContent   bool
19253                         Collides     bool
19254                         Pointable    bool
19255                         Diggable     bool
19256                         Climbable    bool
19257                         Replaceable  bool
19258                         OnRightClick bool
19259
19260                         DmgPerSec int32
19261
19262                         LiquidType   LiquidType
19263                         FlowingAlt   string
19264                         SrcAlt       string
19265                         Viscosity    uint8 // 0-7
19266                         LiqRenewable bool
19267                         FlowRange    uint8
19268                         DrownDmg     uint8
19269                         Floodable    bool
19270
19271                         DrawBox, ColBox, SelBox NodeBox
19272
19273                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19274
19275                         LegacyFaceDir bool
19276                         LegacyMounted bool
19277
19278                         DigPredict string
19279
19280                         MaxLvl uint8
19281
19282                         AlphaUse
19283                 }))(obj)).Tiles {
19284                         if err := pcall(func() {
19285                                 (((*(*(struct {
19286                                         Param0 Content
19287
19288                                         Name   string
19289                                         Groups []Group
19290
19291                                         P1Type   Param1Type
19292                                         P2Type   Param2Type
19293                                         DrawType DrawType
19294
19295                                         Mesh  string
19296                                         Scale float32
19297                                         //mt:const uint8(6)
19298                                         Tiles        [6]TileDef
19299                                         OverlayTiles [6]TileDef
19300                                         //mt:const uint8(6)
19301                                         SpecialTiles [6]TileDef
19302
19303                                         Color   color.NRGBA
19304                                         Palette Texture
19305
19306                                         Waving       WaveType
19307                                         ConnectSides uint8
19308                                         ConnectTo    []Content
19309                                         InsideTint   color.NRGBA
19310                                         Level        uint8 // Must be < 128.
19311
19312                                         Translucent bool // Sunlight is scattered and becomes normal light.
19313                                         Transparent bool // Sunlight isn't scattered.
19314                                         LightSrc    uint8
19315
19316                                         GndContent   bool
19317                                         Collides     bool
19318                                         Pointable    bool
19319                                         Diggable     bool
19320                                         Climbable    bool
19321                                         Replaceable  bool
19322                                         OnRightClick bool
19323
19324                                         DmgPerSec int32
19325
19326                                         LiquidType   LiquidType
19327                                         FlowingAlt   string
19328                                         SrcAlt       string
19329                                         Viscosity    uint8 // 0-7
19330                                         LiqRenewable bool
19331                                         FlowRange    uint8
19332                                         DrownDmg     uint8
19333                                         Floodable    bool
19334
19335                                         DrawBox, ColBox, SelBox NodeBox
19336
19337                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19338
19339                                         LegacyFaceDir bool
19340                                         LegacyMounted bool
19341
19342                                         DigPredict string
19343
19344                                         MaxLvl uint8
19345
19346                                         AlphaUse
19347                                 }))(obj)).Tiles)[local258]).deserialize(r)
19348                         }); err != nil {
19349                                 if err == io.EOF {
19350                                         chk(io.EOF)
19351                                 }
19352                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19353                         }
19354                 }
19355                 for local259 := range (*(*(struct {
19356                         Param0 Content
19357
19358                         Name   string
19359                         Groups []Group
19360
19361                         P1Type   Param1Type
19362                         P2Type   Param2Type
19363                         DrawType DrawType
19364
19365                         Mesh  string
19366                         Scale float32
19367                         //mt:const uint8(6)
19368                         Tiles        [6]TileDef
19369                         OverlayTiles [6]TileDef
19370                         //mt:const uint8(6)
19371                         SpecialTiles [6]TileDef
19372
19373                         Color   color.NRGBA
19374                         Palette Texture
19375
19376                         Waving       WaveType
19377                         ConnectSides uint8
19378                         ConnectTo    []Content
19379                         InsideTint   color.NRGBA
19380                         Level        uint8 // Must be < 128.
19381
19382                         Translucent bool // Sunlight is scattered and becomes normal light.
19383                         Transparent bool // Sunlight isn't scattered.
19384                         LightSrc    uint8
19385
19386                         GndContent   bool
19387                         Collides     bool
19388                         Pointable    bool
19389                         Diggable     bool
19390                         Climbable    bool
19391                         Replaceable  bool
19392                         OnRightClick bool
19393
19394                         DmgPerSec int32
19395
19396                         LiquidType   LiquidType
19397                         FlowingAlt   string
19398                         SrcAlt       string
19399                         Viscosity    uint8 // 0-7
19400                         LiqRenewable bool
19401                         FlowRange    uint8
19402                         DrownDmg     uint8
19403                         Floodable    bool
19404
19405                         DrawBox, ColBox, SelBox NodeBox
19406
19407                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19408
19409                         LegacyFaceDir bool
19410                         LegacyMounted bool
19411
19412                         DigPredict string
19413
19414                         MaxLvl uint8
19415
19416                         AlphaUse
19417                 }))(obj)).OverlayTiles {
19418                         if err := pcall(func() {
19419                                 (((*(*(struct {
19420                                         Param0 Content
19421
19422                                         Name   string
19423                                         Groups []Group
19424
19425                                         P1Type   Param1Type
19426                                         P2Type   Param2Type
19427                                         DrawType DrawType
19428
19429                                         Mesh  string
19430                                         Scale float32
19431                                         //mt:const uint8(6)
19432                                         Tiles        [6]TileDef
19433                                         OverlayTiles [6]TileDef
19434                                         //mt:const uint8(6)
19435                                         SpecialTiles [6]TileDef
19436
19437                                         Color   color.NRGBA
19438                                         Palette Texture
19439
19440                                         Waving       WaveType
19441                                         ConnectSides uint8
19442                                         ConnectTo    []Content
19443                                         InsideTint   color.NRGBA
19444                                         Level        uint8 // Must be < 128.
19445
19446                                         Translucent bool // Sunlight is scattered and becomes normal light.
19447                                         Transparent bool // Sunlight isn't scattered.
19448                                         LightSrc    uint8
19449
19450                                         GndContent   bool
19451                                         Collides     bool
19452                                         Pointable    bool
19453                                         Diggable     bool
19454                                         Climbable    bool
19455                                         Replaceable  bool
19456                                         OnRightClick bool
19457
19458                                         DmgPerSec int32
19459
19460                                         LiquidType   LiquidType
19461                                         FlowingAlt   string
19462                                         SrcAlt       string
19463                                         Viscosity    uint8 // 0-7
19464                                         LiqRenewable bool
19465                                         FlowRange    uint8
19466                                         DrownDmg     uint8
19467                                         Floodable    bool
19468
19469                                         DrawBox, ColBox, SelBox NodeBox
19470
19471                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19472
19473                                         LegacyFaceDir bool
19474                                         LegacyMounted bool
19475
19476                                         DigPredict string
19477
19478                                         MaxLvl uint8
19479
19480                                         AlphaUse
19481                                 }))(obj)).OverlayTiles)[local259]).deserialize(r)
19482                         }); err != nil {
19483                                 if err == io.EOF {
19484                                         chk(io.EOF)
19485                                 }
19486                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19487                         }
19488                 }
19489                 {
19490                         var local260 uint8
19491                         local261 := uint8(6)
19492                         {
19493                                 p := &local260
19494                                 *p = read8(r)
19495                         }
19496                         if local260 != local261 {
19497                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local260))
19498                         }
19499                 }
19500                 for local262 := range (*(*(struct {
19501                         Param0 Content
19502
19503                         Name   string
19504                         Groups []Group
19505
19506                         P1Type   Param1Type
19507                         P2Type   Param2Type
19508                         DrawType DrawType
19509
19510                         Mesh  string
19511                         Scale float32
19512                         //mt:const uint8(6)
19513                         Tiles        [6]TileDef
19514                         OverlayTiles [6]TileDef
19515                         //mt:const uint8(6)
19516                         SpecialTiles [6]TileDef
19517
19518                         Color   color.NRGBA
19519                         Palette Texture
19520
19521                         Waving       WaveType
19522                         ConnectSides uint8
19523                         ConnectTo    []Content
19524                         InsideTint   color.NRGBA
19525                         Level        uint8 // Must be < 128.
19526
19527                         Translucent bool // Sunlight is scattered and becomes normal light.
19528                         Transparent bool // Sunlight isn't scattered.
19529                         LightSrc    uint8
19530
19531                         GndContent   bool
19532                         Collides     bool
19533                         Pointable    bool
19534                         Diggable     bool
19535                         Climbable    bool
19536                         Replaceable  bool
19537                         OnRightClick bool
19538
19539                         DmgPerSec int32
19540
19541                         LiquidType   LiquidType
19542                         FlowingAlt   string
19543                         SrcAlt       string
19544                         Viscosity    uint8 // 0-7
19545                         LiqRenewable bool
19546                         FlowRange    uint8
19547                         DrownDmg     uint8
19548                         Floodable    bool
19549
19550                         DrawBox, ColBox, SelBox NodeBox
19551
19552                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19553
19554                         LegacyFaceDir bool
19555                         LegacyMounted bool
19556
19557                         DigPredict string
19558
19559                         MaxLvl uint8
19560
19561                         AlphaUse
19562                 }))(obj)).SpecialTiles {
19563                         if err := pcall(func() {
19564                                 (((*(*(struct {
19565                                         Param0 Content
19566
19567                                         Name   string
19568                                         Groups []Group
19569
19570                                         P1Type   Param1Type
19571                                         P2Type   Param2Type
19572                                         DrawType DrawType
19573
19574                                         Mesh  string
19575                                         Scale float32
19576                                         //mt:const uint8(6)
19577                                         Tiles        [6]TileDef
19578                                         OverlayTiles [6]TileDef
19579                                         //mt:const uint8(6)
19580                                         SpecialTiles [6]TileDef
19581
19582                                         Color   color.NRGBA
19583                                         Palette Texture
19584
19585                                         Waving       WaveType
19586                                         ConnectSides uint8
19587                                         ConnectTo    []Content
19588                                         InsideTint   color.NRGBA
19589                                         Level        uint8 // Must be < 128.
19590
19591                                         Translucent bool // Sunlight is scattered and becomes normal light.
19592                                         Transparent bool // Sunlight isn't scattered.
19593                                         LightSrc    uint8
19594
19595                                         GndContent   bool
19596                                         Collides     bool
19597                                         Pointable    bool
19598                                         Diggable     bool
19599                                         Climbable    bool
19600                                         Replaceable  bool
19601                                         OnRightClick bool
19602
19603                                         DmgPerSec int32
19604
19605                                         LiquidType   LiquidType
19606                                         FlowingAlt   string
19607                                         SrcAlt       string
19608                                         Viscosity    uint8 // 0-7
19609                                         LiqRenewable bool
19610                                         FlowRange    uint8
19611                                         DrownDmg     uint8
19612                                         Floodable    bool
19613
19614                                         DrawBox, ColBox, SelBox NodeBox
19615
19616                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19617
19618                                         LegacyFaceDir bool
19619                                         LegacyMounted bool
19620
19621                                         DigPredict string
19622
19623                                         MaxLvl uint8
19624
19625                                         AlphaUse
19626                                 }))(obj)).SpecialTiles)[local262]).deserialize(r)
19627                         }); err != nil {
19628                                 if err == io.EOF {
19629                                         chk(io.EOF)
19630                                 }
19631                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19632                         }
19633                 }
19634                 {
19635                         p := &(*(*(struct {
19636                                 Param0 Content
19637
19638                                 Name   string
19639                                 Groups []Group
19640
19641                                 P1Type   Param1Type
19642                                 P2Type   Param2Type
19643                                 DrawType DrawType
19644
19645                                 Mesh  string
19646                                 Scale float32
19647                                 //mt:const uint8(6)
19648                                 Tiles        [6]TileDef
19649                                 OverlayTiles [6]TileDef
19650                                 //mt:const uint8(6)
19651                                 SpecialTiles [6]TileDef
19652
19653                                 Color   color.NRGBA
19654                                 Palette Texture
19655
19656                                 Waving       WaveType
19657                                 ConnectSides uint8
19658                                 ConnectTo    []Content
19659                                 InsideTint   color.NRGBA
19660                                 Level        uint8 // Must be < 128.
19661
19662                                 Translucent bool // Sunlight is scattered and becomes normal light.
19663                                 Transparent bool // Sunlight isn't scattered.
19664                                 LightSrc    uint8
19665
19666                                 GndContent   bool
19667                                 Collides     bool
19668                                 Pointable    bool
19669                                 Diggable     bool
19670                                 Climbable    bool
19671                                 Replaceable  bool
19672                                 OnRightClick bool
19673
19674                                 DmgPerSec int32
19675
19676                                 LiquidType   LiquidType
19677                                 FlowingAlt   string
19678                                 SrcAlt       string
19679                                 Viscosity    uint8 // 0-7
19680                                 LiqRenewable bool
19681                                 FlowRange    uint8
19682                                 DrownDmg     uint8
19683                                 Floodable    bool
19684
19685                                 DrawBox, ColBox, SelBox NodeBox
19686
19687                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19688
19689                                 LegacyFaceDir bool
19690                                 LegacyMounted bool
19691
19692                                 DigPredict string
19693
19694                                 MaxLvl uint8
19695
19696                                 AlphaUse
19697                         }))(obj)).Color
19698                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
19699
19700                 }
19701                 if err := pcall(func() {
19702                         ((*(*(struct {
19703                                 Param0 Content
19704
19705                                 Name   string
19706                                 Groups []Group
19707
19708                                 P1Type   Param1Type
19709                                 P2Type   Param2Type
19710                                 DrawType DrawType
19711
19712                                 Mesh  string
19713                                 Scale float32
19714                                 //mt:const uint8(6)
19715                                 Tiles        [6]TileDef
19716                                 OverlayTiles [6]TileDef
19717                                 //mt:const uint8(6)
19718                                 SpecialTiles [6]TileDef
19719
19720                                 Color   color.NRGBA
19721                                 Palette Texture
19722
19723                                 Waving       WaveType
19724                                 ConnectSides uint8
19725                                 ConnectTo    []Content
19726                                 InsideTint   color.NRGBA
19727                                 Level        uint8 // Must be < 128.
19728
19729                                 Translucent bool // Sunlight is scattered and becomes normal light.
19730                                 Transparent bool // Sunlight isn't scattered.
19731                                 LightSrc    uint8
19732
19733                                 GndContent   bool
19734                                 Collides     bool
19735                                 Pointable    bool
19736                                 Diggable     bool
19737                                 Climbable    bool
19738                                 Replaceable  bool
19739                                 OnRightClick bool
19740
19741                                 DmgPerSec int32
19742
19743                                 LiquidType   LiquidType
19744                                 FlowingAlt   string
19745                                 SrcAlt       string
19746                                 Viscosity    uint8 // 0-7
19747                                 LiqRenewable bool
19748                                 FlowRange    uint8
19749                                 DrownDmg     uint8
19750                                 Floodable    bool
19751
19752                                 DrawBox, ColBox, SelBox NodeBox
19753
19754                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19755
19756                                 LegacyFaceDir bool
19757                                 LegacyMounted bool
19758
19759                                 DigPredict string
19760
19761                                 MaxLvl uint8
19762
19763                                 AlphaUse
19764                         }))(obj)).Palette).deserialize(r)
19765                 }); err != nil {
19766                         if err == io.EOF {
19767                                 chk(io.EOF)
19768                         }
19769                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
19770                 }
19771                 if err := pcall(func() {
19772                         ((*(*(struct {
19773                                 Param0 Content
19774
19775                                 Name   string
19776                                 Groups []Group
19777
19778                                 P1Type   Param1Type
19779                                 P2Type   Param2Type
19780                                 DrawType DrawType
19781
19782                                 Mesh  string
19783                                 Scale float32
19784                                 //mt:const uint8(6)
19785                                 Tiles        [6]TileDef
19786                                 OverlayTiles [6]TileDef
19787                                 //mt:const uint8(6)
19788                                 SpecialTiles [6]TileDef
19789
19790                                 Color   color.NRGBA
19791                                 Palette Texture
19792
19793                                 Waving       WaveType
19794                                 ConnectSides uint8
19795                                 ConnectTo    []Content
19796                                 InsideTint   color.NRGBA
19797                                 Level        uint8 // Must be < 128.
19798
19799                                 Translucent bool // Sunlight is scattered and becomes normal light.
19800                                 Transparent bool // Sunlight isn't scattered.
19801                                 LightSrc    uint8
19802
19803                                 GndContent   bool
19804                                 Collides     bool
19805                                 Pointable    bool
19806                                 Diggable     bool
19807                                 Climbable    bool
19808                                 Replaceable  bool
19809                                 OnRightClick bool
19810
19811                                 DmgPerSec int32
19812
19813                                 LiquidType   LiquidType
19814                                 FlowingAlt   string
19815                                 SrcAlt       string
19816                                 Viscosity    uint8 // 0-7
19817                                 LiqRenewable bool
19818                                 FlowRange    uint8
19819                                 DrownDmg     uint8
19820                                 Floodable    bool
19821
19822                                 DrawBox, ColBox, SelBox NodeBox
19823
19824                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19825
19826                                 LegacyFaceDir bool
19827                                 LegacyMounted bool
19828
19829                                 DigPredict string
19830
19831                                 MaxLvl uint8
19832
19833                                 AlphaUse
19834                         }))(obj)).Waving).deserialize(r)
19835                 }); err != nil {
19836                         if err == io.EOF {
19837                                 chk(io.EOF)
19838                         }
19839                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.WaveType", err))
19840                 }
19841                 {
19842                         p := &(*(*(struct {
19843                                 Param0 Content
19844
19845                                 Name   string
19846                                 Groups []Group
19847
19848                                 P1Type   Param1Type
19849                                 P2Type   Param2Type
19850                                 DrawType DrawType
19851
19852                                 Mesh  string
19853                                 Scale float32
19854                                 //mt:const uint8(6)
19855                                 Tiles        [6]TileDef
19856                                 OverlayTiles [6]TileDef
19857                                 //mt:const uint8(6)
19858                                 SpecialTiles [6]TileDef
19859
19860                                 Color   color.NRGBA
19861                                 Palette Texture
19862
19863                                 Waving       WaveType
19864                                 ConnectSides uint8
19865                                 ConnectTo    []Content
19866                                 InsideTint   color.NRGBA
19867                                 Level        uint8 // Must be < 128.
19868
19869                                 Translucent bool // Sunlight is scattered and becomes normal light.
19870                                 Transparent bool // Sunlight isn't scattered.
19871                                 LightSrc    uint8
19872
19873                                 GndContent   bool
19874                                 Collides     bool
19875                                 Pointable    bool
19876                                 Diggable     bool
19877                                 Climbable    bool
19878                                 Replaceable  bool
19879                                 OnRightClick bool
19880
19881                                 DmgPerSec int32
19882
19883                                 LiquidType   LiquidType
19884                                 FlowingAlt   string
19885                                 SrcAlt       string
19886                                 Viscosity    uint8 // 0-7
19887                                 LiqRenewable bool
19888                                 FlowRange    uint8
19889                                 DrownDmg     uint8
19890                                 Floodable    bool
19891
19892                                 DrawBox, ColBox, SelBox NodeBox
19893
19894                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19895
19896                                 LegacyFaceDir bool
19897                                 LegacyMounted bool
19898
19899                                 DigPredict string
19900
19901                                 MaxLvl uint8
19902
19903                                 AlphaUse
19904                         }))(obj)).ConnectSides
19905                         *p = read8(r)
19906                 }
19907                 var local263 uint16
19908                 {
19909                         p := &local263
19910                         *p = read16(r)
19911                 }
19912                 ((*(*(struct {
19913                         Param0 Content
19914
19915                         Name   string
19916                         Groups []Group
19917
19918                         P1Type   Param1Type
19919                         P2Type   Param2Type
19920                         DrawType DrawType
19921
19922                         Mesh  string
19923                         Scale float32
19924                         //mt:const uint8(6)
19925                         Tiles        [6]TileDef
19926                         OverlayTiles [6]TileDef
19927                         //mt:const uint8(6)
19928                         SpecialTiles [6]TileDef
19929
19930                         Color   color.NRGBA
19931                         Palette Texture
19932
19933                         Waving       WaveType
19934                         ConnectSides uint8
19935                         ConnectTo    []Content
19936                         InsideTint   color.NRGBA
19937                         Level        uint8 // Must be < 128.
19938
19939                         Translucent bool // Sunlight is scattered and becomes normal light.
19940                         Transparent bool // Sunlight isn't scattered.
19941                         LightSrc    uint8
19942
19943                         GndContent   bool
19944                         Collides     bool
19945                         Pointable    bool
19946                         Diggable     bool
19947                         Climbable    bool
19948                         Replaceable  bool
19949                         OnRightClick bool
19950
19951                         DmgPerSec int32
19952
19953                         LiquidType   LiquidType
19954                         FlowingAlt   string
19955                         SrcAlt       string
19956                         Viscosity    uint8 // 0-7
19957                         LiqRenewable bool
19958                         FlowRange    uint8
19959                         DrownDmg     uint8
19960                         Floodable    bool
19961
19962                         DrawBox, ColBox, SelBox NodeBox
19963
19964                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19965
19966                         LegacyFaceDir bool
19967                         LegacyMounted bool
19968
19969                         DigPredict string
19970
19971                         MaxLvl uint8
19972
19973                         AlphaUse
19974                 }))(obj)).ConnectTo) = make([]Content, local263)
19975                 for local264 := range (*(*(struct {
19976                         Param0 Content
19977
19978                         Name   string
19979                         Groups []Group
19980
19981                         P1Type   Param1Type
19982                         P2Type   Param2Type
19983                         DrawType DrawType
19984
19985                         Mesh  string
19986                         Scale float32
19987                         //mt:const uint8(6)
19988                         Tiles        [6]TileDef
19989                         OverlayTiles [6]TileDef
19990                         //mt:const uint8(6)
19991                         SpecialTiles [6]TileDef
19992
19993                         Color   color.NRGBA
19994                         Palette Texture
19995
19996                         Waving       WaveType
19997                         ConnectSides uint8
19998                         ConnectTo    []Content
19999                         InsideTint   color.NRGBA
20000                         Level        uint8 // Must be < 128.
20001
20002                         Translucent bool // Sunlight is scattered and becomes normal light.
20003                         Transparent bool // Sunlight isn't scattered.
20004                         LightSrc    uint8
20005
20006                         GndContent   bool
20007                         Collides     bool
20008                         Pointable    bool
20009                         Diggable     bool
20010                         Climbable    bool
20011                         Replaceable  bool
20012                         OnRightClick bool
20013
20014                         DmgPerSec int32
20015
20016                         LiquidType   LiquidType
20017                         FlowingAlt   string
20018                         SrcAlt       string
20019                         Viscosity    uint8 // 0-7
20020                         LiqRenewable bool
20021                         FlowRange    uint8
20022                         DrownDmg     uint8
20023                         Floodable    bool
20024
20025                         DrawBox, ColBox, SelBox NodeBox
20026
20027                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20028
20029                         LegacyFaceDir bool
20030                         LegacyMounted bool
20031
20032                         DigPredict string
20033
20034                         MaxLvl uint8
20035
20036                         AlphaUse
20037                 }))(obj)).ConnectTo {
20038                         if err := pcall(func() {
20039                                 (((*(*(struct {
20040                                         Param0 Content
20041
20042                                         Name   string
20043                                         Groups []Group
20044
20045                                         P1Type   Param1Type
20046                                         P2Type   Param2Type
20047                                         DrawType DrawType
20048
20049                                         Mesh  string
20050                                         Scale float32
20051                                         //mt:const uint8(6)
20052                                         Tiles        [6]TileDef
20053                                         OverlayTiles [6]TileDef
20054                                         //mt:const uint8(6)
20055                                         SpecialTiles [6]TileDef
20056
20057                                         Color   color.NRGBA
20058                                         Palette Texture
20059
20060                                         Waving       WaveType
20061                                         ConnectSides uint8
20062                                         ConnectTo    []Content
20063                                         InsideTint   color.NRGBA
20064                                         Level        uint8 // Must be < 128.
20065
20066                                         Translucent bool // Sunlight is scattered and becomes normal light.
20067                                         Transparent bool // Sunlight isn't scattered.
20068                                         LightSrc    uint8
20069
20070                                         GndContent   bool
20071                                         Collides     bool
20072                                         Pointable    bool
20073                                         Diggable     bool
20074                                         Climbable    bool
20075                                         Replaceable  bool
20076                                         OnRightClick bool
20077
20078                                         DmgPerSec int32
20079
20080                                         LiquidType   LiquidType
20081                                         FlowingAlt   string
20082                                         SrcAlt       string
20083                                         Viscosity    uint8 // 0-7
20084                                         LiqRenewable bool
20085                                         FlowRange    uint8
20086                                         DrownDmg     uint8
20087                                         Floodable    bool
20088
20089                                         DrawBox, ColBox, SelBox NodeBox
20090
20091                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20092
20093                                         LegacyFaceDir bool
20094                                         LegacyMounted bool
20095
20096                                         DigPredict string
20097
20098                                         MaxLvl uint8
20099
20100                                         AlphaUse
20101                                 }))(obj)).ConnectTo)[local264]).deserialize(r)
20102                         }); err != nil {
20103                                 if err == io.EOF {
20104                                         chk(io.EOF)
20105                                 }
20106                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
20107                         }
20108                 }
20109                 {
20110                         p := &(*(*(struct {
20111                                 Param0 Content
20112
20113                                 Name   string
20114                                 Groups []Group
20115
20116                                 P1Type   Param1Type
20117                                 P2Type   Param2Type
20118                                 DrawType DrawType
20119
20120                                 Mesh  string
20121                                 Scale float32
20122                                 //mt:const uint8(6)
20123                                 Tiles        [6]TileDef
20124                                 OverlayTiles [6]TileDef
20125                                 //mt:const uint8(6)
20126                                 SpecialTiles [6]TileDef
20127
20128                                 Color   color.NRGBA
20129                                 Palette Texture
20130
20131                                 Waving       WaveType
20132                                 ConnectSides uint8
20133                                 ConnectTo    []Content
20134                                 InsideTint   color.NRGBA
20135                                 Level        uint8 // Must be < 128.
20136
20137                                 Translucent bool // Sunlight is scattered and becomes normal light.
20138                                 Transparent bool // Sunlight isn't scattered.
20139                                 LightSrc    uint8
20140
20141                                 GndContent   bool
20142                                 Collides     bool
20143                                 Pointable    bool
20144                                 Diggable     bool
20145                                 Climbable    bool
20146                                 Replaceable  bool
20147                                 OnRightClick bool
20148
20149                                 DmgPerSec int32
20150
20151                                 LiquidType   LiquidType
20152                                 FlowingAlt   string
20153                                 SrcAlt       string
20154                                 Viscosity    uint8 // 0-7
20155                                 LiqRenewable bool
20156                                 FlowRange    uint8
20157                                 DrownDmg     uint8
20158                                 Floodable    bool
20159
20160                                 DrawBox, ColBox, SelBox NodeBox
20161
20162                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20163
20164                                 LegacyFaceDir bool
20165                                 LegacyMounted bool
20166
20167                                 DigPredict string
20168
20169                                 MaxLvl uint8
20170
20171                                 AlphaUse
20172                         }))(obj)).InsideTint
20173                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20174
20175                 }
20176                 {
20177                         p := &(*(*(struct {
20178                                 Param0 Content
20179
20180                                 Name   string
20181                                 Groups []Group
20182
20183                                 P1Type   Param1Type
20184                                 P2Type   Param2Type
20185                                 DrawType DrawType
20186
20187                                 Mesh  string
20188                                 Scale float32
20189                                 //mt:const uint8(6)
20190                                 Tiles        [6]TileDef
20191                                 OverlayTiles [6]TileDef
20192                                 //mt:const uint8(6)
20193                                 SpecialTiles [6]TileDef
20194
20195                                 Color   color.NRGBA
20196                                 Palette Texture
20197
20198                                 Waving       WaveType
20199                                 ConnectSides uint8
20200                                 ConnectTo    []Content
20201                                 InsideTint   color.NRGBA
20202                                 Level        uint8 // Must be < 128.
20203
20204                                 Translucent bool // Sunlight is scattered and becomes normal light.
20205                                 Transparent bool // Sunlight isn't scattered.
20206                                 LightSrc    uint8
20207
20208                                 GndContent   bool
20209                                 Collides     bool
20210                                 Pointable    bool
20211                                 Diggable     bool
20212                                 Climbable    bool
20213                                 Replaceable  bool
20214                                 OnRightClick bool
20215
20216                                 DmgPerSec int32
20217
20218                                 LiquidType   LiquidType
20219                                 FlowingAlt   string
20220                                 SrcAlt       string
20221                                 Viscosity    uint8 // 0-7
20222                                 LiqRenewable bool
20223                                 FlowRange    uint8
20224                                 DrownDmg     uint8
20225                                 Floodable    bool
20226
20227                                 DrawBox, ColBox, SelBox NodeBox
20228
20229                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20230
20231                                 LegacyFaceDir bool
20232                                 LegacyMounted bool
20233
20234                                 DigPredict string
20235
20236                                 MaxLvl uint8
20237
20238                                 AlphaUse
20239                         }))(obj)).Level
20240                         *p = read8(r)
20241                 }
20242                 {
20243                         p := &(*(*(struct {
20244                                 Param0 Content
20245
20246                                 Name   string
20247                                 Groups []Group
20248
20249                                 P1Type   Param1Type
20250                                 P2Type   Param2Type
20251                                 DrawType DrawType
20252
20253                                 Mesh  string
20254                                 Scale float32
20255                                 //mt:const uint8(6)
20256                                 Tiles        [6]TileDef
20257                                 OverlayTiles [6]TileDef
20258                                 //mt:const uint8(6)
20259                                 SpecialTiles [6]TileDef
20260
20261                                 Color   color.NRGBA
20262                                 Palette Texture
20263
20264                                 Waving       WaveType
20265                                 ConnectSides uint8
20266                                 ConnectTo    []Content
20267                                 InsideTint   color.NRGBA
20268                                 Level        uint8 // Must be < 128.
20269
20270                                 Translucent bool // Sunlight is scattered and becomes normal light.
20271                                 Transparent bool // Sunlight isn't scattered.
20272                                 LightSrc    uint8
20273
20274                                 GndContent   bool
20275                                 Collides     bool
20276                                 Pointable    bool
20277                                 Diggable     bool
20278                                 Climbable    bool
20279                                 Replaceable  bool
20280                                 OnRightClick bool
20281
20282                                 DmgPerSec int32
20283
20284                                 LiquidType   LiquidType
20285                                 FlowingAlt   string
20286                                 SrcAlt       string
20287                                 Viscosity    uint8 // 0-7
20288                                 LiqRenewable bool
20289                                 FlowRange    uint8
20290                                 DrownDmg     uint8
20291                                 Floodable    bool
20292
20293                                 DrawBox, ColBox, SelBox NodeBox
20294
20295                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20296
20297                                 LegacyFaceDir bool
20298                                 LegacyMounted bool
20299
20300                                 DigPredict string
20301
20302                                 MaxLvl uint8
20303
20304                                 AlphaUse
20305                         }))(obj)).Translucent
20306                         switch n := read8(r); n {
20307                         case 0:
20308                                 *p = false
20309                         case 1:
20310                                 *p = true
20311                         default:
20312                                 chk(fmt.Errorf("invalid bool: %d", n))
20313                         }
20314
20315                 }
20316                 {
20317                         p := &(*(*(struct {
20318                                 Param0 Content
20319
20320                                 Name   string
20321                                 Groups []Group
20322
20323                                 P1Type   Param1Type
20324                                 P2Type   Param2Type
20325                                 DrawType DrawType
20326
20327                                 Mesh  string
20328                                 Scale float32
20329                                 //mt:const uint8(6)
20330                                 Tiles        [6]TileDef
20331                                 OverlayTiles [6]TileDef
20332                                 //mt:const uint8(6)
20333                                 SpecialTiles [6]TileDef
20334
20335                                 Color   color.NRGBA
20336                                 Palette Texture
20337
20338                                 Waving       WaveType
20339                                 ConnectSides uint8
20340                                 ConnectTo    []Content
20341                                 InsideTint   color.NRGBA
20342                                 Level        uint8 // Must be < 128.
20343
20344                                 Translucent bool // Sunlight is scattered and becomes normal light.
20345                                 Transparent bool // Sunlight isn't scattered.
20346                                 LightSrc    uint8
20347
20348                                 GndContent   bool
20349                                 Collides     bool
20350                                 Pointable    bool
20351                                 Diggable     bool
20352                                 Climbable    bool
20353                                 Replaceable  bool
20354                                 OnRightClick bool
20355
20356                                 DmgPerSec int32
20357
20358                                 LiquidType   LiquidType
20359                                 FlowingAlt   string
20360                                 SrcAlt       string
20361                                 Viscosity    uint8 // 0-7
20362                                 LiqRenewable bool
20363                                 FlowRange    uint8
20364                                 DrownDmg     uint8
20365                                 Floodable    bool
20366
20367                                 DrawBox, ColBox, SelBox NodeBox
20368
20369                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20370
20371                                 LegacyFaceDir bool
20372                                 LegacyMounted bool
20373
20374                                 DigPredict string
20375
20376                                 MaxLvl uint8
20377
20378                                 AlphaUse
20379                         }))(obj)).Transparent
20380                         switch n := read8(r); n {
20381                         case 0:
20382                                 *p = false
20383                         case 1:
20384                                 *p = true
20385                         default:
20386                                 chk(fmt.Errorf("invalid bool: %d", n))
20387                         }
20388
20389                 }
20390                 {
20391                         p := &(*(*(struct {
20392                                 Param0 Content
20393
20394                                 Name   string
20395                                 Groups []Group
20396
20397                                 P1Type   Param1Type
20398                                 P2Type   Param2Type
20399                                 DrawType DrawType
20400
20401                                 Mesh  string
20402                                 Scale float32
20403                                 //mt:const uint8(6)
20404                                 Tiles        [6]TileDef
20405                                 OverlayTiles [6]TileDef
20406                                 //mt:const uint8(6)
20407                                 SpecialTiles [6]TileDef
20408
20409                                 Color   color.NRGBA
20410                                 Palette Texture
20411
20412                                 Waving       WaveType
20413                                 ConnectSides uint8
20414                                 ConnectTo    []Content
20415                                 InsideTint   color.NRGBA
20416                                 Level        uint8 // Must be < 128.
20417
20418                                 Translucent bool // Sunlight is scattered and becomes normal light.
20419                                 Transparent bool // Sunlight isn't scattered.
20420                                 LightSrc    uint8
20421
20422                                 GndContent   bool
20423                                 Collides     bool
20424                                 Pointable    bool
20425                                 Diggable     bool
20426                                 Climbable    bool
20427                                 Replaceable  bool
20428                                 OnRightClick bool
20429
20430                                 DmgPerSec int32
20431
20432                                 LiquidType   LiquidType
20433                                 FlowingAlt   string
20434                                 SrcAlt       string
20435                                 Viscosity    uint8 // 0-7
20436                                 LiqRenewable bool
20437                                 FlowRange    uint8
20438                                 DrownDmg     uint8
20439                                 Floodable    bool
20440
20441                                 DrawBox, ColBox, SelBox NodeBox
20442
20443                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20444
20445                                 LegacyFaceDir bool
20446                                 LegacyMounted bool
20447
20448                                 DigPredict string
20449
20450                                 MaxLvl uint8
20451
20452                                 AlphaUse
20453                         }))(obj)).LightSrc
20454                         *p = read8(r)
20455                 }
20456                 {
20457                         p := &(*(*(struct {
20458                                 Param0 Content
20459
20460                                 Name   string
20461                                 Groups []Group
20462
20463                                 P1Type   Param1Type
20464                                 P2Type   Param2Type
20465                                 DrawType DrawType
20466
20467                                 Mesh  string
20468                                 Scale float32
20469                                 //mt:const uint8(6)
20470                                 Tiles        [6]TileDef
20471                                 OverlayTiles [6]TileDef
20472                                 //mt:const uint8(6)
20473                                 SpecialTiles [6]TileDef
20474
20475                                 Color   color.NRGBA
20476                                 Palette Texture
20477
20478                                 Waving       WaveType
20479                                 ConnectSides uint8
20480                                 ConnectTo    []Content
20481                                 InsideTint   color.NRGBA
20482                                 Level        uint8 // Must be < 128.
20483
20484                                 Translucent bool // Sunlight is scattered and becomes normal light.
20485                                 Transparent bool // Sunlight isn't scattered.
20486                                 LightSrc    uint8
20487
20488                                 GndContent   bool
20489                                 Collides     bool
20490                                 Pointable    bool
20491                                 Diggable     bool
20492                                 Climbable    bool
20493                                 Replaceable  bool
20494                                 OnRightClick bool
20495
20496                                 DmgPerSec int32
20497
20498                                 LiquidType   LiquidType
20499                                 FlowingAlt   string
20500                                 SrcAlt       string
20501                                 Viscosity    uint8 // 0-7
20502                                 LiqRenewable bool
20503                                 FlowRange    uint8
20504                                 DrownDmg     uint8
20505                                 Floodable    bool
20506
20507                                 DrawBox, ColBox, SelBox NodeBox
20508
20509                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20510
20511                                 LegacyFaceDir bool
20512                                 LegacyMounted bool
20513
20514                                 DigPredict string
20515
20516                                 MaxLvl uint8
20517
20518                                 AlphaUse
20519                         }))(obj)).GndContent
20520                         switch n := read8(r); n {
20521                         case 0:
20522                                 *p = false
20523                         case 1:
20524                                 *p = true
20525                         default:
20526                                 chk(fmt.Errorf("invalid bool: %d", n))
20527                         }
20528
20529                 }
20530                 {
20531                         p := &(*(*(struct {
20532                                 Param0 Content
20533
20534                                 Name   string
20535                                 Groups []Group
20536
20537                                 P1Type   Param1Type
20538                                 P2Type   Param2Type
20539                                 DrawType DrawType
20540
20541                                 Mesh  string
20542                                 Scale float32
20543                                 //mt:const uint8(6)
20544                                 Tiles        [6]TileDef
20545                                 OverlayTiles [6]TileDef
20546                                 //mt:const uint8(6)
20547                                 SpecialTiles [6]TileDef
20548
20549                                 Color   color.NRGBA
20550                                 Palette Texture
20551
20552                                 Waving       WaveType
20553                                 ConnectSides uint8
20554                                 ConnectTo    []Content
20555                                 InsideTint   color.NRGBA
20556                                 Level        uint8 // Must be < 128.
20557
20558                                 Translucent bool // Sunlight is scattered and becomes normal light.
20559                                 Transparent bool // Sunlight isn't scattered.
20560                                 LightSrc    uint8
20561
20562                                 GndContent   bool
20563                                 Collides     bool
20564                                 Pointable    bool
20565                                 Diggable     bool
20566                                 Climbable    bool
20567                                 Replaceable  bool
20568                                 OnRightClick bool
20569
20570                                 DmgPerSec int32
20571
20572                                 LiquidType   LiquidType
20573                                 FlowingAlt   string
20574                                 SrcAlt       string
20575                                 Viscosity    uint8 // 0-7
20576                                 LiqRenewable bool
20577                                 FlowRange    uint8
20578                                 DrownDmg     uint8
20579                                 Floodable    bool
20580
20581                                 DrawBox, ColBox, SelBox NodeBox
20582
20583                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20584
20585                                 LegacyFaceDir bool
20586                                 LegacyMounted bool
20587
20588                                 DigPredict string
20589
20590                                 MaxLvl uint8
20591
20592                                 AlphaUse
20593                         }))(obj)).Collides
20594                         switch n := read8(r); n {
20595                         case 0:
20596                                 *p = false
20597                         case 1:
20598                                 *p = true
20599                         default:
20600                                 chk(fmt.Errorf("invalid bool: %d", n))
20601                         }
20602
20603                 }
20604                 {
20605                         p := &(*(*(struct {
20606                                 Param0 Content
20607
20608                                 Name   string
20609                                 Groups []Group
20610
20611                                 P1Type   Param1Type
20612                                 P2Type   Param2Type
20613                                 DrawType DrawType
20614
20615                                 Mesh  string
20616                                 Scale float32
20617                                 //mt:const uint8(6)
20618                                 Tiles        [6]TileDef
20619                                 OverlayTiles [6]TileDef
20620                                 //mt:const uint8(6)
20621                                 SpecialTiles [6]TileDef
20622
20623                                 Color   color.NRGBA
20624                                 Palette Texture
20625
20626                                 Waving       WaveType
20627                                 ConnectSides uint8
20628                                 ConnectTo    []Content
20629                                 InsideTint   color.NRGBA
20630                                 Level        uint8 // Must be < 128.
20631
20632                                 Translucent bool // Sunlight is scattered and becomes normal light.
20633                                 Transparent bool // Sunlight isn't scattered.
20634                                 LightSrc    uint8
20635
20636                                 GndContent   bool
20637                                 Collides     bool
20638                                 Pointable    bool
20639                                 Diggable     bool
20640                                 Climbable    bool
20641                                 Replaceable  bool
20642                                 OnRightClick bool
20643
20644                                 DmgPerSec int32
20645
20646                                 LiquidType   LiquidType
20647                                 FlowingAlt   string
20648                                 SrcAlt       string
20649                                 Viscosity    uint8 // 0-7
20650                                 LiqRenewable bool
20651                                 FlowRange    uint8
20652                                 DrownDmg     uint8
20653                                 Floodable    bool
20654
20655                                 DrawBox, ColBox, SelBox NodeBox
20656
20657                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20658
20659                                 LegacyFaceDir bool
20660                                 LegacyMounted bool
20661
20662                                 DigPredict string
20663
20664                                 MaxLvl uint8
20665
20666                                 AlphaUse
20667                         }))(obj)).Pointable
20668                         switch n := read8(r); n {
20669                         case 0:
20670                                 *p = false
20671                         case 1:
20672                                 *p = true
20673                         default:
20674                                 chk(fmt.Errorf("invalid bool: %d", n))
20675                         }
20676
20677                 }
20678                 {
20679                         p := &(*(*(struct {
20680                                 Param0 Content
20681
20682                                 Name   string
20683                                 Groups []Group
20684
20685                                 P1Type   Param1Type
20686                                 P2Type   Param2Type
20687                                 DrawType DrawType
20688
20689                                 Mesh  string
20690                                 Scale float32
20691                                 //mt:const uint8(6)
20692                                 Tiles        [6]TileDef
20693                                 OverlayTiles [6]TileDef
20694                                 //mt:const uint8(6)
20695                                 SpecialTiles [6]TileDef
20696
20697                                 Color   color.NRGBA
20698                                 Palette Texture
20699
20700                                 Waving       WaveType
20701                                 ConnectSides uint8
20702                                 ConnectTo    []Content
20703                                 InsideTint   color.NRGBA
20704                                 Level        uint8 // Must be < 128.
20705
20706                                 Translucent bool // Sunlight is scattered and becomes normal light.
20707                                 Transparent bool // Sunlight isn't scattered.
20708                                 LightSrc    uint8
20709
20710                                 GndContent   bool
20711                                 Collides     bool
20712                                 Pointable    bool
20713                                 Diggable     bool
20714                                 Climbable    bool
20715                                 Replaceable  bool
20716                                 OnRightClick bool
20717
20718                                 DmgPerSec int32
20719
20720                                 LiquidType   LiquidType
20721                                 FlowingAlt   string
20722                                 SrcAlt       string
20723                                 Viscosity    uint8 // 0-7
20724                                 LiqRenewable bool
20725                                 FlowRange    uint8
20726                                 DrownDmg     uint8
20727                                 Floodable    bool
20728
20729                                 DrawBox, ColBox, SelBox NodeBox
20730
20731                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20732
20733                                 LegacyFaceDir bool
20734                                 LegacyMounted bool
20735
20736                                 DigPredict string
20737
20738                                 MaxLvl uint8
20739
20740                                 AlphaUse
20741                         }))(obj)).Diggable
20742                         switch n := read8(r); n {
20743                         case 0:
20744                                 *p = false
20745                         case 1:
20746                                 *p = true
20747                         default:
20748                                 chk(fmt.Errorf("invalid bool: %d", n))
20749                         }
20750
20751                 }
20752                 {
20753                         p := &(*(*(struct {
20754                                 Param0 Content
20755
20756                                 Name   string
20757                                 Groups []Group
20758
20759                                 P1Type   Param1Type
20760                                 P2Type   Param2Type
20761                                 DrawType DrawType
20762
20763                                 Mesh  string
20764                                 Scale float32
20765                                 //mt:const uint8(6)
20766                                 Tiles        [6]TileDef
20767                                 OverlayTiles [6]TileDef
20768                                 //mt:const uint8(6)
20769                                 SpecialTiles [6]TileDef
20770
20771                                 Color   color.NRGBA
20772                                 Palette Texture
20773
20774                                 Waving       WaveType
20775                                 ConnectSides uint8
20776                                 ConnectTo    []Content
20777                                 InsideTint   color.NRGBA
20778                                 Level        uint8 // Must be < 128.
20779
20780                                 Translucent bool // Sunlight is scattered and becomes normal light.
20781                                 Transparent bool // Sunlight isn't scattered.
20782                                 LightSrc    uint8
20783
20784                                 GndContent   bool
20785                                 Collides     bool
20786                                 Pointable    bool
20787                                 Diggable     bool
20788                                 Climbable    bool
20789                                 Replaceable  bool
20790                                 OnRightClick bool
20791
20792                                 DmgPerSec int32
20793
20794                                 LiquidType   LiquidType
20795                                 FlowingAlt   string
20796                                 SrcAlt       string
20797                                 Viscosity    uint8 // 0-7
20798                                 LiqRenewable bool
20799                                 FlowRange    uint8
20800                                 DrownDmg     uint8
20801                                 Floodable    bool
20802
20803                                 DrawBox, ColBox, SelBox NodeBox
20804
20805                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20806
20807                                 LegacyFaceDir bool
20808                                 LegacyMounted bool
20809
20810                                 DigPredict string
20811
20812                                 MaxLvl uint8
20813
20814                                 AlphaUse
20815                         }))(obj)).Climbable
20816                         switch n := read8(r); n {
20817                         case 0:
20818                                 *p = false
20819                         case 1:
20820                                 *p = true
20821                         default:
20822                                 chk(fmt.Errorf("invalid bool: %d", n))
20823                         }
20824
20825                 }
20826                 {
20827                         p := &(*(*(struct {
20828                                 Param0 Content
20829
20830                                 Name   string
20831                                 Groups []Group
20832
20833                                 P1Type   Param1Type
20834                                 P2Type   Param2Type
20835                                 DrawType DrawType
20836
20837                                 Mesh  string
20838                                 Scale float32
20839                                 //mt:const uint8(6)
20840                                 Tiles        [6]TileDef
20841                                 OverlayTiles [6]TileDef
20842                                 //mt:const uint8(6)
20843                                 SpecialTiles [6]TileDef
20844
20845                                 Color   color.NRGBA
20846                                 Palette Texture
20847
20848                                 Waving       WaveType
20849                                 ConnectSides uint8
20850                                 ConnectTo    []Content
20851                                 InsideTint   color.NRGBA
20852                                 Level        uint8 // Must be < 128.
20853
20854                                 Translucent bool // Sunlight is scattered and becomes normal light.
20855                                 Transparent bool // Sunlight isn't scattered.
20856                                 LightSrc    uint8
20857
20858                                 GndContent   bool
20859                                 Collides     bool
20860                                 Pointable    bool
20861                                 Diggable     bool
20862                                 Climbable    bool
20863                                 Replaceable  bool
20864                                 OnRightClick bool
20865
20866                                 DmgPerSec int32
20867
20868                                 LiquidType   LiquidType
20869                                 FlowingAlt   string
20870                                 SrcAlt       string
20871                                 Viscosity    uint8 // 0-7
20872                                 LiqRenewable bool
20873                                 FlowRange    uint8
20874                                 DrownDmg     uint8
20875                                 Floodable    bool
20876
20877                                 DrawBox, ColBox, SelBox NodeBox
20878
20879                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20880
20881                                 LegacyFaceDir bool
20882                                 LegacyMounted bool
20883
20884                                 DigPredict string
20885
20886                                 MaxLvl uint8
20887
20888                                 AlphaUse
20889                         }))(obj)).Replaceable
20890                         switch n := read8(r); n {
20891                         case 0:
20892                                 *p = false
20893                         case 1:
20894                                 *p = true
20895                         default:
20896                                 chk(fmt.Errorf("invalid bool: %d", n))
20897                         }
20898
20899                 }
20900                 {
20901                         p := &(*(*(struct {
20902                                 Param0 Content
20903
20904                                 Name   string
20905                                 Groups []Group
20906
20907                                 P1Type   Param1Type
20908                                 P2Type   Param2Type
20909                                 DrawType DrawType
20910
20911                                 Mesh  string
20912                                 Scale float32
20913                                 //mt:const uint8(6)
20914                                 Tiles        [6]TileDef
20915                                 OverlayTiles [6]TileDef
20916                                 //mt:const uint8(6)
20917                                 SpecialTiles [6]TileDef
20918
20919                                 Color   color.NRGBA
20920                                 Palette Texture
20921
20922                                 Waving       WaveType
20923                                 ConnectSides uint8
20924                                 ConnectTo    []Content
20925                                 InsideTint   color.NRGBA
20926                                 Level        uint8 // Must be < 128.
20927
20928                                 Translucent bool // Sunlight is scattered and becomes normal light.
20929                                 Transparent bool // Sunlight isn't scattered.
20930                                 LightSrc    uint8
20931
20932                                 GndContent   bool
20933                                 Collides     bool
20934                                 Pointable    bool
20935                                 Diggable     bool
20936                                 Climbable    bool
20937                                 Replaceable  bool
20938                                 OnRightClick bool
20939
20940                                 DmgPerSec int32
20941
20942                                 LiquidType   LiquidType
20943                                 FlowingAlt   string
20944                                 SrcAlt       string
20945                                 Viscosity    uint8 // 0-7
20946                                 LiqRenewable bool
20947                                 FlowRange    uint8
20948                                 DrownDmg     uint8
20949                                 Floodable    bool
20950
20951                                 DrawBox, ColBox, SelBox NodeBox
20952
20953                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20954
20955                                 LegacyFaceDir bool
20956                                 LegacyMounted bool
20957
20958                                 DigPredict string
20959
20960                                 MaxLvl uint8
20961
20962                                 AlphaUse
20963                         }))(obj)).OnRightClick
20964                         switch n := read8(r); n {
20965                         case 0:
20966                                 *p = false
20967                         case 1:
20968                                 *p = true
20969                         default:
20970                                 chk(fmt.Errorf("invalid bool: %d", n))
20971                         }
20972
20973                 }
20974                 {
20975                         p := &(*(*(struct {
20976                                 Param0 Content
20977
20978                                 Name   string
20979                                 Groups []Group
20980
20981                                 P1Type   Param1Type
20982                                 P2Type   Param2Type
20983                                 DrawType DrawType
20984
20985                                 Mesh  string
20986                                 Scale float32
20987                                 //mt:const uint8(6)
20988                                 Tiles        [6]TileDef
20989                                 OverlayTiles [6]TileDef
20990                                 //mt:const uint8(6)
20991                                 SpecialTiles [6]TileDef
20992
20993                                 Color   color.NRGBA
20994                                 Palette Texture
20995
20996                                 Waving       WaveType
20997                                 ConnectSides uint8
20998                                 ConnectTo    []Content
20999                                 InsideTint   color.NRGBA
21000                                 Level        uint8 // Must be < 128.
21001
21002                                 Translucent bool // Sunlight is scattered and becomes normal light.
21003                                 Transparent bool // Sunlight isn't scattered.
21004                                 LightSrc    uint8
21005
21006                                 GndContent   bool
21007                                 Collides     bool
21008                                 Pointable    bool
21009                                 Diggable     bool
21010                                 Climbable    bool
21011                                 Replaceable  bool
21012                                 OnRightClick bool
21013
21014                                 DmgPerSec int32
21015
21016                                 LiquidType   LiquidType
21017                                 FlowingAlt   string
21018                                 SrcAlt       string
21019                                 Viscosity    uint8 // 0-7
21020                                 LiqRenewable bool
21021                                 FlowRange    uint8
21022                                 DrownDmg     uint8
21023                                 Floodable    bool
21024
21025                                 DrawBox, ColBox, SelBox NodeBox
21026
21027                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21028
21029                                 LegacyFaceDir bool
21030                                 LegacyMounted bool
21031
21032                                 DigPredict string
21033
21034                                 MaxLvl uint8
21035
21036                                 AlphaUse
21037                         }))(obj)).DmgPerSec
21038                         *p = int32(read32(r))
21039                 }
21040                 if err := pcall(func() {
21041                         ((*(*(struct {
21042                                 Param0 Content
21043
21044                                 Name   string
21045                                 Groups []Group
21046
21047                                 P1Type   Param1Type
21048                                 P2Type   Param2Type
21049                                 DrawType DrawType
21050
21051                                 Mesh  string
21052                                 Scale float32
21053                                 //mt:const uint8(6)
21054                                 Tiles        [6]TileDef
21055                                 OverlayTiles [6]TileDef
21056                                 //mt:const uint8(6)
21057                                 SpecialTiles [6]TileDef
21058
21059                                 Color   color.NRGBA
21060                                 Palette Texture
21061
21062                                 Waving       WaveType
21063                                 ConnectSides uint8
21064                                 ConnectTo    []Content
21065                                 InsideTint   color.NRGBA
21066                                 Level        uint8 // Must be < 128.
21067
21068                                 Translucent bool // Sunlight is scattered and becomes normal light.
21069                                 Transparent bool // Sunlight isn't scattered.
21070                                 LightSrc    uint8
21071
21072                                 GndContent   bool
21073                                 Collides     bool
21074                                 Pointable    bool
21075                                 Diggable     bool
21076                                 Climbable    bool
21077                                 Replaceable  bool
21078                                 OnRightClick bool
21079
21080                                 DmgPerSec int32
21081
21082                                 LiquidType   LiquidType
21083                                 FlowingAlt   string
21084                                 SrcAlt       string
21085                                 Viscosity    uint8 // 0-7
21086                                 LiqRenewable bool
21087                                 FlowRange    uint8
21088                                 DrownDmg     uint8
21089                                 Floodable    bool
21090
21091                                 DrawBox, ColBox, SelBox NodeBox
21092
21093                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21094
21095                                 LegacyFaceDir bool
21096                                 LegacyMounted bool
21097
21098                                 DigPredict string
21099
21100                                 MaxLvl uint8
21101
21102                                 AlphaUse
21103                         }))(obj)).LiquidType).deserialize(r)
21104                 }); err != nil {
21105                         if err == io.EOF {
21106                                 chk(io.EOF)
21107                         }
21108                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
21109                 }
21110                 var local265 []uint8
21111                 var local266 uint16
21112                 {
21113                         p := &local266
21114                         *p = read16(r)
21115                 }
21116                 (local265) = make([]uint8, local266)
21117                 {
21118                         _, err := io.ReadFull(r, (local265)[:])
21119                         chk(err)
21120                 }
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)).FlowingAlt) = string(local265)
21184                 var local267 []uint8
21185                 var local268 uint16
21186                 {
21187                         p := &local268
21188                         *p = read16(r)
21189                 }
21190                 (local267) = make([]uint8, local268)
21191                 {
21192                         _, err := io.ReadFull(r, (local267)[:])
21193                         chk(err)
21194                 }
21195                 ((*(*(struct {
21196                         Param0 Content
21197
21198                         Name   string
21199                         Groups []Group
21200
21201                         P1Type   Param1Type
21202                         P2Type   Param2Type
21203                         DrawType DrawType
21204
21205                         Mesh  string
21206                         Scale float32
21207                         //mt:const uint8(6)
21208                         Tiles        [6]TileDef
21209                         OverlayTiles [6]TileDef
21210                         //mt:const uint8(6)
21211                         SpecialTiles [6]TileDef
21212
21213                         Color   color.NRGBA
21214                         Palette Texture
21215
21216                         Waving       WaveType
21217                         ConnectSides uint8
21218                         ConnectTo    []Content
21219                         InsideTint   color.NRGBA
21220                         Level        uint8 // Must be < 128.
21221
21222                         Translucent bool // Sunlight is scattered and becomes normal light.
21223                         Transparent bool // Sunlight isn't scattered.
21224                         LightSrc    uint8
21225
21226                         GndContent   bool
21227                         Collides     bool
21228                         Pointable    bool
21229                         Diggable     bool
21230                         Climbable    bool
21231                         Replaceable  bool
21232                         OnRightClick bool
21233
21234                         DmgPerSec int32
21235
21236                         LiquidType   LiquidType
21237                         FlowingAlt   string
21238                         SrcAlt       string
21239                         Viscosity    uint8 // 0-7
21240                         LiqRenewable bool
21241                         FlowRange    uint8
21242                         DrownDmg     uint8
21243                         Floodable    bool
21244
21245                         DrawBox, ColBox, SelBox NodeBox
21246
21247                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21248
21249                         LegacyFaceDir bool
21250                         LegacyMounted bool
21251
21252                         DigPredict string
21253
21254                         MaxLvl uint8
21255
21256                         AlphaUse
21257                 }))(obj)).SrcAlt) = string(local267)
21258                 {
21259                         p := &(*(*(struct {
21260                                 Param0 Content
21261
21262                                 Name   string
21263                                 Groups []Group
21264
21265                                 P1Type   Param1Type
21266                                 P2Type   Param2Type
21267                                 DrawType DrawType
21268
21269                                 Mesh  string
21270                                 Scale float32
21271                                 //mt:const uint8(6)
21272                                 Tiles        [6]TileDef
21273                                 OverlayTiles [6]TileDef
21274                                 //mt:const uint8(6)
21275                                 SpecialTiles [6]TileDef
21276
21277                                 Color   color.NRGBA
21278                                 Palette Texture
21279
21280                                 Waving       WaveType
21281                                 ConnectSides uint8
21282                                 ConnectTo    []Content
21283                                 InsideTint   color.NRGBA
21284                                 Level        uint8 // Must be < 128.
21285
21286                                 Translucent bool // Sunlight is scattered and becomes normal light.
21287                                 Transparent bool // Sunlight isn't scattered.
21288                                 LightSrc    uint8
21289
21290                                 GndContent   bool
21291                                 Collides     bool
21292                                 Pointable    bool
21293                                 Diggable     bool
21294                                 Climbable    bool
21295                                 Replaceable  bool
21296                                 OnRightClick bool
21297
21298                                 DmgPerSec int32
21299
21300                                 LiquidType   LiquidType
21301                                 FlowingAlt   string
21302                                 SrcAlt       string
21303                                 Viscosity    uint8 // 0-7
21304                                 LiqRenewable bool
21305                                 FlowRange    uint8
21306                                 DrownDmg     uint8
21307                                 Floodable    bool
21308
21309                                 DrawBox, ColBox, SelBox NodeBox
21310
21311                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21312
21313                                 LegacyFaceDir bool
21314                                 LegacyMounted bool
21315
21316                                 DigPredict string
21317
21318                                 MaxLvl uint8
21319
21320                                 AlphaUse
21321                         }))(obj)).Viscosity
21322                         *p = read8(r)
21323                 }
21324                 {
21325                         p := &(*(*(struct {
21326                                 Param0 Content
21327
21328                                 Name   string
21329                                 Groups []Group
21330
21331                                 P1Type   Param1Type
21332                                 P2Type   Param2Type
21333                                 DrawType DrawType
21334
21335                                 Mesh  string
21336                                 Scale float32
21337                                 //mt:const uint8(6)
21338                                 Tiles        [6]TileDef
21339                                 OverlayTiles [6]TileDef
21340                                 //mt:const uint8(6)
21341                                 SpecialTiles [6]TileDef
21342
21343                                 Color   color.NRGBA
21344                                 Palette Texture
21345
21346                                 Waving       WaveType
21347                                 ConnectSides uint8
21348                                 ConnectTo    []Content
21349                                 InsideTint   color.NRGBA
21350                                 Level        uint8 // Must be < 128.
21351
21352                                 Translucent bool // Sunlight is scattered and becomes normal light.
21353                                 Transparent bool // Sunlight isn't scattered.
21354                                 LightSrc    uint8
21355
21356                                 GndContent   bool
21357                                 Collides     bool
21358                                 Pointable    bool
21359                                 Diggable     bool
21360                                 Climbable    bool
21361                                 Replaceable  bool
21362                                 OnRightClick bool
21363
21364                                 DmgPerSec int32
21365
21366                                 LiquidType   LiquidType
21367                                 FlowingAlt   string
21368                                 SrcAlt       string
21369                                 Viscosity    uint8 // 0-7
21370                                 LiqRenewable bool
21371                                 FlowRange    uint8
21372                                 DrownDmg     uint8
21373                                 Floodable    bool
21374
21375                                 DrawBox, ColBox, SelBox NodeBox
21376
21377                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21378
21379                                 LegacyFaceDir bool
21380                                 LegacyMounted bool
21381
21382                                 DigPredict string
21383
21384                                 MaxLvl uint8
21385
21386                                 AlphaUse
21387                         }))(obj)).LiqRenewable
21388                         switch n := read8(r); n {
21389                         case 0:
21390                                 *p = false
21391                         case 1:
21392                                 *p = true
21393                         default:
21394                                 chk(fmt.Errorf("invalid bool: %d", n))
21395                         }
21396
21397                 }
21398                 {
21399                         p := &(*(*(struct {
21400                                 Param0 Content
21401
21402                                 Name   string
21403                                 Groups []Group
21404
21405                                 P1Type   Param1Type
21406                                 P2Type   Param2Type
21407                                 DrawType DrawType
21408
21409                                 Mesh  string
21410                                 Scale float32
21411                                 //mt:const uint8(6)
21412                                 Tiles        [6]TileDef
21413                                 OverlayTiles [6]TileDef
21414                                 //mt:const uint8(6)
21415                                 SpecialTiles [6]TileDef
21416
21417                                 Color   color.NRGBA
21418                                 Palette Texture
21419
21420                                 Waving       WaveType
21421                                 ConnectSides uint8
21422                                 ConnectTo    []Content
21423                                 InsideTint   color.NRGBA
21424                                 Level        uint8 // Must be < 128.
21425
21426                                 Translucent bool // Sunlight is scattered and becomes normal light.
21427                                 Transparent bool // Sunlight isn't scattered.
21428                                 LightSrc    uint8
21429
21430                                 GndContent   bool
21431                                 Collides     bool
21432                                 Pointable    bool
21433                                 Diggable     bool
21434                                 Climbable    bool
21435                                 Replaceable  bool
21436                                 OnRightClick bool
21437
21438                                 DmgPerSec int32
21439
21440                                 LiquidType   LiquidType
21441                                 FlowingAlt   string
21442                                 SrcAlt       string
21443                                 Viscosity    uint8 // 0-7
21444                                 LiqRenewable bool
21445                                 FlowRange    uint8
21446                                 DrownDmg     uint8
21447                                 Floodable    bool
21448
21449                                 DrawBox, ColBox, SelBox NodeBox
21450
21451                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21452
21453                                 LegacyFaceDir bool
21454                                 LegacyMounted bool
21455
21456                                 DigPredict string
21457
21458                                 MaxLvl uint8
21459
21460                                 AlphaUse
21461                         }))(obj)).FlowRange
21462                         *p = read8(r)
21463                 }
21464                 {
21465                         p := &(*(*(struct {
21466                                 Param0 Content
21467
21468                                 Name   string
21469                                 Groups []Group
21470
21471                                 P1Type   Param1Type
21472                                 P2Type   Param2Type
21473                                 DrawType DrawType
21474
21475                                 Mesh  string
21476                                 Scale float32
21477                                 //mt:const uint8(6)
21478                                 Tiles        [6]TileDef
21479                                 OverlayTiles [6]TileDef
21480                                 //mt:const uint8(6)
21481                                 SpecialTiles [6]TileDef
21482
21483                                 Color   color.NRGBA
21484                                 Palette Texture
21485
21486                                 Waving       WaveType
21487                                 ConnectSides uint8
21488                                 ConnectTo    []Content
21489                                 InsideTint   color.NRGBA
21490                                 Level        uint8 // Must be < 128.
21491
21492                                 Translucent bool // Sunlight is scattered and becomes normal light.
21493                                 Transparent bool // Sunlight isn't scattered.
21494                                 LightSrc    uint8
21495
21496                                 GndContent   bool
21497                                 Collides     bool
21498                                 Pointable    bool
21499                                 Diggable     bool
21500                                 Climbable    bool
21501                                 Replaceable  bool
21502                                 OnRightClick bool
21503
21504                                 DmgPerSec int32
21505
21506                                 LiquidType   LiquidType
21507                                 FlowingAlt   string
21508                                 SrcAlt       string
21509                                 Viscosity    uint8 // 0-7
21510                                 LiqRenewable bool
21511                                 FlowRange    uint8
21512                                 DrownDmg     uint8
21513                                 Floodable    bool
21514
21515                                 DrawBox, ColBox, SelBox NodeBox
21516
21517                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21518
21519                                 LegacyFaceDir bool
21520                                 LegacyMounted bool
21521
21522                                 DigPredict string
21523
21524                                 MaxLvl uint8
21525
21526                                 AlphaUse
21527                         }))(obj)).DrownDmg
21528                         *p = read8(r)
21529                 }
21530                 {
21531                         p := &(*(*(struct {
21532                                 Param0 Content
21533
21534                                 Name   string
21535                                 Groups []Group
21536
21537                                 P1Type   Param1Type
21538                                 P2Type   Param2Type
21539                                 DrawType DrawType
21540
21541                                 Mesh  string
21542                                 Scale float32
21543                                 //mt:const uint8(6)
21544                                 Tiles        [6]TileDef
21545                                 OverlayTiles [6]TileDef
21546                                 //mt:const uint8(6)
21547                                 SpecialTiles [6]TileDef
21548
21549                                 Color   color.NRGBA
21550                                 Palette Texture
21551
21552                                 Waving       WaveType
21553                                 ConnectSides uint8
21554                                 ConnectTo    []Content
21555                                 InsideTint   color.NRGBA
21556                                 Level        uint8 // Must be < 128.
21557
21558                                 Translucent bool // Sunlight is scattered and becomes normal light.
21559                                 Transparent bool // Sunlight isn't scattered.
21560                                 LightSrc    uint8
21561
21562                                 GndContent   bool
21563                                 Collides     bool
21564                                 Pointable    bool
21565                                 Diggable     bool
21566                                 Climbable    bool
21567                                 Replaceable  bool
21568                                 OnRightClick bool
21569
21570                                 DmgPerSec int32
21571
21572                                 LiquidType   LiquidType
21573                                 FlowingAlt   string
21574                                 SrcAlt       string
21575                                 Viscosity    uint8 // 0-7
21576                                 LiqRenewable bool
21577                                 FlowRange    uint8
21578                                 DrownDmg     uint8
21579                                 Floodable    bool
21580
21581                                 DrawBox, ColBox, SelBox NodeBox
21582
21583                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21584
21585                                 LegacyFaceDir bool
21586                                 LegacyMounted bool
21587
21588                                 DigPredict string
21589
21590                                 MaxLvl uint8
21591
21592                                 AlphaUse
21593                         }))(obj)).Floodable
21594                         switch n := read8(r); n {
21595                         case 0:
21596                                 *p = false
21597                         case 1:
21598                                 *p = true
21599                         default:
21600                                 chk(fmt.Errorf("invalid bool: %d", n))
21601                         }
21602
21603                 }
21604                 if err := pcall(func() {
21605                         ((*(*(struct {
21606                                 Param0 Content
21607
21608                                 Name   string
21609                                 Groups []Group
21610
21611                                 P1Type   Param1Type
21612                                 P2Type   Param2Type
21613                                 DrawType DrawType
21614
21615                                 Mesh  string
21616                                 Scale float32
21617                                 //mt:const uint8(6)
21618                                 Tiles        [6]TileDef
21619                                 OverlayTiles [6]TileDef
21620                                 //mt:const uint8(6)
21621                                 SpecialTiles [6]TileDef
21622
21623                                 Color   color.NRGBA
21624                                 Palette Texture
21625
21626                                 Waving       WaveType
21627                                 ConnectSides uint8
21628                                 ConnectTo    []Content
21629                                 InsideTint   color.NRGBA
21630                                 Level        uint8 // Must be < 128.
21631
21632                                 Translucent bool // Sunlight is scattered and becomes normal light.
21633                                 Transparent bool // Sunlight isn't scattered.
21634                                 LightSrc    uint8
21635
21636                                 GndContent   bool
21637                                 Collides     bool
21638                                 Pointable    bool
21639                                 Diggable     bool
21640                                 Climbable    bool
21641                                 Replaceable  bool
21642                                 OnRightClick bool
21643
21644                                 DmgPerSec int32
21645
21646                                 LiquidType   LiquidType
21647                                 FlowingAlt   string
21648                                 SrcAlt       string
21649                                 Viscosity    uint8 // 0-7
21650                                 LiqRenewable bool
21651                                 FlowRange    uint8
21652                                 DrownDmg     uint8
21653                                 Floodable    bool
21654
21655                                 DrawBox, ColBox, SelBox NodeBox
21656
21657                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21658
21659                                 LegacyFaceDir bool
21660                                 LegacyMounted bool
21661
21662                                 DigPredict string
21663
21664                                 MaxLvl uint8
21665
21666                                 AlphaUse
21667                         }))(obj)).DrawBox).deserialize(r)
21668                 }); err != nil {
21669                         if err == io.EOF {
21670                                 chk(io.EOF)
21671                         }
21672                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21673                 }
21674                 if err := pcall(func() {
21675                         ((*(*(struct {
21676                                 Param0 Content
21677
21678                                 Name   string
21679                                 Groups []Group
21680
21681                                 P1Type   Param1Type
21682                                 P2Type   Param2Type
21683                                 DrawType DrawType
21684
21685                                 Mesh  string
21686                                 Scale float32
21687                                 //mt:const uint8(6)
21688                                 Tiles        [6]TileDef
21689                                 OverlayTiles [6]TileDef
21690                                 //mt:const uint8(6)
21691                                 SpecialTiles [6]TileDef
21692
21693                                 Color   color.NRGBA
21694                                 Palette Texture
21695
21696                                 Waving       WaveType
21697                                 ConnectSides uint8
21698                                 ConnectTo    []Content
21699                                 InsideTint   color.NRGBA
21700                                 Level        uint8 // Must be < 128.
21701
21702                                 Translucent bool // Sunlight is scattered and becomes normal light.
21703                                 Transparent bool // Sunlight isn't scattered.
21704                                 LightSrc    uint8
21705
21706                                 GndContent   bool
21707                                 Collides     bool
21708                                 Pointable    bool
21709                                 Diggable     bool
21710                                 Climbable    bool
21711                                 Replaceable  bool
21712                                 OnRightClick bool
21713
21714                                 DmgPerSec int32
21715
21716                                 LiquidType   LiquidType
21717                                 FlowingAlt   string
21718                                 SrcAlt       string
21719                                 Viscosity    uint8 // 0-7
21720                                 LiqRenewable bool
21721                                 FlowRange    uint8
21722                                 DrownDmg     uint8
21723                                 Floodable    bool
21724
21725                                 DrawBox, ColBox, SelBox NodeBox
21726
21727                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21728
21729                                 LegacyFaceDir bool
21730                                 LegacyMounted bool
21731
21732                                 DigPredict string
21733
21734                                 MaxLvl uint8
21735
21736                                 AlphaUse
21737                         }))(obj)).ColBox).deserialize(r)
21738                 }); err != nil {
21739                         if err == io.EOF {
21740                                 chk(io.EOF)
21741                         }
21742                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21743                 }
21744                 if err := pcall(func() {
21745                         ((*(*(struct {
21746                                 Param0 Content
21747
21748                                 Name   string
21749                                 Groups []Group
21750
21751                                 P1Type   Param1Type
21752                                 P2Type   Param2Type
21753                                 DrawType DrawType
21754
21755                                 Mesh  string
21756                                 Scale float32
21757                                 //mt:const uint8(6)
21758                                 Tiles        [6]TileDef
21759                                 OverlayTiles [6]TileDef
21760                                 //mt:const uint8(6)
21761                                 SpecialTiles [6]TileDef
21762
21763                                 Color   color.NRGBA
21764                                 Palette Texture
21765
21766                                 Waving       WaveType
21767                                 ConnectSides uint8
21768                                 ConnectTo    []Content
21769                                 InsideTint   color.NRGBA
21770                                 Level        uint8 // Must be < 128.
21771
21772                                 Translucent bool // Sunlight is scattered and becomes normal light.
21773                                 Transparent bool // Sunlight isn't scattered.
21774                                 LightSrc    uint8
21775
21776                                 GndContent   bool
21777                                 Collides     bool
21778                                 Pointable    bool
21779                                 Diggable     bool
21780                                 Climbable    bool
21781                                 Replaceable  bool
21782                                 OnRightClick bool
21783
21784                                 DmgPerSec int32
21785
21786                                 LiquidType   LiquidType
21787                                 FlowingAlt   string
21788                                 SrcAlt       string
21789                                 Viscosity    uint8 // 0-7
21790                                 LiqRenewable bool
21791                                 FlowRange    uint8
21792                                 DrownDmg     uint8
21793                                 Floodable    bool
21794
21795                                 DrawBox, ColBox, SelBox NodeBox
21796
21797                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21798
21799                                 LegacyFaceDir bool
21800                                 LegacyMounted bool
21801
21802                                 DigPredict string
21803
21804                                 MaxLvl uint8
21805
21806                                 AlphaUse
21807                         }))(obj)).SelBox).deserialize(r)
21808                 }); err != nil {
21809                         if err == io.EOF {
21810                                 chk(io.EOF)
21811                         }
21812                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21813                 }
21814                 if err := pcall(func() {
21815                         ((*(*(struct {
21816                                 Param0 Content
21817
21818                                 Name   string
21819                                 Groups []Group
21820
21821                                 P1Type   Param1Type
21822                                 P2Type   Param2Type
21823                                 DrawType DrawType
21824
21825                                 Mesh  string
21826                                 Scale float32
21827                                 //mt:const uint8(6)
21828                                 Tiles        [6]TileDef
21829                                 OverlayTiles [6]TileDef
21830                                 //mt:const uint8(6)
21831                                 SpecialTiles [6]TileDef
21832
21833                                 Color   color.NRGBA
21834                                 Palette Texture
21835
21836                                 Waving       WaveType
21837                                 ConnectSides uint8
21838                                 ConnectTo    []Content
21839                                 InsideTint   color.NRGBA
21840                                 Level        uint8 // Must be < 128.
21841
21842                                 Translucent bool // Sunlight is scattered and becomes normal light.
21843                                 Transparent bool // Sunlight isn't scattered.
21844                                 LightSrc    uint8
21845
21846                                 GndContent   bool
21847                                 Collides     bool
21848                                 Pointable    bool
21849                                 Diggable     bool
21850                                 Climbable    bool
21851                                 Replaceable  bool
21852                                 OnRightClick bool
21853
21854                                 DmgPerSec int32
21855
21856                                 LiquidType   LiquidType
21857                                 FlowingAlt   string
21858                                 SrcAlt       string
21859                                 Viscosity    uint8 // 0-7
21860                                 LiqRenewable bool
21861                                 FlowRange    uint8
21862                                 DrownDmg     uint8
21863                                 Floodable    bool
21864
21865                                 DrawBox, ColBox, SelBox NodeBox
21866
21867                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21868
21869                                 LegacyFaceDir bool
21870                                 LegacyMounted bool
21871
21872                                 DigPredict string
21873
21874                                 MaxLvl uint8
21875
21876                                 AlphaUse
21877                         }))(obj)).FootstepSnd).deserialize(r)
21878                 }); err != nil {
21879                         if err == io.EOF {
21880                                 chk(io.EOF)
21881                         }
21882                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
21883                 }
21884                 if err := pcall(func() {
21885                         ((*(*(struct {
21886                                 Param0 Content
21887
21888                                 Name   string
21889                                 Groups []Group
21890
21891                                 P1Type   Param1Type
21892                                 P2Type   Param2Type
21893                                 DrawType DrawType
21894
21895                                 Mesh  string
21896                                 Scale float32
21897                                 //mt:const uint8(6)
21898                                 Tiles        [6]TileDef
21899                                 OverlayTiles [6]TileDef
21900                                 //mt:const uint8(6)
21901                                 SpecialTiles [6]TileDef
21902
21903                                 Color   color.NRGBA
21904                                 Palette Texture
21905
21906                                 Waving       WaveType
21907                                 ConnectSides uint8
21908                                 ConnectTo    []Content
21909                                 InsideTint   color.NRGBA
21910                                 Level        uint8 // Must be < 128.
21911
21912                                 Translucent bool // Sunlight is scattered and becomes normal light.
21913                                 Transparent bool // Sunlight isn't scattered.
21914                                 LightSrc    uint8
21915
21916                                 GndContent   bool
21917                                 Collides     bool
21918                                 Pointable    bool
21919                                 Diggable     bool
21920                                 Climbable    bool
21921                                 Replaceable  bool
21922                                 OnRightClick bool
21923
21924                                 DmgPerSec int32
21925
21926                                 LiquidType   LiquidType
21927                                 FlowingAlt   string
21928                                 SrcAlt       string
21929                                 Viscosity    uint8 // 0-7
21930                                 LiqRenewable bool
21931                                 FlowRange    uint8
21932                                 DrownDmg     uint8
21933                                 Floodable    bool
21934
21935                                 DrawBox, ColBox, SelBox NodeBox
21936
21937                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21938
21939                                 LegacyFaceDir bool
21940                                 LegacyMounted bool
21941
21942                                 DigPredict string
21943
21944                                 MaxLvl uint8
21945
21946                                 AlphaUse
21947                         }))(obj)).DiggingSnd).deserialize(r)
21948                 }); err != nil {
21949                         if err == io.EOF {
21950                                 chk(io.EOF)
21951                         }
21952                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
21953                 }
21954                 if err := pcall(func() {
21955                         ((*(*(struct {
21956                                 Param0 Content
21957
21958                                 Name   string
21959                                 Groups []Group
21960
21961                                 P1Type   Param1Type
21962                                 P2Type   Param2Type
21963                                 DrawType DrawType
21964
21965                                 Mesh  string
21966                                 Scale float32
21967                                 //mt:const uint8(6)
21968                                 Tiles        [6]TileDef
21969                                 OverlayTiles [6]TileDef
21970                                 //mt:const uint8(6)
21971                                 SpecialTiles [6]TileDef
21972
21973                                 Color   color.NRGBA
21974                                 Palette Texture
21975
21976                                 Waving       WaveType
21977                                 ConnectSides uint8
21978                                 ConnectTo    []Content
21979                                 InsideTint   color.NRGBA
21980                                 Level        uint8 // Must be < 128.
21981
21982                                 Translucent bool // Sunlight is scattered and becomes normal light.
21983                                 Transparent bool // Sunlight isn't scattered.
21984                                 LightSrc    uint8
21985
21986                                 GndContent   bool
21987                                 Collides     bool
21988                                 Pointable    bool
21989                                 Diggable     bool
21990                                 Climbable    bool
21991                                 Replaceable  bool
21992                                 OnRightClick bool
21993
21994                                 DmgPerSec int32
21995
21996                                 LiquidType   LiquidType
21997                                 FlowingAlt   string
21998                                 SrcAlt       string
21999                                 Viscosity    uint8 // 0-7
22000                                 LiqRenewable bool
22001                                 FlowRange    uint8
22002                                 DrownDmg     uint8
22003                                 Floodable    bool
22004
22005                                 DrawBox, ColBox, SelBox NodeBox
22006
22007                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22008
22009                                 LegacyFaceDir bool
22010                                 LegacyMounted bool
22011
22012                                 DigPredict string
22013
22014                                 MaxLvl uint8
22015
22016                                 AlphaUse
22017                         }))(obj)).DugSnd).deserialize(r)
22018                 }); err != nil {
22019                         if err == io.EOF {
22020                                 chk(io.EOF)
22021                         }
22022                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
22023                 }
22024                 {
22025                         p := &(*(*(struct {
22026                                 Param0 Content
22027
22028                                 Name   string
22029                                 Groups []Group
22030
22031                                 P1Type   Param1Type
22032                                 P2Type   Param2Type
22033                                 DrawType DrawType
22034
22035                                 Mesh  string
22036                                 Scale float32
22037                                 //mt:const uint8(6)
22038                                 Tiles        [6]TileDef
22039                                 OverlayTiles [6]TileDef
22040                                 //mt:const uint8(6)
22041                                 SpecialTiles [6]TileDef
22042
22043                                 Color   color.NRGBA
22044                                 Palette Texture
22045
22046                                 Waving       WaveType
22047                                 ConnectSides uint8
22048                                 ConnectTo    []Content
22049                                 InsideTint   color.NRGBA
22050                                 Level        uint8 // Must be < 128.
22051
22052                                 Translucent bool // Sunlight is scattered and becomes normal light.
22053                                 Transparent bool // Sunlight isn't scattered.
22054                                 LightSrc    uint8
22055
22056                                 GndContent   bool
22057                                 Collides     bool
22058                                 Pointable    bool
22059                                 Diggable     bool
22060                                 Climbable    bool
22061                                 Replaceable  bool
22062                                 OnRightClick bool
22063
22064                                 DmgPerSec int32
22065
22066                                 LiquidType   LiquidType
22067                                 FlowingAlt   string
22068                                 SrcAlt       string
22069                                 Viscosity    uint8 // 0-7
22070                                 LiqRenewable bool
22071                                 FlowRange    uint8
22072                                 DrownDmg     uint8
22073                                 Floodable    bool
22074
22075                                 DrawBox, ColBox, SelBox NodeBox
22076
22077                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22078
22079                                 LegacyFaceDir bool
22080                                 LegacyMounted bool
22081
22082                                 DigPredict string
22083
22084                                 MaxLvl uint8
22085
22086                                 AlphaUse
22087                         }))(obj)).LegacyFaceDir
22088                         switch n := read8(r); n {
22089                         case 0:
22090                                 *p = false
22091                         case 1:
22092                                 *p = true
22093                         default:
22094                                 chk(fmt.Errorf("invalid bool: %d", n))
22095                         }
22096
22097                 }
22098                 {
22099                         p := &(*(*(struct {
22100                                 Param0 Content
22101
22102                                 Name   string
22103                                 Groups []Group
22104
22105                                 P1Type   Param1Type
22106                                 P2Type   Param2Type
22107                                 DrawType DrawType
22108
22109                                 Mesh  string
22110                                 Scale float32
22111                                 //mt:const uint8(6)
22112                                 Tiles        [6]TileDef
22113                                 OverlayTiles [6]TileDef
22114                                 //mt:const uint8(6)
22115                                 SpecialTiles [6]TileDef
22116
22117                                 Color   color.NRGBA
22118                                 Palette Texture
22119
22120                                 Waving       WaveType
22121                                 ConnectSides uint8
22122                                 ConnectTo    []Content
22123                                 InsideTint   color.NRGBA
22124                                 Level        uint8 // Must be < 128.
22125
22126                                 Translucent bool // Sunlight is scattered and becomes normal light.
22127                                 Transparent bool // Sunlight isn't scattered.
22128                                 LightSrc    uint8
22129
22130                                 GndContent   bool
22131                                 Collides     bool
22132                                 Pointable    bool
22133                                 Diggable     bool
22134                                 Climbable    bool
22135                                 Replaceable  bool
22136                                 OnRightClick bool
22137
22138                                 DmgPerSec int32
22139
22140                                 LiquidType   LiquidType
22141                                 FlowingAlt   string
22142                                 SrcAlt       string
22143                                 Viscosity    uint8 // 0-7
22144                                 LiqRenewable bool
22145                                 FlowRange    uint8
22146                                 DrownDmg     uint8
22147                                 Floodable    bool
22148
22149                                 DrawBox, ColBox, SelBox NodeBox
22150
22151                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22152
22153                                 LegacyFaceDir bool
22154                                 LegacyMounted bool
22155
22156                                 DigPredict string
22157
22158                                 MaxLvl uint8
22159
22160                                 AlphaUse
22161                         }))(obj)).LegacyMounted
22162                         switch n := read8(r); n {
22163                         case 0:
22164                                 *p = false
22165                         case 1:
22166                                 *p = true
22167                         default:
22168                                 chk(fmt.Errorf("invalid bool: %d", n))
22169                         }
22170
22171                 }
22172                 var local269 []uint8
22173                 var local270 uint16
22174                 {
22175                         p := &local270
22176                         *p = read16(r)
22177                 }
22178                 (local269) = make([]uint8, local270)
22179                 {
22180                         _, err := io.ReadFull(r, (local269)[:])
22181                         chk(err)
22182                 }
22183                 ((*(*(struct {
22184                         Param0 Content
22185
22186                         Name   string
22187                         Groups []Group
22188
22189                         P1Type   Param1Type
22190                         P2Type   Param2Type
22191                         DrawType DrawType
22192
22193                         Mesh  string
22194                         Scale float32
22195                         //mt:const uint8(6)
22196                         Tiles        [6]TileDef
22197                         OverlayTiles [6]TileDef
22198                         //mt:const uint8(6)
22199                         SpecialTiles [6]TileDef
22200
22201                         Color   color.NRGBA
22202                         Palette Texture
22203
22204                         Waving       WaveType
22205                         ConnectSides uint8
22206                         ConnectTo    []Content
22207                         InsideTint   color.NRGBA
22208                         Level        uint8 // Must be < 128.
22209
22210                         Translucent bool // Sunlight is scattered and becomes normal light.
22211                         Transparent bool // Sunlight isn't scattered.
22212                         LightSrc    uint8
22213
22214                         GndContent   bool
22215                         Collides     bool
22216                         Pointable    bool
22217                         Diggable     bool
22218                         Climbable    bool
22219                         Replaceable  bool
22220                         OnRightClick bool
22221
22222                         DmgPerSec int32
22223
22224                         LiquidType   LiquidType
22225                         FlowingAlt   string
22226                         SrcAlt       string
22227                         Viscosity    uint8 // 0-7
22228                         LiqRenewable bool
22229                         FlowRange    uint8
22230                         DrownDmg     uint8
22231                         Floodable    bool
22232
22233                         DrawBox, ColBox, SelBox NodeBox
22234
22235                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22236
22237                         LegacyFaceDir bool
22238                         LegacyMounted bool
22239
22240                         DigPredict string
22241
22242                         MaxLvl uint8
22243
22244                         AlphaUse
22245                 }))(obj)).DigPredict) = string(local269)
22246                 {
22247                         p := &(*(*(struct {
22248                                 Param0 Content
22249
22250                                 Name   string
22251                                 Groups []Group
22252
22253                                 P1Type   Param1Type
22254                                 P2Type   Param2Type
22255                                 DrawType DrawType
22256
22257                                 Mesh  string
22258                                 Scale float32
22259                                 //mt:const uint8(6)
22260                                 Tiles        [6]TileDef
22261                                 OverlayTiles [6]TileDef
22262                                 //mt:const uint8(6)
22263                                 SpecialTiles [6]TileDef
22264
22265                                 Color   color.NRGBA
22266                                 Palette Texture
22267
22268                                 Waving       WaveType
22269                                 ConnectSides uint8
22270                                 ConnectTo    []Content
22271                                 InsideTint   color.NRGBA
22272                                 Level        uint8 // Must be < 128.
22273
22274                                 Translucent bool // Sunlight is scattered and becomes normal light.
22275                                 Transparent bool // Sunlight isn't scattered.
22276                                 LightSrc    uint8
22277
22278                                 GndContent   bool
22279                                 Collides     bool
22280                                 Pointable    bool
22281                                 Diggable     bool
22282                                 Climbable    bool
22283                                 Replaceable  bool
22284                                 OnRightClick bool
22285
22286                                 DmgPerSec int32
22287
22288                                 LiquidType   LiquidType
22289                                 FlowingAlt   string
22290                                 SrcAlt       string
22291                                 Viscosity    uint8 // 0-7
22292                                 LiqRenewable bool
22293                                 FlowRange    uint8
22294                                 DrownDmg     uint8
22295                                 Floodable    bool
22296
22297                                 DrawBox, ColBox, SelBox NodeBox
22298
22299                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22300
22301                                 LegacyFaceDir bool
22302                                 LegacyMounted bool
22303
22304                                 DigPredict string
22305
22306                                 MaxLvl uint8
22307
22308                                 AlphaUse
22309                         }))(obj)).MaxLvl
22310                         *p = read8(r)
22311                 }
22312                 if err := pcall(func() {
22313                         ((*(*(struct {
22314                                 Param0 Content
22315
22316                                 Name   string
22317                                 Groups []Group
22318
22319                                 P1Type   Param1Type
22320                                 P2Type   Param2Type
22321                                 DrawType DrawType
22322
22323                                 Mesh  string
22324                                 Scale float32
22325                                 //mt:const uint8(6)
22326                                 Tiles        [6]TileDef
22327                                 OverlayTiles [6]TileDef
22328                                 //mt:const uint8(6)
22329                                 SpecialTiles [6]TileDef
22330
22331                                 Color   color.NRGBA
22332                                 Palette Texture
22333
22334                                 Waving       WaveType
22335                                 ConnectSides uint8
22336                                 ConnectTo    []Content
22337                                 InsideTint   color.NRGBA
22338                                 Level        uint8 // Must be < 128.
22339
22340                                 Translucent bool // Sunlight is scattered and becomes normal light.
22341                                 Transparent bool // Sunlight isn't scattered.
22342                                 LightSrc    uint8
22343
22344                                 GndContent   bool
22345                                 Collides     bool
22346                                 Pointable    bool
22347                                 Diggable     bool
22348                                 Climbable    bool
22349                                 Replaceable  bool
22350                                 OnRightClick bool
22351
22352                                 DmgPerSec int32
22353
22354                                 LiquidType   LiquidType
22355                                 FlowingAlt   string
22356                                 SrcAlt       string
22357                                 Viscosity    uint8 // 0-7
22358                                 LiqRenewable bool
22359                                 FlowRange    uint8
22360                                 DrownDmg     uint8
22361                                 Floodable    bool
22362
22363                                 DrawBox, ColBox, SelBox NodeBox
22364
22365                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22366
22367                                 LegacyFaceDir bool
22368                                 LegacyMounted bool
22369
22370                                 DigPredict string
22371
22372                                 MaxLvl uint8
22373
22374                                 AlphaUse
22375                         }))(obj)).AlphaUse).deserialize(r)
22376                 }); err != nil {
22377                         if err == io.EOF {
22378                                 chk(io.EOF)
22379                         }
22380                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlphaUse", err))
22381                 }
22382                 if r.N > 0 {
22383                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
22384                 }
22385         }
22386 }
22387
22388 func (obj *PointedNode) serialize(w io.Writer) {
22389         for local271 := range (*(*(struct {
22390                 Under, Above [3]int16
22391         }))(obj)).Under {
22392                 {
22393                         x := ((*(*(struct {
22394                                 Under, Above [3]int16
22395                         }))(obj)).Under)[local271]
22396                         write16(w, uint16(x))
22397                 }
22398         }
22399         for local272 := range (*(*(struct {
22400                 Under, Above [3]int16
22401         }))(obj)).Above {
22402                 {
22403                         x := ((*(*(struct {
22404                                 Under, Above [3]int16
22405                         }))(obj)).Above)[local272]
22406                         write16(w, uint16(x))
22407                 }
22408         }
22409 }
22410
22411 func (obj *PointedNode) deserialize(r io.Reader) {
22412         for local273 := range (*(*(struct {
22413                 Under, Above [3]int16
22414         }))(obj)).Under {
22415                 {
22416                         p := &((*(*(struct {
22417                                 Under, Above [3]int16
22418                         }))(obj)).Under)[local273]
22419                         *p = int16(read16(r))
22420                 }
22421         }
22422         for local274 := range (*(*(struct {
22423                 Under, Above [3]int16
22424         }))(obj)).Above {
22425                 {
22426                         p := &((*(*(struct {
22427                                 Under, Above [3]int16
22428                         }))(obj)).Above)[local274]
22429                         *p = int16(read16(r))
22430                 }
22431         }
22432 }
22433
22434 func (obj *PointedAO) serialize(w io.Writer) {
22435         if err := pcall(func() {
22436                 ((*(*(struct {
22437                         ID AOID
22438                 }))(obj)).ID).serialize(w)
22439         }); err != nil {
22440                 if err == io.EOF {
22441                         chk(io.EOF)
22442                 }
22443                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
22444         }
22445 }
22446
22447 func (obj *PointedAO) deserialize(r io.Reader) {
22448         if err := pcall(func() {
22449                 ((*(*(struct {
22450                         ID AOID
22451                 }))(obj)).ID).deserialize(r)
22452         }); err != nil {
22453                 if err == io.EOF {
22454                         chk(io.EOF)
22455                 }
22456                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
22457         }
22458 }
22459
22460 func (obj *CompressionModes) serialize(w io.Writer) {
22461         {
22462                 x := *(*(uint16))(obj)
22463                 write16(w, uint16(x))
22464         }
22465 }
22466
22467 func (obj *CompressionModes) deserialize(r io.Reader) {
22468         {
22469                 p := &*(*(uint16))(obj)
22470                 *p = read16(r)
22471         }
22472 }
22473
22474 func (obj *PlayerPos) serialize(w io.Writer) {
22475         for local275 := range (*(*(struct {
22476                 Pos100, Vel100   [3]int32
22477                 Pitch100, Yaw100 int32
22478                 Keys             Keys
22479                 FOV80            uint8
22480                 WantedRange      uint8 // in MapBlks.
22481         }))(obj)).Pos100 {
22482                 {
22483                         x := ((*(*(struct {
22484                                 Pos100, Vel100   [3]int32
22485                                 Pitch100, Yaw100 int32
22486                                 Keys             Keys
22487                                 FOV80            uint8
22488                                 WantedRange      uint8 // in MapBlks.
22489                         }))(obj)).Pos100)[local275]
22490                         write32(w, uint32(x))
22491                 }
22492         }
22493         for local276 := range (*(*(struct {
22494                 Pos100, Vel100   [3]int32
22495                 Pitch100, Yaw100 int32
22496                 Keys             Keys
22497                 FOV80            uint8
22498                 WantedRange      uint8 // in MapBlks.
22499         }))(obj)).Vel100 {
22500                 {
22501                         x := ((*(*(struct {
22502                                 Pos100, Vel100   [3]int32
22503                                 Pitch100, Yaw100 int32
22504                                 Keys             Keys
22505                                 FOV80            uint8
22506                                 WantedRange      uint8 // in MapBlks.
22507                         }))(obj)).Vel100)[local276]
22508                         write32(w, uint32(x))
22509                 }
22510         }
22511         {
22512                 x := (*(*(struct {
22513                         Pos100, Vel100   [3]int32
22514                         Pitch100, Yaw100 int32
22515                         Keys             Keys
22516                         FOV80            uint8
22517                         WantedRange      uint8 // in MapBlks.
22518                 }))(obj)).Pitch100
22519                 write32(w, uint32(x))
22520         }
22521         {
22522                 x := (*(*(struct {
22523                         Pos100, Vel100   [3]int32
22524                         Pitch100, Yaw100 int32
22525                         Keys             Keys
22526                         FOV80            uint8
22527                         WantedRange      uint8 // in MapBlks.
22528                 }))(obj)).Yaw100
22529                 write32(w, uint32(x))
22530         }
22531         if err := pcall(func() {
22532                 ((*(*(struct {
22533                         Pos100, Vel100   [3]int32
22534                         Pitch100, Yaw100 int32
22535                         Keys             Keys
22536                         FOV80            uint8
22537                         WantedRange      uint8 // in MapBlks.
22538                 }))(obj)).Keys).serialize(w)
22539         }); err != nil {
22540                 if err == io.EOF {
22541                         chk(io.EOF)
22542                 }
22543                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Keys", err))
22544         }
22545         {
22546                 x := (*(*(struct {
22547                         Pos100, Vel100   [3]int32
22548                         Pitch100, Yaw100 int32
22549                         Keys             Keys
22550                         FOV80            uint8
22551                         WantedRange      uint8 // in MapBlks.
22552                 }))(obj)).FOV80
22553                 write8(w, uint8(x))
22554         }
22555         {
22556                 x := (*(*(struct {
22557                         Pos100, Vel100   [3]int32
22558                         Pitch100, Yaw100 int32
22559                         Keys             Keys
22560                         FOV80            uint8
22561                         WantedRange      uint8 // in MapBlks.
22562                 }))(obj)).WantedRange
22563                 write8(w, uint8(x))
22564         }
22565 }
22566
22567 func (obj *PlayerPos) deserialize(r io.Reader) {
22568         for local277 := range (*(*(struct {
22569                 Pos100, Vel100   [3]int32
22570                 Pitch100, Yaw100 int32
22571                 Keys             Keys
22572                 FOV80            uint8
22573                 WantedRange      uint8 // in MapBlks.
22574         }))(obj)).Pos100 {
22575                 {
22576                         p := &((*(*(struct {
22577                                 Pos100, Vel100   [3]int32
22578                                 Pitch100, Yaw100 int32
22579                                 Keys             Keys
22580                                 FOV80            uint8
22581                                 WantedRange      uint8 // in MapBlks.
22582                         }))(obj)).Pos100)[local277]
22583                         *p = int32(read32(r))
22584                 }
22585         }
22586         for local278 := range (*(*(struct {
22587                 Pos100, Vel100   [3]int32
22588                 Pitch100, Yaw100 int32
22589                 Keys             Keys
22590                 FOV80            uint8
22591                 WantedRange      uint8 // in MapBlks.
22592         }))(obj)).Vel100 {
22593                 {
22594                         p := &((*(*(struct {
22595                                 Pos100, Vel100   [3]int32
22596                                 Pitch100, Yaw100 int32
22597                                 Keys             Keys
22598                                 FOV80            uint8
22599                                 WantedRange      uint8 // in MapBlks.
22600                         }))(obj)).Vel100)[local278]
22601                         *p = int32(read32(r))
22602                 }
22603         }
22604         {
22605                 p := &(*(*(struct {
22606                         Pos100, Vel100   [3]int32
22607                         Pitch100, Yaw100 int32
22608                         Keys             Keys
22609                         FOV80            uint8
22610                         WantedRange      uint8 // in MapBlks.
22611                 }))(obj)).Pitch100
22612                 *p = int32(read32(r))
22613         }
22614         {
22615                 p := &(*(*(struct {
22616                         Pos100, Vel100   [3]int32
22617                         Pitch100, Yaw100 int32
22618                         Keys             Keys
22619                         FOV80            uint8
22620                         WantedRange      uint8 // in MapBlks.
22621                 }))(obj)).Yaw100
22622                 *p = int32(read32(r))
22623         }
22624         if err := pcall(func() {
22625                 ((*(*(struct {
22626                         Pos100, Vel100   [3]int32
22627                         Pitch100, Yaw100 int32
22628                         Keys             Keys
22629                         FOV80            uint8
22630                         WantedRange      uint8 // in MapBlks.
22631                 }))(obj)).Keys).deserialize(r)
22632         }); err != nil {
22633                 if err == io.EOF {
22634                         chk(io.EOF)
22635                 }
22636                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Keys", err))
22637         }
22638         {
22639                 p := &(*(*(struct {
22640                         Pos100, Vel100   [3]int32
22641                         Pitch100, Yaw100 int32
22642                         Keys             Keys
22643                         FOV80            uint8
22644                         WantedRange      uint8 // in MapBlks.
22645                 }))(obj)).FOV80
22646                 *p = read8(r)
22647         }
22648         {
22649                 p := &(*(*(struct {
22650                         Pos100, Vel100   [3]int32
22651                         Pitch100, Yaw100 int32
22652                         Keys             Keys
22653                         FOV80            uint8
22654                         WantedRange      uint8 // in MapBlks.
22655                 }))(obj)).WantedRange
22656                 *p = read8(r)
22657         }
22658 }
22659
22660 func (obj *Interaction) serialize(w io.Writer) {
22661         {
22662                 x := *(*(uint8))(obj)
22663                 write8(w, uint8(x))
22664         }
22665 }
22666
22667 func (obj *Interaction) deserialize(r io.Reader) {
22668         {
22669                 p := &*(*(uint8))(obj)
22670                 *p = read8(r)
22671         }
22672 }
22673
22674 func (obj *SoundID) serialize(w io.Writer) {
22675         {
22676                 x := *(*(int32))(obj)
22677                 write32(w, uint32(x))
22678         }
22679 }
22680
22681 func (obj *SoundID) deserialize(r io.Reader) {
22682         {
22683                 p := &*(*(int32))(obj)
22684                 *p = int32(read32(r))
22685         }
22686 }
22687
22688 func (obj *Field) serialize(w io.Writer) {
22689         if len(([]byte((*(*(struct {
22690                 Name string
22691
22692                 //mt:len32
22693                 Value string
22694         }))(obj)).Name))) > math.MaxUint16 {
22695                 chk(ErrTooLong)
22696         }
22697         {
22698                 x := uint16(len(([]byte((*(*(struct {
22699                         Name string
22700
22701                         //mt:len32
22702                         Value string
22703                 }))(obj)).Name))))
22704                 write16(w, uint16(x))
22705         }
22706         {
22707                 _, err := w.Write(([]byte((*(*(struct {
22708                         Name string
22709
22710                         //mt:len32
22711                         Value string
22712                 }))(obj)).Name))[:])
22713                 chk(err)
22714         }
22715         if len(([]byte((*(*(struct {
22716                 Name string
22717
22718                 //mt:len32
22719                 Value string
22720         }))(obj)).Value))) > math.MaxUint32 {
22721                 chk(ErrTooLong)
22722         }
22723         {
22724                 x := uint32(len(([]byte((*(*(struct {
22725                         Name string
22726
22727                         //mt:len32
22728                         Value string
22729                 }))(obj)).Value))))
22730                 write32(w, uint32(x))
22731         }
22732         {
22733                 _, err := w.Write(([]byte((*(*(struct {
22734                         Name string
22735
22736                         //mt:len32
22737                         Value string
22738                 }))(obj)).Value))[:])
22739                 chk(err)
22740         }
22741 }
22742
22743 func (obj *Field) deserialize(r io.Reader) {
22744         var local279 []uint8
22745         var local280 uint16
22746         {
22747                 p := &local280
22748                 *p = read16(r)
22749         }
22750         (local279) = make([]uint8, local280)
22751         {
22752                 _, err := io.ReadFull(r, (local279)[:])
22753                 chk(err)
22754         }
22755         ((*(*(struct {
22756                 Name string
22757
22758                 //mt:len32
22759                 Value string
22760         }))(obj)).Name) = string(local279)
22761         var local281 []uint8
22762         var local282 uint32
22763         {
22764                 p := &local282
22765                 *p = read32(r)
22766         }
22767         (local281) = make([]uint8, local282)
22768         {
22769                 _, err := io.ReadFull(r, (local281)[:])
22770                 chk(err)
22771         }
22772         ((*(*(struct {
22773                 Name string
22774
22775                 //mt:len32
22776                 Value string
22777         }))(obj)).Value) = string(local281)
22778 }
22779
22780 func (obj *AuthMethods) serialize(w io.Writer) {
22781         {
22782                 x := *(*(uint32))(obj)
22783                 write32(w, uint32(x))
22784         }
22785 }
22786
22787 func (obj *AuthMethods) deserialize(r io.Reader) {
22788         {
22789                 p := &*(*(uint32))(obj)
22790                 *p = read32(r)
22791         }
22792 }
22793
22794 func (obj *Pos) serialize(w io.Writer) {
22795         if err := pcall(func() {
22796                 (*(*(Vec))(obj)).serialize(w)
22797         }); err != nil {
22798                 if err == io.EOF {
22799                         chk(io.EOF)
22800                 }
22801                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
22802         }
22803 }
22804
22805 func (obj *Pos) deserialize(r io.Reader) {
22806         if err := pcall(func() {
22807                 (*(*(Vec))(obj)).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.Vec", err))
22813         }
22814 }
22815
22816 func (obj *KickReason) serialize(w io.Writer) {
22817         {
22818                 x := *(*(uint8))(obj)
22819                 write8(w, uint8(x))
22820         }
22821 }
22822
22823 func (obj *KickReason) deserialize(r io.Reader) {
22824         {
22825                 p := &*(*(uint8))(obj)
22826                 *p = read8(r)
22827         }
22828 }
22829
22830 func (obj *MapBlk) serialize(w io.Writer) {
22831         if err := pcall(func() {
22832                 ((*(*(struct {
22833                         Flags   MapBlkFlags
22834                         LitFrom LitFromBlks
22835
22836                         //mt:zstd
22837                         Param0 [4096]Content
22838                         Param1 [4096]uint8
22839                         Param2 [4096]uint8
22840
22841                         NodeMetas map[uint16]*NodeMeta
22842                 }))(obj)).Flags).serialize(w)
22843         }); err != nil {
22844                 if err == io.EOF {
22845                         chk(io.EOF)
22846                 }
22847                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlkFlags", err))
22848         }
22849         if err := pcall(func() {
22850                 ((*(*(struct {
22851                         Flags   MapBlkFlags
22852                         LitFrom LitFromBlks
22853
22854                         //mt:zstd
22855                         Param0 [4096]Content
22856                         Param1 [4096]uint8
22857                         Param2 [4096]uint8
22858
22859                         NodeMetas map[uint16]*NodeMeta
22860                 }))(obj)).LitFrom).serialize(w)
22861         }); err != nil {
22862                 if err == io.EOF {
22863                         chk(io.EOF)
22864                 }
22865                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
22866         }
22867         {
22868                 local283 := uint8(2) // Size of param0 in bytes.
22869                 {
22870                         x := local283
22871                         write8(w, uint8(x))
22872                 }
22873         }
22874         {
22875                 local284 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
22876                 {
22877                         x := local284
22878                         write8(w, uint8(x))
22879                 }
22880         }
22881         {
22882                 w := zstd.NewWriter(w)
22883                 for local285 := range (*(*(struct {
22884                         Flags   MapBlkFlags
22885                         LitFrom LitFromBlks
22886
22887                         //mt:zstd
22888                         Param0 [4096]Content
22889                         Param1 [4096]uint8
22890                         Param2 [4096]uint8
22891
22892                         NodeMetas map[uint16]*NodeMeta
22893                 }))(obj)).Param0 {
22894                         if err := pcall(func() {
22895                                 (((*(*(struct {
22896                                         Flags   MapBlkFlags
22897                                         LitFrom LitFromBlks
22898
22899                                         //mt:zstd
22900                                         Param0 [4096]Content
22901                                         Param1 [4096]uint8
22902                                         Param2 [4096]uint8
22903
22904                                         NodeMetas map[uint16]*NodeMeta
22905                                 }))(obj)).Param0)[local285]).serialize(w)
22906                         }); err != nil {
22907                                 if err == io.EOF {
22908                                         chk(io.EOF)
22909                                 }
22910                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
22911                         }
22912                 }
22913                 {
22914                         _, err := w.Write(((*(*(struct {
22915                                 Flags   MapBlkFlags
22916                                 LitFrom LitFromBlks
22917
22918                                 //mt:zstd
22919                                 Param0 [4096]Content
22920                                 Param1 [4096]uint8
22921                                 Param2 [4096]uint8
22922
22923                                 NodeMetas map[uint16]*NodeMeta
22924                         }))(obj)).Param1)[:])
22925                         chk(err)
22926                 }
22927                 {
22928                         _, err := w.Write(((*(*(struct {
22929                                 Flags   MapBlkFlags
22930                                 LitFrom LitFromBlks
22931
22932                                 //mt:zstd
22933                                 Param0 [4096]Content
22934                                 Param1 [4096]uint8
22935                                 Param2 [4096]uint8
22936
22937                                 NodeMetas map[uint16]*NodeMeta
22938                         }))(obj)).Param2)[:])
22939                         chk(err)
22940                 }
22941                 chk(w.Close())
22942         }
22943         {
22944                 x := (*(*(struct {
22945                         Flags   MapBlkFlags
22946                         LitFrom LitFromBlks
22947
22948                         //mt:zstd
22949                         Param0 [4096]Content
22950                         Param1 [4096]uint8
22951                         Param2 [4096]uint8
22952
22953                         NodeMetas map[uint16]*NodeMeta
22954                 }))(obj)).NodeMetas
22955                 {
22956                         w := zlib.NewWriter(w)
22957
22958                         if x == nil {
22959                                 write8(w, 0)
22960                         } else {
22961                                 write8(w, 2)
22962                                 // len(map[uint16]...) always < math.MaxUint16
22963                                 write16(w, uint16(len(x)))
22964                                 keys := make([]uint16, 0, len(x))
22965                                 for key := range x {
22966                                         keys = append(keys, key)
22967                                 }
22968                                 sort.Slice(keys, func(i, j int) bool {
22969                                         i2pos := func(i int) [3]int16 {
22970                                                 return Blkpos2Pos([3]int16{}, keys[i])
22971                                         }
22972
22973                                         p, q := i2pos(i), i2pos(j)
22974
22975                                         for i := range p {
22976                                                 switch {
22977                                                 case p[i] < q[i]:
22978                                                         return true
22979                                                 case p[i] > q[i]:
22980                                                         return false
22981                                                 }
22982                                         }
22983
22984                                         return false
22985                                 })
22986                                 for _, key := range keys {
22987                                         write16(w, key)
22988                                         chk(serialize(w, x[key]))
22989                                 }
22990                         }
22991
22992                         chk(w.Close())
22993                 }
22994
22995         }
22996         {
22997                 local286 := uint8(2) // version
22998                 {
22999                         x := local286
23000                         write8(w, uint8(x))
23001                 }
23002         }
23003 }
23004
23005 func (obj *MapBlk) deserialize(r io.Reader) {
23006         if err := pcall(func() {
23007                 ((*(*(struct {
23008                         Flags   MapBlkFlags
23009                         LitFrom LitFromBlks
23010
23011                         //mt:zstd
23012                         Param0 [4096]Content
23013                         Param1 [4096]uint8
23014                         Param2 [4096]uint8
23015
23016                         NodeMetas map[uint16]*NodeMeta
23017                 }))(obj)).Flags).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.MapBlkFlags", err))
23023         }
23024         if err := pcall(func() {
23025                 ((*(*(struct {
23026                         Flags   MapBlkFlags
23027                         LitFrom LitFromBlks
23028
23029                         //mt:zstd
23030                         Param0 [4096]Content
23031                         Param1 [4096]uint8
23032                         Param2 [4096]uint8
23033
23034                         NodeMetas map[uint16]*NodeMeta
23035                 }))(obj)).LitFrom).deserialize(r)
23036         }); err != nil {
23037                 if err == io.EOF {
23038                         chk(io.EOF)
23039                 }
23040                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
23041         }
23042         {
23043                 var local287 uint8
23044                 local288 := uint8(2) // Size of param0 in bytes.
23045                 {
23046                         p := &local287
23047                         *p = read8(r)
23048                 }
23049                 if local287 != local288 {
23050                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local287))
23051                 }
23052         }
23053         {
23054                 var local289 uint8
23055                 local290 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23056                 {
23057                         p := &local289
23058                         *p = read8(r)
23059                 }
23060                 if local289 != local290 {
23061                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local289))
23062                 }
23063         }
23064         {
23065                 r, err := zstd.NewReader(byteReader{r})
23066                 chk(err)
23067                 for local291 := range (*(*(struct {
23068                         Flags   MapBlkFlags
23069                         LitFrom LitFromBlks
23070
23071                         //mt:zstd
23072                         Param0 [4096]Content
23073                         Param1 [4096]uint8
23074                         Param2 [4096]uint8
23075
23076                         NodeMetas map[uint16]*NodeMeta
23077                 }))(obj)).Param0 {
23078                         if err := pcall(func() {
23079                                 (((*(*(struct {
23080                                         Flags   MapBlkFlags
23081                                         LitFrom LitFromBlks
23082
23083                                         //mt:zstd
23084                                         Param0 [4096]Content
23085                                         Param1 [4096]uint8
23086                                         Param2 [4096]uint8
23087
23088                                         NodeMetas map[uint16]*NodeMeta
23089                                 }))(obj)).Param0)[local291]).deserialize(r)
23090                         }); err != nil {
23091                                 if err == io.EOF {
23092                                         chk(io.EOF)
23093                                 }
23094                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23095                         }
23096                 }
23097                 {
23098                         _, err := io.ReadFull(r, ((*(*(struct {
23099                                 Flags   MapBlkFlags
23100                                 LitFrom LitFromBlks
23101
23102                                 //mt:zstd
23103                                 Param0 [4096]Content
23104                                 Param1 [4096]uint8
23105                                 Param2 [4096]uint8
23106
23107                                 NodeMetas map[uint16]*NodeMeta
23108                         }))(obj)).Param1)[:])
23109                         chk(err)
23110                 }
23111                 {
23112                         _, err := io.ReadFull(r, ((*(*(struct {
23113                                 Flags   MapBlkFlags
23114                                 LitFrom LitFromBlks
23115
23116                                 //mt:zstd
23117                                 Param0 [4096]Content
23118                                 Param1 [4096]uint8
23119                                 Param2 [4096]uint8
23120
23121                                 NodeMetas map[uint16]*NodeMeta
23122                         }))(obj)).Param2)[:])
23123                         chk(err)
23124                 }
23125                 chk(r.Close())
23126         }
23127         {
23128                 p := &(*(*(struct {
23129                         Flags   MapBlkFlags
23130                         LitFrom LitFromBlks
23131
23132                         //mt:zstd
23133                         Param0 [4096]Content
23134                         Param1 [4096]uint8
23135                         Param2 [4096]uint8
23136
23137                         NodeMetas map[uint16]*NodeMeta
23138                 }))(obj)).NodeMetas
23139                 {
23140                         r, err := zlib.NewReader(byteReader{r})
23141                         chk(err)
23142
23143                         switch ver := read8(r); ver {
23144                         case 0:
23145                                 *p = nil
23146                         case 2:
23147                                 n := read16(r)
23148                                 *p = make(map[uint16]*NodeMeta, n)
23149                                 for ; n > 0; n-- {
23150                                         pos := read16(r)
23151                                         nm := new(NodeMeta)
23152                                         chk(deserialize(r, nm))
23153                                         (*p)[pos] = nm
23154                                 }
23155                         default:
23156                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
23157                         }
23158
23159                         chk(r.Close())
23160                 }
23161
23162         }
23163         {
23164                 var local292 uint8
23165                 local293 := uint8(2) // version
23166                 {
23167                         p := &local292
23168                         *p = read8(r)
23169                 }
23170                 if local292 != local293 {
23171                         chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local292))
23172                 }
23173         }
23174 }
23175
23176 func (obj *Node) serialize(w io.Writer) {
23177         if err := pcall(func() {
23178                 ((*(*(struct {
23179                         Param0         Content
23180                         Param1, Param2 uint8
23181                 }))(obj)).Param0).serialize(w)
23182         }); err != nil {
23183                 if err == io.EOF {
23184                         chk(io.EOF)
23185                 }
23186                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23187         }
23188         {
23189                 x := (*(*(struct {
23190                         Param0         Content
23191                         Param1, Param2 uint8
23192                 }))(obj)).Param1
23193                 write8(w, uint8(x))
23194         }
23195         {
23196                 x := (*(*(struct {
23197                         Param0         Content
23198                         Param1, Param2 uint8
23199                 }))(obj)).Param2
23200                 write8(w, uint8(x))
23201         }
23202 }
23203
23204 func (obj *Node) deserialize(r io.Reader) {
23205         if err := pcall(func() {
23206                 ((*(*(struct {
23207                         Param0         Content
23208                         Param1, Param2 uint8
23209                 }))(obj)).Param0).deserialize(r)
23210         }); err != nil {
23211                 if err == io.EOF {
23212                         chk(io.EOF)
23213                 }
23214                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23215         }
23216         {
23217                 p := &(*(*(struct {
23218                         Param0         Content
23219                         Param1, Param2 uint8
23220                 }))(obj)).Param1
23221                 *p = read8(r)
23222         }
23223         {
23224                 p := &(*(*(struct {
23225                         Param0         Content
23226                         Param1, Param2 uint8
23227                 }))(obj)).Param2
23228                 *p = read8(r)
23229         }
23230 }
23231
23232 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
23233         {
23234                 x := *(*(uint64))(obj)
23235                 write64(w, uint64(x))
23236
23237         }
23238 }
23239
23240 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
23241         {
23242                 p := &*(*(uint64))(obj)
23243                 *p = read64(r)
23244
23245         }
23246 }
23247
23248 func (obj *Vec) serialize(w io.Writer) {
23249         for local294 := range *(*([3]float32))(obj) {
23250                 {
23251                         x := (*(*([3]float32))(obj))[local294]
23252                         write32(w, math.Float32bits(x))
23253                 }
23254         }
23255 }
23256
23257 func (obj *Vec) deserialize(r io.Reader) {
23258         for local295 := range *(*([3]float32))(obj) {
23259                 {
23260                         p := &(*(*([3]float32))(obj))[local295]
23261                         *p = math.Float32frombits(read32(r))
23262                 }
23263         }
23264 }
23265
23266 func (obj *ChatMsgType) serialize(w io.Writer) {
23267         {
23268                 x := *(*(uint8))(obj)
23269                 write8(w, uint8(x))
23270         }
23271 }
23272
23273 func (obj *ChatMsgType) deserialize(r io.Reader) {
23274         {
23275                 p := &*(*(uint8))(obj)
23276                 *p = read8(r)
23277         }
23278 }
23279
23280 func (obj *AOID) serialize(w io.Writer) {
23281         {
23282                 x := *(*(uint16))(obj)
23283                 write16(w, uint16(x))
23284         }
23285 }
23286
23287 func (obj *AOID) deserialize(r io.Reader) {
23288         {
23289                 p := &*(*(uint16))(obj)
23290                 *p = read16(r)
23291         }
23292 }
23293
23294 func (obj *AOAdd) serialize(w io.Writer) {
23295         if err := pcall(func() {
23296                 ((*(*(struct {
23297                         ID AOID
23298                         //mt:const genericCAO
23299                         //mt:lenhdr 32
23300                         InitData AOInitData
23301                 }))(obj)).ID).serialize(w)
23302         }); err != nil {
23303                 if err == io.EOF {
23304                         chk(io.EOF)
23305                 }
23306                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23307         }
23308         {
23309                 local296 := genericCAO
23310                 if err := pcall(func() {
23311                         (local296).serialize(w)
23312                 }); err != nil {
23313                         if err == io.EOF {
23314                                 chk(io.EOF)
23315                         }
23316                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
23317                 }
23318         }
23319         {
23320                 ow := w
23321                 w := new(bytes.Buffer)
23322                 if err := pcall(func() {
23323                         ((*(*(struct {
23324                                 ID AOID
23325                                 //mt:const genericCAO
23326                                 //mt:lenhdr 32
23327                                 InitData AOInitData
23328                         }))(obj)).InitData).serialize(w)
23329                 }); err != nil {
23330                         if err == io.EOF {
23331                                 chk(io.EOF)
23332                         }
23333                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
23334                 }
23335                 {
23336                         buf := w
23337                         w := ow
23338                         if len((buf.Bytes())) > math.MaxUint32 {
23339                                 chk(ErrTooLong)
23340                         }
23341                         {
23342                                 x := uint32(len((buf.Bytes())))
23343                                 write32(w, uint32(x))
23344                         }
23345                         {
23346                                 _, err := w.Write((buf.Bytes())[:])
23347                                 chk(err)
23348                         }
23349                 }
23350         }
23351 }
23352
23353 func (obj *AOAdd) deserialize(r io.Reader) {
23354         if err := pcall(func() {
23355                 ((*(*(struct {
23356                         ID AOID
23357                         //mt:const genericCAO
23358                         //mt:lenhdr 32
23359                         InitData AOInitData
23360                 }))(obj)).ID).deserialize(r)
23361         }); err != nil {
23362                 if err == io.EOF {
23363                         chk(io.EOF)
23364                 }
23365                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23366         }
23367         {
23368                 var local297 aoType
23369                 local298 := genericCAO
23370                 if err := pcall(func() {
23371                         (local297).deserialize(r)
23372                 }); err != nil {
23373                         if err == io.EOF {
23374                                 chk(io.EOF)
23375                         }
23376                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
23377                 }
23378                 if local297 != local298 {
23379                         chk(fmt.Errorf("const %v: %v", "genericCAO", local297))
23380                 }
23381         }
23382         {
23383                 var n uint32
23384                 {
23385                         p := &n
23386                         *p = read32(r)
23387                 }
23388                 r := &io.LimitedReader{R: r, N: int64(n)}
23389                 if err := pcall(func() {
23390                         ((*(*(struct {
23391                                 ID AOID
23392                                 //mt:const genericCAO
23393                                 //mt:lenhdr 32
23394                                 InitData AOInitData
23395                         }))(obj)).InitData).deserialize(r)
23396                 }); err != nil {
23397                         if err == io.EOF {
23398                                 chk(io.EOF)
23399                         }
23400                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
23401                 }
23402                 if r.N > 0 {
23403                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23404                 }
23405         }
23406 }
23407
23408 func (obj *IDAOMsg) serialize(w io.Writer) {
23409         if err := pcall(func() {
23410                 ((*(*(struct {
23411                         ID AOID
23412                         //mt:lenhdr 16
23413                         Msg AOMsg
23414                 }))(obj)).ID).serialize(w)
23415         }); err != nil {
23416                 if err == io.EOF {
23417                         chk(io.EOF)
23418                 }
23419                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23420         }
23421         {
23422                 ow := w
23423                 w := new(bytes.Buffer)
23424                 {
23425                         x := (*(*(struct {
23426                                 ID AOID
23427                                 //mt:lenhdr 16
23428                                 Msg AOMsg
23429                         }))(obj)).Msg
23430                         writeAOMsg(w, x)
23431
23432                 }
23433                 {
23434                         buf := w
23435                         w := ow
23436                         if len((buf.Bytes())) > math.MaxUint16 {
23437                                 chk(ErrTooLong)
23438                         }
23439                         {
23440                                 x := uint16(len((buf.Bytes())))
23441                                 write16(w, uint16(x))
23442                         }
23443                         {
23444                                 _, err := w.Write((buf.Bytes())[:])
23445                                 chk(err)
23446                         }
23447                 }
23448         }
23449 }
23450
23451 func (obj *IDAOMsg) deserialize(r io.Reader) {
23452         if err := pcall(func() {
23453                 ((*(*(struct {
23454                         ID AOID
23455                         //mt:lenhdr 16
23456                         Msg AOMsg
23457                 }))(obj)).ID).deserialize(r)
23458         }); err != nil {
23459                 if err == io.EOF {
23460                         chk(io.EOF)
23461                 }
23462                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23463         }
23464         {
23465                 var n uint16
23466                 {
23467                         p := &n
23468                         *p = read16(r)
23469                 }
23470                 r := &io.LimitedReader{R: r, N: int64(n)}
23471                 {
23472                         p := &(*(*(struct {
23473                                 ID AOID
23474                                 //mt:lenhdr 16
23475                                 Msg AOMsg
23476                         }))(obj)).Msg
23477                         {
23478                                 var err error
23479                                 *p, err = readAOMsg(r)
23480                                 chk(err)
23481                         }
23482
23483                 }
23484                 if r.N > 0 {
23485                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23486                 }
23487         }
23488 }
23489
23490 func (obj *ItemDef) serialize(w io.Writer) {
23491         {
23492                 ow := w
23493                 w := new(bytes.Buffer)
23494                 {
23495                         local299 := uint8(6)
23496                         {
23497                                 x := local299
23498                                 write8(w, uint8(x))
23499                         }
23500                 }
23501                 if err := pcall(func() {
23502                         ((*(*(struct {
23503                                 Type ItemType
23504
23505                                 Name, Desc string
23506
23507                                 InvImg, WieldImg Texture
23508                                 WieldScale       [3]float32
23509
23510                                 StackMax uint16
23511
23512                                 Usable          bool
23513                                 CanPointLiquids bool
23514
23515                                 ToolCaps ToolCaps
23516
23517                                 Groups []Group
23518
23519                                 PlacePredict string
23520
23521                                 PlaceSnd, PlaceFailSnd SoundDef
23522
23523                                 PointRange float32
23524
23525                                 // Set index in Palette with "palette_index" item meta field,
23526                                 // this overrides Color.
23527                                 Palette Texture
23528                                 Color   color.NRGBA
23529
23530                                 // Texture overlays.
23531                                 InvOverlay, WieldOverlay Texture
23532
23533                                 ShortDesc string
23534                         }))(obj)).Type).serialize(w)
23535                 }); err != nil {
23536                         if err == io.EOF {
23537                                 chk(io.EOF)
23538                         }
23539                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
23540                 }
23541                 if len(([]byte((*(*(struct {
23542                         Type ItemType
23543
23544                         Name, Desc string
23545
23546                         InvImg, WieldImg Texture
23547                         WieldScale       [3]float32
23548
23549                         StackMax uint16
23550
23551                         Usable          bool
23552                         CanPointLiquids bool
23553
23554                         ToolCaps ToolCaps
23555
23556                         Groups []Group
23557
23558                         PlacePredict string
23559
23560                         PlaceSnd, PlaceFailSnd SoundDef
23561
23562                         PointRange float32
23563
23564                         // Set index in Palette with "palette_index" item meta field,
23565                         // this overrides Color.
23566                         Palette Texture
23567                         Color   color.NRGBA
23568
23569                         // Texture overlays.
23570                         InvOverlay, WieldOverlay Texture
23571
23572                         ShortDesc string
23573                 }))(obj)).Name))) > math.MaxUint16 {
23574                         chk(ErrTooLong)
23575                 }
23576                 {
23577                         x := uint16(len(([]byte((*(*(struct {
23578                                 Type ItemType
23579
23580                                 Name, Desc string
23581
23582                                 InvImg, WieldImg Texture
23583                                 WieldScale       [3]float32
23584
23585                                 StackMax uint16
23586
23587                                 Usable          bool
23588                                 CanPointLiquids bool
23589
23590                                 ToolCaps ToolCaps
23591
23592                                 Groups []Group
23593
23594                                 PlacePredict string
23595
23596                                 PlaceSnd, PlaceFailSnd SoundDef
23597
23598                                 PointRange float32
23599
23600                                 // Set index in Palette with "palette_index" item meta field,
23601                                 // this overrides Color.
23602                                 Palette Texture
23603                                 Color   color.NRGBA
23604
23605                                 // Texture overlays.
23606                                 InvOverlay, WieldOverlay Texture
23607
23608                                 ShortDesc string
23609                         }))(obj)).Name))))
23610                         write16(w, uint16(x))
23611                 }
23612                 {
23613                         _, err := w.Write(([]byte((*(*(struct {
23614                                 Type ItemType
23615
23616                                 Name, Desc string
23617
23618                                 InvImg, WieldImg Texture
23619                                 WieldScale       [3]float32
23620
23621                                 StackMax uint16
23622
23623                                 Usable          bool
23624                                 CanPointLiquids bool
23625
23626                                 ToolCaps ToolCaps
23627
23628                                 Groups []Group
23629
23630                                 PlacePredict string
23631
23632                                 PlaceSnd, PlaceFailSnd SoundDef
23633
23634                                 PointRange float32
23635
23636                                 // Set index in Palette with "palette_index" item meta field,
23637                                 // this overrides Color.
23638                                 Palette Texture
23639                                 Color   color.NRGBA
23640
23641                                 // Texture overlays.
23642                                 InvOverlay, WieldOverlay Texture
23643
23644                                 ShortDesc string
23645                         }))(obj)).Name))[:])
23646                         chk(err)
23647                 }
23648                 if len(([]byte((*(*(struct {
23649                         Type ItemType
23650
23651                         Name, Desc string
23652
23653                         InvImg, WieldImg Texture
23654                         WieldScale       [3]float32
23655
23656                         StackMax uint16
23657
23658                         Usable          bool
23659                         CanPointLiquids bool
23660
23661                         ToolCaps ToolCaps
23662
23663                         Groups []Group
23664
23665                         PlacePredict string
23666
23667                         PlaceSnd, PlaceFailSnd SoundDef
23668
23669                         PointRange float32
23670
23671                         // Set index in Palette with "palette_index" item meta field,
23672                         // this overrides Color.
23673                         Palette Texture
23674                         Color   color.NRGBA
23675
23676                         // Texture overlays.
23677                         InvOverlay, WieldOverlay Texture
23678
23679                         ShortDesc string
23680                 }))(obj)).Desc))) > math.MaxUint16 {
23681                         chk(ErrTooLong)
23682                 }
23683                 {
23684                         x := uint16(len(([]byte((*(*(struct {
23685                                 Type ItemType
23686
23687                                 Name, Desc string
23688
23689                                 InvImg, WieldImg Texture
23690                                 WieldScale       [3]float32
23691
23692                                 StackMax uint16
23693
23694                                 Usable          bool
23695                                 CanPointLiquids bool
23696
23697                                 ToolCaps ToolCaps
23698
23699                                 Groups []Group
23700
23701                                 PlacePredict string
23702
23703                                 PlaceSnd, PlaceFailSnd SoundDef
23704
23705                                 PointRange float32
23706
23707                                 // Set index in Palette with "palette_index" item meta field,
23708                                 // this overrides Color.
23709                                 Palette Texture
23710                                 Color   color.NRGBA
23711
23712                                 // Texture overlays.
23713                                 InvOverlay, WieldOverlay Texture
23714
23715                                 ShortDesc string
23716                         }))(obj)).Desc))))
23717                         write16(w, uint16(x))
23718                 }
23719                 {
23720                         _, err := w.Write(([]byte((*(*(struct {
23721                                 Type ItemType
23722
23723                                 Name, Desc string
23724
23725                                 InvImg, WieldImg Texture
23726                                 WieldScale       [3]float32
23727
23728                                 StackMax uint16
23729
23730                                 Usable          bool
23731                                 CanPointLiquids bool
23732
23733                                 ToolCaps ToolCaps
23734
23735                                 Groups []Group
23736
23737                                 PlacePredict string
23738
23739                                 PlaceSnd, PlaceFailSnd SoundDef
23740
23741                                 PointRange float32
23742
23743                                 // Set index in Palette with "palette_index" item meta field,
23744                                 // this overrides Color.
23745                                 Palette Texture
23746                                 Color   color.NRGBA
23747
23748                                 // Texture overlays.
23749                                 InvOverlay, WieldOverlay Texture
23750
23751                                 ShortDesc string
23752                         }))(obj)).Desc))[:])
23753                         chk(err)
23754                 }
23755                 if err := pcall(func() {
23756                         ((*(*(struct {
23757                                 Type ItemType
23758
23759                                 Name, Desc string
23760
23761                                 InvImg, WieldImg Texture
23762                                 WieldScale       [3]float32
23763
23764                                 StackMax uint16
23765
23766                                 Usable          bool
23767                                 CanPointLiquids bool
23768
23769                                 ToolCaps ToolCaps
23770
23771                                 Groups []Group
23772
23773                                 PlacePredict string
23774
23775                                 PlaceSnd, PlaceFailSnd SoundDef
23776
23777                                 PointRange float32
23778
23779                                 // Set index in Palette with "palette_index" item meta field,
23780                                 // this overrides Color.
23781                                 Palette Texture
23782                                 Color   color.NRGBA
23783
23784                                 // Texture overlays.
23785                                 InvOverlay, WieldOverlay Texture
23786
23787                                 ShortDesc string
23788                         }))(obj)).InvImg).serialize(w)
23789                 }); err != nil {
23790                         if err == io.EOF {
23791                                 chk(io.EOF)
23792                         }
23793                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
23794                 }
23795                 if err := pcall(func() {
23796                         ((*(*(struct {
23797                                 Type ItemType
23798
23799                                 Name, Desc string
23800
23801                                 InvImg, WieldImg Texture
23802                                 WieldScale       [3]float32
23803
23804                                 StackMax uint16
23805
23806                                 Usable          bool
23807                                 CanPointLiquids bool
23808
23809                                 ToolCaps ToolCaps
23810
23811                                 Groups []Group
23812
23813                                 PlacePredict string
23814
23815                                 PlaceSnd, PlaceFailSnd SoundDef
23816
23817                                 PointRange float32
23818
23819                                 // Set index in Palette with "palette_index" item meta field,
23820                                 // this overrides Color.
23821                                 Palette Texture
23822                                 Color   color.NRGBA
23823
23824                                 // Texture overlays.
23825                                 InvOverlay, WieldOverlay Texture
23826
23827                                 ShortDesc string
23828                         }))(obj)).WieldImg).serialize(w)
23829                 }); err != nil {
23830                         if err == io.EOF {
23831                                 chk(io.EOF)
23832                         }
23833                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
23834                 }
23835                 for local300 := range (*(*(struct {
23836                         Type ItemType
23837
23838                         Name, Desc string
23839
23840                         InvImg, WieldImg Texture
23841                         WieldScale       [3]float32
23842
23843                         StackMax uint16
23844
23845                         Usable          bool
23846                         CanPointLiquids bool
23847
23848                         ToolCaps ToolCaps
23849
23850                         Groups []Group
23851
23852                         PlacePredict string
23853
23854                         PlaceSnd, PlaceFailSnd SoundDef
23855
23856                         PointRange float32
23857
23858                         // Set index in Palette with "palette_index" item meta field,
23859                         // this overrides Color.
23860                         Palette Texture
23861                         Color   color.NRGBA
23862
23863                         // Texture overlays.
23864                         InvOverlay, WieldOverlay Texture
23865
23866                         ShortDesc string
23867                 }))(obj)).WieldScale {
23868                         {
23869                                 x := ((*(*(struct {
23870                                         Type ItemType
23871
23872                                         Name, Desc string
23873
23874                                         InvImg, WieldImg Texture
23875                                         WieldScale       [3]float32
23876
23877                                         StackMax uint16
23878
23879                                         Usable          bool
23880                                         CanPointLiquids bool
23881
23882                                         ToolCaps ToolCaps
23883
23884                                         Groups []Group
23885
23886                                         PlacePredict string
23887
23888                                         PlaceSnd, PlaceFailSnd SoundDef
23889
23890                                         PointRange float32
23891
23892                                         // Set index in Palette with "palette_index" item meta field,
23893                                         // this overrides Color.
23894                                         Palette Texture
23895                                         Color   color.NRGBA
23896
23897                                         // Texture overlays.
23898                                         InvOverlay, WieldOverlay Texture
23899
23900                                         ShortDesc string
23901                                 }))(obj)).WieldScale)[local300]
23902                                 write32(w, math.Float32bits(x))
23903                         }
23904                 }
23905                 {
23906                         x := (*(*(struct {
23907                                 Type ItemType
23908
23909                                 Name, Desc string
23910
23911                                 InvImg, WieldImg Texture
23912                                 WieldScale       [3]float32
23913
23914                                 StackMax uint16
23915
23916                                 Usable          bool
23917                                 CanPointLiquids bool
23918
23919                                 ToolCaps ToolCaps
23920
23921                                 Groups []Group
23922
23923                                 PlacePredict string
23924
23925                                 PlaceSnd, PlaceFailSnd SoundDef
23926
23927                                 PointRange float32
23928
23929                                 // Set index in Palette with "palette_index" item meta field,
23930                                 // this overrides Color.
23931                                 Palette Texture
23932                                 Color   color.NRGBA
23933
23934                                 // Texture overlays.
23935                                 InvOverlay, WieldOverlay Texture
23936
23937                                 ShortDesc string
23938                         }))(obj)).StackMax
23939                         write16(w, uint16(x))
23940                 }
23941                 {
23942                         x := (*(*(struct {
23943                                 Type ItemType
23944
23945                                 Name, Desc string
23946
23947                                 InvImg, WieldImg Texture
23948                                 WieldScale       [3]float32
23949
23950                                 StackMax uint16
23951
23952                                 Usable          bool
23953                                 CanPointLiquids bool
23954
23955                                 ToolCaps ToolCaps
23956
23957                                 Groups []Group
23958
23959                                 PlacePredict string
23960
23961                                 PlaceSnd, PlaceFailSnd SoundDef
23962
23963                                 PointRange float32
23964
23965                                 // Set index in Palette with "palette_index" item meta field,
23966                                 // this overrides Color.
23967                                 Palette Texture
23968                                 Color   color.NRGBA
23969
23970                                 // Texture overlays.
23971                                 InvOverlay, WieldOverlay Texture
23972
23973                                 ShortDesc string
23974                         }))(obj)).Usable
23975                         if x {
23976                                 write8(w, 1)
23977                         } else {
23978                                 write8(w, 0)
23979                         }
23980
23981                 }
23982                 {
23983                         x := (*(*(struct {
23984                                 Type ItemType
23985
23986                                 Name, Desc string
23987
23988                                 InvImg, WieldImg Texture
23989                                 WieldScale       [3]float32
23990
23991                                 StackMax uint16
23992
23993                                 Usable          bool
23994                                 CanPointLiquids bool
23995
23996                                 ToolCaps ToolCaps
23997
23998                                 Groups []Group
23999
24000                                 PlacePredict string
24001
24002                                 PlaceSnd, PlaceFailSnd SoundDef
24003
24004                                 PointRange float32
24005
24006                                 // Set index in Palette with "palette_index" item meta field,
24007                                 // this overrides Color.
24008                                 Palette Texture
24009                                 Color   color.NRGBA
24010
24011                                 // Texture overlays.
24012                                 InvOverlay, WieldOverlay Texture
24013
24014                                 ShortDesc string
24015                         }))(obj)).CanPointLiquids
24016                         if x {
24017                                 write8(w, 1)
24018                         } else {
24019                                 write8(w, 0)
24020                         }
24021
24022                 }
24023                 if err := pcall(func() {
24024                         ((*(*(struct {
24025                                 Type ItemType
24026
24027                                 Name, Desc string
24028
24029                                 InvImg, WieldImg Texture
24030                                 WieldScale       [3]float32
24031
24032                                 StackMax uint16
24033
24034                                 Usable          bool
24035                                 CanPointLiquids bool
24036
24037                                 ToolCaps ToolCaps
24038
24039                                 Groups []Group
24040
24041                                 PlacePredict string
24042
24043                                 PlaceSnd, PlaceFailSnd SoundDef
24044
24045                                 PointRange float32
24046
24047                                 // Set index in Palette with "palette_index" item meta field,
24048                                 // this overrides Color.
24049                                 Palette Texture
24050                                 Color   color.NRGBA
24051
24052                                 // Texture overlays.
24053                                 InvOverlay, WieldOverlay Texture
24054
24055                                 ShortDesc string
24056                         }))(obj)).ToolCaps).serialize(w)
24057                 }); err != nil {
24058                         if err == io.EOF {
24059                                 chk(io.EOF)
24060                         }
24061                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
24062                 }
24063                 if len(((*(*(struct {
24064                         Type ItemType
24065
24066                         Name, Desc string
24067
24068                         InvImg, WieldImg Texture
24069                         WieldScale       [3]float32
24070
24071                         StackMax uint16
24072
24073                         Usable          bool
24074                         CanPointLiquids bool
24075
24076                         ToolCaps ToolCaps
24077
24078                         Groups []Group
24079
24080                         PlacePredict string
24081
24082                         PlaceSnd, PlaceFailSnd SoundDef
24083
24084                         PointRange float32
24085
24086                         // Set index in Palette with "palette_index" item meta field,
24087                         // this overrides Color.
24088                         Palette Texture
24089                         Color   color.NRGBA
24090
24091                         // Texture overlays.
24092                         InvOverlay, WieldOverlay Texture
24093
24094                         ShortDesc string
24095                 }))(obj)).Groups)) > math.MaxUint16 {
24096                         chk(ErrTooLong)
24097                 }
24098                 {
24099                         x := uint16(len(((*(*(struct {
24100                                 Type ItemType
24101
24102                                 Name, Desc string
24103
24104                                 InvImg, WieldImg Texture
24105                                 WieldScale       [3]float32
24106
24107                                 StackMax uint16
24108
24109                                 Usable          bool
24110                                 CanPointLiquids bool
24111
24112                                 ToolCaps ToolCaps
24113
24114                                 Groups []Group
24115
24116                                 PlacePredict string
24117
24118                                 PlaceSnd, PlaceFailSnd SoundDef
24119
24120                                 PointRange float32
24121
24122                                 // Set index in Palette with "palette_index" item meta field,
24123                                 // this overrides Color.
24124                                 Palette Texture
24125                                 Color   color.NRGBA
24126
24127                                 // Texture overlays.
24128                                 InvOverlay, WieldOverlay Texture
24129
24130                                 ShortDesc string
24131                         }))(obj)).Groups)))
24132                         write16(w, uint16(x))
24133                 }
24134                 for local301 := range (*(*(struct {
24135                         Type ItemType
24136
24137                         Name, Desc string
24138
24139                         InvImg, WieldImg Texture
24140                         WieldScale       [3]float32
24141
24142                         StackMax uint16
24143
24144                         Usable          bool
24145                         CanPointLiquids bool
24146
24147                         ToolCaps ToolCaps
24148
24149                         Groups []Group
24150
24151                         PlacePredict string
24152
24153                         PlaceSnd, PlaceFailSnd SoundDef
24154
24155                         PointRange float32
24156
24157                         // Set index in Palette with "palette_index" item meta field,
24158                         // this overrides Color.
24159                         Palette Texture
24160                         Color   color.NRGBA
24161
24162                         // Texture overlays.
24163                         InvOverlay, WieldOverlay Texture
24164
24165                         ShortDesc string
24166                 }))(obj)).Groups {
24167                         if err := pcall(func() {
24168                                 (((*(*(struct {
24169                                         Type ItemType
24170
24171                                         Name, Desc string
24172
24173                                         InvImg, WieldImg Texture
24174                                         WieldScale       [3]float32
24175
24176                                         StackMax uint16
24177
24178                                         Usable          bool
24179                                         CanPointLiquids bool
24180
24181                                         ToolCaps ToolCaps
24182
24183                                         Groups []Group
24184
24185                                         PlacePredict string
24186
24187                                         PlaceSnd, PlaceFailSnd SoundDef
24188
24189                                         PointRange float32
24190
24191                                         // Set index in Palette with "palette_index" item meta field,
24192                                         // this overrides Color.
24193                                         Palette Texture
24194                                         Color   color.NRGBA
24195
24196                                         // Texture overlays.
24197                                         InvOverlay, WieldOverlay Texture
24198
24199                                         ShortDesc string
24200                                 }))(obj)).Groups)[local301]).serialize(w)
24201                         }); err != nil {
24202                                 if err == io.EOF {
24203                                         chk(io.EOF)
24204                                 }
24205                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
24206                         }
24207                 }
24208                 if len(([]byte((*(*(struct {
24209                         Type ItemType
24210
24211                         Name, Desc string
24212
24213                         InvImg, WieldImg Texture
24214                         WieldScale       [3]float32
24215
24216                         StackMax uint16
24217
24218                         Usable          bool
24219                         CanPointLiquids bool
24220
24221                         ToolCaps ToolCaps
24222
24223                         Groups []Group
24224
24225                         PlacePredict string
24226
24227                         PlaceSnd, PlaceFailSnd SoundDef
24228
24229                         PointRange float32
24230
24231                         // Set index in Palette with "palette_index" item meta field,
24232                         // this overrides Color.
24233                         Palette Texture
24234                         Color   color.NRGBA
24235
24236                         // Texture overlays.
24237                         InvOverlay, WieldOverlay Texture
24238
24239                         ShortDesc string
24240                 }))(obj)).PlacePredict))) > math.MaxUint16 {
24241                         chk(ErrTooLong)
24242                 }
24243                 {
24244                         x := uint16(len(([]byte((*(*(struct {
24245                                 Type ItemType
24246
24247                                 Name, Desc string
24248
24249                                 InvImg, WieldImg Texture
24250                                 WieldScale       [3]float32
24251
24252                                 StackMax uint16
24253
24254                                 Usable          bool
24255                                 CanPointLiquids bool
24256
24257                                 ToolCaps ToolCaps
24258
24259                                 Groups []Group
24260
24261                                 PlacePredict string
24262
24263                                 PlaceSnd, PlaceFailSnd SoundDef
24264
24265                                 PointRange float32
24266
24267                                 // Set index in Palette with "palette_index" item meta field,
24268                                 // this overrides Color.
24269                                 Palette Texture
24270                                 Color   color.NRGBA
24271
24272                                 // Texture overlays.
24273                                 InvOverlay, WieldOverlay Texture
24274
24275                                 ShortDesc string
24276                         }))(obj)).PlacePredict))))
24277                         write16(w, uint16(x))
24278                 }
24279                 {
24280                         _, err := w.Write(([]byte((*(*(struct {
24281                                 Type ItemType
24282
24283                                 Name, Desc string
24284
24285                                 InvImg, WieldImg Texture
24286                                 WieldScale       [3]float32
24287
24288                                 StackMax uint16
24289
24290                                 Usable          bool
24291                                 CanPointLiquids bool
24292
24293                                 ToolCaps ToolCaps
24294
24295                                 Groups []Group
24296
24297                                 PlacePredict string
24298
24299                                 PlaceSnd, PlaceFailSnd SoundDef
24300
24301                                 PointRange float32
24302
24303                                 // Set index in Palette with "palette_index" item meta field,
24304                                 // this overrides Color.
24305                                 Palette Texture
24306                                 Color   color.NRGBA
24307
24308                                 // Texture overlays.
24309                                 InvOverlay, WieldOverlay Texture
24310
24311                                 ShortDesc string
24312                         }))(obj)).PlacePredict))[:])
24313                         chk(err)
24314                 }
24315                 if err := pcall(func() {
24316                         ((*(*(struct {
24317                                 Type ItemType
24318
24319                                 Name, Desc string
24320
24321                                 InvImg, WieldImg Texture
24322                                 WieldScale       [3]float32
24323
24324                                 StackMax uint16
24325
24326                                 Usable          bool
24327                                 CanPointLiquids bool
24328
24329                                 ToolCaps ToolCaps
24330
24331                                 Groups []Group
24332
24333                                 PlacePredict string
24334
24335                                 PlaceSnd, PlaceFailSnd SoundDef
24336
24337                                 PointRange float32
24338
24339                                 // Set index in Palette with "palette_index" item meta field,
24340                                 // this overrides Color.
24341                                 Palette Texture
24342                                 Color   color.NRGBA
24343
24344                                 // Texture overlays.
24345                                 InvOverlay, WieldOverlay Texture
24346
24347                                 ShortDesc string
24348                         }))(obj)).PlaceSnd).serialize(w)
24349                 }); err != nil {
24350                         if err == io.EOF {
24351                                 chk(io.EOF)
24352                         }
24353                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
24354                 }
24355                 if err := pcall(func() {
24356                         ((*(*(struct {
24357                                 Type ItemType
24358
24359                                 Name, Desc string
24360
24361                                 InvImg, WieldImg Texture
24362                                 WieldScale       [3]float32
24363
24364                                 StackMax uint16
24365
24366                                 Usable          bool
24367                                 CanPointLiquids bool
24368
24369                                 ToolCaps ToolCaps
24370
24371                                 Groups []Group
24372
24373                                 PlacePredict string
24374
24375                                 PlaceSnd, PlaceFailSnd SoundDef
24376
24377                                 PointRange float32
24378
24379                                 // Set index in Palette with "palette_index" item meta field,
24380                                 // this overrides Color.
24381                                 Palette Texture
24382                                 Color   color.NRGBA
24383
24384                                 // Texture overlays.
24385                                 InvOverlay, WieldOverlay Texture
24386
24387                                 ShortDesc string
24388                         }))(obj)).PlaceFailSnd).serialize(w)
24389                 }); err != nil {
24390                         if err == io.EOF {
24391                                 chk(io.EOF)
24392                         }
24393                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
24394                 }
24395                 {
24396                         x := (*(*(struct {
24397                                 Type ItemType
24398
24399                                 Name, Desc string
24400
24401                                 InvImg, WieldImg Texture
24402                                 WieldScale       [3]float32
24403
24404                                 StackMax uint16
24405
24406                                 Usable          bool
24407                                 CanPointLiquids bool
24408
24409                                 ToolCaps ToolCaps
24410
24411                                 Groups []Group
24412
24413                                 PlacePredict string
24414
24415                                 PlaceSnd, PlaceFailSnd SoundDef
24416
24417                                 PointRange float32
24418
24419                                 // Set index in Palette with "palette_index" item meta field,
24420                                 // this overrides Color.
24421                                 Palette Texture
24422                                 Color   color.NRGBA
24423
24424                                 // Texture overlays.
24425                                 InvOverlay, WieldOverlay Texture
24426
24427                                 ShortDesc string
24428                         }))(obj)).PointRange
24429                         write32(w, math.Float32bits(x))
24430                 }
24431                 if err := pcall(func() {
24432                         ((*(*(struct {
24433                                 Type ItemType
24434
24435                                 Name, Desc string
24436
24437                                 InvImg, WieldImg Texture
24438                                 WieldScale       [3]float32
24439
24440                                 StackMax uint16
24441
24442                                 Usable          bool
24443                                 CanPointLiquids bool
24444
24445                                 ToolCaps ToolCaps
24446
24447                                 Groups []Group
24448
24449                                 PlacePredict string
24450
24451                                 PlaceSnd, PlaceFailSnd SoundDef
24452
24453                                 PointRange float32
24454
24455                                 // Set index in Palette with "palette_index" item meta field,
24456                                 // this overrides Color.
24457                                 Palette Texture
24458                                 Color   color.NRGBA
24459
24460                                 // Texture overlays.
24461                                 InvOverlay, WieldOverlay Texture
24462
24463                                 ShortDesc string
24464                         }))(obj)).Palette).serialize(w)
24465                 }); err != nil {
24466                         if err == io.EOF {
24467                                 chk(io.EOF)
24468                         }
24469                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24470                 }
24471                 {
24472                         x := (*(*(struct {
24473                                 Type ItemType
24474
24475                                 Name, Desc string
24476
24477                                 InvImg, WieldImg Texture
24478                                 WieldScale       [3]float32
24479
24480                                 StackMax uint16
24481
24482                                 Usable          bool
24483                                 CanPointLiquids bool
24484
24485                                 ToolCaps ToolCaps
24486
24487                                 Groups []Group
24488
24489                                 PlacePredict string
24490
24491                                 PlaceSnd, PlaceFailSnd SoundDef
24492
24493                                 PointRange float32
24494
24495                                 // Set index in Palette with "palette_index" item meta field,
24496                                 // this overrides Color.
24497                                 Palette Texture
24498                                 Color   color.NRGBA
24499
24500                                 // Texture overlays.
24501                                 InvOverlay, WieldOverlay Texture
24502
24503                                 ShortDesc string
24504                         }))(obj)).Color
24505                         w.Write([]byte{x.A, x.R, x.G, x.B})
24506
24507                 }
24508                 if err := pcall(func() {
24509                         ((*(*(struct {
24510                                 Type ItemType
24511
24512                                 Name, Desc string
24513
24514                                 InvImg, WieldImg Texture
24515                                 WieldScale       [3]float32
24516
24517                                 StackMax uint16
24518
24519                                 Usable          bool
24520                                 CanPointLiquids bool
24521
24522                                 ToolCaps ToolCaps
24523
24524                                 Groups []Group
24525
24526                                 PlacePredict string
24527
24528                                 PlaceSnd, PlaceFailSnd SoundDef
24529
24530                                 PointRange float32
24531
24532                                 // Set index in Palette with "palette_index" item meta field,
24533                                 // this overrides Color.
24534                                 Palette Texture
24535                                 Color   color.NRGBA
24536
24537                                 // Texture overlays.
24538                                 InvOverlay, WieldOverlay Texture
24539
24540                                 ShortDesc string
24541                         }))(obj)).InvOverlay).serialize(w)
24542                 }); err != nil {
24543                         if err == io.EOF {
24544                                 chk(io.EOF)
24545                         }
24546                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24547                 }
24548                 if err := pcall(func() {
24549                         ((*(*(struct {
24550                                 Type ItemType
24551
24552                                 Name, Desc string
24553
24554                                 InvImg, WieldImg Texture
24555                                 WieldScale       [3]float32
24556
24557                                 StackMax uint16
24558
24559                                 Usable          bool
24560                                 CanPointLiquids bool
24561
24562                                 ToolCaps ToolCaps
24563
24564                                 Groups []Group
24565
24566                                 PlacePredict string
24567
24568                                 PlaceSnd, PlaceFailSnd SoundDef
24569
24570                                 PointRange float32
24571
24572                                 // Set index in Palette with "palette_index" item meta field,
24573                                 // this overrides Color.
24574                                 Palette Texture
24575                                 Color   color.NRGBA
24576
24577                                 // Texture overlays.
24578                                 InvOverlay, WieldOverlay Texture
24579
24580                                 ShortDesc string
24581                         }))(obj)).WieldOverlay).serialize(w)
24582                 }); err != nil {
24583                         if err == io.EOF {
24584                                 chk(io.EOF)
24585                         }
24586                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24587                 }
24588                 if len(([]byte((*(*(struct {
24589                         Type ItemType
24590
24591                         Name, Desc string
24592
24593                         InvImg, WieldImg Texture
24594                         WieldScale       [3]float32
24595
24596                         StackMax uint16
24597
24598                         Usable          bool
24599                         CanPointLiquids bool
24600
24601                         ToolCaps ToolCaps
24602
24603                         Groups []Group
24604
24605                         PlacePredict string
24606
24607                         PlaceSnd, PlaceFailSnd SoundDef
24608
24609                         PointRange float32
24610
24611                         // Set index in Palette with "palette_index" item meta field,
24612                         // this overrides Color.
24613                         Palette Texture
24614                         Color   color.NRGBA
24615
24616                         // Texture overlays.
24617                         InvOverlay, WieldOverlay Texture
24618
24619                         ShortDesc string
24620                 }))(obj)).ShortDesc))) > math.MaxUint16 {
24621                         chk(ErrTooLong)
24622                 }
24623                 {
24624                         x := uint16(len(([]byte((*(*(struct {
24625                                 Type ItemType
24626
24627                                 Name, Desc string
24628
24629                                 InvImg, WieldImg Texture
24630                                 WieldScale       [3]float32
24631
24632                                 StackMax uint16
24633
24634                                 Usable          bool
24635                                 CanPointLiquids bool
24636
24637                                 ToolCaps ToolCaps
24638
24639                                 Groups []Group
24640
24641                                 PlacePredict string
24642
24643                                 PlaceSnd, PlaceFailSnd SoundDef
24644
24645                                 PointRange float32
24646
24647                                 // Set index in Palette with "palette_index" item meta field,
24648                                 // this overrides Color.
24649                                 Palette Texture
24650                                 Color   color.NRGBA
24651
24652                                 // Texture overlays.
24653                                 InvOverlay, WieldOverlay Texture
24654
24655                                 ShortDesc string
24656                         }))(obj)).ShortDesc))))
24657                         write16(w, uint16(x))
24658                 }
24659                 {
24660                         _, err := w.Write(([]byte((*(*(struct {
24661                                 Type ItemType
24662
24663                                 Name, Desc string
24664
24665                                 InvImg, WieldImg Texture
24666                                 WieldScale       [3]float32
24667
24668                                 StackMax uint16
24669
24670                                 Usable          bool
24671                                 CanPointLiquids bool
24672
24673                                 ToolCaps ToolCaps
24674
24675                                 Groups []Group
24676
24677                                 PlacePredict string
24678
24679                                 PlaceSnd, PlaceFailSnd SoundDef
24680
24681                                 PointRange float32
24682
24683                                 // Set index in Palette with "palette_index" item meta field,
24684                                 // this overrides Color.
24685                                 Palette Texture
24686                                 Color   color.NRGBA
24687
24688                                 // Texture overlays.
24689                                 InvOverlay, WieldOverlay Texture
24690
24691                                 ShortDesc string
24692                         }))(obj)).ShortDesc))[:])
24693                         chk(err)
24694                 }
24695                 {
24696                         buf := w
24697                         w := ow
24698                         if len((buf.Bytes())) > math.MaxUint16 {
24699                                 chk(ErrTooLong)
24700                         }
24701                         {
24702                                 x := uint16(len((buf.Bytes())))
24703                                 write16(w, uint16(x))
24704                         }
24705                         {
24706                                 _, err := w.Write((buf.Bytes())[:])
24707                                 chk(err)
24708                         }
24709                 }
24710         }
24711 }
24712
24713 func (obj *ItemDef) deserialize(r io.Reader) {
24714         {
24715                 var n uint16
24716                 {
24717                         p := &n
24718                         *p = read16(r)
24719                 }
24720                 r := &io.LimitedReader{R: r, N: int64(n)}
24721                 {
24722                         var local302 uint8
24723                         local303 := uint8(6)
24724                         {
24725                                 p := &local302
24726                                 *p = read8(r)
24727                         }
24728                         if local302 != local303 {
24729                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local302))
24730                         }
24731                 }
24732                 if err := pcall(func() {
24733                         ((*(*(struct {
24734                                 Type ItemType
24735
24736                                 Name, Desc string
24737
24738                                 InvImg, WieldImg Texture
24739                                 WieldScale       [3]float32
24740
24741                                 StackMax uint16
24742
24743                                 Usable          bool
24744                                 CanPointLiquids bool
24745
24746                                 ToolCaps ToolCaps
24747
24748                                 Groups []Group
24749
24750                                 PlacePredict string
24751
24752                                 PlaceSnd, PlaceFailSnd SoundDef
24753
24754                                 PointRange float32
24755
24756                                 // Set index in Palette with "palette_index" item meta field,
24757                                 // this overrides Color.
24758                                 Palette Texture
24759                                 Color   color.NRGBA
24760
24761                                 // Texture overlays.
24762                                 InvOverlay, WieldOverlay Texture
24763
24764                                 ShortDesc string
24765                         }))(obj)).Type).deserialize(r)
24766                 }); err != nil {
24767                         if err == io.EOF {
24768                                 chk(io.EOF)
24769                         }
24770                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
24771                 }
24772                 var local304 []uint8
24773                 var local305 uint16
24774                 {
24775                         p := &local305
24776                         *p = read16(r)
24777                 }
24778                 (local304) = make([]uint8, local305)
24779                 {
24780                         _, err := io.ReadFull(r, (local304)[:])
24781                         chk(err)
24782                 }
24783                 ((*(*(struct {
24784                         Type ItemType
24785
24786                         Name, Desc string
24787
24788                         InvImg, WieldImg Texture
24789                         WieldScale       [3]float32
24790
24791                         StackMax uint16
24792
24793                         Usable          bool
24794                         CanPointLiquids bool
24795
24796                         ToolCaps ToolCaps
24797
24798                         Groups []Group
24799
24800                         PlacePredict string
24801
24802                         PlaceSnd, PlaceFailSnd SoundDef
24803
24804                         PointRange float32
24805
24806                         // Set index in Palette with "palette_index" item meta field,
24807                         // this overrides Color.
24808                         Palette Texture
24809                         Color   color.NRGBA
24810
24811                         // Texture overlays.
24812                         InvOverlay, WieldOverlay Texture
24813
24814                         ShortDesc string
24815                 }))(obj)).Name) = string(local304)
24816                 var local306 []uint8
24817                 var local307 uint16
24818                 {
24819                         p := &local307
24820                         *p = read16(r)
24821                 }
24822                 (local306) = make([]uint8, local307)
24823                 {
24824                         _, err := io.ReadFull(r, (local306)[:])
24825                         chk(err)
24826                 }
24827                 ((*(*(struct {
24828                         Type ItemType
24829
24830                         Name, Desc string
24831
24832                         InvImg, WieldImg Texture
24833                         WieldScale       [3]float32
24834
24835                         StackMax uint16
24836
24837                         Usable          bool
24838                         CanPointLiquids bool
24839
24840                         ToolCaps ToolCaps
24841
24842                         Groups []Group
24843
24844                         PlacePredict string
24845
24846                         PlaceSnd, PlaceFailSnd SoundDef
24847
24848                         PointRange float32
24849
24850                         // Set index in Palette with "palette_index" item meta field,
24851                         // this overrides Color.
24852                         Palette Texture
24853                         Color   color.NRGBA
24854
24855                         // Texture overlays.
24856                         InvOverlay, WieldOverlay Texture
24857
24858                         ShortDesc string
24859                 }))(obj)).Desc) = string(local306)
24860                 if err := pcall(func() {
24861                         ((*(*(struct {
24862                                 Type ItemType
24863
24864                                 Name, Desc string
24865
24866                                 InvImg, WieldImg Texture
24867                                 WieldScale       [3]float32
24868
24869                                 StackMax uint16
24870
24871                                 Usable          bool
24872                                 CanPointLiquids bool
24873
24874                                 ToolCaps ToolCaps
24875
24876                                 Groups []Group
24877
24878                                 PlacePredict string
24879
24880                                 PlaceSnd, PlaceFailSnd SoundDef
24881
24882                                 PointRange float32
24883
24884                                 // Set index in Palette with "palette_index" item meta field,
24885                                 // this overrides Color.
24886                                 Palette Texture
24887                                 Color   color.NRGBA
24888
24889                                 // Texture overlays.
24890                                 InvOverlay, WieldOverlay Texture
24891
24892                                 ShortDesc string
24893                         }))(obj)).InvImg).deserialize(r)
24894                 }); err != nil {
24895                         if err == io.EOF {
24896                                 chk(io.EOF)
24897                         }
24898                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24899                 }
24900                 if err := pcall(func() {
24901                         ((*(*(struct {
24902                                 Type ItemType
24903
24904                                 Name, Desc string
24905
24906                                 InvImg, WieldImg Texture
24907                                 WieldScale       [3]float32
24908
24909                                 StackMax uint16
24910
24911                                 Usable          bool
24912                                 CanPointLiquids bool
24913
24914                                 ToolCaps ToolCaps
24915
24916                                 Groups []Group
24917
24918                                 PlacePredict string
24919
24920                                 PlaceSnd, PlaceFailSnd SoundDef
24921
24922                                 PointRange float32
24923
24924                                 // Set index in Palette with "palette_index" item meta field,
24925                                 // this overrides Color.
24926                                 Palette Texture
24927                                 Color   color.NRGBA
24928
24929                                 // Texture overlays.
24930                                 InvOverlay, WieldOverlay Texture
24931
24932                                 ShortDesc string
24933                         }))(obj)).WieldImg).deserialize(r)
24934                 }); err != nil {
24935                         if err == io.EOF {
24936                                 chk(io.EOF)
24937                         }
24938                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24939                 }
24940                 for local308 := range (*(*(struct {
24941                         Type ItemType
24942
24943                         Name, Desc string
24944
24945                         InvImg, WieldImg Texture
24946                         WieldScale       [3]float32
24947
24948                         StackMax uint16
24949
24950                         Usable          bool
24951                         CanPointLiquids bool
24952
24953                         ToolCaps ToolCaps
24954
24955                         Groups []Group
24956
24957                         PlacePredict string
24958
24959                         PlaceSnd, PlaceFailSnd SoundDef
24960
24961                         PointRange float32
24962
24963                         // Set index in Palette with "palette_index" item meta field,
24964                         // this overrides Color.
24965                         Palette Texture
24966                         Color   color.NRGBA
24967
24968                         // Texture overlays.
24969                         InvOverlay, WieldOverlay Texture
24970
24971                         ShortDesc string
24972                 }))(obj)).WieldScale {
24973                         {
24974                                 p := &((*(*(struct {
24975                                         Type ItemType
24976
24977                                         Name, Desc string
24978
24979                                         InvImg, WieldImg Texture
24980                                         WieldScale       [3]float32
24981
24982                                         StackMax uint16
24983
24984                                         Usable          bool
24985                                         CanPointLiquids bool
24986
24987                                         ToolCaps ToolCaps
24988
24989                                         Groups []Group
24990
24991                                         PlacePredict string
24992
24993                                         PlaceSnd, PlaceFailSnd SoundDef
24994
24995                                         PointRange float32
24996
24997                                         // Set index in Palette with "palette_index" item meta field,
24998                                         // this overrides Color.
24999                                         Palette Texture
25000                                         Color   color.NRGBA
25001
25002                                         // Texture overlays.
25003                                         InvOverlay, WieldOverlay Texture
25004
25005                                         ShortDesc string
25006                                 }))(obj)).WieldScale)[local308]
25007                                 *p = math.Float32frombits(read32(r))
25008                         }
25009                 }
25010                 {
25011                         p := &(*(*(struct {
25012                                 Type ItemType
25013
25014                                 Name, Desc string
25015
25016                                 InvImg, WieldImg Texture
25017                                 WieldScale       [3]float32
25018
25019                                 StackMax uint16
25020
25021                                 Usable          bool
25022                                 CanPointLiquids bool
25023
25024                                 ToolCaps ToolCaps
25025
25026                                 Groups []Group
25027
25028                                 PlacePredict string
25029
25030                                 PlaceSnd, PlaceFailSnd SoundDef
25031
25032                                 PointRange float32
25033
25034                                 // Set index in Palette with "palette_index" item meta field,
25035                                 // this overrides Color.
25036                                 Palette Texture
25037                                 Color   color.NRGBA
25038
25039                                 // Texture overlays.
25040                                 InvOverlay, WieldOverlay Texture
25041
25042                                 ShortDesc string
25043                         }))(obj)).StackMax
25044                         *p = read16(r)
25045                 }
25046                 {
25047                         p := &(*(*(struct {
25048                                 Type ItemType
25049
25050                                 Name, Desc string
25051
25052                                 InvImg, WieldImg Texture
25053                                 WieldScale       [3]float32
25054
25055                                 StackMax uint16
25056
25057                                 Usable          bool
25058                                 CanPointLiquids bool
25059
25060                                 ToolCaps ToolCaps
25061
25062                                 Groups []Group
25063
25064                                 PlacePredict string
25065
25066                                 PlaceSnd, PlaceFailSnd SoundDef
25067
25068                                 PointRange float32
25069
25070                                 // Set index in Palette with "palette_index" item meta field,
25071                                 // this overrides Color.
25072                                 Palette Texture
25073                                 Color   color.NRGBA
25074
25075                                 // Texture overlays.
25076                                 InvOverlay, WieldOverlay Texture
25077
25078                                 ShortDesc string
25079                         }))(obj)).Usable
25080                         switch n := read8(r); n {
25081                         case 0:
25082                                 *p = false
25083                         case 1:
25084                                 *p = true
25085                         default:
25086                                 chk(fmt.Errorf("invalid bool: %d", n))
25087                         }
25088
25089                 }
25090                 {
25091                         p := &(*(*(struct {
25092                                 Type ItemType
25093
25094                                 Name, Desc string
25095
25096                                 InvImg, WieldImg Texture
25097                                 WieldScale       [3]float32
25098
25099                                 StackMax uint16
25100
25101                                 Usable          bool
25102                                 CanPointLiquids bool
25103
25104                                 ToolCaps ToolCaps
25105
25106                                 Groups []Group
25107
25108                                 PlacePredict string
25109
25110                                 PlaceSnd, PlaceFailSnd SoundDef
25111
25112                                 PointRange float32
25113
25114                                 // Set index in Palette with "palette_index" item meta field,
25115                                 // this overrides Color.
25116                                 Palette Texture
25117                                 Color   color.NRGBA
25118
25119                                 // Texture overlays.
25120                                 InvOverlay, WieldOverlay Texture
25121
25122                                 ShortDesc string
25123                         }))(obj)).CanPointLiquids
25124                         switch n := read8(r); n {
25125                         case 0:
25126                                 *p = false
25127                         case 1:
25128                                 *p = true
25129                         default:
25130                                 chk(fmt.Errorf("invalid bool: %d", n))
25131                         }
25132
25133                 }
25134                 if err := pcall(func() {
25135                         ((*(*(struct {
25136                                 Type ItemType
25137
25138                                 Name, Desc string
25139
25140                                 InvImg, WieldImg Texture
25141                                 WieldScale       [3]float32
25142
25143                                 StackMax uint16
25144
25145                                 Usable          bool
25146                                 CanPointLiquids bool
25147
25148                                 ToolCaps ToolCaps
25149
25150                                 Groups []Group
25151
25152                                 PlacePredict string
25153
25154                                 PlaceSnd, PlaceFailSnd SoundDef
25155
25156                                 PointRange float32
25157
25158                                 // Set index in Palette with "palette_index" item meta field,
25159                                 // this overrides Color.
25160                                 Palette Texture
25161                                 Color   color.NRGBA
25162
25163                                 // Texture overlays.
25164                                 InvOverlay, WieldOverlay Texture
25165
25166                                 ShortDesc string
25167                         }))(obj)).ToolCaps).deserialize(r)
25168                 }); err != nil {
25169                         if err == io.EOF {
25170                                 chk(io.EOF)
25171                         }
25172                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
25173                 }
25174                 var local309 uint16
25175                 {
25176                         p := &local309
25177                         *p = read16(r)
25178                 }
25179                 ((*(*(struct {
25180                         Type ItemType
25181
25182                         Name, Desc string
25183
25184                         InvImg, WieldImg Texture
25185                         WieldScale       [3]float32
25186
25187                         StackMax uint16
25188
25189                         Usable          bool
25190                         CanPointLiquids bool
25191
25192                         ToolCaps ToolCaps
25193
25194                         Groups []Group
25195
25196                         PlacePredict string
25197
25198                         PlaceSnd, PlaceFailSnd SoundDef
25199
25200                         PointRange float32
25201
25202                         // Set index in Palette with "palette_index" item meta field,
25203                         // this overrides Color.
25204                         Palette Texture
25205                         Color   color.NRGBA
25206
25207                         // Texture overlays.
25208                         InvOverlay, WieldOverlay Texture
25209
25210                         ShortDesc string
25211                 }))(obj)).Groups) = make([]Group, local309)
25212                 for local310 := range (*(*(struct {
25213                         Type ItemType
25214
25215                         Name, Desc string
25216
25217                         InvImg, WieldImg Texture
25218                         WieldScale       [3]float32
25219
25220                         StackMax uint16
25221
25222                         Usable          bool
25223                         CanPointLiquids bool
25224
25225                         ToolCaps ToolCaps
25226
25227                         Groups []Group
25228
25229                         PlacePredict string
25230
25231                         PlaceSnd, PlaceFailSnd SoundDef
25232
25233                         PointRange float32
25234
25235                         // Set index in Palette with "palette_index" item meta field,
25236                         // this overrides Color.
25237                         Palette Texture
25238                         Color   color.NRGBA
25239
25240                         // Texture overlays.
25241                         InvOverlay, WieldOverlay Texture
25242
25243                         ShortDesc string
25244                 }))(obj)).Groups {
25245                         if err := pcall(func() {
25246                                 (((*(*(struct {
25247                                         Type ItemType
25248
25249                                         Name, Desc string
25250
25251                                         InvImg, WieldImg Texture
25252                                         WieldScale       [3]float32
25253
25254                                         StackMax uint16
25255
25256                                         Usable          bool
25257                                         CanPointLiquids bool
25258
25259                                         ToolCaps ToolCaps
25260
25261                                         Groups []Group
25262
25263                                         PlacePredict string
25264
25265                                         PlaceSnd, PlaceFailSnd SoundDef
25266
25267                                         PointRange float32
25268
25269                                         // Set index in Palette with "palette_index" item meta field,
25270                                         // this overrides Color.
25271                                         Palette Texture
25272                                         Color   color.NRGBA
25273
25274                                         // Texture overlays.
25275                                         InvOverlay, WieldOverlay Texture
25276
25277                                         ShortDesc string
25278                                 }))(obj)).Groups)[local310]).deserialize(r)
25279                         }); err != nil {
25280                                 if err == io.EOF {
25281                                         chk(io.EOF)
25282                                 }
25283                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
25284                         }
25285                 }
25286                 var local311 []uint8
25287                 var local312 uint16
25288                 {
25289                         p := &local312
25290                         *p = read16(r)
25291                 }
25292                 (local311) = make([]uint8, local312)
25293                 {
25294                         _, err := io.ReadFull(r, (local311)[:])
25295                         chk(err)
25296                 }
25297                 ((*(*(struct {
25298                         Type ItemType
25299
25300                         Name, Desc string
25301
25302                         InvImg, WieldImg Texture
25303                         WieldScale       [3]float32
25304
25305                         StackMax uint16
25306
25307                         Usable          bool
25308                         CanPointLiquids bool
25309
25310                         ToolCaps ToolCaps
25311
25312                         Groups []Group
25313
25314                         PlacePredict string
25315
25316                         PlaceSnd, PlaceFailSnd SoundDef
25317
25318                         PointRange float32
25319
25320                         // Set index in Palette with "palette_index" item meta field,
25321                         // this overrides Color.
25322                         Palette Texture
25323                         Color   color.NRGBA
25324
25325                         // Texture overlays.
25326                         InvOverlay, WieldOverlay Texture
25327
25328                         ShortDesc string
25329                 }))(obj)).PlacePredict) = string(local311)
25330                 if err := pcall(func() {
25331                         ((*(*(struct {
25332                                 Type ItemType
25333
25334                                 Name, Desc string
25335
25336                                 InvImg, WieldImg Texture
25337                                 WieldScale       [3]float32
25338
25339                                 StackMax uint16
25340
25341                                 Usable          bool
25342                                 CanPointLiquids bool
25343
25344                                 ToolCaps ToolCaps
25345
25346                                 Groups []Group
25347
25348                                 PlacePredict string
25349
25350                                 PlaceSnd, PlaceFailSnd SoundDef
25351
25352                                 PointRange float32
25353
25354                                 // Set index in Palette with "palette_index" item meta field,
25355                                 // this overrides Color.
25356                                 Palette Texture
25357                                 Color   color.NRGBA
25358
25359                                 // Texture overlays.
25360                                 InvOverlay, WieldOverlay Texture
25361
25362                                 ShortDesc string
25363                         }))(obj)).PlaceSnd).deserialize(r)
25364                 }); err != nil {
25365                         if err == io.EOF {
25366                                 chk(io.EOF)
25367                         }
25368                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25369                 }
25370                 if err := pcall(func() {
25371                         ((*(*(struct {
25372                                 Type ItemType
25373
25374                                 Name, Desc string
25375
25376                                 InvImg, WieldImg Texture
25377                                 WieldScale       [3]float32
25378
25379                                 StackMax uint16
25380
25381                                 Usable          bool
25382                                 CanPointLiquids bool
25383
25384                                 ToolCaps ToolCaps
25385
25386                                 Groups []Group
25387
25388                                 PlacePredict string
25389
25390                                 PlaceSnd, PlaceFailSnd SoundDef
25391
25392                                 PointRange float32
25393
25394                                 // Set index in Palette with "palette_index" item meta field,
25395                                 // this overrides Color.
25396                                 Palette Texture
25397                                 Color   color.NRGBA
25398
25399                                 // Texture overlays.
25400                                 InvOverlay, WieldOverlay Texture
25401
25402                                 ShortDesc string
25403                         }))(obj)).PlaceFailSnd).deserialize(r)
25404                 }); err != nil {
25405                         if err == io.EOF {
25406                                 chk(io.EOF)
25407                         }
25408                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25409                 }
25410                 {
25411                         p := &(*(*(struct {
25412                                 Type ItemType
25413
25414                                 Name, Desc string
25415
25416                                 InvImg, WieldImg Texture
25417                                 WieldScale       [3]float32
25418
25419                                 StackMax uint16
25420
25421                                 Usable          bool
25422                                 CanPointLiquids bool
25423
25424                                 ToolCaps ToolCaps
25425
25426                                 Groups []Group
25427
25428                                 PlacePredict string
25429
25430                                 PlaceSnd, PlaceFailSnd SoundDef
25431
25432                                 PointRange float32
25433
25434                                 // Set index in Palette with "palette_index" item meta field,
25435                                 // this overrides Color.
25436                                 Palette Texture
25437                                 Color   color.NRGBA
25438
25439                                 // Texture overlays.
25440                                 InvOverlay, WieldOverlay Texture
25441
25442                                 ShortDesc string
25443                         }))(obj)).PointRange
25444                         *p = math.Float32frombits(read32(r))
25445                 }
25446                 if err := pcall(func() {
25447                         ((*(*(struct {
25448                                 Type ItemType
25449
25450                                 Name, Desc string
25451
25452                                 InvImg, WieldImg Texture
25453                                 WieldScale       [3]float32
25454
25455                                 StackMax uint16
25456
25457                                 Usable          bool
25458                                 CanPointLiquids bool
25459
25460                                 ToolCaps ToolCaps
25461
25462                                 Groups []Group
25463
25464                                 PlacePredict string
25465
25466                                 PlaceSnd, PlaceFailSnd SoundDef
25467
25468                                 PointRange float32
25469
25470                                 // Set index in Palette with "palette_index" item meta field,
25471                                 // this overrides Color.
25472                                 Palette Texture
25473                                 Color   color.NRGBA
25474
25475                                 // Texture overlays.
25476                                 InvOverlay, WieldOverlay Texture
25477
25478                                 ShortDesc string
25479                         }))(obj)).Palette).deserialize(r)
25480                 }); err != nil {
25481                         if err == io.EOF {
25482                                 chk(io.EOF)
25483                         }
25484                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25485                 }
25486                 {
25487                         p := &(*(*(struct {
25488                                 Type ItemType
25489
25490                                 Name, Desc string
25491
25492                                 InvImg, WieldImg Texture
25493                                 WieldScale       [3]float32
25494
25495                                 StackMax uint16
25496
25497                                 Usable          bool
25498                                 CanPointLiquids bool
25499
25500                                 ToolCaps ToolCaps
25501
25502                                 Groups []Group
25503
25504                                 PlacePredict string
25505
25506                                 PlaceSnd, PlaceFailSnd SoundDef
25507
25508                                 PointRange float32
25509
25510                                 // Set index in Palette with "palette_index" item meta field,
25511                                 // this overrides Color.
25512                                 Palette Texture
25513                                 Color   color.NRGBA
25514
25515                                 // Texture overlays.
25516                                 InvOverlay, WieldOverlay Texture
25517
25518                                 ShortDesc string
25519                         }))(obj)).Color
25520                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
25521
25522                 }
25523                 if err := pcall(func() {
25524                         ((*(*(struct {
25525                                 Type ItemType
25526
25527                                 Name, Desc string
25528
25529                                 InvImg, WieldImg Texture
25530                                 WieldScale       [3]float32
25531
25532                                 StackMax uint16
25533
25534                                 Usable          bool
25535                                 CanPointLiquids bool
25536
25537                                 ToolCaps ToolCaps
25538
25539                                 Groups []Group
25540
25541                                 PlacePredict string
25542
25543                                 PlaceSnd, PlaceFailSnd SoundDef
25544
25545                                 PointRange float32
25546
25547                                 // Set index in Palette with "palette_index" item meta field,
25548                                 // this overrides Color.
25549                                 Palette Texture
25550                                 Color   color.NRGBA
25551
25552                                 // Texture overlays.
25553                                 InvOverlay, WieldOverlay Texture
25554
25555                                 ShortDesc string
25556                         }))(obj)).InvOverlay).deserialize(r)
25557                 }); err != nil {
25558                         if err == io.EOF {
25559                                 chk(io.EOF)
25560                         }
25561                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25562                 }
25563                 if err := pcall(func() {
25564                         ((*(*(struct {
25565                                 Type ItemType
25566
25567                                 Name, Desc string
25568
25569                                 InvImg, WieldImg Texture
25570                                 WieldScale       [3]float32
25571
25572                                 StackMax uint16
25573
25574                                 Usable          bool
25575                                 CanPointLiquids bool
25576
25577                                 ToolCaps ToolCaps
25578
25579                                 Groups []Group
25580
25581                                 PlacePredict string
25582
25583                                 PlaceSnd, PlaceFailSnd SoundDef
25584
25585                                 PointRange float32
25586
25587                                 // Set index in Palette with "palette_index" item meta field,
25588                                 // this overrides Color.
25589                                 Palette Texture
25590                                 Color   color.NRGBA
25591
25592                                 // Texture overlays.
25593                                 InvOverlay, WieldOverlay Texture
25594
25595                                 ShortDesc string
25596                         }))(obj)).WieldOverlay).deserialize(r)
25597                 }); err != nil {
25598                         if err == io.EOF {
25599                                 chk(io.EOF)
25600                         }
25601                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25602                 }
25603                 var local313 []uint8
25604                 var local314 uint16
25605                 {
25606                         p := &local314
25607                         *p = read16(r)
25608                 }
25609                 (local313) = make([]uint8, local314)
25610                 {
25611                         _, err := io.ReadFull(r, (local313)[:])
25612                         chk(err)
25613                 }
25614                 ((*(*(struct {
25615                         Type ItemType
25616
25617                         Name, Desc string
25618
25619                         InvImg, WieldImg Texture
25620                         WieldScale       [3]float32
25621
25622                         StackMax uint16
25623
25624                         Usable          bool
25625                         CanPointLiquids bool
25626
25627                         ToolCaps ToolCaps
25628
25629                         Groups []Group
25630
25631                         PlacePredict string
25632
25633                         PlaceSnd, PlaceFailSnd SoundDef
25634
25635                         PointRange float32
25636
25637                         // Set index in Palette with "palette_index" item meta field,
25638                         // this overrides Color.
25639                         Palette Texture
25640                         Color   color.NRGBA
25641
25642                         // Texture overlays.
25643                         InvOverlay, WieldOverlay Texture
25644
25645                         ShortDesc string
25646                 }))(obj)).ShortDesc) = string(local313)
25647                 if r.N > 0 {
25648                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
25649                 }
25650         }
25651 }
25652
25653 func (obj *SoundSrcType) serialize(w io.Writer) {
25654         {
25655                 x := *(*(uint8))(obj)
25656                 write8(w, uint8(x))
25657         }
25658 }
25659
25660 func (obj *SoundSrcType) deserialize(r io.Reader) {
25661         {
25662                 p := &*(*(uint8))(obj)
25663                 *p = read8(r)
25664         }
25665 }
25666
25667 func (obj *TileAnim) serialize(w io.Writer) {
25668         if err := pcall(func() {
25669                 ((*(*(struct {
25670                         Type AnimType
25671
25672                         //mt:if %s.Type == SpriteSheetAnim
25673                         AspectRatio [2]uint8
25674
25675                         //mt:if %s.Type == VerticalFrameAnim
25676                         NFrames [2]uint16
25677
25678                         //mt:if %s.Type != NoAnim
25679                         Duration float32 // in seconds
25680
25681                 }))(obj)).Type).serialize(w)
25682         }); err != nil {
25683                 if err == io.EOF {
25684                         chk(io.EOF)
25685                 }
25686                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
25687         }
25688         if !((*(*(struct {
25689                 Type AnimType
25690
25691                 //mt:if %s.Type == SpriteSheetAnim
25692                 AspectRatio [2]uint8
25693
25694                 //mt:if %s.Type == VerticalFrameAnim
25695                 NFrames [2]uint16
25696
25697                 //mt:if %s.Type != NoAnim
25698                 Duration float32 // in seconds
25699
25700         }))(obj)).Type < maxAnim) {
25701                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25702         }
25703         if (*(*(struct {
25704                 Type AnimType
25705
25706                 //mt:if %s.Type == SpriteSheetAnim
25707                 AspectRatio [2]uint8
25708
25709                 //mt:if %s.Type == VerticalFrameAnim
25710                 NFrames [2]uint16
25711
25712                 //mt:if %s.Type != NoAnim
25713                 Duration float32 // in seconds
25714
25715         }))(obj)).Type == SpriteSheetAnim {
25716                 {
25717                         _, err := w.Write(((*(*(struct {
25718                                 Type AnimType
25719
25720                                 //mt:if %s.Type == SpriteSheetAnim
25721                                 AspectRatio [2]uint8
25722
25723                                 //mt:if %s.Type == VerticalFrameAnim
25724                                 NFrames [2]uint16
25725
25726                                 //mt:if %s.Type != NoAnim
25727                                 Duration float32 // in seconds
25728
25729                         }))(obj)).AspectRatio)[:])
25730                         chk(err)
25731                 }
25732         }
25733         if (*(*(struct {
25734                 Type AnimType
25735
25736                 //mt:if %s.Type == SpriteSheetAnim
25737                 AspectRatio [2]uint8
25738
25739                 //mt:if %s.Type == VerticalFrameAnim
25740                 NFrames [2]uint16
25741
25742                 //mt:if %s.Type != NoAnim
25743                 Duration float32 // in seconds
25744
25745         }))(obj)).Type == VerticalFrameAnim {
25746                 for local315 := range (*(*(struct {
25747                         Type AnimType
25748
25749                         //mt:if %s.Type == SpriteSheetAnim
25750                         AspectRatio [2]uint8
25751
25752                         //mt:if %s.Type == VerticalFrameAnim
25753                         NFrames [2]uint16
25754
25755                         //mt:if %s.Type != NoAnim
25756                         Duration float32 // in seconds
25757
25758                 }))(obj)).NFrames {
25759                         {
25760                                 x := ((*(*(struct {
25761                                         Type AnimType
25762
25763                                         //mt:if %s.Type == SpriteSheetAnim
25764                                         AspectRatio [2]uint8
25765
25766                                         //mt:if %s.Type == VerticalFrameAnim
25767                                         NFrames [2]uint16
25768
25769                                         //mt:if %s.Type != NoAnim
25770                                         Duration float32 // in seconds
25771
25772                                 }))(obj)).NFrames)[local315]
25773                                 write16(w, uint16(x))
25774                         }
25775                 }
25776         }
25777         if (*(*(struct {
25778                 Type AnimType
25779
25780                 //mt:if %s.Type == SpriteSheetAnim
25781                 AspectRatio [2]uint8
25782
25783                 //mt:if %s.Type == VerticalFrameAnim
25784                 NFrames [2]uint16
25785
25786                 //mt:if %s.Type != NoAnim
25787                 Duration float32 // in seconds
25788
25789         }))(obj)).Type != NoAnim {
25790                 {
25791                         x := (*(*(struct {
25792                                 Type AnimType
25793
25794                                 //mt:if %s.Type == SpriteSheetAnim
25795                                 AspectRatio [2]uint8
25796
25797                                 //mt:if %s.Type == VerticalFrameAnim
25798                                 NFrames [2]uint16
25799
25800                                 //mt:if %s.Type != NoAnim
25801                                 Duration float32 // in seconds
25802
25803                         }))(obj)).Duration
25804                         write32(w, math.Float32bits(x))
25805                 }
25806         }
25807 }
25808
25809 func (obj *TileAnim) deserialize(r io.Reader) {
25810         if err := pcall(func() {
25811                 ((*(*(struct {
25812                         Type AnimType
25813
25814                         //mt:if %s.Type == SpriteSheetAnim
25815                         AspectRatio [2]uint8
25816
25817                         //mt:if %s.Type == VerticalFrameAnim
25818                         NFrames [2]uint16
25819
25820                         //mt:if %s.Type != NoAnim
25821                         Duration float32 // in seconds
25822
25823                 }))(obj)).Type).deserialize(r)
25824         }); err != nil {
25825                 if err == io.EOF {
25826                         chk(io.EOF)
25827                 }
25828                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
25829         }
25830         if !((*(*(struct {
25831                 Type AnimType
25832
25833                 //mt:if %s.Type == SpriteSheetAnim
25834                 AspectRatio [2]uint8
25835
25836                 //mt:if %s.Type == VerticalFrameAnim
25837                 NFrames [2]uint16
25838
25839                 //mt:if %s.Type != NoAnim
25840                 Duration float32 // in seconds
25841
25842         }))(obj)).Type < maxAnim) {
25843                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25844         }
25845         if (*(*(struct {
25846                 Type AnimType
25847
25848                 //mt:if %s.Type == SpriteSheetAnim
25849                 AspectRatio [2]uint8
25850
25851                 //mt:if %s.Type == VerticalFrameAnim
25852                 NFrames [2]uint16
25853
25854                 //mt:if %s.Type != NoAnim
25855                 Duration float32 // in seconds
25856
25857         }))(obj)).Type == SpriteSheetAnim {
25858                 {
25859                         _, err := io.ReadFull(r, ((*(*(struct {
25860                                 Type AnimType
25861
25862                                 //mt:if %s.Type == SpriteSheetAnim
25863                                 AspectRatio [2]uint8
25864
25865                                 //mt:if %s.Type == VerticalFrameAnim
25866                                 NFrames [2]uint16
25867
25868                                 //mt:if %s.Type != NoAnim
25869                                 Duration float32 // in seconds
25870
25871                         }))(obj)).AspectRatio)[:])
25872                         chk(err)
25873                 }
25874         }
25875         if (*(*(struct {
25876                 Type AnimType
25877
25878                 //mt:if %s.Type == SpriteSheetAnim
25879                 AspectRatio [2]uint8
25880
25881                 //mt:if %s.Type == VerticalFrameAnim
25882                 NFrames [2]uint16
25883
25884                 //mt:if %s.Type != NoAnim
25885                 Duration float32 // in seconds
25886
25887         }))(obj)).Type == VerticalFrameAnim {
25888                 for local316 := range (*(*(struct {
25889                         Type AnimType
25890
25891                         //mt:if %s.Type == SpriteSheetAnim
25892                         AspectRatio [2]uint8
25893
25894                         //mt:if %s.Type == VerticalFrameAnim
25895                         NFrames [2]uint16
25896
25897                         //mt:if %s.Type != NoAnim
25898                         Duration float32 // in seconds
25899
25900                 }))(obj)).NFrames {
25901                         {
25902                                 p := &((*(*(struct {
25903                                         Type AnimType
25904
25905                                         //mt:if %s.Type == SpriteSheetAnim
25906                                         AspectRatio [2]uint8
25907
25908                                         //mt:if %s.Type == VerticalFrameAnim
25909                                         NFrames [2]uint16
25910
25911                                         //mt:if %s.Type != NoAnim
25912                                         Duration float32 // in seconds
25913
25914                                 }))(obj)).NFrames)[local316]
25915                                 *p = read16(r)
25916                         }
25917                 }
25918         }
25919         if (*(*(struct {
25920                 Type AnimType
25921
25922                 //mt:if %s.Type == SpriteSheetAnim
25923                 AspectRatio [2]uint8
25924
25925                 //mt:if %s.Type == VerticalFrameAnim
25926                 NFrames [2]uint16
25927
25928                 //mt:if %s.Type != NoAnim
25929                 Duration float32 // in seconds
25930
25931         }))(obj)).Type != NoAnim {
25932                 {
25933                         p := &(*(*(struct {
25934                                 Type AnimType
25935
25936                                 //mt:if %s.Type == SpriteSheetAnim
25937                                 AspectRatio [2]uint8
25938
25939                                 //mt:if %s.Type == VerticalFrameAnim
25940                                 NFrames [2]uint16
25941
25942                                 //mt:if %s.Type != NoAnim
25943                                 Duration float32 // in seconds
25944
25945                         }))(obj)).Duration
25946                         *p = math.Float32frombits(read32(r))
25947                 }
25948         }
25949 }
25950
25951 func (obj *Content) serialize(w io.Writer) {
25952         {
25953                 x := *(*(uint16))(obj)
25954                 write16(w, uint16(x))
25955         }
25956 }
25957
25958 func (obj *Content) deserialize(r io.Reader) {
25959         {
25960                 p := &*(*(uint16))(obj)
25961                 *p = read16(r)
25962         }
25963 }
25964
25965 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
25966         {
25967                 x := *(*(uint32))(obj)
25968                 write32(w, uint32(x))
25969         }
25970 }
25971
25972 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
25973         {
25974                 p := &*(*(uint32))(obj)
25975                 *p = read32(r)
25976         }
25977 }
25978
25979 func (obj *HUDID) serialize(w io.Writer) {
25980         {
25981                 x := *(*(uint32))(obj)
25982                 write32(w, uint32(x))
25983         }
25984 }
25985
25986 func (obj *HUDID) deserialize(r io.Reader) {
25987         {
25988                 p := &*(*(uint32))(obj)
25989                 *p = read32(r)
25990         }
25991 }
25992
25993 func (obj *HUD) serialize(w io.Writer) {
25994         if err := pcall(func() {
25995                 ((*(*(struct {
25996                         Type HUDType
25997
25998                         Pos      [2]float32
25999                         Name     string
26000                         Scale    [2]float32
26001                         Text     string
26002                         Number   uint32
26003                         Item     uint32
26004                         Dir      uint32
26005                         Align    [2]float32
26006                         Offset   [2]float32
26007                         WorldPos Pos
26008                         Size     [2]int32
26009                         ZIndex   int16
26010                         Text2    string
26011                 }))(obj)).Type).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.HUDType", err))
26017         }
26018         for local317 := range (*(*(struct {
26019                 Type HUDType
26020
26021                 Pos      [2]float32
26022                 Name     string
26023                 Scale    [2]float32
26024                 Text     string
26025                 Number   uint32
26026                 Item     uint32
26027                 Dir      uint32
26028                 Align    [2]float32
26029                 Offset   [2]float32
26030                 WorldPos Pos
26031                 Size     [2]int32
26032                 ZIndex   int16
26033                 Text2    string
26034         }))(obj)).Pos {
26035                 {
26036                         x := ((*(*(struct {
26037                                 Type HUDType
26038
26039                                 Pos      [2]float32
26040                                 Name     string
26041                                 Scale    [2]float32
26042                                 Text     string
26043                                 Number   uint32
26044                                 Item     uint32
26045                                 Dir      uint32
26046                                 Align    [2]float32
26047                                 Offset   [2]float32
26048                                 WorldPos Pos
26049                                 Size     [2]int32
26050                                 ZIndex   int16
26051                                 Text2    string
26052                         }))(obj)).Pos)[local317]
26053                         write32(w, math.Float32bits(x))
26054                 }
26055         }
26056         if len(([]byte((*(*(struct {
26057                 Type HUDType
26058
26059                 Pos      [2]float32
26060                 Name     string
26061                 Scale    [2]float32
26062                 Text     string
26063                 Number   uint32
26064                 Item     uint32
26065                 Dir      uint32
26066                 Align    [2]float32
26067                 Offset   [2]float32
26068                 WorldPos Pos
26069                 Size     [2]int32
26070                 ZIndex   int16
26071                 Text2    string
26072         }))(obj)).Name))) > math.MaxUint16 {
26073                 chk(ErrTooLong)
26074         }
26075         {
26076                 x := uint16(len(([]byte((*(*(struct {
26077                         Type HUDType
26078
26079                         Pos      [2]float32
26080                         Name     string
26081                         Scale    [2]float32
26082                         Text     string
26083                         Number   uint32
26084                         Item     uint32
26085                         Dir      uint32
26086                         Align    [2]float32
26087                         Offset   [2]float32
26088                         WorldPos Pos
26089                         Size     [2]int32
26090                         ZIndex   int16
26091                         Text2    string
26092                 }))(obj)).Name))))
26093                 write16(w, uint16(x))
26094         }
26095         {
26096                 _, err := w.Write(([]byte((*(*(struct {
26097                         Type HUDType
26098
26099                         Pos      [2]float32
26100                         Name     string
26101                         Scale    [2]float32
26102                         Text     string
26103                         Number   uint32
26104                         Item     uint32
26105                         Dir      uint32
26106                         Align    [2]float32
26107                         Offset   [2]float32
26108                         WorldPos Pos
26109                         Size     [2]int32
26110                         ZIndex   int16
26111                         Text2    string
26112                 }))(obj)).Name))[:])
26113                 chk(err)
26114         }
26115         for local318 := range (*(*(struct {
26116                 Type HUDType
26117
26118                 Pos      [2]float32
26119                 Name     string
26120                 Scale    [2]float32
26121                 Text     string
26122                 Number   uint32
26123                 Item     uint32
26124                 Dir      uint32
26125                 Align    [2]float32
26126                 Offset   [2]float32
26127                 WorldPos Pos
26128                 Size     [2]int32
26129                 ZIndex   int16
26130                 Text2    string
26131         }))(obj)).Scale {
26132                 {
26133                         x := ((*(*(struct {
26134                                 Type HUDType
26135
26136                                 Pos      [2]float32
26137                                 Name     string
26138                                 Scale    [2]float32
26139                                 Text     string
26140                                 Number   uint32
26141                                 Item     uint32
26142                                 Dir      uint32
26143                                 Align    [2]float32
26144                                 Offset   [2]float32
26145                                 WorldPos Pos
26146                                 Size     [2]int32
26147                                 ZIndex   int16
26148                                 Text2    string
26149                         }))(obj)).Scale)[local318]
26150                         write32(w, math.Float32bits(x))
26151                 }
26152         }
26153         if len(([]byte((*(*(struct {
26154                 Type HUDType
26155
26156                 Pos      [2]float32
26157                 Name     string
26158                 Scale    [2]float32
26159                 Text     string
26160                 Number   uint32
26161                 Item     uint32
26162                 Dir      uint32
26163                 Align    [2]float32
26164                 Offset   [2]float32
26165                 WorldPos Pos
26166                 Size     [2]int32
26167                 ZIndex   int16
26168                 Text2    string
26169         }))(obj)).Text))) > math.MaxUint16 {
26170                 chk(ErrTooLong)
26171         }
26172         {
26173                 x := uint16(len(([]byte((*(*(struct {
26174                         Type HUDType
26175
26176                         Pos      [2]float32
26177                         Name     string
26178                         Scale    [2]float32
26179                         Text     string
26180                         Number   uint32
26181                         Item     uint32
26182                         Dir      uint32
26183                         Align    [2]float32
26184                         Offset   [2]float32
26185                         WorldPos Pos
26186                         Size     [2]int32
26187                         ZIndex   int16
26188                         Text2    string
26189                 }))(obj)).Text))))
26190                 write16(w, uint16(x))
26191         }
26192         {
26193                 _, err := w.Write(([]byte((*(*(struct {
26194                         Type HUDType
26195
26196                         Pos      [2]float32
26197                         Name     string
26198                         Scale    [2]float32
26199                         Text     string
26200                         Number   uint32
26201                         Item     uint32
26202                         Dir      uint32
26203                         Align    [2]float32
26204                         Offset   [2]float32
26205                         WorldPos Pos
26206                         Size     [2]int32
26207                         ZIndex   int16
26208                         Text2    string
26209                 }))(obj)).Text))[:])
26210                 chk(err)
26211         }
26212         {
26213                 x := (*(*(struct {
26214                         Type HUDType
26215
26216                         Pos      [2]float32
26217                         Name     string
26218                         Scale    [2]float32
26219                         Text     string
26220                         Number   uint32
26221                         Item     uint32
26222                         Dir      uint32
26223                         Align    [2]float32
26224                         Offset   [2]float32
26225                         WorldPos Pos
26226                         Size     [2]int32
26227                         ZIndex   int16
26228                         Text2    string
26229                 }))(obj)).Number
26230                 write32(w, uint32(x))
26231         }
26232         {
26233                 x := (*(*(struct {
26234                         Type HUDType
26235
26236                         Pos      [2]float32
26237                         Name     string
26238                         Scale    [2]float32
26239                         Text     string
26240                         Number   uint32
26241                         Item     uint32
26242                         Dir      uint32
26243                         Align    [2]float32
26244                         Offset   [2]float32
26245                         WorldPos Pos
26246                         Size     [2]int32
26247                         ZIndex   int16
26248                         Text2    string
26249                 }))(obj)).Item
26250                 write32(w, uint32(x))
26251         }
26252         {
26253                 x := (*(*(struct {
26254                         Type HUDType
26255
26256                         Pos      [2]float32
26257                         Name     string
26258                         Scale    [2]float32
26259                         Text     string
26260                         Number   uint32
26261                         Item     uint32
26262                         Dir      uint32
26263                         Align    [2]float32
26264                         Offset   [2]float32
26265                         WorldPos Pos
26266                         Size     [2]int32
26267                         ZIndex   int16
26268                         Text2    string
26269                 }))(obj)).Dir
26270                 write32(w, uint32(x))
26271         }
26272         for local319 := range (*(*(struct {
26273                 Type HUDType
26274
26275                 Pos      [2]float32
26276                 Name     string
26277                 Scale    [2]float32
26278                 Text     string
26279                 Number   uint32
26280                 Item     uint32
26281                 Dir      uint32
26282                 Align    [2]float32
26283                 Offset   [2]float32
26284                 WorldPos Pos
26285                 Size     [2]int32
26286                 ZIndex   int16
26287                 Text2    string
26288         }))(obj)).Align {
26289                 {
26290                         x := ((*(*(struct {
26291                                 Type HUDType
26292
26293                                 Pos      [2]float32
26294                                 Name     string
26295                                 Scale    [2]float32
26296                                 Text     string
26297                                 Number   uint32
26298                                 Item     uint32
26299                                 Dir      uint32
26300                                 Align    [2]float32
26301                                 Offset   [2]float32
26302                                 WorldPos Pos
26303                                 Size     [2]int32
26304                                 ZIndex   int16
26305                                 Text2    string
26306                         }))(obj)).Align)[local319]
26307                         write32(w, math.Float32bits(x))
26308                 }
26309         }
26310         for local320 := range (*(*(struct {
26311                 Type HUDType
26312
26313                 Pos      [2]float32
26314                 Name     string
26315                 Scale    [2]float32
26316                 Text     string
26317                 Number   uint32
26318                 Item     uint32
26319                 Dir      uint32
26320                 Align    [2]float32
26321                 Offset   [2]float32
26322                 WorldPos Pos
26323                 Size     [2]int32
26324                 ZIndex   int16
26325                 Text2    string
26326         }))(obj)).Offset {
26327                 {
26328                         x := ((*(*(struct {
26329                                 Type HUDType
26330
26331                                 Pos      [2]float32
26332                                 Name     string
26333                                 Scale    [2]float32
26334                                 Text     string
26335                                 Number   uint32
26336                                 Item     uint32
26337                                 Dir      uint32
26338                                 Align    [2]float32
26339                                 Offset   [2]float32
26340                                 WorldPos Pos
26341                                 Size     [2]int32
26342                                 ZIndex   int16
26343                                 Text2    string
26344                         }))(obj)).Offset)[local320]
26345                         write32(w, math.Float32bits(x))
26346                 }
26347         }
26348         if err := pcall(func() {
26349                 ((*(*(struct {
26350                         Type HUDType
26351
26352                         Pos      [2]float32
26353                         Name     string
26354                         Scale    [2]float32
26355                         Text     string
26356                         Number   uint32
26357                         Item     uint32
26358                         Dir      uint32
26359                         Align    [2]float32
26360                         Offset   [2]float32
26361                         WorldPos Pos
26362                         Size     [2]int32
26363                         ZIndex   int16
26364                         Text2    string
26365                 }))(obj)).WorldPos).serialize(w)
26366         }); err != nil {
26367                 if err == io.EOF {
26368                         chk(io.EOF)
26369                 }
26370                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
26371         }
26372         for local321 := range (*(*(struct {
26373                 Type HUDType
26374
26375                 Pos      [2]float32
26376                 Name     string
26377                 Scale    [2]float32
26378                 Text     string
26379                 Number   uint32
26380                 Item     uint32
26381                 Dir      uint32
26382                 Align    [2]float32
26383                 Offset   [2]float32
26384                 WorldPos Pos
26385                 Size     [2]int32
26386                 ZIndex   int16
26387                 Text2    string
26388         }))(obj)).Size {
26389                 {
26390                         x := ((*(*(struct {
26391                                 Type HUDType
26392
26393                                 Pos      [2]float32
26394                                 Name     string
26395                                 Scale    [2]float32
26396                                 Text     string
26397                                 Number   uint32
26398                                 Item     uint32
26399                                 Dir      uint32
26400                                 Align    [2]float32
26401                                 Offset   [2]float32
26402                                 WorldPos Pos
26403                                 Size     [2]int32
26404                                 ZIndex   int16
26405                                 Text2    string
26406                         }))(obj)).Size)[local321]
26407                         write32(w, uint32(x))
26408                 }
26409         }
26410         {
26411                 x := (*(*(struct {
26412                         Type HUDType
26413
26414                         Pos      [2]float32
26415                         Name     string
26416                         Scale    [2]float32
26417                         Text     string
26418                         Number   uint32
26419                         Item     uint32
26420                         Dir      uint32
26421                         Align    [2]float32
26422                         Offset   [2]float32
26423                         WorldPos Pos
26424                         Size     [2]int32
26425                         ZIndex   int16
26426                         Text2    string
26427                 }))(obj)).ZIndex
26428                 write16(w, uint16(x))
26429         }
26430         if len(([]byte((*(*(struct {
26431                 Type HUDType
26432
26433                 Pos      [2]float32
26434                 Name     string
26435                 Scale    [2]float32
26436                 Text     string
26437                 Number   uint32
26438                 Item     uint32
26439                 Dir      uint32
26440                 Align    [2]float32
26441                 Offset   [2]float32
26442                 WorldPos Pos
26443                 Size     [2]int32
26444                 ZIndex   int16
26445                 Text2    string
26446         }))(obj)).Text2))) > math.MaxUint16 {
26447                 chk(ErrTooLong)
26448         }
26449         {
26450                 x := uint16(len(([]byte((*(*(struct {
26451                         Type HUDType
26452
26453                         Pos      [2]float32
26454                         Name     string
26455                         Scale    [2]float32
26456                         Text     string
26457                         Number   uint32
26458                         Item     uint32
26459                         Dir      uint32
26460                         Align    [2]float32
26461                         Offset   [2]float32
26462                         WorldPos Pos
26463                         Size     [2]int32
26464                         ZIndex   int16
26465                         Text2    string
26466                 }))(obj)).Text2))))
26467                 write16(w, uint16(x))
26468         }
26469         {
26470                 _, err := w.Write(([]byte((*(*(struct {
26471                         Type HUDType
26472
26473                         Pos      [2]float32
26474                         Name     string
26475                         Scale    [2]float32
26476                         Text     string
26477                         Number   uint32
26478                         Item     uint32
26479                         Dir      uint32
26480                         Align    [2]float32
26481                         Offset   [2]float32
26482                         WorldPos Pos
26483                         Size     [2]int32
26484                         ZIndex   int16
26485                         Text2    string
26486                 }))(obj)).Text2))[:])
26487                 chk(err)
26488         }
26489 }
26490
26491 func (obj *HUD) deserialize(r io.Reader) {
26492         if err := pcall(func() {
26493                 ((*(*(struct {
26494                         Type HUDType
26495
26496                         Pos      [2]float32
26497                         Name     string
26498                         Scale    [2]float32
26499                         Text     string
26500                         Number   uint32
26501                         Item     uint32
26502                         Dir      uint32
26503                         Align    [2]float32
26504                         Offset   [2]float32
26505                         WorldPos Pos
26506                         Size     [2]int32
26507                         ZIndex   int16
26508                         Text2    string
26509                 }))(obj)).Type).deserialize(r)
26510         }); err != nil {
26511                 if err == io.EOF {
26512                         chk(io.EOF)
26513                 }
26514                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
26515         }
26516         for local322 := range (*(*(struct {
26517                 Type HUDType
26518
26519                 Pos      [2]float32
26520                 Name     string
26521                 Scale    [2]float32
26522                 Text     string
26523                 Number   uint32
26524                 Item     uint32
26525                 Dir      uint32
26526                 Align    [2]float32
26527                 Offset   [2]float32
26528                 WorldPos Pos
26529                 Size     [2]int32
26530                 ZIndex   int16
26531                 Text2    string
26532         }))(obj)).Pos {
26533                 {
26534                         p := &((*(*(struct {
26535                                 Type HUDType
26536
26537                                 Pos      [2]float32
26538                                 Name     string
26539                                 Scale    [2]float32
26540                                 Text     string
26541                                 Number   uint32
26542                                 Item     uint32
26543                                 Dir      uint32
26544                                 Align    [2]float32
26545                                 Offset   [2]float32
26546                                 WorldPos Pos
26547                                 Size     [2]int32
26548                                 ZIndex   int16
26549                                 Text2    string
26550                         }))(obj)).Pos)[local322]
26551                         *p = math.Float32frombits(read32(r))
26552                 }
26553         }
26554         var local323 []uint8
26555         var local324 uint16
26556         {
26557                 p := &local324
26558                 *p = read16(r)
26559         }
26560         (local323) = make([]uint8, local324)
26561         {
26562                 _, err := io.ReadFull(r, (local323)[:])
26563                 chk(err)
26564         }
26565         ((*(*(struct {
26566                 Type HUDType
26567
26568                 Pos      [2]float32
26569                 Name     string
26570                 Scale    [2]float32
26571                 Text     string
26572                 Number   uint32
26573                 Item     uint32
26574                 Dir      uint32
26575                 Align    [2]float32
26576                 Offset   [2]float32
26577                 WorldPos Pos
26578                 Size     [2]int32
26579                 ZIndex   int16
26580                 Text2    string
26581         }))(obj)).Name) = string(local323)
26582         for local325 := range (*(*(struct {
26583                 Type HUDType
26584
26585                 Pos      [2]float32
26586                 Name     string
26587                 Scale    [2]float32
26588                 Text     string
26589                 Number   uint32
26590                 Item     uint32
26591                 Dir      uint32
26592                 Align    [2]float32
26593                 Offset   [2]float32
26594                 WorldPos Pos
26595                 Size     [2]int32
26596                 ZIndex   int16
26597                 Text2    string
26598         }))(obj)).Scale {
26599                 {
26600                         p := &((*(*(struct {
26601                                 Type HUDType
26602
26603                                 Pos      [2]float32
26604                                 Name     string
26605                                 Scale    [2]float32
26606                                 Text     string
26607                                 Number   uint32
26608                                 Item     uint32
26609                                 Dir      uint32
26610                                 Align    [2]float32
26611                                 Offset   [2]float32
26612                                 WorldPos Pos
26613                                 Size     [2]int32
26614                                 ZIndex   int16
26615                                 Text2    string
26616                         }))(obj)).Scale)[local325]
26617                         *p = math.Float32frombits(read32(r))
26618                 }
26619         }
26620         var local326 []uint8
26621         var local327 uint16
26622         {
26623                 p := &local327
26624                 *p = read16(r)
26625         }
26626         (local326) = make([]uint8, local327)
26627         {
26628                 _, err := io.ReadFull(r, (local326)[:])
26629                 chk(err)
26630         }
26631         ((*(*(struct {
26632                 Type HUDType
26633
26634                 Pos      [2]float32
26635                 Name     string
26636                 Scale    [2]float32
26637                 Text     string
26638                 Number   uint32
26639                 Item     uint32
26640                 Dir      uint32
26641                 Align    [2]float32
26642                 Offset   [2]float32
26643                 WorldPos Pos
26644                 Size     [2]int32
26645                 ZIndex   int16
26646                 Text2    string
26647         }))(obj)).Text) = string(local326)
26648         {
26649                 p := &(*(*(struct {
26650                         Type HUDType
26651
26652                         Pos      [2]float32
26653                         Name     string
26654                         Scale    [2]float32
26655                         Text     string
26656                         Number   uint32
26657                         Item     uint32
26658                         Dir      uint32
26659                         Align    [2]float32
26660                         Offset   [2]float32
26661                         WorldPos Pos
26662                         Size     [2]int32
26663                         ZIndex   int16
26664                         Text2    string
26665                 }))(obj)).Number
26666                 *p = read32(r)
26667         }
26668         {
26669                 p := &(*(*(struct {
26670                         Type HUDType
26671
26672                         Pos      [2]float32
26673                         Name     string
26674                         Scale    [2]float32
26675                         Text     string
26676                         Number   uint32
26677                         Item     uint32
26678                         Dir      uint32
26679                         Align    [2]float32
26680                         Offset   [2]float32
26681                         WorldPos Pos
26682                         Size     [2]int32
26683                         ZIndex   int16
26684                         Text2    string
26685                 }))(obj)).Item
26686                 *p = read32(r)
26687         }
26688         {
26689                 p := &(*(*(struct {
26690                         Type HUDType
26691
26692                         Pos      [2]float32
26693                         Name     string
26694                         Scale    [2]float32
26695                         Text     string
26696                         Number   uint32
26697                         Item     uint32
26698                         Dir      uint32
26699                         Align    [2]float32
26700                         Offset   [2]float32
26701                         WorldPos Pos
26702                         Size     [2]int32
26703                         ZIndex   int16
26704                         Text2    string
26705                 }))(obj)).Dir
26706                 *p = read32(r)
26707         }
26708         for local328 := range (*(*(struct {
26709                 Type HUDType
26710
26711                 Pos      [2]float32
26712                 Name     string
26713                 Scale    [2]float32
26714                 Text     string
26715                 Number   uint32
26716                 Item     uint32
26717                 Dir      uint32
26718                 Align    [2]float32
26719                 Offset   [2]float32
26720                 WorldPos Pos
26721                 Size     [2]int32
26722                 ZIndex   int16
26723                 Text2    string
26724         }))(obj)).Align {
26725                 {
26726                         p := &((*(*(struct {
26727                                 Type HUDType
26728
26729                                 Pos      [2]float32
26730                                 Name     string
26731                                 Scale    [2]float32
26732                                 Text     string
26733                                 Number   uint32
26734                                 Item     uint32
26735                                 Dir      uint32
26736                                 Align    [2]float32
26737                                 Offset   [2]float32
26738                                 WorldPos Pos
26739                                 Size     [2]int32
26740                                 ZIndex   int16
26741                                 Text2    string
26742                         }))(obj)).Align)[local328]
26743                         *p = math.Float32frombits(read32(r))
26744                 }
26745         }
26746         for local329 := range (*(*(struct {
26747                 Type HUDType
26748
26749                 Pos      [2]float32
26750                 Name     string
26751                 Scale    [2]float32
26752                 Text     string
26753                 Number   uint32
26754                 Item     uint32
26755                 Dir      uint32
26756                 Align    [2]float32
26757                 Offset   [2]float32
26758                 WorldPos Pos
26759                 Size     [2]int32
26760                 ZIndex   int16
26761                 Text2    string
26762         }))(obj)).Offset {
26763                 {
26764                         p := &((*(*(struct {
26765                                 Type HUDType
26766
26767                                 Pos      [2]float32
26768                                 Name     string
26769                                 Scale    [2]float32
26770                                 Text     string
26771                                 Number   uint32
26772                                 Item     uint32
26773                                 Dir      uint32
26774                                 Align    [2]float32
26775                                 Offset   [2]float32
26776                                 WorldPos Pos
26777                                 Size     [2]int32
26778                                 ZIndex   int16
26779                                 Text2    string
26780                         }))(obj)).Offset)[local329]
26781                         *p = math.Float32frombits(read32(r))
26782                 }
26783         }
26784         if err := pcall(func() {
26785                 ((*(*(struct {
26786                         Type HUDType
26787
26788                         Pos      [2]float32
26789                         Name     string
26790                         Scale    [2]float32
26791                         Text     string
26792                         Number   uint32
26793                         Item     uint32
26794                         Dir      uint32
26795                         Align    [2]float32
26796                         Offset   [2]float32
26797                         WorldPos Pos
26798                         Size     [2]int32
26799                         ZIndex   int16
26800                         Text2    string
26801                 }))(obj)).WorldPos).deserialize(r)
26802         }); err != nil {
26803                 if err == io.EOF {
26804                         chk(io.EOF)
26805                 }
26806                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
26807         }
26808         for local330 := range (*(*(struct {
26809                 Type HUDType
26810
26811                 Pos      [2]float32
26812                 Name     string
26813                 Scale    [2]float32
26814                 Text     string
26815                 Number   uint32
26816                 Item     uint32
26817                 Dir      uint32
26818                 Align    [2]float32
26819                 Offset   [2]float32
26820                 WorldPos Pos
26821                 Size     [2]int32
26822                 ZIndex   int16
26823                 Text2    string
26824         }))(obj)).Size {
26825                 {
26826                         p := &((*(*(struct {
26827                                 Type HUDType
26828
26829                                 Pos      [2]float32
26830                                 Name     string
26831                                 Scale    [2]float32
26832                                 Text     string
26833                                 Number   uint32
26834                                 Item     uint32
26835                                 Dir      uint32
26836                                 Align    [2]float32
26837                                 Offset   [2]float32
26838                                 WorldPos Pos
26839                                 Size     [2]int32
26840                                 ZIndex   int16
26841                                 Text2    string
26842                         }))(obj)).Size)[local330]
26843                         *p = int32(read32(r))
26844                 }
26845         }
26846         {
26847                 p := &(*(*(struct {
26848                         Type HUDType
26849
26850                         Pos      [2]float32
26851                         Name     string
26852                         Scale    [2]float32
26853                         Text     string
26854                         Number   uint32
26855                         Item     uint32
26856                         Dir      uint32
26857                         Align    [2]float32
26858                         Offset   [2]float32
26859                         WorldPos Pos
26860                         Size     [2]int32
26861                         ZIndex   int16
26862                         Text2    string
26863                 }))(obj)).ZIndex
26864                 *p = int16(read16(r))
26865         }
26866         var local331 []uint8
26867         var local332 uint16
26868         {
26869                 p := &local332
26870                 *p = read16(r)
26871         }
26872         (local331) = make([]uint8, local332)
26873         {
26874                 _, err := io.ReadFull(r, (local331)[:])
26875                 chk(err)
26876         }
26877         ((*(*(struct {
26878                 Type HUDType
26879
26880                 Pos      [2]float32
26881                 Name     string
26882                 Scale    [2]float32
26883                 Text     string
26884                 Number   uint32
26885                 Item     uint32
26886                 Dir      uint32
26887                 Align    [2]float32
26888                 Offset   [2]float32
26889                 WorldPos Pos
26890                 Size     [2]int32
26891                 ZIndex   int16
26892                 Text2    string
26893         }))(obj)).Text2) = string(local331)
26894 }
26895
26896 func (obj *HUDField) serialize(w io.Writer) {
26897         {
26898                 x := *(*(uint8))(obj)
26899                 write8(w, uint8(x))
26900         }
26901 }
26902
26903 func (obj *HUDField) deserialize(r io.Reader) {
26904         {
26905                 p := &*(*(uint8))(obj)
26906                 *p = read8(r)
26907         }
26908 }
26909
26910 func (obj *HUDFlags) serialize(w io.Writer) {
26911         {
26912                 x := *(*(uint32))(obj)
26913                 write32(w, uint32(x))
26914         }
26915 }
26916
26917 func (obj *HUDFlags) deserialize(r io.Reader) {
26918         {
26919                 p := &*(*(uint32))(obj)
26920                 *p = read32(r)
26921         }
26922 }
26923
26924 func (obj *HotbarParam) serialize(w io.Writer) {
26925         {
26926                 x := *(*(uint16))(obj)
26927                 write16(w, uint16(x))
26928         }
26929 }
26930
26931 func (obj *HotbarParam) deserialize(r io.Reader) {
26932         {
26933                 p := &*(*(uint16))(obj)
26934                 *p = read16(r)
26935         }
26936 }
26937
26938 func (obj *Texture) serialize(w io.Writer) {
26939         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
26940                 chk(ErrTooLong)
26941         }
26942         {
26943                 x := uint16(len(([]byte(*(*(string))(obj)))))
26944                 write16(w, uint16(x))
26945         }
26946         {
26947                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
26948                 chk(err)
26949         }
26950 }
26951
26952 func (obj *Texture) deserialize(r io.Reader) {
26953         var local333 []uint8
26954         var local334 uint16
26955         {
26956                 p := &local334
26957                 *p = read16(r)
26958         }
26959         (local333) = make([]uint8, local334)
26960         {
26961                 _, err := io.ReadFull(r, (local333)[:])
26962                 chk(err)
26963         }
26964         (*(*(string))(obj)) = string(local333)
26965 }
26966
26967 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
26968         {
26969                 x := *(*(uint8))(obj)
26970                 write8(w, uint8(x))
26971         }
26972 }
26973
26974 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
26975         {
26976                 p := &*(*(uint8))(obj)
26977                 *p = read8(r)
26978         }
26979 }
26980
26981 func (obj *ModChanSig) serialize(w io.Writer) {
26982         {
26983                 x := *(*(uint8))(obj)
26984                 write8(w, uint8(x))
26985         }
26986 }
26987
26988 func (obj *ModChanSig) deserialize(r io.Reader) {
26989         {
26990                 p := &*(*(uint8))(obj)
26991                 *p = read8(r)
26992         }
26993 }
26994
26995 func (obj *AOProps) serialize(w io.Writer) {
26996         {
26997                 local335 := uint8(4)
26998                 {
26999                         x := local335
27000                         write8(w, uint8(x))
27001                 }
27002         }
27003         {
27004                 x := (*(*(struct {
27005                         MaxHP            uint16 // Player only.
27006                         CollideWithNodes bool
27007                         Weight           float32 // deprecated
27008                         ColBox, SelBox   Box
27009                         Pointable        bool
27010                         Visual           string
27011                         VisualSize       [3]float32
27012                         Textures         []Texture
27013                         SpriteSheetSize  [2]int16 // in sprites.
27014                         SpritePos        [2]int16 // in sprite sheet.
27015                         Visible          bool
27016                         MakeFootstepSnds bool
27017                         RotateSpeed      float32 // in radians per second.
27018                         Mesh             string
27019                         Colors           []color.NRGBA
27020                         CollideWithAOs   bool
27021                         StepHeight       float32
27022                         FaceRotateDir    bool
27023                         FaceRotateDirOff float32 // in degrees.
27024                         BackfaceCull     bool
27025                         Nametag          string
27026                         NametagColor     color.NRGBA
27027                         FaceRotateSpeed  float32 // in degrees per second.
27028                         Infotext         string
27029                         Itemstring       string
27030                         Glow             int8
27031                         MaxBreath        uint16  // Player only.
27032                         EyeHeight        float32 // Player only.
27033                         ZoomFOV          float32 // in degrees. Player only.
27034                         UseTextureAlpha  bool
27035                         DmgTextureMod    Texture // suffix
27036                         Shaded           bool
27037                         ShowOnMinimap    bool
27038                         NametagBG        color.NRGBA
27039                 }))(obj)).MaxHP
27040                 write16(w, uint16(x))
27041         }
27042         {
27043                 x := (*(*(struct {
27044                         MaxHP            uint16 // Player only.
27045                         CollideWithNodes bool
27046                         Weight           float32 // deprecated
27047                         ColBox, SelBox   Box
27048                         Pointable        bool
27049                         Visual           string
27050                         VisualSize       [3]float32
27051                         Textures         []Texture
27052                         SpriteSheetSize  [2]int16 // in sprites.
27053                         SpritePos        [2]int16 // in sprite sheet.
27054                         Visible          bool
27055                         MakeFootstepSnds bool
27056                         RotateSpeed      float32 // in radians per second.
27057                         Mesh             string
27058                         Colors           []color.NRGBA
27059                         CollideWithAOs   bool
27060                         StepHeight       float32
27061                         FaceRotateDir    bool
27062                         FaceRotateDirOff float32 // in degrees.
27063                         BackfaceCull     bool
27064                         Nametag          string
27065                         NametagColor     color.NRGBA
27066                         FaceRotateSpeed  float32 // in degrees per second.
27067                         Infotext         string
27068                         Itemstring       string
27069                         Glow             int8
27070                         MaxBreath        uint16  // Player only.
27071                         EyeHeight        float32 // Player only.
27072                         ZoomFOV          float32 // in degrees. Player only.
27073                         UseTextureAlpha  bool
27074                         DmgTextureMod    Texture // suffix
27075                         Shaded           bool
27076                         ShowOnMinimap    bool
27077                         NametagBG        color.NRGBA
27078                 }))(obj)).CollideWithNodes
27079                 if x {
27080                         write8(w, 1)
27081                 } else {
27082                         write8(w, 0)
27083                 }
27084
27085         }
27086         {
27087                 x := (*(*(struct {
27088                         MaxHP            uint16 // Player only.
27089                         CollideWithNodes bool
27090                         Weight           float32 // deprecated
27091                         ColBox, SelBox   Box
27092                         Pointable        bool
27093                         Visual           string
27094                         VisualSize       [3]float32
27095                         Textures         []Texture
27096                         SpriteSheetSize  [2]int16 // in sprites.
27097                         SpritePos        [2]int16 // in sprite sheet.
27098                         Visible          bool
27099                         MakeFootstepSnds bool
27100                         RotateSpeed      float32 // in radians per second.
27101                         Mesh             string
27102                         Colors           []color.NRGBA
27103                         CollideWithAOs   bool
27104                         StepHeight       float32
27105                         FaceRotateDir    bool
27106                         FaceRotateDirOff float32 // in degrees.
27107                         BackfaceCull     bool
27108                         Nametag          string
27109                         NametagColor     color.NRGBA
27110                         FaceRotateSpeed  float32 // in degrees per second.
27111                         Infotext         string
27112                         Itemstring       string
27113                         Glow             int8
27114                         MaxBreath        uint16  // Player only.
27115                         EyeHeight        float32 // Player only.
27116                         ZoomFOV          float32 // in degrees. Player only.
27117                         UseTextureAlpha  bool
27118                         DmgTextureMod    Texture // suffix
27119                         Shaded           bool
27120                         ShowOnMinimap    bool
27121                         NametagBG        color.NRGBA
27122                 }))(obj)).Weight
27123                 write32(w, math.Float32bits(x))
27124         }
27125         if err := pcall(func() {
27126                 ((*(*(struct {
27127                         MaxHP            uint16 // Player only.
27128                         CollideWithNodes bool
27129                         Weight           float32 // deprecated
27130                         ColBox, SelBox   Box
27131                         Pointable        bool
27132                         Visual           string
27133                         VisualSize       [3]float32
27134                         Textures         []Texture
27135                         SpriteSheetSize  [2]int16 // in sprites.
27136                         SpritePos        [2]int16 // in sprite sheet.
27137                         Visible          bool
27138                         MakeFootstepSnds bool
27139                         RotateSpeed      float32 // in radians per second.
27140                         Mesh             string
27141                         Colors           []color.NRGBA
27142                         CollideWithAOs   bool
27143                         StepHeight       float32
27144                         FaceRotateDir    bool
27145                         FaceRotateDirOff float32 // in degrees.
27146                         BackfaceCull     bool
27147                         Nametag          string
27148                         NametagColor     color.NRGBA
27149                         FaceRotateSpeed  float32 // in degrees per second.
27150                         Infotext         string
27151                         Itemstring       string
27152                         Glow             int8
27153                         MaxBreath        uint16  // Player only.
27154                         EyeHeight        float32 // Player only.
27155                         ZoomFOV          float32 // in degrees. Player only.
27156                         UseTextureAlpha  bool
27157                         DmgTextureMod    Texture // suffix
27158                         Shaded           bool
27159                         ShowOnMinimap    bool
27160                         NametagBG        color.NRGBA
27161                 }))(obj)).ColBox).serialize(w)
27162         }); err != nil {
27163                 if err == io.EOF {
27164                         chk(io.EOF)
27165                 }
27166                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27167         }
27168         if err := pcall(func() {
27169                 ((*(*(struct {
27170                         MaxHP            uint16 // Player only.
27171                         CollideWithNodes bool
27172                         Weight           float32 // deprecated
27173                         ColBox, SelBox   Box
27174                         Pointable        bool
27175                         Visual           string
27176                         VisualSize       [3]float32
27177                         Textures         []Texture
27178                         SpriteSheetSize  [2]int16 // in sprites.
27179                         SpritePos        [2]int16 // in sprite sheet.
27180                         Visible          bool
27181                         MakeFootstepSnds bool
27182                         RotateSpeed      float32 // in radians per second.
27183                         Mesh             string
27184                         Colors           []color.NRGBA
27185                         CollideWithAOs   bool
27186                         StepHeight       float32
27187                         FaceRotateDir    bool
27188                         FaceRotateDirOff float32 // in degrees.
27189                         BackfaceCull     bool
27190                         Nametag          string
27191                         NametagColor     color.NRGBA
27192                         FaceRotateSpeed  float32 // in degrees per second.
27193                         Infotext         string
27194                         Itemstring       string
27195                         Glow             int8
27196                         MaxBreath        uint16  // Player only.
27197                         EyeHeight        float32 // Player only.
27198                         ZoomFOV          float32 // in degrees. Player only.
27199                         UseTextureAlpha  bool
27200                         DmgTextureMod    Texture // suffix
27201                         Shaded           bool
27202                         ShowOnMinimap    bool
27203                         NametagBG        color.NRGBA
27204                 }))(obj)).SelBox).serialize(w)
27205         }); err != nil {
27206                 if err == io.EOF {
27207                         chk(io.EOF)
27208                 }
27209                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27210         }
27211         {
27212                 x := (*(*(struct {
27213                         MaxHP            uint16 // Player only.
27214                         CollideWithNodes bool
27215                         Weight           float32 // deprecated
27216                         ColBox, SelBox   Box
27217                         Pointable        bool
27218                         Visual           string
27219                         VisualSize       [3]float32
27220                         Textures         []Texture
27221                         SpriteSheetSize  [2]int16 // in sprites.
27222                         SpritePos        [2]int16 // in sprite sheet.
27223                         Visible          bool
27224                         MakeFootstepSnds bool
27225                         RotateSpeed      float32 // in radians per second.
27226                         Mesh             string
27227                         Colors           []color.NRGBA
27228                         CollideWithAOs   bool
27229                         StepHeight       float32
27230                         FaceRotateDir    bool
27231                         FaceRotateDirOff float32 // in degrees.
27232                         BackfaceCull     bool
27233                         Nametag          string
27234                         NametagColor     color.NRGBA
27235                         FaceRotateSpeed  float32 // in degrees per second.
27236                         Infotext         string
27237                         Itemstring       string
27238                         Glow             int8
27239                         MaxBreath        uint16  // Player only.
27240                         EyeHeight        float32 // Player only.
27241                         ZoomFOV          float32 // in degrees. Player only.
27242                         UseTextureAlpha  bool
27243                         DmgTextureMod    Texture // suffix
27244                         Shaded           bool
27245                         ShowOnMinimap    bool
27246                         NametagBG        color.NRGBA
27247                 }))(obj)).Pointable
27248                 if x {
27249                         write8(w, 1)
27250                 } else {
27251                         write8(w, 0)
27252                 }
27253
27254         }
27255         if len(([]byte((*(*(struct {
27256                 MaxHP            uint16 // Player only.
27257                 CollideWithNodes bool
27258                 Weight           float32 // deprecated
27259                 ColBox, SelBox   Box
27260                 Pointable        bool
27261                 Visual           string
27262                 VisualSize       [3]float32
27263                 Textures         []Texture
27264                 SpriteSheetSize  [2]int16 // in sprites.
27265                 SpritePos        [2]int16 // in sprite sheet.
27266                 Visible          bool
27267                 MakeFootstepSnds bool
27268                 RotateSpeed      float32 // in radians per second.
27269                 Mesh             string
27270                 Colors           []color.NRGBA
27271                 CollideWithAOs   bool
27272                 StepHeight       float32
27273                 FaceRotateDir    bool
27274                 FaceRotateDirOff float32 // in degrees.
27275                 BackfaceCull     bool
27276                 Nametag          string
27277                 NametagColor     color.NRGBA
27278                 FaceRotateSpeed  float32 // in degrees per second.
27279                 Infotext         string
27280                 Itemstring       string
27281                 Glow             int8
27282                 MaxBreath        uint16  // Player only.
27283                 EyeHeight        float32 // Player only.
27284                 ZoomFOV          float32 // in degrees. Player only.
27285                 UseTextureAlpha  bool
27286                 DmgTextureMod    Texture // suffix
27287                 Shaded           bool
27288                 ShowOnMinimap    bool
27289                 NametagBG        color.NRGBA
27290         }))(obj)).Visual))) > math.MaxUint16 {
27291                 chk(ErrTooLong)
27292         }
27293         {
27294                 x := uint16(len(([]byte((*(*(struct {
27295                         MaxHP            uint16 // Player only.
27296                         CollideWithNodes bool
27297                         Weight           float32 // deprecated
27298                         ColBox, SelBox   Box
27299                         Pointable        bool
27300                         Visual           string
27301                         VisualSize       [3]float32
27302                         Textures         []Texture
27303                         SpriteSheetSize  [2]int16 // in sprites.
27304                         SpritePos        [2]int16 // in sprite sheet.
27305                         Visible          bool
27306                         MakeFootstepSnds bool
27307                         RotateSpeed      float32 // in radians per second.
27308                         Mesh             string
27309                         Colors           []color.NRGBA
27310                         CollideWithAOs   bool
27311                         StepHeight       float32
27312                         FaceRotateDir    bool
27313                         FaceRotateDirOff float32 // in degrees.
27314                         BackfaceCull     bool
27315                         Nametag          string
27316                         NametagColor     color.NRGBA
27317                         FaceRotateSpeed  float32 // in degrees per second.
27318                         Infotext         string
27319                         Itemstring       string
27320                         Glow             int8
27321                         MaxBreath        uint16  // Player only.
27322                         EyeHeight        float32 // Player only.
27323                         ZoomFOV          float32 // in degrees. Player only.
27324                         UseTextureAlpha  bool
27325                         DmgTextureMod    Texture // suffix
27326                         Shaded           bool
27327                         ShowOnMinimap    bool
27328                         NametagBG        color.NRGBA
27329                 }))(obj)).Visual))))
27330                 write16(w, uint16(x))
27331         }
27332         {
27333                 _, err := w.Write(([]byte((*(*(struct {
27334                         MaxHP            uint16 // Player only.
27335                         CollideWithNodes bool
27336                         Weight           float32 // deprecated
27337                         ColBox, SelBox   Box
27338                         Pointable        bool
27339                         Visual           string
27340                         VisualSize       [3]float32
27341                         Textures         []Texture
27342                         SpriteSheetSize  [2]int16 // in sprites.
27343                         SpritePos        [2]int16 // in sprite sheet.
27344                         Visible          bool
27345                         MakeFootstepSnds bool
27346                         RotateSpeed      float32 // in radians per second.
27347                         Mesh             string
27348                         Colors           []color.NRGBA
27349                         CollideWithAOs   bool
27350                         StepHeight       float32
27351                         FaceRotateDir    bool
27352                         FaceRotateDirOff float32 // in degrees.
27353                         BackfaceCull     bool
27354                         Nametag          string
27355                         NametagColor     color.NRGBA
27356                         FaceRotateSpeed  float32 // in degrees per second.
27357                         Infotext         string
27358                         Itemstring       string
27359                         Glow             int8
27360                         MaxBreath        uint16  // Player only.
27361                         EyeHeight        float32 // Player only.
27362                         ZoomFOV          float32 // in degrees. Player only.
27363                         UseTextureAlpha  bool
27364                         DmgTextureMod    Texture // suffix
27365                         Shaded           bool
27366                         ShowOnMinimap    bool
27367                         NametagBG        color.NRGBA
27368                 }))(obj)).Visual))[:])
27369                 chk(err)
27370         }
27371         for local336 := range (*(*(struct {
27372                 MaxHP            uint16 // Player only.
27373                 CollideWithNodes bool
27374                 Weight           float32 // deprecated
27375                 ColBox, SelBox   Box
27376                 Pointable        bool
27377                 Visual           string
27378                 VisualSize       [3]float32
27379                 Textures         []Texture
27380                 SpriteSheetSize  [2]int16 // in sprites.
27381                 SpritePos        [2]int16 // in sprite sheet.
27382                 Visible          bool
27383                 MakeFootstepSnds bool
27384                 RotateSpeed      float32 // in radians per second.
27385                 Mesh             string
27386                 Colors           []color.NRGBA
27387                 CollideWithAOs   bool
27388                 StepHeight       float32
27389                 FaceRotateDir    bool
27390                 FaceRotateDirOff float32 // in degrees.
27391                 BackfaceCull     bool
27392                 Nametag          string
27393                 NametagColor     color.NRGBA
27394                 FaceRotateSpeed  float32 // in degrees per second.
27395                 Infotext         string
27396                 Itemstring       string
27397                 Glow             int8
27398                 MaxBreath        uint16  // Player only.
27399                 EyeHeight        float32 // Player only.
27400                 ZoomFOV          float32 // in degrees. Player only.
27401                 UseTextureAlpha  bool
27402                 DmgTextureMod    Texture // suffix
27403                 Shaded           bool
27404                 ShowOnMinimap    bool
27405                 NametagBG        color.NRGBA
27406         }))(obj)).VisualSize {
27407                 {
27408                         x := ((*(*(struct {
27409                                 MaxHP            uint16 // Player only.
27410                                 CollideWithNodes bool
27411                                 Weight           float32 // deprecated
27412                                 ColBox, SelBox   Box
27413                                 Pointable        bool
27414                                 Visual           string
27415                                 VisualSize       [3]float32
27416                                 Textures         []Texture
27417                                 SpriteSheetSize  [2]int16 // in sprites.
27418                                 SpritePos        [2]int16 // in sprite sheet.
27419                                 Visible          bool
27420                                 MakeFootstepSnds bool
27421                                 RotateSpeed      float32 // in radians per second.
27422                                 Mesh             string
27423                                 Colors           []color.NRGBA
27424                                 CollideWithAOs   bool
27425                                 StepHeight       float32
27426                                 FaceRotateDir    bool
27427                                 FaceRotateDirOff float32 // in degrees.
27428                                 BackfaceCull     bool
27429                                 Nametag          string
27430                                 NametagColor     color.NRGBA
27431                                 FaceRotateSpeed  float32 // in degrees per second.
27432                                 Infotext         string
27433                                 Itemstring       string
27434                                 Glow             int8
27435                                 MaxBreath        uint16  // Player only.
27436                                 EyeHeight        float32 // Player only.
27437                                 ZoomFOV          float32 // in degrees. Player only.
27438                                 UseTextureAlpha  bool
27439                                 DmgTextureMod    Texture // suffix
27440                                 Shaded           bool
27441                                 ShowOnMinimap    bool
27442                                 NametagBG        color.NRGBA
27443                         }))(obj)).VisualSize)[local336]
27444                         write32(w, math.Float32bits(x))
27445                 }
27446         }
27447         if len(((*(*(struct {
27448                 MaxHP            uint16 // Player only.
27449                 CollideWithNodes bool
27450                 Weight           float32 // deprecated
27451                 ColBox, SelBox   Box
27452                 Pointable        bool
27453                 Visual           string
27454                 VisualSize       [3]float32
27455                 Textures         []Texture
27456                 SpriteSheetSize  [2]int16 // in sprites.
27457                 SpritePos        [2]int16 // in sprite sheet.
27458                 Visible          bool
27459                 MakeFootstepSnds bool
27460                 RotateSpeed      float32 // in radians per second.
27461                 Mesh             string
27462                 Colors           []color.NRGBA
27463                 CollideWithAOs   bool
27464                 StepHeight       float32
27465                 FaceRotateDir    bool
27466                 FaceRotateDirOff float32 // in degrees.
27467                 BackfaceCull     bool
27468                 Nametag          string
27469                 NametagColor     color.NRGBA
27470                 FaceRotateSpeed  float32 // in degrees per second.
27471                 Infotext         string
27472                 Itemstring       string
27473                 Glow             int8
27474                 MaxBreath        uint16  // Player only.
27475                 EyeHeight        float32 // Player only.
27476                 ZoomFOV          float32 // in degrees. Player only.
27477                 UseTextureAlpha  bool
27478                 DmgTextureMod    Texture // suffix
27479                 Shaded           bool
27480                 ShowOnMinimap    bool
27481                 NametagBG        color.NRGBA
27482         }))(obj)).Textures)) > math.MaxUint16 {
27483                 chk(ErrTooLong)
27484         }
27485         {
27486                 x := uint16(len(((*(*(struct {
27487                         MaxHP            uint16 // Player only.
27488                         CollideWithNodes bool
27489                         Weight           float32 // deprecated
27490                         ColBox, SelBox   Box
27491                         Pointable        bool
27492                         Visual           string
27493                         VisualSize       [3]float32
27494                         Textures         []Texture
27495                         SpriteSheetSize  [2]int16 // in sprites.
27496                         SpritePos        [2]int16 // in sprite sheet.
27497                         Visible          bool
27498                         MakeFootstepSnds bool
27499                         RotateSpeed      float32 // in radians per second.
27500                         Mesh             string
27501                         Colors           []color.NRGBA
27502                         CollideWithAOs   bool
27503                         StepHeight       float32
27504                         FaceRotateDir    bool
27505                         FaceRotateDirOff float32 // in degrees.
27506                         BackfaceCull     bool
27507                         Nametag          string
27508                         NametagColor     color.NRGBA
27509                         FaceRotateSpeed  float32 // in degrees per second.
27510                         Infotext         string
27511                         Itemstring       string
27512                         Glow             int8
27513                         MaxBreath        uint16  // Player only.
27514                         EyeHeight        float32 // Player only.
27515                         ZoomFOV          float32 // in degrees. Player only.
27516                         UseTextureAlpha  bool
27517                         DmgTextureMod    Texture // suffix
27518                         Shaded           bool
27519                         ShowOnMinimap    bool
27520                         NametagBG        color.NRGBA
27521                 }))(obj)).Textures)))
27522                 write16(w, uint16(x))
27523         }
27524         for local337 := range (*(*(struct {
27525                 MaxHP            uint16 // Player only.
27526                 CollideWithNodes bool
27527                 Weight           float32 // deprecated
27528                 ColBox, SelBox   Box
27529                 Pointable        bool
27530                 Visual           string
27531                 VisualSize       [3]float32
27532                 Textures         []Texture
27533                 SpriteSheetSize  [2]int16 // in sprites.
27534                 SpritePos        [2]int16 // in sprite sheet.
27535                 Visible          bool
27536                 MakeFootstepSnds bool
27537                 RotateSpeed      float32 // in radians per second.
27538                 Mesh             string
27539                 Colors           []color.NRGBA
27540                 CollideWithAOs   bool
27541                 StepHeight       float32
27542                 FaceRotateDir    bool
27543                 FaceRotateDirOff float32 // in degrees.
27544                 BackfaceCull     bool
27545                 Nametag          string
27546                 NametagColor     color.NRGBA
27547                 FaceRotateSpeed  float32 // in degrees per second.
27548                 Infotext         string
27549                 Itemstring       string
27550                 Glow             int8
27551                 MaxBreath        uint16  // Player only.
27552                 EyeHeight        float32 // Player only.
27553                 ZoomFOV          float32 // in degrees. Player only.
27554                 UseTextureAlpha  bool
27555                 DmgTextureMod    Texture // suffix
27556                 Shaded           bool
27557                 ShowOnMinimap    bool
27558                 NametagBG        color.NRGBA
27559         }))(obj)).Textures {
27560                 if err := pcall(func() {
27561                         (((*(*(struct {
27562                                 MaxHP            uint16 // Player only.
27563                                 CollideWithNodes bool
27564                                 Weight           float32 // deprecated
27565                                 ColBox, SelBox   Box
27566                                 Pointable        bool
27567                                 Visual           string
27568                                 VisualSize       [3]float32
27569                                 Textures         []Texture
27570                                 SpriteSheetSize  [2]int16 // in sprites.
27571                                 SpritePos        [2]int16 // in sprite sheet.
27572                                 Visible          bool
27573                                 MakeFootstepSnds bool
27574                                 RotateSpeed      float32 // in radians per second.
27575                                 Mesh             string
27576                                 Colors           []color.NRGBA
27577                                 CollideWithAOs   bool
27578                                 StepHeight       float32
27579                                 FaceRotateDir    bool
27580                                 FaceRotateDirOff float32 // in degrees.
27581                                 BackfaceCull     bool
27582                                 Nametag          string
27583                                 NametagColor     color.NRGBA
27584                                 FaceRotateSpeed  float32 // in degrees per second.
27585                                 Infotext         string
27586                                 Itemstring       string
27587                                 Glow             int8
27588                                 MaxBreath        uint16  // Player only.
27589                                 EyeHeight        float32 // Player only.
27590                                 ZoomFOV          float32 // in degrees. Player only.
27591                                 UseTextureAlpha  bool
27592                                 DmgTextureMod    Texture // suffix
27593                                 Shaded           bool
27594                                 ShowOnMinimap    bool
27595                                 NametagBG        color.NRGBA
27596                         }))(obj)).Textures)[local337]).serialize(w)
27597                 }); err != nil {
27598                         if err == io.EOF {
27599                                 chk(io.EOF)
27600                         }
27601                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
27602                 }
27603         }
27604         for local338 := range (*(*(struct {
27605                 MaxHP            uint16 // Player only.
27606                 CollideWithNodes bool
27607                 Weight           float32 // deprecated
27608                 ColBox, SelBox   Box
27609                 Pointable        bool
27610                 Visual           string
27611                 VisualSize       [3]float32
27612                 Textures         []Texture
27613                 SpriteSheetSize  [2]int16 // in sprites.
27614                 SpritePos        [2]int16 // in sprite sheet.
27615                 Visible          bool
27616                 MakeFootstepSnds bool
27617                 RotateSpeed      float32 // in radians per second.
27618                 Mesh             string
27619                 Colors           []color.NRGBA
27620                 CollideWithAOs   bool
27621                 StepHeight       float32
27622                 FaceRotateDir    bool
27623                 FaceRotateDirOff float32 // in degrees.
27624                 BackfaceCull     bool
27625                 Nametag          string
27626                 NametagColor     color.NRGBA
27627                 FaceRotateSpeed  float32 // in degrees per second.
27628                 Infotext         string
27629                 Itemstring       string
27630                 Glow             int8
27631                 MaxBreath        uint16  // Player only.
27632                 EyeHeight        float32 // Player only.
27633                 ZoomFOV          float32 // in degrees. Player only.
27634                 UseTextureAlpha  bool
27635                 DmgTextureMod    Texture // suffix
27636                 Shaded           bool
27637                 ShowOnMinimap    bool
27638                 NametagBG        color.NRGBA
27639         }))(obj)).SpriteSheetSize {
27640                 {
27641                         x := ((*(*(struct {
27642                                 MaxHP            uint16 // Player only.
27643                                 CollideWithNodes bool
27644                                 Weight           float32 // deprecated
27645                                 ColBox, SelBox   Box
27646                                 Pointable        bool
27647                                 Visual           string
27648                                 VisualSize       [3]float32
27649                                 Textures         []Texture
27650                                 SpriteSheetSize  [2]int16 // in sprites.
27651                                 SpritePos        [2]int16 // in sprite sheet.
27652                                 Visible          bool
27653                                 MakeFootstepSnds bool
27654                                 RotateSpeed      float32 // in radians per second.
27655                                 Mesh             string
27656                                 Colors           []color.NRGBA
27657                                 CollideWithAOs   bool
27658                                 StepHeight       float32
27659                                 FaceRotateDir    bool
27660                                 FaceRotateDirOff float32 // in degrees.
27661                                 BackfaceCull     bool
27662                                 Nametag          string
27663                                 NametagColor     color.NRGBA
27664                                 FaceRotateSpeed  float32 // in degrees per second.
27665                                 Infotext         string
27666                                 Itemstring       string
27667                                 Glow             int8
27668                                 MaxBreath        uint16  // Player only.
27669                                 EyeHeight        float32 // Player only.
27670                                 ZoomFOV          float32 // in degrees. Player only.
27671                                 UseTextureAlpha  bool
27672                                 DmgTextureMod    Texture // suffix
27673                                 Shaded           bool
27674                                 ShowOnMinimap    bool
27675                                 NametagBG        color.NRGBA
27676                         }))(obj)).SpriteSheetSize)[local338]
27677                         write16(w, uint16(x))
27678                 }
27679         }
27680         for local339 := range (*(*(struct {
27681                 MaxHP            uint16 // Player only.
27682                 CollideWithNodes bool
27683                 Weight           float32 // deprecated
27684                 ColBox, SelBox   Box
27685                 Pointable        bool
27686                 Visual           string
27687                 VisualSize       [3]float32
27688                 Textures         []Texture
27689                 SpriteSheetSize  [2]int16 // in sprites.
27690                 SpritePos        [2]int16 // in sprite sheet.
27691                 Visible          bool
27692                 MakeFootstepSnds bool
27693                 RotateSpeed      float32 // in radians per second.
27694                 Mesh             string
27695                 Colors           []color.NRGBA
27696                 CollideWithAOs   bool
27697                 StepHeight       float32
27698                 FaceRotateDir    bool
27699                 FaceRotateDirOff float32 // in degrees.
27700                 BackfaceCull     bool
27701                 Nametag          string
27702                 NametagColor     color.NRGBA
27703                 FaceRotateSpeed  float32 // in degrees per second.
27704                 Infotext         string
27705                 Itemstring       string
27706                 Glow             int8
27707                 MaxBreath        uint16  // Player only.
27708                 EyeHeight        float32 // Player only.
27709                 ZoomFOV          float32 // in degrees. Player only.
27710                 UseTextureAlpha  bool
27711                 DmgTextureMod    Texture // suffix
27712                 Shaded           bool
27713                 ShowOnMinimap    bool
27714                 NametagBG        color.NRGBA
27715         }))(obj)).SpritePos {
27716                 {
27717                         x := ((*(*(struct {
27718                                 MaxHP            uint16 // Player only.
27719                                 CollideWithNodes bool
27720                                 Weight           float32 // deprecated
27721                                 ColBox, SelBox   Box
27722                                 Pointable        bool
27723                                 Visual           string
27724                                 VisualSize       [3]float32
27725                                 Textures         []Texture
27726                                 SpriteSheetSize  [2]int16 // in sprites.
27727                                 SpritePos        [2]int16 // in sprite sheet.
27728                                 Visible          bool
27729                                 MakeFootstepSnds bool
27730                                 RotateSpeed      float32 // in radians per second.
27731                                 Mesh             string
27732                                 Colors           []color.NRGBA
27733                                 CollideWithAOs   bool
27734                                 StepHeight       float32
27735                                 FaceRotateDir    bool
27736                                 FaceRotateDirOff float32 // in degrees.
27737                                 BackfaceCull     bool
27738                                 Nametag          string
27739                                 NametagColor     color.NRGBA
27740                                 FaceRotateSpeed  float32 // in degrees per second.
27741                                 Infotext         string
27742                                 Itemstring       string
27743                                 Glow             int8
27744                                 MaxBreath        uint16  // Player only.
27745                                 EyeHeight        float32 // Player only.
27746                                 ZoomFOV          float32 // in degrees. Player only.
27747                                 UseTextureAlpha  bool
27748                                 DmgTextureMod    Texture // suffix
27749                                 Shaded           bool
27750                                 ShowOnMinimap    bool
27751                                 NametagBG        color.NRGBA
27752                         }))(obj)).SpritePos)[local339]
27753                         write16(w, uint16(x))
27754                 }
27755         }
27756         {
27757                 x := (*(*(struct {
27758                         MaxHP            uint16 // Player only.
27759                         CollideWithNodes bool
27760                         Weight           float32 // deprecated
27761                         ColBox, SelBox   Box
27762                         Pointable        bool
27763                         Visual           string
27764                         VisualSize       [3]float32
27765                         Textures         []Texture
27766                         SpriteSheetSize  [2]int16 // in sprites.
27767                         SpritePos        [2]int16 // in sprite sheet.
27768                         Visible          bool
27769                         MakeFootstepSnds bool
27770                         RotateSpeed      float32 // in radians per second.
27771                         Mesh             string
27772                         Colors           []color.NRGBA
27773                         CollideWithAOs   bool
27774                         StepHeight       float32
27775                         FaceRotateDir    bool
27776                         FaceRotateDirOff float32 // in degrees.
27777                         BackfaceCull     bool
27778                         Nametag          string
27779                         NametagColor     color.NRGBA
27780                         FaceRotateSpeed  float32 // in degrees per second.
27781                         Infotext         string
27782                         Itemstring       string
27783                         Glow             int8
27784                         MaxBreath        uint16  // Player only.
27785                         EyeHeight        float32 // Player only.
27786                         ZoomFOV          float32 // in degrees. Player only.
27787                         UseTextureAlpha  bool
27788                         DmgTextureMod    Texture // suffix
27789                         Shaded           bool
27790                         ShowOnMinimap    bool
27791                         NametagBG        color.NRGBA
27792                 }))(obj)).Visible
27793                 if x {
27794                         write8(w, 1)
27795                 } else {
27796                         write8(w, 0)
27797                 }
27798
27799         }
27800         {
27801                 x := (*(*(struct {
27802                         MaxHP            uint16 // Player only.
27803                         CollideWithNodes bool
27804                         Weight           float32 // deprecated
27805                         ColBox, SelBox   Box
27806                         Pointable        bool
27807                         Visual           string
27808                         VisualSize       [3]float32
27809                         Textures         []Texture
27810                         SpriteSheetSize  [2]int16 // in sprites.
27811                         SpritePos        [2]int16 // in sprite sheet.
27812                         Visible          bool
27813                         MakeFootstepSnds bool
27814                         RotateSpeed      float32 // in radians per second.
27815                         Mesh             string
27816                         Colors           []color.NRGBA
27817                         CollideWithAOs   bool
27818                         StepHeight       float32
27819                         FaceRotateDir    bool
27820                         FaceRotateDirOff float32 // in degrees.
27821                         BackfaceCull     bool
27822                         Nametag          string
27823                         NametagColor     color.NRGBA
27824                         FaceRotateSpeed  float32 // in degrees per second.
27825                         Infotext         string
27826                         Itemstring       string
27827                         Glow             int8
27828                         MaxBreath        uint16  // Player only.
27829                         EyeHeight        float32 // Player only.
27830                         ZoomFOV          float32 // in degrees. Player only.
27831                         UseTextureAlpha  bool
27832                         DmgTextureMod    Texture // suffix
27833                         Shaded           bool
27834                         ShowOnMinimap    bool
27835                         NametagBG        color.NRGBA
27836                 }))(obj)).MakeFootstepSnds
27837                 if x {
27838                         write8(w, 1)
27839                 } else {
27840                         write8(w, 0)
27841                 }
27842
27843         }
27844         {
27845                 x := (*(*(struct {
27846                         MaxHP            uint16 // Player only.
27847                         CollideWithNodes bool
27848                         Weight           float32 // deprecated
27849                         ColBox, SelBox   Box
27850                         Pointable        bool
27851                         Visual           string
27852                         VisualSize       [3]float32
27853                         Textures         []Texture
27854                         SpriteSheetSize  [2]int16 // in sprites.
27855                         SpritePos        [2]int16 // in sprite sheet.
27856                         Visible          bool
27857                         MakeFootstepSnds bool
27858                         RotateSpeed      float32 // in radians per second.
27859                         Mesh             string
27860                         Colors           []color.NRGBA
27861                         CollideWithAOs   bool
27862                         StepHeight       float32
27863                         FaceRotateDir    bool
27864                         FaceRotateDirOff float32 // in degrees.
27865                         BackfaceCull     bool
27866                         Nametag          string
27867                         NametagColor     color.NRGBA
27868                         FaceRotateSpeed  float32 // in degrees per second.
27869                         Infotext         string
27870                         Itemstring       string
27871                         Glow             int8
27872                         MaxBreath        uint16  // Player only.
27873                         EyeHeight        float32 // Player only.
27874                         ZoomFOV          float32 // in degrees. Player only.
27875                         UseTextureAlpha  bool
27876                         DmgTextureMod    Texture // suffix
27877                         Shaded           bool
27878                         ShowOnMinimap    bool
27879                         NametagBG        color.NRGBA
27880                 }))(obj)).RotateSpeed
27881                 write32(w, math.Float32bits(x))
27882         }
27883         if len(([]byte((*(*(struct {
27884                 MaxHP            uint16 // Player only.
27885                 CollideWithNodes bool
27886                 Weight           float32 // deprecated
27887                 ColBox, SelBox   Box
27888                 Pointable        bool
27889                 Visual           string
27890                 VisualSize       [3]float32
27891                 Textures         []Texture
27892                 SpriteSheetSize  [2]int16 // in sprites.
27893                 SpritePos        [2]int16 // in sprite sheet.
27894                 Visible          bool
27895                 MakeFootstepSnds bool
27896                 RotateSpeed      float32 // in radians per second.
27897                 Mesh             string
27898                 Colors           []color.NRGBA
27899                 CollideWithAOs   bool
27900                 StepHeight       float32
27901                 FaceRotateDir    bool
27902                 FaceRotateDirOff float32 // in degrees.
27903                 BackfaceCull     bool
27904                 Nametag          string
27905                 NametagColor     color.NRGBA
27906                 FaceRotateSpeed  float32 // in degrees per second.
27907                 Infotext         string
27908                 Itemstring       string
27909                 Glow             int8
27910                 MaxBreath        uint16  // Player only.
27911                 EyeHeight        float32 // Player only.
27912                 ZoomFOV          float32 // in degrees. Player only.
27913                 UseTextureAlpha  bool
27914                 DmgTextureMod    Texture // suffix
27915                 Shaded           bool
27916                 ShowOnMinimap    bool
27917                 NametagBG        color.NRGBA
27918         }))(obj)).Mesh))) > math.MaxUint16 {
27919                 chk(ErrTooLong)
27920         }
27921         {
27922                 x := uint16(len(([]byte((*(*(struct {
27923                         MaxHP            uint16 // Player only.
27924                         CollideWithNodes bool
27925                         Weight           float32 // deprecated
27926                         ColBox, SelBox   Box
27927                         Pointable        bool
27928                         Visual           string
27929                         VisualSize       [3]float32
27930                         Textures         []Texture
27931                         SpriteSheetSize  [2]int16 // in sprites.
27932                         SpritePos        [2]int16 // in sprite sheet.
27933                         Visible          bool
27934                         MakeFootstepSnds bool
27935                         RotateSpeed      float32 // in radians per second.
27936                         Mesh             string
27937                         Colors           []color.NRGBA
27938                         CollideWithAOs   bool
27939                         StepHeight       float32
27940                         FaceRotateDir    bool
27941                         FaceRotateDirOff float32 // in degrees.
27942                         BackfaceCull     bool
27943                         Nametag          string
27944                         NametagColor     color.NRGBA
27945                         FaceRotateSpeed  float32 // in degrees per second.
27946                         Infotext         string
27947                         Itemstring       string
27948                         Glow             int8
27949                         MaxBreath        uint16  // Player only.
27950                         EyeHeight        float32 // Player only.
27951                         ZoomFOV          float32 // in degrees. Player only.
27952                         UseTextureAlpha  bool
27953                         DmgTextureMod    Texture // suffix
27954                         Shaded           bool
27955                         ShowOnMinimap    bool
27956                         NametagBG        color.NRGBA
27957                 }))(obj)).Mesh))))
27958                 write16(w, uint16(x))
27959         }
27960         {
27961                 _, err := w.Write(([]byte((*(*(struct {
27962                         MaxHP            uint16 // Player only.
27963                         CollideWithNodes bool
27964                         Weight           float32 // deprecated
27965                         ColBox, SelBox   Box
27966                         Pointable        bool
27967                         Visual           string
27968                         VisualSize       [3]float32
27969                         Textures         []Texture
27970                         SpriteSheetSize  [2]int16 // in sprites.
27971                         SpritePos        [2]int16 // in sprite sheet.
27972                         Visible          bool
27973                         MakeFootstepSnds bool
27974                         RotateSpeed      float32 // in radians per second.
27975                         Mesh             string
27976                         Colors           []color.NRGBA
27977                         CollideWithAOs   bool
27978                         StepHeight       float32
27979                         FaceRotateDir    bool
27980                         FaceRotateDirOff float32 // in degrees.
27981                         BackfaceCull     bool
27982                         Nametag          string
27983                         NametagColor     color.NRGBA
27984                         FaceRotateSpeed  float32 // in degrees per second.
27985                         Infotext         string
27986                         Itemstring       string
27987                         Glow             int8
27988                         MaxBreath        uint16  // Player only.
27989                         EyeHeight        float32 // Player only.
27990                         ZoomFOV          float32 // in degrees. Player only.
27991                         UseTextureAlpha  bool
27992                         DmgTextureMod    Texture // suffix
27993                         Shaded           bool
27994                         ShowOnMinimap    bool
27995                         NametagBG        color.NRGBA
27996                 }))(obj)).Mesh))[:])
27997                 chk(err)
27998         }
27999         if len(((*(*(struct {
28000                 MaxHP            uint16 // Player only.
28001                 CollideWithNodes bool
28002                 Weight           float32 // deprecated
28003                 ColBox, SelBox   Box
28004                 Pointable        bool
28005                 Visual           string
28006                 VisualSize       [3]float32
28007                 Textures         []Texture
28008                 SpriteSheetSize  [2]int16 // in sprites.
28009                 SpritePos        [2]int16 // in sprite sheet.
28010                 Visible          bool
28011                 MakeFootstepSnds bool
28012                 RotateSpeed      float32 // in radians per second.
28013                 Mesh             string
28014                 Colors           []color.NRGBA
28015                 CollideWithAOs   bool
28016                 StepHeight       float32
28017                 FaceRotateDir    bool
28018                 FaceRotateDirOff float32 // in degrees.
28019                 BackfaceCull     bool
28020                 Nametag          string
28021                 NametagColor     color.NRGBA
28022                 FaceRotateSpeed  float32 // in degrees per second.
28023                 Infotext         string
28024                 Itemstring       string
28025                 Glow             int8
28026                 MaxBreath        uint16  // Player only.
28027                 EyeHeight        float32 // Player only.
28028                 ZoomFOV          float32 // in degrees. Player only.
28029                 UseTextureAlpha  bool
28030                 DmgTextureMod    Texture // suffix
28031                 Shaded           bool
28032                 ShowOnMinimap    bool
28033                 NametagBG        color.NRGBA
28034         }))(obj)).Colors)) > math.MaxUint16 {
28035                 chk(ErrTooLong)
28036         }
28037         {
28038                 x := uint16(len(((*(*(struct {
28039                         MaxHP            uint16 // Player only.
28040                         CollideWithNodes bool
28041                         Weight           float32 // deprecated
28042                         ColBox, SelBox   Box
28043                         Pointable        bool
28044                         Visual           string
28045                         VisualSize       [3]float32
28046                         Textures         []Texture
28047                         SpriteSheetSize  [2]int16 // in sprites.
28048                         SpritePos        [2]int16 // in sprite sheet.
28049                         Visible          bool
28050                         MakeFootstepSnds bool
28051                         RotateSpeed      float32 // in radians per second.
28052                         Mesh             string
28053                         Colors           []color.NRGBA
28054                         CollideWithAOs   bool
28055                         StepHeight       float32
28056                         FaceRotateDir    bool
28057                         FaceRotateDirOff float32 // in degrees.
28058                         BackfaceCull     bool
28059                         Nametag          string
28060                         NametagColor     color.NRGBA
28061                         FaceRotateSpeed  float32 // in degrees per second.
28062                         Infotext         string
28063                         Itemstring       string
28064                         Glow             int8
28065                         MaxBreath        uint16  // Player only.
28066                         EyeHeight        float32 // Player only.
28067                         ZoomFOV          float32 // in degrees. Player only.
28068                         UseTextureAlpha  bool
28069                         DmgTextureMod    Texture // suffix
28070                         Shaded           bool
28071                         ShowOnMinimap    bool
28072                         NametagBG        color.NRGBA
28073                 }))(obj)).Colors)))
28074                 write16(w, uint16(x))
28075         }
28076         for local340 := range (*(*(struct {
28077                 MaxHP            uint16 // Player only.
28078                 CollideWithNodes bool
28079                 Weight           float32 // deprecated
28080                 ColBox, SelBox   Box
28081                 Pointable        bool
28082                 Visual           string
28083                 VisualSize       [3]float32
28084                 Textures         []Texture
28085                 SpriteSheetSize  [2]int16 // in sprites.
28086                 SpritePos        [2]int16 // in sprite sheet.
28087                 Visible          bool
28088                 MakeFootstepSnds bool
28089                 RotateSpeed      float32 // in radians per second.
28090                 Mesh             string
28091                 Colors           []color.NRGBA
28092                 CollideWithAOs   bool
28093                 StepHeight       float32
28094                 FaceRotateDir    bool
28095                 FaceRotateDirOff float32 // in degrees.
28096                 BackfaceCull     bool
28097                 Nametag          string
28098                 NametagColor     color.NRGBA
28099                 FaceRotateSpeed  float32 // in degrees per second.
28100                 Infotext         string
28101                 Itemstring       string
28102                 Glow             int8
28103                 MaxBreath        uint16  // Player only.
28104                 EyeHeight        float32 // Player only.
28105                 ZoomFOV          float32 // in degrees. Player only.
28106                 UseTextureAlpha  bool
28107                 DmgTextureMod    Texture // suffix
28108                 Shaded           bool
28109                 ShowOnMinimap    bool
28110                 NametagBG        color.NRGBA
28111         }))(obj)).Colors {
28112                 {
28113                         x := ((*(*(struct {
28114                                 MaxHP            uint16 // Player only.
28115                                 CollideWithNodes bool
28116                                 Weight           float32 // deprecated
28117                                 ColBox, SelBox   Box
28118                                 Pointable        bool
28119                                 Visual           string
28120                                 VisualSize       [3]float32
28121                                 Textures         []Texture
28122                                 SpriteSheetSize  [2]int16 // in sprites.
28123                                 SpritePos        [2]int16 // in sprite sheet.
28124                                 Visible          bool
28125                                 MakeFootstepSnds bool
28126                                 RotateSpeed      float32 // in radians per second.
28127                                 Mesh             string
28128                                 Colors           []color.NRGBA
28129                                 CollideWithAOs   bool
28130                                 StepHeight       float32
28131                                 FaceRotateDir    bool
28132                                 FaceRotateDirOff float32 // in degrees.
28133                                 BackfaceCull     bool
28134                                 Nametag          string
28135                                 NametagColor     color.NRGBA
28136                                 FaceRotateSpeed  float32 // in degrees per second.
28137                                 Infotext         string
28138                                 Itemstring       string
28139                                 Glow             int8
28140                                 MaxBreath        uint16  // Player only.
28141                                 EyeHeight        float32 // Player only.
28142                                 ZoomFOV          float32 // in degrees. Player only.
28143                                 UseTextureAlpha  bool
28144                                 DmgTextureMod    Texture // suffix
28145                                 Shaded           bool
28146                                 ShowOnMinimap    bool
28147                                 NametagBG        color.NRGBA
28148                         }))(obj)).Colors)[local340]
28149                         w.Write([]byte{x.A, x.R, x.G, x.B})
28150
28151                 }
28152         }
28153         {
28154                 x := (*(*(struct {
28155                         MaxHP            uint16 // Player only.
28156                         CollideWithNodes bool
28157                         Weight           float32 // deprecated
28158                         ColBox, SelBox   Box
28159                         Pointable        bool
28160                         Visual           string
28161                         VisualSize       [3]float32
28162                         Textures         []Texture
28163                         SpriteSheetSize  [2]int16 // in sprites.
28164                         SpritePos        [2]int16 // in sprite sheet.
28165                         Visible          bool
28166                         MakeFootstepSnds bool
28167                         RotateSpeed      float32 // in radians per second.
28168                         Mesh             string
28169                         Colors           []color.NRGBA
28170                         CollideWithAOs   bool
28171                         StepHeight       float32
28172                         FaceRotateDir    bool
28173                         FaceRotateDirOff float32 // in degrees.
28174                         BackfaceCull     bool
28175                         Nametag          string
28176                         NametagColor     color.NRGBA
28177                         FaceRotateSpeed  float32 // in degrees per second.
28178                         Infotext         string
28179                         Itemstring       string
28180                         Glow             int8
28181                         MaxBreath        uint16  // Player only.
28182                         EyeHeight        float32 // Player only.
28183                         ZoomFOV          float32 // in degrees. Player only.
28184                         UseTextureAlpha  bool
28185                         DmgTextureMod    Texture // suffix
28186                         Shaded           bool
28187                         ShowOnMinimap    bool
28188                         NametagBG        color.NRGBA
28189                 }))(obj)).CollideWithAOs
28190                 if x {
28191                         write8(w, 1)
28192                 } else {
28193                         write8(w, 0)
28194                 }
28195
28196         }
28197         {
28198                 x := (*(*(struct {
28199                         MaxHP            uint16 // Player only.
28200                         CollideWithNodes bool
28201                         Weight           float32 // deprecated
28202                         ColBox, SelBox   Box
28203                         Pointable        bool
28204                         Visual           string
28205                         VisualSize       [3]float32
28206                         Textures         []Texture
28207                         SpriteSheetSize  [2]int16 // in sprites.
28208                         SpritePos        [2]int16 // in sprite sheet.
28209                         Visible          bool
28210                         MakeFootstepSnds bool
28211                         RotateSpeed      float32 // in radians per second.
28212                         Mesh             string
28213                         Colors           []color.NRGBA
28214                         CollideWithAOs   bool
28215                         StepHeight       float32
28216                         FaceRotateDir    bool
28217                         FaceRotateDirOff float32 // in degrees.
28218                         BackfaceCull     bool
28219                         Nametag          string
28220                         NametagColor     color.NRGBA
28221                         FaceRotateSpeed  float32 // in degrees per second.
28222                         Infotext         string
28223                         Itemstring       string
28224                         Glow             int8
28225                         MaxBreath        uint16  // Player only.
28226                         EyeHeight        float32 // Player only.
28227                         ZoomFOV          float32 // in degrees. Player only.
28228                         UseTextureAlpha  bool
28229                         DmgTextureMod    Texture // suffix
28230                         Shaded           bool
28231                         ShowOnMinimap    bool
28232                         NametagBG        color.NRGBA
28233                 }))(obj)).StepHeight
28234                 write32(w, math.Float32bits(x))
28235         }
28236         {
28237                 x := (*(*(struct {
28238                         MaxHP            uint16 // Player only.
28239                         CollideWithNodes bool
28240                         Weight           float32 // deprecated
28241                         ColBox, SelBox   Box
28242                         Pointable        bool
28243                         Visual           string
28244                         VisualSize       [3]float32
28245                         Textures         []Texture
28246                         SpriteSheetSize  [2]int16 // in sprites.
28247                         SpritePos        [2]int16 // in sprite sheet.
28248                         Visible          bool
28249                         MakeFootstepSnds bool
28250                         RotateSpeed      float32 // in radians per second.
28251                         Mesh             string
28252                         Colors           []color.NRGBA
28253                         CollideWithAOs   bool
28254                         StepHeight       float32
28255                         FaceRotateDir    bool
28256                         FaceRotateDirOff float32 // in degrees.
28257                         BackfaceCull     bool
28258                         Nametag          string
28259                         NametagColor     color.NRGBA
28260                         FaceRotateSpeed  float32 // in degrees per second.
28261                         Infotext         string
28262                         Itemstring       string
28263                         Glow             int8
28264                         MaxBreath        uint16  // Player only.
28265                         EyeHeight        float32 // Player only.
28266                         ZoomFOV          float32 // in degrees. Player only.
28267                         UseTextureAlpha  bool
28268                         DmgTextureMod    Texture // suffix
28269                         Shaded           bool
28270                         ShowOnMinimap    bool
28271                         NametagBG        color.NRGBA
28272                 }))(obj)).FaceRotateDir
28273                 if x {
28274                         write8(w, 1)
28275                 } else {
28276                         write8(w, 0)
28277                 }
28278
28279         }
28280         {
28281                 x := (*(*(struct {
28282                         MaxHP            uint16 // Player only.
28283                         CollideWithNodes bool
28284                         Weight           float32 // deprecated
28285                         ColBox, SelBox   Box
28286                         Pointable        bool
28287                         Visual           string
28288                         VisualSize       [3]float32
28289                         Textures         []Texture
28290                         SpriteSheetSize  [2]int16 // in sprites.
28291                         SpritePos        [2]int16 // in sprite sheet.
28292                         Visible          bool
28293                         MakeFootstepSnds bool
28294                         RotateSpeed      float32 // in radians per second.
28295                         Mesh             string
28296                         Colors           []color.NRGBA
28297                         CollideWithAOs   bool
28298                         StepHeight       float32
28299                         FaceRotateDir    bool
28300                         FaceRotateDirOff float32 // in degrees.
28301                         BackfaceCull     bool
28302                         Nametag          string
28303                         NametagColor     color.NRGBA
28304                         FaceRotateSpeed  float32 // in degrees per second.
28305                         Infotext         string
28306                         Itemstring       string
28307                         Glow             int8
28308                         MaxBreath        uint16  // Player only.
28309                         EyeHeight        float32 // Player only.
28310                         ZoomFOV          float32 // in degrees. Player only.
28311                         UseTextureAlpha  bool
28312                         DmgTextureMod    Texture // suffix
28313                         Shaded           bool
28314                         ShowOnMinimap    bool
28315                         NametagBG        color.NRGBA
28316                 }))(obj)).FaceRotateDirOff
28317                 write32(w, math.Float32bits(x))
28318         }
28319         {
28320                 x := (*(*(struct {
28321                         MaxHP            uint16 // Player only.
28322                         CollideWithNodes bool
28323                         Weight           float32 // deprecated
28324                         ColBox, SelBox   Box
28325                         Pointable        bool
28326                         Visual           string
28327                         VisualSize       [3]float32
28328                         Textures         []Texture
28329                         SpriteSheetSize  [2]int16 // in sprites.
28330                         SpritePos        [2]int16 // in sprite sheet.
28331                         Visible          bool
28332                         MakeFootstepSnds bool
28333                         RotateSpeed      float32 // in radians per second.
28334                         Mesh             string
28335                         Colors           []color.NRGBA
28336                         CollideWithAOs   bool
28337                         StepHeight       float32
28338                         FaceRotateDir    bool
28339                         FaceRotateDirOff float32 // in degrees.
28340                         BackfaceCull     bool
28341                         Nametag          string
28342                         NametagColor     color.NRGBA
28343                         FaceRotateSpeed  float32 // in degrees per second.
28344                         Infotext         string
28345                         Itemstring       string
28346                         Glow             int8
28347                         MaxBreath        uint16  // Player only.
28348                         EyeHeight        float32 // Player only.
28349                         ZoomFOV          float32 // in degrees. Player only.
28350                         UseTextureAlpha  bool
28351                         DmgTextureMod    Texture // suffix
28352                         Shaded           bool
28353                         ShowOnMinimap    bool
28354                         NametagBG        color.NRGBA
28355                 }))(obj)).BackfaceCull
28356                 if x {
28357                         write8(w, 1)
28358                 } else {
28359                         write8(w, 0)
28360                 }
28361
28362         }
28363         if len(([]byte((*(*(struct {
28364                 MaxHP            uint16 // Player only.
28365                 CollideWithNodes bool
28366                 Weight           float32 // deprecated
28367                 ColBox, SelBox   Box
28368                 Pointable        bool
28369                 Visual           string
28370                 VisualSize       [3]float32
28371                 Textures         []Texture
28372                 SpriteSheetSize  [2]int16 // in sprites.
28373                 SpritePos        [2]int16 // in sprite sheet.
28374                 Visible          bool
28375                 MakeFootstepSnds bool
28376                 RotateSpeed      float32 // in radians per second.
28377                 Mesh             string
28378                 Colors           []color.NRGBA
28379                 CollideWithAOs   bool
28380                 StepHeight       float32
28381                 FaceRotateDir    bool
28382                 FaceRotateDirOff float32 // in degrees.
28383                 BackfaceCull     bool
28384                 Nametag          string
28385                 NametagColor     color.NRGBA
28386                 FaceRotateSpeed  float32 // in degrees per second.
28387                 Infotext         string
28388                 Itemstring       string
28389                 Glow             int8
28390                 MaxBreath        uint16  // Player only.
28391                 EyeHeight        float32 // Player only.
28392                 ZoomFOV          float32 // in degrees. Player only.
28393                 UseTextureAlpha  bool
28394                 DmgTextureMod    Texture // suffix
28395                 Shaded           bool
28396                 ShowOnMinimap    bool
28397                 NametagBG        color.NRGBA
28398         }))(obj)).Nametag))) > math.MaxUint16 {
28399                 chk(ErrTooLong)
28400         }
28401         {
28402                 x := uint16(len(([]byte((*(*(struct {
28403                         MaxHP            uint16 // Player only.
28404                         CollideWithNodes bool
28405                         Weight           float32 // deprecated
28406                         ColBox, SelBox   Box
28407                         Pointable        bool
28408                         Visual           string
28409                         VisualSize       [3]float32
28410                         Textures         []Texture
28411                         SpriteSheetSize  [2]int16 // in sprites.
28412                         SpritePos        [2]int16 // in sprite sheet.
28413                         Visible          bool
28414                         MakeFootstepSnds bool
28415                         RotateSpeed      float32 // in radians per second.
28416                         Mesh             string
28417                         Colors           []color.NRGBA
28418                         CollideWithAOs   bool
28419                         StepHeight       float32
28420                         FaceRotateDir    bool
28421                         FaceRotateDirOff float32 // in degrees.
28422                         BackfaceCull     bool
28423                         Nametag          string
28424                         NametagColor     color.NRGBA
28425                         FaceRotateSpeed  float32 // in degrees per second.
28426                         Infotext         string
28427                         Itemstring       string
28428                         Glow             int8
28429                         MaxBreath        uint16  // Player only.
28430                         EyeHeight        float32 // Player only.
28431                         ZoomFOV          float32 // in degrees. Player only.
28432                         UseTextureAlpha  bool
28433                         DmgTextureMod    Texture // suffix
28434                         Shaded           bool
28435                         ShowOnMinimap    bool
28436                         NametagBG        color.NRGBA
28437                 }))(obj)).Nametag))))
28438                 write16(w, uint16(x))
28439         }
28440         {
28441                 _, err := w.Write(([]byte((*(*(struct {
28442                         MaxHP            uint16 // Player only.
28443                         CollideWithNodes bool
28444                         Weight           float32 // deprecated
28445                         ColBox, SelBox   Box
28446                         Pointable        bool
28447                         Visual           string
28448                         VisualSize       [3]float32
28449                         Textures         []Texture
28450                         SpriteSheetSize  [2]int16 // in sprites.
28451                         SpritePos        [2]int16 // in sprite sheet.
28452                         Visible          bool
28453                         MakeFootstepSnds bool
28454                         RotateSpeed      float32 // in radians per second.
28455                         Mesh             string
28456                         Colors           []color.NRGBA
28457                         CollideWithAOs   bool
28458                         StepHeight       float32
28459                         FaceRotateDir    bool
28460                         FaceRotateDirOff float32 // in degrees.
28461                         BackfaceCull     bool
28462                         Nametag          string
28463                         NametagColor     color.NRGBA
28464                         FaceRotateSpeed  float32 // in degrees per second.
28465                         Infotext         string
28466                         Itemstring       string
28467                         Glow             int8
28468                         MaxBreath        uint16  // Player only.
28469                         EyeHeight        float32 // Player only.
28470                         ZoomFOV          float32 // in degrees. Player only.
28471                         UseTextureAlpha  bool
28472                         DmgTextureMod    Texture // suffix
28473                         Shaded           bool
28474                         ShowOnMinimap    bool
28475                         NametagBG        color.NRGBA
28476                 }))(obj)).Nametag))[:])
28477                 chk(err)
28478         }
28479         {
28480                 x := (*(*(struct {
28481                         MaxHP            uint16 // Player only.
28482                         CollideWithNodes bool
28483                         Weight           float32 // deprecated
28484                         ColBox, SelBox   Box
28485                         Pointable        bool
28486                         Visual           string
28487                         VisualSize       [3]float32
28488                         Textures         []Texture
28489                         SpriteSheetSize  [2]int16 // in sprites.
28490                         SpritePos        [2]int16 // in sprite sheet.
28491                         Visible          bool
28492                         MakeFootstepSnds bool
28493                         RotateSpeed      float32 // in radians per second.
28494                         Mesh             string
28495                         Colors           []color.NRGBA
28496                         CollideWithAOs   bool
28497                         StepHeight       float32
28498                         FaceRotateDir    bool
28499                         FaceRotateDirOff float32 // in degrees.
28500                         BackfaceCull     bool
28501                         Nametag          string
28502                         NametagColor     color.NRGBA
28503                         FaceRotateSpeed  float32 // in degrees per second.
28504                         Infotext         string
28505                         Itemstring       string
28506                         Glow             int8
28507                         MaxBreath        uint16  // Player only.
28508                         EyeHeight        float32 // Player only.
28509                         ZoomFOV          float32 // in degrees. Player only.
28510                         UseTextureAlpha  bool
28511                         DmgTextureMod    Texture // suffix
28512                         Shaded           bool
28513                         ShowOnMinimap    bool
28514                         NametagBG        color.NRGBA
28515                 }))(obj)).NametagColor
28516                 w.Write([]byte{x.A, x.R, x.G, x.B})
28517
28518         }
28519         {
28520                 x := (*(*(struct {
28521                         MaxHP            uint16 // Player only.
28522                         CollideWithNodes bool
28523                         Weight           float32 // deprecated
28524                         ColBox, SelBox   Box
28525                         Pointable        bool
28526                         Visual           string
28527                         VisualSize       [3]float32
28528                         Textures         []Texture
28529                         SpriteSheetSize  [2]int16 // in sprites.
28530                         SpritePos        [2]int16 // in sprite sheet.
28531                         Visible          bool
28532                         MakeFootstepSnds bool
28533                         RotateSpeed      float32 // in radians per second.
28534                         Mesh             string
28535                         Colors           []color.NRGBA
28536                         CollideWithAOs   bool
28537                         StepHeight       float32
28538                         FaceRotateDir    bool
28539                         FaceRotateDirOff float32 // in degrees.
28540                         BackfaceCull     bool
28541                         Nametag          string
28542                         NametagColor     color.NRGBA
28543                         FaceRotateSpeed  float32 // in degrees per second.
28544                         Infotext         string
28545                         Itemstring       string
28546                         Glow             int8
28547                         MaxBreath        uint16  // Player only.
28548                         EyeHeight        float32 // Player only.
28549                         ZoomFOV          float32 // in degrees. Player only.
28550                         UseTextureAlpha  bool
28551                         DmgTextureMod    Texture // suffix
28552                         Shaded           bool
28553                         ShowOnMinimap    bool
28554                         NametagBG        color.NRGBA
28555                 }))(obj)).FaceRotateSpeed
28556                 write32(w, math.Float32bits(x))
28557         }
28558         if len(([]byte((*(*(struct {
28559                 MaxHP            uint16 // Player only.
28560                 CollideWithNodes bool
28561                 Weight           float32 // deprecated
28562                 ColBox, SelBox   Box
28563                 Pointable        bool
28564                 Visual           string
28565                 VisualSize       [3]float32
28566                 Textures         []Texture
28567                 SpriteSheetSize  [2]int16 // in sprites.
28568                 SpritePos        [2]int16 // in sprite sheet.
28569                 Visible          bool
28570                 MakeFootstepSnds bool
28571                 RotateSpeed      float32 // in radians per second.
28572                 Mesh             string
28573                 Colors           []color.NRGBA
28574                 CollideWithAOs   bool
28575                 StepHeight       float32
28576                 FaceRotateDir    bool
28577                 FaceRotateDirOff float32 // in degrees.
28578                 BackfaceCull     bool
28579                 Nametag          string
28580                 NametagColor     color.NRGBA
28581                 FaceRotateSpeed  float32 // in degrees per second.
28582                 Infotext         string
28583                 Itemstring       string
28584                 Glow             int8
28585                 MaxBreath        uint16  // Player only.
28586                 EyeHeight        float32 // Player only.
28587                 ZoomFOV          float32 // in degrees. Player only.
28588                 UseTextureAlpha  bool
28589                 DmgTextureMod    Texture // suffix
28590                 Shaded           bool
28591                 ShowOnMinimap    bool
28592                 NametagBG        color.NRGBA
28593         }))(obj)).Infotext))) > math.MaxUint16 {
28594                 chk(ErrTooLong)
28595         }
28596         {
28597                 x := uint16(len(([]byte((*(*(struct {
28598                         MaxHP            uint16 // Player only.
28599                         CollideWithNodes bool
28600                         Weight           float32 // deprecated
28601                         ColBox, SelBox   Box
28602                         Pointable        bool
28603                         Visual           string
28604                         VisualSize       [3]float32
28605                         Textures         []Texture
28606                         SpriteSheetSize  [2]int16 // in sprites.
28607                         SpritePos        [2]int16 // in sprite sheet.
28608                         Visible          bool
28609                         MakeFootstepSnds bool
28610                         RotateSpeed      float32 // in radians per second.
28611                         Mesh             string
28612                         Colors           []color.NRGBA
28613                         CollideWithAOs   bool
28614                         StepHeight       float32
28615                         FaceRotateDir    bool
28616                         FaceRotateDirOff float32 // in degrees.
28617                         BackfaceCull     bool
28618                         Nametag          string
28619                         NametagColor     color.NRGBA
28620                         FaceRotateSpeed  float32 // in degrees per second.
28621                         Infotext         string
28622                         Itemstring       string
28623                         Glow             int8
28624                         MaxBreath        uint16  // Player only.
28625                         EyeHeight        float32 // Player only.
28626                         ZoomFOV          float32 // in degrees. Player only.
28627                         UseTextureAlpha  bool
28628                         DmgTextureMod    Texture // suffix
28629                         Shaded           bool
28630                         ShowOnMinimap    bool
28631                         NametagBG        color.NRGBA
28632                 }))(obj)).Infotext))))
28633                 write16(w, uint16(x))
28634         }
28635         {
28636                 _, err := w.Write(([]byte((*(*(struct {
28637                         MaxHP            uint16 // Player only.
28638                         CollideWithNodes bool
28639                         Weight           float32 // deprecated
28640                         ColBox, SelBox   Box
28641                         Pointable        bool
28642                         Visual           string
28643                         VisualSize       [3]float32
28644                         Textures         []Texture
28645                         SpriteSheetSize  [2]int16 // in sprites.
28646                         SpritePos        [2]int16 // in sprite sheet.
28647                         Visible          bool
28648                         MakeFootstepSnds bool
28649                         RotateSpeed      float32 // in radians per second.
28650                         Mesh             string
28651                         Colors           []color.NRGBA
28652                         CollideWithAOs   bool
28653                         StepHeight       float32
28654                         FaceRotateDir    bool
28655                         FaceRotateDirOff float32 // in degrees.
28656                         BackfaceCull     bool
28657                         Nametag          string
28658                         NametagColor     color.NRGBA
28659                         FaceRotateSpeed  float32 // in degrees per second.
28660                         Infotext         string
28661                         Itemstring       string
28662                         Glow             int8
28663                         MaxBreath        uint16  // Player only.
28664                         EyeHeight        float32 // Player only.
28665                         ZoomFOV          float32 // in degrees. Player only.
28666                         UseTextureAlpha  bool
28667                         DmgTextureMod    Texture // suffix
28668                         Shaded           bool
28669                         ShowOnMinimap    bool
28670                         NametagBG        color.NRGBA
28671                 }))(obj)).Infotext))[:])
28672                 chk(err)
28673         }
28674         if len(([]byte((*(*(struct {
28675                 MaxHP            uint16 // Player only.
28676                 CollideWithNodes bool
28677                 Weight           float32 // deprecated
28678                 ColBox, SelBox   Box
28679                 Pointable        bool
28680                 Visual           string
28681                 VisualSize       [3]float32
28682                 Textures         []Texture
28683                 SpriteSheetSize  [2]int16 // in sprites.
28684                 SpritePos        [2]int16 // in sprite sheet.
28685                 Visible          bool
28686                 MakeFootstepSnds bool
28687                 RotateSpeed      float32 // in radians per second.
28688                 Mesh             string
28689                 Colors           []color.NRGBA
28690                 CollideWithAOs   bool
28691                 StepHeight       float32
28692                 FaceRotateDir    bool
28693                 FaceRotateDirOff float32 // in degrees.
28694                 BackfaceCull     bool
28695                 Nametag          string
28696                 NametagColor     color.NRGBA
28697                 FaceRotateSpeed  float32 // in degrees per second.
28698                 Infotext         string
28699                 Itemstring       string
28700                 Glow             int8
28701                 MaxBreath        uint16  // Player only.
28702                 EyeHeight        float32 // Player only.
28703                 ZoomFOV          float32 // in degrees. Player only.
28704                 UseTextureAlpha  bool
28705                 DmgTextureMod    Texture // suffix
28706                 Shaded           bool
28707                 ShowOnMinimap    bool
28708                 NametagBG        color.NRGBA
28709         }))(obj)).Itemstring))) > math.MaxUint16 {
28710                 chk(ErrTooLong)
28711         }
28712         {
28713                 x := uint16(len(([]byte((*(*(struct {
28714                         MaxHP            uint16 // Player only.
28715                         CollideWithNodes bool
28716                         Weight           float32 // deprecated
28717                         ColBox, SelBox   Box
28718                         Pointable        bool
28719                         Visual           string
28720                         VisualSize       [3]float32
28721                         Textures         []Texture
28722                         SpriteSheetSize  [2]int16 // in sprites.
28723                         SpritePos        [2]int16 // in sprite sheet.
28724                         Visible          bool
28725                         MakeFootstepSnds bool
28726                         RotateSpeed      float32 // in radians per second.
28727                         Mesh             string
28728                         Colors           []color.NRGBA
28729                         CollideWithAOs   bool
28730                         StepHeight       float32
28731                         FaceRotateDir    bool
28732                         FaceRotateDirOff float32 // in degrees.
28733                         BackfaceCull     bool
28734                         Nametag          string
28735                         NametagColor     color.NRGBA
28736                         FaceRotateSpeed  float32 // in degrees per second.
28737                         Infotext         string
28738                         Itemstring       string
28739                         Glow             int8
28740                         MaxBreath        uint16  // Player only.
28741                         EyeHeight        float32 // Player only.
28742                         ZoomFOV          float32 // in degrees. Player only.
28743                         UseTextureAlpha  bool
28744                         DmgTextureMod    Texture // suffix
28745                         Shaded           bool
28746                         ShowOnMinimap    bool
28747                         NametagBG        color.NRGBA
28748                 }))(obj)).Itemstring))))
28749                 write16(w, uint16(x))
28750         }
28751         {
28752                 _, err := w.Write(([]byte((*(*(struct {
28753                         MaxHP            uint16 // Player only.
28754                         CollideWithNodes bool
28755                         Weight           float32 // deprecated
28756                         ColBox, SelBox   Box
28757                         Pointable        bool
28758                         Visual           string
28759                         VisualSize       [3]float32
28760                         Textures         []Texture
28761                         SpriteSheetSize  [2]int16 // in sprites.
28762                         SpritePos        [2]int16 // in sprite sheet.
28763                         Visible          bool
28764                         MakeFootstepSnds bool
28765                         RotateSpeed      float32 // in radians per second.
28766                         Mesh             string
28767                         Colors           []color.NRGBA
28768                         CollideWithAOs   bool
28769                         StepHeight       float32
28770                         FaceRotateDir    bool
28771                         FaceRotateDirOff float32 // in degrees.
28772                         BackfaceCull     bool
28773                         Nametag          string
28774                         NametagColor     color.NRGBA
28775                         FaceRotateSpeed  float32 // in degrees per second.
28776                         Infotext         string
28777                         Itemstring       string
28778                         Glow             int8
28779                         MaxBreath        uint16  // Player only.
28780                         EyeHeight        float32 // Player only.
28781                         ZoomFOV          float32 // in degrees. Player only.
28782                         UseTextureAlpha  bool
28783                         DmgTextureMod    Texture // suffix
28784                         Shaded           bool
28785                         ShowOnMinimap    bool
28786                         NametagBG        color.NRGBA
28787                 }))(obj)).Itemstring))[:])
28788                 chk(err)
28789         }
28790         {
28791                 x := (*(*(struct {
28792                         MaxHP            uint16 // Player only.
28793                         CollideWithNodes bool
28794                         Weight           float32 // deprecated
28795                         ColBox, SelBox   Box
28796                         Pointable        bool
28797                         Visual           string
28798                         VisualSize       [3]float32
28799                         Textures         []Texture
28800                         SpriteSheetSize  [2]int16 // in sprites.
28801                         SpritePos        [2]int16 // in sprite sheet.
28802                         Visible          bool
28803                         MakeFootstepSnds bool
28804                         RotateSpeed      float32 // in radians per second.
28805                         Mesh             string
28806                         Colors           []color.NRGBA
28807                         CollideWithAOs   bool
28808                         StepHeight       float32
28809                         FaceRotateDir    bool
28810                         FaceRotateDirOff float32 // in degrees.
28811                         BackfaceCull     bool
28812                         Nametag          string
28813                         NametagColor     color.NRGBA
28814                         FaceRotateSpeed  float32 // in degrees per second.
28815                         Infotext         string
28816                         Itemstring       string
28817                         Glow             int8
28818                         MaxBreath        uint16  // Player only.
28819                         EyeHeight        float32 // Player only.
28820                         ZoomFOV          float32 // in degrees. Player only.
28821                         UseTextureAlpha  bool
28822                         DmgTextureMod    Texture // suffix
28823                         Shaded           bool
28824                         ShowOnMinimap    bool
28825                         NametagBG        color.NRGBA
28826                 }))(obj)).Glow
28827                 write8(w, uint8(x))
28828         }
28829         {
28830                 x := (*(*(struct {
28831                         MaxHP            uint16 // Player only.
28832                         CollideWithNodes bool
28833                         Weight           float32 // deprecated
28834                         ColBox, SelBox   Box
28835                         Pointable        bool
28836                         Visual           string
28837                         VisualSize       [3]float32
28838                         Textures         []Texture
28839                         SpriteSheetSize  [2]int16 // in sprites.
28840                         SpritePos        [2]int16 // in sprite sheet.
28841                         Visible          bool
28842                         MakeFootstepSnds bool
28843                         RotateSpeed      float32 // in radians per second.
28844                         Mesh             string
28845                         Colors           []color.NRGBA
28846                         CollideWithAOs   bool
28847                         StepHeight       float32
28848                         FaceRotateDir    bool
28849                         FaceRotateDirOff float32 // in degrees.
28850                         BackfaceCull     bool
28851                         Nametag          string
28852                         NametagColor     color.NRGBA
28853                         FaceRotateSpeed  float32 // in degrees per second.
28854                         Infotext         string
28855                         Itemstring       string
28856                         Glow             int8
28857                         MaxBreath        uint16  // Player only.
28858                         EyeHeight        float32 // Player only.
28859                         ZoomFOV          float32 // in degrees. Player only.
28860                         UseTextureAlpha  bool
28861                         DmgTextureMod    Texture // suffix
28862                         Shaded           bool
28863                         ShowOnMinimap    bool
28864                         NametagBG        color.NRGBA
28865                 }))(obj)).MaxBreath
28866                 write16(w, uint16(x))
28867         }
28868         {
28869                 x := (*(*(struct {
28870                         MaxHP            uint16 // Player only.
28871                         CollideWithNodes bool
28872                         Weight           float32 // deprecated
28873                         ColBox, SelBox   Box
28874                         Pointable        bool
28875                         Visual           string
28876                         VisualSize       [3]float32
28877                         Textures         []Texture
28878                         SpriteSheetSize  [2]int16 // in sprites.
28879                         SpritePos        [2]int16 // in sprite sheet.
28880                         Visible          bool
28881                         MakeFootstepSnds bool
28882                         RotateSpeed      float32 // in radians per second.
28883                         Mesh             string
28884                         Colors           []color.NRGBA
28885                         CollideWithAOs   bool
28886                         StepHeight       float32
28887                         FaceRotateDir    bool
28888                         FaceRotateDirOff float32 // in degrees.
28889                         BackfaceCull     bool
28890                         Nametag          string
28891                         NametagColor     color.NRGBA
28892                         FaceRotateSpeed  float32 // in degrees per second.
28893                         Infotext         string
28894                         Itemstring       string
28895                         Glow             int8
28896                         MaxBreath        uint16  // Player only.
28897                         EyeHeight        float32 // Player only.
28898                         ZoomFOV          float32 // in degrees. Player only.
28899                         UseTextureAlpha  bool
28900                         DmgTextureMod    Texture // suffix
28901                         Shaded           bool
28902                         ShowOnMinimap    bool
28903                         NametagBG        color.NRGBA
28904                 }))(obj)).EyeHeight
28905                 write32(w, math.Float32bits(x))
28906         }
28907         {
28908                 x := (*(*(struct {
28909                         MaxHP            uint16 // Player only.
28910                         CollideWithNodes bool
28911                         Weight           float32 // deprecated
28912                         ColBox, SelBox   Box
28913                         Pointable        bool
28914                         Visual           string
28915                         VisualSize       [3]float32
28916                         Textures         []Texture
28917                         SpriteSheetSize  [2]int16 // in sprites.
28918                         SpritePos        [2]int16 // in sprite sheet.
28919                         Visible          bool
28920                         MakeFootstepSnds bool
28921                         RotateSpeed      float32 // in radians per second.
28922                         Mesh             string
28923                         Colors           []color.NRGBA
28924                         CollideWithAOs   bool
28925                         StepHeight       float32
28926                         FaceRotateDir    bool
28927                         FaceRotateDirOff float32 // in degrees.
28928                         BackfaceCull     bool
28929                         Nametag          string
28930                         NametagColor     color.NRGBA
28931                         FaceRotateSpeed  float32 // in degrees per second.
28932                         Infotext         string
28933                         Itemstring       string
28934                         Glow             int8
28935                         MaxBreath        uint16  // Player only.
28936                         EyeHeight        float32 // Player only.
28937                         ZoomFOV          float32 // in degrees. Player only.
28938                         UseTextureAlpha  bool
28939                         DmgTextureMod    Texture // suffix
28940                         Shaded           bool
28941                         ShowOnMinimap    bool
28942                         NametagBG        color.NRGBA
28943                 }))(obj)).ZoomFOV
28944                 write32(w, math.Float32bits(x))
28945         }
28946         {
28947                 x := (*(*(struct {
28948                         MaxHP            uint16 // Player only.
28949                         CollideWithNodes bool
28950                         Weight           float32 // deprecated
28951                         ColBox, SelBox   Box
28952                         Pointable        bool
28953                         Visual           string
28954                         VisualSize       [3]float32
28955                         Textures         []Texture
28956                         SpriteSheetSize  [2]int16 // in sprites.
28957                         SpritePos        [2]int16 // in sprite sheet.
28958                         Visible          bool
28959                         MakeFootstepSnds bool
28960                         RotateSpeed      float32 // in radians per second.
28961                         Mesh             string
28962                         Colors           []color.NRGBA
28963                         CollideWithAOs   bool
28964                         StepHeight       float32
28965                         FaceRotateDir    bool
28966                         FaceRotateDirOff float32 // in degrees.
28967                         BackfaceCull     bool
28968                         Nametag          string
28969                         NametagColor     color.NRGBA
28970                         FaceRotateSpeed  float32 // in degrees per second.
28971                         Infotext         string
28972                         Itemstring       string
28973                         Glow             int8
28974                         MaxBreath        uint16  // Player only.
28975                         EyeHeight        float32 // Player only.
28976                         ZoomFOV          float32 // in degrees. Player only.
28977                         UseTextureAlpha  bool
28978                         DmgTextureMod    Texture // suffix
28979                         Shaded           bool
28980                         ShowOnMinimap    bool
28981                         NametagBG        color.NRGBA
28982                 }))(obj)).UseTextureAlpha
28983                 if x {
28984                         write8(w, 1)
28985                 } else {
28986                         write8(w, 0)
28987                 }
28988
28989         }
28990         if err := pcall(func() {
28991                 ((*(*(struct {
28992                         MaxHP            uint16 // Player only.
28993                         CollideWithNodes bool
28994                         Weight           float32 // deprecated
28995                         ColBox, SelBox   Box
28996                         Pointable        bool
28997                         Visual           string
28998                         VisualSize       [3]float32
28999                         Textures         []Texture
29000                         SpriteSheetSize  [2]int16 // in sprites.
29001                         SpritePos        [2]int16 // in sprite sheet.
29002                         Visible          bool
29003                         MakeFootstepSnds bool
29004                         RotateSpeed      float32 // in radians per second.
29005                         Mesh             string
29006                         Colors           []color.NRGBA
29007                         CollideWithAOs   bool
29008                         StepHeight       float32
29009                         FaceRotateDir    bool
29010                         FaceRotateDirOff float32 // in degrees.
29011                         BackfaceCull     bool
29012                         Nametag          string
29013                         NametagColor     color.NRGBA
29014                         FaceRotateSpeed  float32 // in degrees per second.
29015                         Infotext         string
29016                         Itemstring       string
29017                         Glow             int8
29018                         MaxBreath        uint16  // Player only.
29019                         EyeHeight        float32 // Player only.
29020                         ZoomFOV          float32 // in degrees. Player only.
29021                         UseTextureAlpha  bool
29022                         DmgTextureMod    Texture // suffix
29023                         Shaded           bool
29024                         ShowOnMinimap    bool
29025                         NametagBG        color.NRGBA
29026                 }))(obj)).DmgTextureMod).serialize(w)
29027         }); err != nil {
29028                 if err == io.EOF {
29029                         chk(io.EOF)
29030                 }
29031                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
29032         }
29033         {
29034                 x := (*(*(struct {
29035                         MaxHP            uint16 // Player only.
29036                         CollideWithNodes bool
29037                         Weight           float32 // deprecated
29038                         ColBox, SelBox   Box
29039                         Pointable        bool
29040                         Visual           string
29041                         VisualSize       [3]float32
29042                         Textures         []Texture
29043                         SpriteSheetSize  [2]int16 // in sprites.
29044                         SpritePos        [2]int16 // in sprite sheet.
29045                         Visible          bool
29046                         MakeFootstepSnds bool
29047                         RotateSpeed      float32 // in radians per second.
29048                         Mesh             string
29049                         Colors           []color.NRGBA
29050                         CollideWithAOs   bool
29051                         StepHeight       float32
29052                         FaceRotateDir    bool
29053                         FaceRotateDirOff float32 // in degrees.
29054                         BackfaceCull     bool
29055                         Nametag          string
29056                         NametagColor     color.NRGBA
29057                         FaceRotateSpeed  float32 // in degrees per second.
29058                         Infotext         string
29059                         Itemstring       string
29060                         Glow             int8
29061                         MaxBreath        uint16  // Player only.
29062                         EyeHeight        float32 // Player only.
29063                         ZoomFOV          float32 // in degrees. Player only.
29064                         UseTextureAlpha  bool
29065                         DmgTextureMod    Texture // suffix
29066                         Shaded           bool
29067                         ShowOnMinimap    bool
29068                         NametagBG        color.NRGBA
29069                 }))(obj)).Shaded
29070                 if x {
29071                         write8(w, 1)
29072                 } else {
29073                         write8(w, 0)
29074                 }
29075
29076         }
29077         {
29078                 x := (*(*(struct {
29079                         MaxHP            uint16 // Player only.
29080                         CollideWithNodes bool
29081                         Weight           float32 // deprecated
29082                         ColBox, SelBox   Box
29083                         Pointable        bool
29084                         Visual           string
29085                         VisualSize       [3]float32
29086                         Textures         []Texture
29087                         SpriteSheetSize  [2]int16 // in sprites.
29088                         SpritePos        [2]int16 // in sprite sheet.
29089                         Visible          bool
29090                         MakeFootstepSnds bool
29091                         RotateSpeed      float32 // in radians per second.
29092                         Mesh             string
29093                         Colors           []color.NRGBA
29094                         CollideWithAOs   bool
29095                         StepHeight       float32
29096                         FaceRotateDir    bool
29097                         FaceRotateDirOff float32 // in degrees.
29098                         BackfaceCull     bool
29099                         Nametag          string
29100                         NametagColor     color.NRGBA
29101                         FaceRotateSpeed  float32 // in degrees per second.
29102                         Infotext         string
29103                         Itemstring       string
29104                         Glow             int8
29105                         MaxBreath        uint16  // Player only.
29106                         EyeHeight        float32 // Player only.
29107                         ZoomFOV          float32 // in degrees. Player only.
29108                         UseTextureAlpha  bool
29109                         DmgTextureMod    Texture // suffix
29110                         Shaded           bool
29111                         ShowOnMinimap    bool
29112                         NametagBG        color.NRGBA
29113                 }))(obj)).ShowOnMinimap
29114                 if x {
29115                         write8(w, 1)
29116                 } else {
29117                         write8(w, 0)
29118                 }
29119
29120         }
29121         {
29122                 x := (*(*(struct {
29123                         MaxHP            uint16 // Player only.
29124                         CollideWithNodes bool
29125                         Weight           float32 // deprecated
29126                         ColBox, SelBox   Box
29127                         Pointable        bool
29128                         Visual           string
29129                         VisualSize       [3]float32
29130                         Textures         []Texture
29131                         SpriteSheetSize  [2]int16 // in sprites.
29132                         SpritePos        [2]int16 // in sprite sheet.
29133                         Visible          bool
29134                         MakeFootstepSnds bool
29135                         RotateSpeed      float32 // in radians per second.
29136                         Mesh             string
29137                         Colors           []color.NRGBA
29138                         CollideWithAOs   bool
29139                         StepHeight       float32
29140                         FaceRotateDir    bool
29141                         FaceRotateDirOff float32 // in degrees.
29142                         BackfaceCull     bool
29143                         Nametag          string
29144                         NametagColor     color.NRGBA
29145                         FaceRotateSpeed  float32 // in degrees per second.
29146                         Infotext         string
29147                         Itemstring       string
29148                         Glow             int8
29149                         MaxBreath        uint16  // Player only.
29150                         EyeHeight        float32 // Player only.
29151                         ZoomFOV          float32 // in degrees. Player only.
29152                         UseTextureAlpha  bool
29153                         DmgTextureMod    Texture // suffix
29154                         Shaded           bool
29155                         ShowOnMinimap    bool
29156                         NametagBG        color.NRGBA
29157                 }))(obj)).NametagBG
29158                 w.Write([]byte{x.A, x.R, x.G, x.B})
29159
29160         }
29161 }
29162
29163 func (obj *AOProps) deserialize(r io.Reader) {
29164         {
29165                 var local341 uint8
29166                 local342 := uint8(4)
29167                 {
29168                         p := &local341
29169                         *p = read8(r)
29170                 }
29171                 if local341 != local342 {
29172                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local341))
29173                 }
29174         }
29175         {
29176                 p := &(*(*(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)).MaxHP
29212                 *p = read16(r)
29213         }
29214         {
29215                 p := &(*(*(struct {
29216                         MaxHP            uint16 // Player only.
29217                         CollideWithNodes bool
29218                         Weight           float32 // deprecated
29219                         ColBox, SelBox   Box
29220                         Pointable        bool
29221                         Visual           string
29222                         VisualSize       [3]float32
29223                         Textures         []Texture
29224                         SpriteSheetSize  [2]int16 // in sprites.
29225                         SpritePos        [2]int16 // in sprite sheet.
29226                         Visible          bool
29227                         MakeFootstepSnds bool
29228                         RotateSpeed      float32 // in radians per second.
29229                         Mesh             string
29230                         Colors           []color.NRGBA
29231                         CollideWithAOs   bool
29232                         StepHeight       float32
29233                         FaceRotateDir    bool
29234                         FaceRotateDirOff float32 // in degrees.
29235                         BackfaceCull     bool
29236                         Nametag          string
29237                         NametagColor     color.NRGBA
29238                         FaceRotateSpeed  float32 // in degrees per second.
29239                         Infotext         string
29240                         Itemstring       string
29241                         Glow             int8
29242                         MaxBreath        uint16  // Player only.
29243                         EyeHeight        float32 // Player only.
29244                         ZoomFOV          float32 // in degrees. Player only.
29245                         UseTextureAlpha  bool
29246                         DmgTextureMod    Texture // suffix
29247                         Shaded           bool
29248                         ShowOnMinimap    bool
29249                         NametagBG        color.NRGBA
29250                 }))(obj)).CollideWithNodes
29251                 switch n := read8(r); n {
29252                 case 0:
29253                         *p = false
29254                 case 1:
29255                         *p = true
29256                 default:
29257                         chk(fmt.Errorf("invalid bool: %d", n))
29258                 }
29259
29260         }
29261         {
29262                 p := &(*(*(struct {
29263                         MaxHP            uint16 // Player only.
29264                         CollideWithNodes bool
29265                         Weight           float32 // deprecated
29266                         ColBox, SelBox   Box
29267                         Pointable        bool
29268                         Visual           string
29269                         VisualSize       [3]float32
29270                         Textures         []Texture
29271                         SpriteSheetSize  [2]int16 // in sprites.
29272                         SpritePos        [2]int16 // in sprite sheet.
29273                         Visible          bool
29274                         MakeFootstepSnds bool
29275                         RotateSpeed      float32 // in radians per second.
29276                         Mesh             string
29277                         Colors           []color.NRGBA
29278                         CollideWithAOs   bool
29279                         StepHeight       float32
29280                         FaceRotateDir    bool
29281                         FaceRotateDirOff float32 // in degrees.
29282                         BackfaceCull     bool
29283                         Nametag          string
29284                         NametagColor     color.NRGBA
29285                         FaceRotateSpeed  float32 // in degrees per second.
29286                         Infotext         string
29287                         Itemstring       string
29288                         Glow             int8
29289                         MaxBreath        uint16  // Player only.
29290                         EyeHeight        float32 // Player only.
29291                         ZoomFOV          float32 // in degrees. Player only.
29292                         UseTextureAlpha  bool
29293                         DmgTextureMod    Texture // suffix
29294                         Shaded           bool
29295                         ShowOnMinimap    bool
29296                         NametagBG        color.NRGBA
29297                 }))(obj)).Weight
29298                 *p = math.Float32frombits(read32(r))
29299         }
29300         if err := pcall(func() {
29301                 ((*(*(struct {
29302                         MaxHP            uint16 // Player only.
29303                         CollideWithNodes bool
29304                         Weight           float32 // deprecated
29305                         ColBox, SelBox   Box
29306                         Pointable        bool
29307                         Visual           string
29308                         VisualSize       [3]float32
29309                         Textures         []Texture
29310                         SpriteSheetSize  [2]int16 // in sprites.
29311                         SpritePos        [2]int16 // in sprite sheet.
29312                         Visible          bool
29313                         MakeFootstepSnds bool
29314                         RotateSpeed      float32 // in radians per second.
29315                         Mesh             string
29316                         Colors           []color.NRGBA
29317                         CollideWithAOs   bool
29318                         StepHeight       float32
29319                         FaceRotateDir    bool
29320                         FaceRotateDirOff float32 // in degrees.
29321                         BackfaceCull     bool
29322                         Nametag          string
29323                         NametagColor     color.NRGBA
29324                         FaceRotateSpeed  float32 // in degrees per second.
29325                         Infotext         string
29326                         Itemstring       string
29327                         Glow             int8
29328                         MaxBreath        uint16  // Player only.
29329                         EyeHeight        float32 // Player only.
29330                         ZoomFOV          float32 // in degrees. Player only.
29331                         UseTextureAlpha  bool
29332                         DmgTextureMod    Texture // suffix
29333                         Shaded           bool
29334                         ShowOnMinimap    bool
29335                         NametagBG        color.NRGBA
29336                 }))(obj)).ColBox).deserialize(r)
29337         }); err != nil {
29338                 if err == io.EOF {
29339                         chk(io.EOF)
29340                 }
29341                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29342         }
29343         if err := pcall(func() {
29344                 ((*(*(struct {
29345                         MaxHP            uint16 // Player only.
29346                         CollideWithNodes bool
29347                         Weight           float32 // deprecated
29348                         ColBox, SelBox   Box
29349                         Pointable        bool
29350                         Visual           string
29351                         VisualSize       [3]float32
29352                         Textures         []Texture
29353                         SpriteSheetSize  [2]int16 // in sprites.
29354                         SpritePos        [2]int16 // in sprite sheet.
29355                         Visible          bool
29356                         MakeFootstepSnds bool
29357                         RotateSpeed      float32 // in radians per second.
29358                         Mesh             string
29359                         Colors           []color.NRGBA
29360                         CollideWithAOs   bool
29361                         StepHeight       float32
29362                         FaceRotateDir    bool
29363                         FaceRotateDirOff float32 // in degrees.
29364                         BackfaceCull     bool
29365                         Nametag          string
29366                         NametagColor     color.NRGBA
29367                         FaceRotateSpeed  float32 // in degrees per second.
29368                         Infotext         string
29369                         Itemstring       string
29370                         Glow             int8
29371                         MaxBreath        uint16  // Player only.
29372                         EyeHeight        float32 // Player only.
29373                         ZoomFOV          float32 // in degrees. Player only.
29374                         UseTextureAlpha  bool
29375                         DmgTextureMod    Texture // suffix
29376                         Shaded           bool
29377                         ShowOnMinimap    bool
29378                         NametagBG        color.NRGBA
29379                 }))(obj)).SelBox).deserialize(r)
29380         }); err != nil {
29381                 if err == io.EOF {
29382                         chk(io.EOF)
29383                 }
29384                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29385         }
29386         {
29387                 p := &(*(*(struct {
29388                         MaxHP            uint16 // Player only.
29389                         CollideWithNodes bool
29390                         Weight           float32 // deprecated
29391                         ColBox, SelBox   Box
29392                         Pointable        bool
29393                         Visual           string
29394                         VisualSize       [3]float32
29395                         Textures         []Texture
29396                         SpriteSheetSize  [2]int16 // in sprites.
29397                         SpritePos        [2]int16 // in sprite sheet.
29398                         Visible          bool
29399                         MakeFootstepSnds bool
29400                         RotateSpeed      float32 // in radians per second.
29401                         Mesh             string
29402                         Colors           []color.NRGBA
29403                         CollideWithAOs   bool
29404                         StepHeight       float32
29405                         FaceRotateDir    bool
29406                         FaceRotateDirOff float32 // in degrees.
29407                         BackfaceCull     bool
29408                         Nametag          string
29409                         NametagColor     color.NRGBA
29410                         FaceRotateSpeed  float32 // in degrees per second.
29411                         Infotext         string
29412                         Itemstring       string
29413                         Glow             int8
29414                         MaxBreath        uint16  // Player only.
29415                         EyeHeight        float32 // Player only.
29416                         ZoomFOV          float32 // in degrees. Player only.
29417                         UseTextureAlpha  bool
29418                         DmgTextureMod    Texture // suffix
29419                         Shaded           bool
29420                         ShowOnMinimap    bool
29421                         NametagBG        color.NRGBA
29422                 }))(obj)).Pointable
29423                 switch n := read8(r); n {
29424                 case 0:
29425                         *p = false
29426                 case 1:
29427                         *p = true
29428                 default:
29429                         chk(fmt.Errorf("invalid bool: %d", n))
29430                 }
29431
29432         }
29433         var local343 []uint8
29434         var local344 uint16
29435         {
29436                 p := &local344
29437                 *p = read16(r)
29438         }
29439         (local343) = make([]uint8, local344)
29440         {
29441                 _, err := io.ReadFull(r, (local343)[:])
29442                 chk(err)
29443         }
29444         ((*(*(struct {
29445                 MaxHP            uint16 // Player only.
29446                 CollideWithNodes bool
29447                 Weight           float32 // deprecated
29448                 ColBox, SelBox   Box
29449                 Pointable        bool
29450                 Visual           string
29451                 VisualSize       [3]float32
29452                 Textures         []Texture
29453                 SpriteSheetSize  [2]int16 // in sprites.
29454                 SpritePos        [2]int16 // in sprite sheet.
29455                 Visible          bool
29456                 MakeFootstepSnds bool
29457                 RotateSpeed      float32 // in radians per second.
29458                 Mesh             string
29459                 Colors           []color.NRGBA
29460                 CollideWithAOs   bool
29461                 StepHeight       float32
29462                 FaceRotateDir    bool
29463                 FaceRotateDirOff float32 // in degrees.
29464                 BackfaceCull     bool
29465                 Nametag          string
29466                 NametagColor     color.NRGBA
29467                 FaceRotateSpeed  float32 // in degrees per second.
29468                 Infotext         string
29469                 Itemstring       string
29470                 Glow             int8
29471                 MaxBreath        uint16  // Player only.
29472                 EyeHeight        float32 // Player only.
29473                 ZoomFOV          float32 // in degrees. Player only.
29474                 UseTextureAlpha  bool
29475                 DmgTextureMod    Texture // suffix
29476                 Shaded           bool
29477                 ShowOnMinimap    bool
29478                 NametagBG        color.NRGBA
29479         }))(obj)).Visual) = string(local343)
29480         for local345 := range (*(*(struct {
29481                 MaxHP            uint16 // Player only.
29482                 CollideWithNodes bool
29483                 Weight           float32 // deprecated
29484                 ColBox, SelBox   Box
29485                 Pointable        bool
29486                 Visual           string
29487                 VisualSize       [3]float32
29488                 Textures         []Texture
29489                 SpriteSheetSize  [2]int16 // in sprites.
29490                 SpritePos        [2]int16 // in sprite sheet.
29491                 Visible          bool
29492                 MakeFootstepSnds bool
29493                 RotateSpeed      float32 // in radians per second.
29494                 Mesh             string
29495                 Colors           []color.NRGBA
29496                 CollideWithAOs   bool
29497                 StepHeight       float32
29498                 FaceRotateDir    bool
29499                 FaceRotateDirOff float32 // in degrees.
29500                 BackfaceCull     bool
29501                 Nametag          string
29502                 NametagColor     color.NRGBA
29503                 FaceRotateSpeed  float32 // in degrees per second.
29504                 Infotext         string
29505                 Itemstring       string
29506                 Glow             int8
29507                 MaxBreath        uint16  // Player only.
29508                 EyeHeight        float32 // Player only.
29509                 ZoomFOV          float32 // in degrees. Player only.
29510                 UseTextureAlpha  bool
29511                 DmgTextureMod    Texture // suffix
29512                 Shaded           bool
29513                 ShowOnMinimap    bool
29514                 NametagBG        color.NRGBA
29515         }))(obj)).VisualSize {
29516                 {
29517                         p := &((*(*(struct {
29518                                 MaxHP            uint16 // Player only.
29519                                 CollideWithNodes bool
29520                                 Weight           float32 // deprecated
29521                                 ColBox, SelBox   Box
29522                                 Pointable        bool
29523                                 Visual           string
29524                                 VisualSize       [3]float32
29525                                 Textures         []Texture
29526                                 SpriteSheetSize  [2]int16 // in sprites.
29527                                 SpritePos        [2]int16 // in sprite sheet.
29528                                 Visible          bool
29529                                 MakeFootstepSnds bool
29530                                 RotateSpeed      float32 // in radians per second.
29531                                 Mesh             string
29532                                 Colors           []color.NRGBA
29533                                 CollideWithAOs   bool
29534                                 StepHeight       float32
29535                                 FaceRotateDir    bool
29536                                 FaceRotateDirOff float32 // in degrees.
29537                                 BackfaceCull     bool
29538                                 Nametag          string
29539                                 NametagColor     color.NRGBA
29540                                 FaceRotateSpeed  float32 // in degrees per second.
29541                                 Infotext         string
29542                                 Itemstring       string
29543                                 Glow             int8
29544                                 MaxBreath        uint16  // Player only.
29545                                 EyeHeight        float32 // Player only.
29546                                 ZoomFOV          float32 // in degrees. Player only.
29547                                 UseTextureAlpha  bool
29548                                 DmgTextureMod    Texture // suffix
29549                                 Shaded           bool
29550                                 ShowOnMinimap    bool
29551                                 NametagBG        color.NRGBA
29552                         }))(obj)).VisualSize)[local345]
29553                         *p = math.Float32frombits(read32(r))
29554                 }
29555         }
29556         var local346 uint16
29557         {
29558                 p := &local346
29559                 *p = read16(r)
29560         }
29561         ((*(*(struct {
29562                 MaxHP            uint16 // Player only.
29563                 CollideWithNodes bool
29564                 Weight           float32 // deprecated
29565                 ColBox, SelBox   Box
29566                 Pointable        bool
29567                 Visual           string
29568                 VisualSize       [3]float32
29569                 Textures         []Texture
29570                 SpriteSheetSize  [2]int16 // in sprites.
29571                 SpritePos        [2]int16 // in sprite sheet.
29572                 Visible          bool
29573                 MakeFootstepSnds bool
29574                 RotateSpeed      float32 // in radians per second.
29575                 Mesh             string
29576                 Colors           []color.NRGBA
29577                 CollideWithAOs   bool
29578                 StepHeight       float32
29579                 FaceRotateDir    bool
29580                 FaceRotateDirOff float32 // in degrees.
29581                 BackfaceCull     bool
29582                 Nametag          string
29583                 NametagColor     color.NRGBA
29584                 FaceRotateSpeed  float32 // in degrees per second.
29585                 Infotext         string
29586                 Itemstring       string
29587                 Glow             int8
29588                 MaxBreath        uint16  // Player only.
29589                 EyeHeight        float32 // Player only.
29590                 ZoomFOV          float32 // in degrees. Player only.
29591                 UseTextureAlpha  bool
29592                 DmgTextureMod    Texture // suffix
29593                 Shaded           bool
29594                 ShowOnMinimap    bool
29595                 NametagBG        color.NRGBA
29596         }))(obj)).Textures) = make([]Texture, local346)
29597         for local347 := range (*(*(struct {
29598                 MaxHP            uint16 // Player only.
29599                 CollideWithNodes bool
29600                 Weight           float32 // deprecated
29601                 ColBox, SelBox   Box
29602                 Pointable        bool
29603                 Visual           string
29604                 VisualSize       [3]float32
29605                 Textures         []Texture
29606                 SpriteSheetSize  [2]int16 // in sprites.
29607                 SpritePos        [2]int16 // in sprite sheet.
29608                 Visible          bool
29609                 MakeFootstepSnds bool
29610                 RotateSpeed      float32 // in radians per second.
29611                 Mesh             string
29612                 Colors           []color.NRGBA
29613                 CollideWithAOs   bool
29614                 StepHeight       float32
29615                 FaceRotateDir    bool
29616                 FaceRotateDirOff float32 // in degrees.
29617                 BackfaceCull     bool
29618                 Nametag          string
29619                 NametagColor     color.NRGBA
29620                 FaceRotateSpeed  float32 // in degrees per second.
29621                 Infotext         string
29622                 Itemstring       string
29623                 Glow             int8
29624                 MaxBreath        uint16  // Player only.
29625                 EyeHeight        float32 // Player only.
29626                 ZoomFOV          float32 // in degrees. Player only.
29627                 UseTextureAlpha  bool
29628                 DmgTextureMod    Texture // suffix
29629                 Shaded           bool
29630                 ShowOnMinimap    bool
29631                 NametagBG        color.NRGBA
29632         }))(obj)).Textures {
29633                 if err := pcall(func() {
29634                         (((*(*(struct {
29635                                 MaxHP            uint16 // Player only.
29636                                 CollideWithNodes bool
29637                                 Weight           float32 // deprecated
29638                                 ColBox, SelBox   Box
29639                                 Pointable        bool
29640                                 Visual           string
29641                                 VisualSize       [3]float32
29642                                 Textures         []Texture
29643                                 SpriteSheetSize  [2]int16 // in sprites.
29644                                 SpritePos        [2]int16 // in sprite sheet.
29645                                 Visible          bool
29646                                 MakeFootstepSnds bool
29647                                 RotateSpeed      float32 // in radians per second.
29648                                 Mesh             string
29649                                 Colors           []color.NRGBA
29650                                 CollideWithAOs   bool
29651                                 StepHeight       float32
29652                                 FaceRotateDir    bool
29653                                 FaceRotateDirOff float32 // in degrees.
29654                                 BackfaceCull     bool
29655                                 Nametag          string
29656                                 NametagColor     color.NRGBA
29657                                 FaceRotateSpeed  float32 // in degrees per second.
29658                                 Infotext         string
29659                                 Itemstring       string
29660                                 Glow             int8
29661                                 MaxBreath        uint16  // Player only.
29662                                 EyeHeight        float32 // Player only.
29663                                 ZoomFOV          float32 // in degrees. Player only.
29664                                 UseTextureAlpha  bool
29665                                 DmgTextureMod    Texture // suffix
29666                                 Shaded           bool
29667                                 ShowOnMinimap    bool
29668                                 NametagBG        color.NRGBA
29669                         }))(obj)).Textures)[local347]).deserialize(r)
29670                 }); err != nil {
29671                         if err == io.EOF {
29672                                 chk(io.EOF)
29673                         }
29674                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
29675                 }
29676         }
29677         for local348 := range (*(*(struct {
29678                 MaxHP            uint16 // Player only.
29679                 CollideWithNodes bool
29680                 Weight           float32 // deprecated
29681                 ColBox, SelBox   Box
29682                 Pointable        bool
29683                 Visual           string
29684                 VisualSize       [3]float32
29685                 Textures         []Texture
29686                 SpriteSheetSize  [2]int16 // in sprites.
29687                 SpritePos        [2]int16 // in sprite sheet.
29688                 Visible          bool
29689                 MakeFootstepSnds bool
29690                 RotateSpeed      float32 // in radians per second.
29691                 Mesh             string
29692                 Colors           []color.NRGBA
29693                 CollideWithAOs   bool
29694                 StepHeight       float32
29695                 FaceRotateDir    bool
29696                 FaceRotateDirOff float32 // in degrees.
29697                 BackfaceCull     bool
29698                 Nametag          string
29699                 NametagColor     color.NRGBA
29700                 FaceRotateSpeed  float32 // in degrees per second.
29701                 Infotext         string
29702                 Itemstring       string
29703                 Glow             int8
29704                 MaxBreath        uint16  // Player only.
29705                 EyeHeight        float32 // Player only.
29706                 ZoomFOV          float32 // in degrees. Player only.
29707                 UseTextureAlpha  bool
29708                 DmgTextureMod    Texture // suffix
29709                 Shaded           bool
29710                 ShowOnMinimap    bool
29711                 NametagBG        color.NRGBA
29712         }))(obj)).SpriteSheetSize {
29713                 {
29714                         p := &((*(*(struct {
29715                                 MaxHP            uint16 // Player only.
29716                                 CollideWithNodes bool
29717                                 Weight           float32 // deprecated
29718                                 ColBox, SelBox   Box
29719                                 Pointable        bool
29720                                 Visual           string
29721                                 VisualSize       [3]float32
29722                                 Textures         []Texture
29723                                 SpriteSheetSize  [2]int16 // in sprites.
29724                                 SpritePos        [2]int16 // in sprite sheet.
29725                                 Visible          bool
29726                                 MakeFootstepSnds bool
29727                                 RotateSpeed      float32 // in radians per second.
29728                                 Mesh             string
29729                                 Colors           []color.NRGBA
29730                                 CollideWithAOs   bool
29731                                 StepHeight       float32
29732                                 FaceRotateDir    bool
29733                                 FaceRotateDirOff float32 // in degrees.
29734                                 BackfaceCull     bool
29735                                 Nametag          string
29736                                 NametagColor     color.NRGBA
29737                                 FaceRotateSpeed  float32 // in degrees per second.
29738                                 Infotext         string
29739                                 Itemstring       string
29740                                 Glow             int8
29741                                 MaxBreath        uint16  // Player only.
29742                                 EyeHeight        float32 // Player only.
29743                                 ZoomFOV          float32 // in degrees. Player only.
29744                                 UseTextureAlpha  bool
29745                                 DmgTextureMod    Texture // suffix
29746                                 Shaded           bool
29747                                 ShowOnMinimap    bool
29748                                 NametagBG        color.NRGBA
29749                         }))(obj)).SpriteSheetSize)[local348]
29750                         *p = int16(read16(r))
29751                 }
29752         }
29753         for local349 := range (*(*(struct {
29754                 MaxHP            uint16 // Player only.
29755                 CollideWithNodes bool
29756                 Weight           float32 // deprecated
29757                 ColBox, SelBox   Box
29758                 Pointable        bool
29759                 Visual           string
29760                 VisualSize       [3]float32
29761                 Textures         []Texture
29762                 SpriteSheetSize  [2]int16 // in sprites.
29763                 SpritePos        [2]int16 // in sprite sheet.
29764                 Visible          bool
29765                 MakeFootstepSnds bool
29766                 RotateSpeed      float32 // in radians per second.
29767                 Mesh             string
29768                 Colors           []color.NRGBA
29769                 CollideWithAOs   bool
29770                 StepHeight       float32
29771                 FaceRotateDir    bool
29772                 FaceRotateDirOff float32 // in degrees.
29773                 BackfaceCull     bool
29774                 Nametag          string
29775                 NametagColor     color.NRGBA
29776                 FaceRotateSpeed  float32 // in degrees per second.
29777                 Infotext         string
29778                 Itemstring       string
29779                 Glow             int8
29780                 MaxBreath        uint16  // Player only.
29781                 EyeHeight        float32 // Player only.
29782                 ZoomFOV          float32 // in degrees. Player only.
29783                 UseTextureAlpha  bool
29784                 DmgTextureMod    Texture // suffix
29785                 Shaded           bool
29786                 ShowOnMinimap    bool
29787                 NametagBG        color.NRGBA
29788         }))(obj)).SpritePos {
29789                 {
29790                         p := &((*(*(struct {
29791                                 MaxHP            uint16 // Player only.
29792                                 CollideWithNodes bool
29793                                 Weight           float32 // deprecated
29794                                 ColBox, SelBox   Box
29795                                 Pointable        bool
29796                                 Visual           string
29797                                 VisualSize       [3]float32
29798                                 Textures         []Texture
29799                                 SpriteSheetSize  [2]int16 // in sprites.
29800                                 SpritePos        [2]int16 // in sprite sheet.
29801                                 Visible          bool
29802                                 MakeFootstepSnds bool
29803                                 RotateSpeed      float32 // in radians per second.
29804                                 Mesh             string
29805                                 Colors           []color.NRGBA
29806                                 CollideWithAOs   bool
29807                                 StepHeight       float32
29808                                 FaceRotateDir    bool
29809                                 FaceRotateDirOff float32 // in degrees.
29810                                 BackfaceCull     bool
29811                                 Nametag          string
29812                                 NametagColor     color.NRGBA
29813                                 FaceRotateSpeed  float32 // in degrees per second.
29814                                 Infotext         string
29815                                 Itemstring       string
29816                                 Glow             int8
29817                                 MaxBreath        uint16  // Player only.
29818                                 EyeHeight        float32 // Player only.
29819                                 ZoomFOV          float32 // in degrees. Player only.
29820                                 UseTextureAlpha  bool
29821                                 DmgTextureMod    Texture // suffix
29822                                 Shaded           bool
29823                                 ShowOnMinimap    bool
29824                                 NametagBG        color.NRGBA
29825                         }))(obj)).SpritePos)[local349]
29826                         *p = int16(read16(r))
29827                 }
29828         }
29829         {
29830                 p := &(*(*(struct {
29831                         MaxHP            uint16 // Player only.
29832                         CollideWithNodes bool
29833                         Weight           float32 // deprecated
29834                         ColBox, SelBox   Box
29835                         Pointable        bool
29836                         Visual           string
29837                         VisualSize       [3]float32
29838                         Textures         []Texture
29839                         SpriteSheetSize  [2]int16 // in sprites.
29840                         SpritePos        [2]int16 // in sprite sheet.
29841                         Visible          bool
29842                         MakeFootstepSnds bool
29843                         RotateSpeed      float32 // in radians per second.
29844                         Mesh             string
29845                         Colors           []color.NRGBA
29846                         CollideWithAOs   bool
29847                         StepHeight       float32
29848                         FaceRotateDir    bool
29849                         FaceRotateDirOff float32 // in degrees.
29850                         BackfaceCull     bool
29851                         Nametag          string
29852                         NametagColor     color.NRGBA
29853                         FaceRotateSpeed  float32 // in degrees per second.
29854                         Infotext         string
29855                         Itemstring       string
29856                         Glow             int8
29857                         MaxBreath        uint16  // Player only.
29858                         EyeHeight        float32 // Player only.
29859                         ZoomFOV          float32 // in degrees. Player only.
29860                         UseTextureAlpha  bool
29861                         DmgTextureMod    Texture // suffix
29862                         Shaded           bool
29863                         ShowOnMinimap    bool
29864                         NametagBG        color.NRGBA
29865                 }))(obj)).Visible
29866                 switch n := read8(r); n {
29867                 case 0:
29868                         *p = false
29869                 case 1:
29870                         *p = true
29871                 default:
29872                         chk(fmt.Errorf("invalid bool: %d", n))
29873                 }
29874
29875         }
29876         {
29877                 p := &(*(*(struct {
29878                         MaxHP            uint16 // Player only.
29879                         CollideWithNodes bool
29880                         Weight           float32 // deprecated
29881                         ColBox, SelBox   Box
29882                         Pointable        bool
29883                         Visual           string
29884                         VisualSize       [3]float32
29885                         Textures         []Texture
29886                         SpriteSheetSize  [2]int16 // in sprites.
29887                         SpritePos        [2]int16 // in sprite sheet.
29888                         Visible          bool
29889                         MakeFootstepSnds bool
29890                         RotateSpeed      float32 // in radians per second.
29891                         Mesh             string
29892                         Colors           []color.NRGBA
29893                         CollideWithAOs   bool
29894                         StepHeight       float32
29895                         FaceRotateDir    bool
29896                         FaceRotateDirOff float32 // in degrees.
29897                         BackfaceCull     bool
29898                         Nametag          string
29899                         NametagColor     color.NRGBA
29900                         FaceRotateSpeed  float32 // in degrees per second.
29901                         Infotext         string
29902                         Itemstring       string
29903                         Glow             int8
29904                         MaxBreath        uint16  // Player only.
29905                         EyeHeight        float32 // Player only.
29906                         ZoomFOV          float32 // in degrees. Player only.
29907                         UseTextureAlpha  bool
29908                         DmgTextureMod    Texture // suffix
29909                         Shaded           bool
29910                         ShowOnMinimap    bool
29911                         NametagBG        color.NRGBA
29912                 }))(obj)).MakeFootstepSnds
29913                 switch n := read8(r); n {
29914                 case 0:
29915                         *p = false
29916                 case 1:
29917                         *p = true
29918                 default:
29919                         chk(fmt.Errorf("invalid bool: %d", n))
29920                 }
29921
29922         }
29923         {
29924                 p := &(*(*(struct {
29925                         MaxHP            uint16 // Player only.
29926                         CollideWithNodes bool
29927                         Weight           float32 // deprecated
29928                         ColBox, SelBox   Box
29929                         Pointable        bool
29930                         Visual           string
29931                         VisualSize       [3]float32
29932                         Textures         []Texture
29933                         SpriteSheetSize  [2]int16 // in sprites.
29934                         SpritePos        [2]int16 // in sprite sheet.
29935                         Visible          bool
29936                         MakeFootstepSnds bool
29937                         RotateSpeed      float32 // in radians per second.
29938                         Mesh             string
29939                         Colors           []color.NRGBA
29940                         CollideWithAOs   bool
29941                         StepHeight       float32
29942                         FaceRotateDir    bool
29943                         FaceRotateDirOff float32 // in degrees.
29944                         BackfaceCull     bool
29945                         Nametag          string
29946                         NametagColor     color.NRGBA
29947                         FaceRotateSpeed  float32 // in degrees per second.
29948                         Infotext         string
29949                         Itemstring       string
29950                         Glow             int8
29951                         MaxBreath        uint16  // Player only.
29952                         EyeHeight        float32 // Player only.
29953                         ZoomFOV          float32 // in degrees. Player only.
29954                         UseTextureAlpha  bool
29955                         DmgTextureMod    Texture // suffix
29956                         Shaded           bool
29957                         ShowOnMinimap    bool
29958                         NametagBG        color.NRGBA
29959                 }))(obj)).RotateSpeed
29960                 *p = math.Float32frombits(read32(r))
29961         }
29962         var local350 []uint8
29963         var local351 uint16
29964         {
29965                 p := &local351
29966                 *p = read16(r)
29967         }
29968         (local350) = make([]uint8, local351)
29969         {
29970                 _, err := io.ReadFull(r, (local350)[:])
29971                 chk(err)
29972         }
29973         ((*(*(struct {
29974                 MaxHP            uint16 // Player only.
29975                 CollideWithNodes bool
29976                 Weight           float32 // deprecated
29977                 ColBox, SelBox   Box
29978                 Pointable        bool
29979                 Visual           string
29980                 VisualSize       [3]float32
29981                 Textures         []Texture
29982                 SpriteSheetSize  [2]int16 // in sprites.
29983                 SpritePos        [2]int16 // in sprite sheet.
29984                 Visible          bool
29985                 MakeFootstepSnds bool
29986                 RotateSpeed      float32 // in radians per second.
29987                 Mesh             string
29988                 Colors           []color.NRGBA
29989                 CollideWithAOs   bool
29990                 StepHeight       float32
29991                 FaceRotateDir    bool
29992                 FaceRotateDirOff float32 // in degrees.
29993                 BackfaceCull     bool
29994                 Nametag          string
29995                 NametagColor     color.NRGBA
29996                 FaceRotateSpeed  float32 // in degrees per second.
29997                 Infotext         string
29998                 Itemstring       string
29999                 Glow             int8
30000                 MaxBreath        uint16  // Player only.
30001                 EyeHeight        float32 // Player only.
30002                 ZoomFOV          float32 // in degrees. Player only.
30003                 UseTextureAlpha  bool
30004                 DmgTextureMod    Texture // suffix
30005                 Shaded           bool
30006                 ShowOnMinimap    bool
30007                 NametagBG        color.NRGBA
30008         }))(obj)).Mesh) = string(local350)
30009         var local352 uint16
30010         {
30011                 p := &local352
30012                 *p = read16(r)
30013         }
30014         ((*(*(struct {
30015                 MaxHP            uint16 // Player only.
30016                 CollideWithNodes bool
30017                 Weight           float32 // deprecated
30018                 ColBox, SelBox   Box
30019                 Pointable        bool
30020                 Visual           string
30021                 VisualSize       [3]float32
30022                 Textures         []Texture
30023                 SpriteSheetSize  [2]int16 // in sprites.
30024                 SpritePos        [2]int16 // in sprite sheet.
30025                 Visible          bool
30026                 MakeFootstepSnds bool
30027                 RotateSpeed      float32 // in radians per second.
30028                 Mesh             string
30029                 Colors           []color.NRGBA
30030                 CollideWithAOs   bool
30031                 StepHeight       float32
30032                 FaceRotateDir    bool
30033                 FaceRotateDirOff float32 // in degrees.
30034                 BackfaceCull     bool
30035                 Nametag          string
30036                 NametagColor     color.NRGBA
30037                 FaceRotateSpeed  float32 // in degrees per second.
30038                 Infotext         string
30039                 Itemstring       string
30040                 Glow             int8
30041                 MaxBreath        uint16  // Player only.
30042                 EyeHeight        float32 // Player only.
30043                 ZoomFOV          float32 // in degrees. Player only.
30044                 UseTextureAlpha  bool
30045                 DmgTextureMod    Texture // suffix
30046                 Shaded           bool
30047                 ShowOnMinimap    bool
30048                 NametagBG        color.NRGBA
30049         }))(obj)).Colors) = make([]color.NRGBA, local352)
30050         for local353 := range (*(*(struct {
30051                 MaxHP            uint16 // Player only.
30052                 CollideWithNodes bool
30053                 Weight           float32 // deprecated
30054                 ColBox, SelBox   Box
30055                 Pointable        bool
30056                 Visual           string
30057                 VisualSize       [3]float32
30058                 Textures         []Texture
30059                 SpriteSheetSize  [2]int16 // in sprites.
30060                 SpritePos        [2]int16 // in sprite sheet.
30061                 Visible          bool
30062                 MakeFootstepSnds bool
30063                 RotateSpeed      float32 // in radians per second.
30064                 Mesh             string
30065                 Colors           []color.NRGBA
30066                 CollideWithAOs   bool
30067                 StepHeight       float32
30068                 FaceRotateDir    bool
30069                 FaceRotateDirOff float32 // in degrees.
30070                 BackfaceCull     bool
30071                 Nametag          string
30072                 NametagColor     color.NRGBA
30073                 FaceRotateSpeed  float32 // in degrees per second.
30074                 Infotext         string
30075                 Itemstring       string
30076                 Glow             int8
30077                 MaxBreath        uint16  // Player only.
30078                 EyeHeight        float32 // Player only.
30079                 ZoomFOV          float32 // in degrees. Player only.
30080                 UseTextureAlpha  bool
30081                 DmgTextureMod    Texture // suffix
30082                 Shaded           bool
30083                 ShowOnMinimap    bool
30084                 NametagBG        color.NRGBA
30085         }))(obj)).Colors {
30086                 {
30087                         p := &((*(*(struct {
30088                                 MaxHP            uint16 // Player only.
30089                                 CollideWithNodes bool
30090                                 Weight           float32 // deprecated
30091                                 ColBox, SelBox   Box
30092                                 Pointable        bool
30093                                 Visual           string
30094                                 VisualSize       [3]float32
30095                                 Textures         []Texture
30096                                 SpriteSheetSize  [2]int16 // in sprites.
30097                                 SpritePos        [2]int16 // in sprite sheet.
30098                                 Visible          bool
30099                                 MakeFootstepSnds bool
30100                                 RotateSpeed      float32 // in radians per second.
30101                                 Mesh             string
30102                                 Colors           []color.NRGBA
30103                                 CollideWithAOs   bool
30104                                 StepHeight       float32
30105                                 FaceRotateDir    bool
30106                                 FaceRotateDirOff float32 // in degrees.
30107                                 BackfaceCull     bool
30108                                 Nametag          string
30109                                 NametagColor     color.NRGBA
30110                                 FaceRotateSpeed  float32 // in degrees per second.
30111                                 Infotext         string
30112                                 Itemstring       string
30113                                 Glow             int8
30114                                 MaxBreath        uint16  // Player only.
30115                                 EyeHeight        float32 // Player only.
30116                                 ZoomFOV          float32 // in degrees. Player only.
30117                                 UseTextureAlpha  bool
30118                                 DmgTextureMod    Texture // suffix
30119                                 Shaded           bool
30120                                 ShowOnMinimap    bool
30121                                 NametagBG        color.NRGBA
30122                         }))(obj)).Colors)[local353]
30123                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30124
30125                 }
30126         }
30127         {
30128                 p := &(*(*(struct {
30129                         MaxHP            uint16 // Player only.
30130                         CollideWithNodes bool
30131                         Weight           float32 // deprecated
30132                         ColBox, SelBox   Box
30133                         Pointable        bool
30134                         Visual           string
30135                         VisualSize       [3]float32
30136                         Textures         []Texture
30137                         SpriteSheetSize  [2]int16 // in sprites.
30138                         SpritePos        [2]int16 // in sprite sheet.
30139                         Visible          bool
30140                         MakeFootstepSnds bool
30141                         RotateSpeed      float32 // in radians per second.
30142                         Mesh             string
30143                         Colors           []color.NRGBA
30144                         CollideWithAOs   bool
30145                         StepHeight       float32
30146                         FaceRotateDir    bool
30147                         FaceRotateDirOff float32 // in degrees.
30148                         BackfaceCull     bool
30149                         Nametag          string
30150                         NametagColor     color.NRGBA
30151                         FaceRotateSpeed  float32 // in degrees per second.
30152                         Infotext         string
30153                         Itemstring       string
30154                         Glow             int8
30155                         MaxBreath        uint16  // Player only.
30156                         EyeHeight        float32 // Player only.
30157                         ZoomFOV          float32 // in degrees. Player only.
30158                         UseTextureAlpha  bool
30159                         DmgTextureMod    Texture // suffix
30160                         Shaded           bool
30161                         ShowOnMinimap    bool
30162                         NametagBG        color.NRGBA
30163                 }))(obj)).CollideWithAOs
30164                 switch n := read8(r); n {
30165                 case 0:
30166                         *p = false
30167                 case 1:
30168                         *p = true
30169                 default:
30170                         chk(fmt.Errorf("invalid bool: %d", n))
30171                 }
30172
30173         }
30174         {
30175                 p := &(*(*(struct {
30176                         MaxHP            uint16 // Player only.
30177                         CollideWithNodes bool
30178                         Weight           float32 // deprecated
30179                         ColBox, SelBox   Box
30180                         Pointable        bool
30181                         Visual           string
30182                         VisualSize       [3]float32
30183                         Textures         []Texture
30184                         SpriteSheetSize  [2]int16 // in sprites.
30185                         SpritePos        [2]int16 // in sprite sheet.
30186                         Visible          bool
30187                         MakeFootstepSnds bool
30188                         RotateSpeed      float32 // in radians per second.
30189                         Mesh             string
30190                         Colors           []color.NRGBA
30191                         CollideWithAOs   bool
30192                         StepHeight       float32
30193                         FaceRotateDir    bool
30194                         FaceRotateDirOff float32 // in degrees.
30195                         BackfaceCull     bool
30196                         Nametag          string
30197                         NametagColor     color.NRGBA
30198                         FaceRotateSpeed  float32 // in degrees per second.
30199                         Infotext         string
30200                         Itemstring       string
30201                         Glow             int8
30202                         MaxBreath        uint16  // Player only.
30203                         EyeHeight        float32 // Player only.
30204                         ZoomFOV          float32 // in degrees. Player only.
30205                         UseTextureAlpha  bool
30206                         DmgTextureMod    Texture // suffix
30207                         Shaded           bool
30208                         ShowOnMinimap    bool
30209                         NametagBG        color.NRGBA
30210                 }))(obj)).StepHeight
30211                 *p = math.Float32frombits(read32(r))
30212         }
30213         {
30214                 p := &(*(*(struct {
30215                         MaxHP            uint16 // Player only.
30216                         CollideWithNodes bool
30217                         Weight           float32 // deprecated
30218                         ColBox, SelBox   Box
30219                         Pointable        bool
30220                         Visual           string
30221                         VisualSize       [3]float32
30222                         Textures         []Texture
30223                         SpriteSheetSize  [2]int16 // in sprites.
30224                         SpritePos        [2]int16 // in sprite sheet.
30225                         Visible          bool
30226                         MakeFootstepSnds bool
30227                         RotateSpeed      float32 // in radians per second.
30228                         Mesh             string
30229                         Colors           []color.NRGBA
30230                         CollideWithAOs   bool
30231                         StepHeight       float32
30232                         FaceRotateDir    bool
30233                         FaceRotateDirOff float32 // in degrees.
30234                         BackfaceCull     bool
30235                         Nametag          string
30236                         NametagColor     color.NRGBA
30237                         FaceRotateSpeed  float32 // in degrees per second.
30238                         Infotext         string
30239                         Itemstring       string
30240                         Glow             int8
30241                         MaxBreath        uint16  // Player only.
30242                         EyeHeight        float32 // Player only.
30243                         ZoomFOV          float32 // in degrees. Player only.
30244                         UseTextureAlpha  bool
30245                         DmgTextureMod    Texture // suffix
30246                         Shaded           bool
30247                         ShowOnMinimap    bool
30248                         NametagBG        color.NRGBA
30249                 }))(obj)).FaceRotateDir
30250                 switch n := read8(r); n {
30251                 case 0:
30252                         *p = false
30253                 case 1:
30254                         *p = true
30255                 default:
30256                         chk(fmt.Errorf("invalid bool: %d", n))
30257                 }
30258
30259         }
30260         {
30261                 p := &(*(*(struct {
30262                         MaxHP            uint16 // Player only.
30263                         CollideWithNodes bool
30264                         Weight           float32 // deprecated
30265                         ColBox, SelBox   Box
30266                         Pointable        bool
30267                         Visual           string
30268                         VisualSize       [3]float32
30269                         Textures         []Texture
30270                         SpriteSheetSize  [2]int16 // in sprites.
30271                         SpritePos        [2]int16 // in sprite sheet.
30272                         Visible          bool
30273                         MakeFootstepSnds bool
30274                         RotateSpeed      float32 // in radians per second.
30275                         Mesh             string
30276                         Colors           []color.NRGBA
30277                         CollideWithAOs   bool
30278                         StepHeight       float32
30279                         FaceRotateDir    bool
30280                         FaceRotateDirOff float32 // in degrees.
30281                         BackfaceCull     bool
30282                         Nametag          string
30283                         NametagColor     color.NRGBA
30284                         FaceRotateSpeed  float32 // in degrees per second.
30285                         Infotext         string
30286                         Itemstring       string
30287                         Glow             int8
30288                         MaxBreath        uint16  // Player only.
30289                         EyeHeight        float32 // Player only.
30290                         ZoomFOV          float32 // in degrees. Player only.
30291                         UseTextureAlpha  bool
30292                         DmgTextureMod    Texture // suffix
30293                         Shaded           bool
30294                         ShowOnMinimap    bool
30295                         NametagBG        color.NRGBA
30296                 }))(obj)).FaceRotateDirOff
30297                 *p = math.Float32frombits(read32(r))
30298         }
30299         {
30300                 p := &(*(*(struct {
30301                         MaxHP            uint16 // Player only.
30302                         CollideWithNodes bool
30303                         Weight           float32 // deprecated
30304                         ColBox, SelBox   Box
30305                         Pointable        bool
30306                         Visual           string
30307                         VisualSize       [3]float32
30308                         Textures         []Texture
30309                         SpriteSheetSize  [2]int16 // in sprites.
30310                         SpritePos        [2]int16 // in sprite sheet.
30311                         Visible          bool
30312                         MakeFootstepSnds bool
30313                         RotateSpeed      float32 // in radians per second.
30314                         Mesh             string
30315                         Colors           []color.NRGBA
30316                         CollideWithAOs   bool
30317                         StepHeight       float32
30318                         FaceRotateDir    bool
30319                         FaceRotateDirOff float32 // in degrees.
30320                         BackfaceCull     bool
30321                         Nametag          string
30322                         NametagColor     color.NRGBA
30323                         FaceRotateSpeed  float32 // in degrees per second.
30324                         Infotext         string
30325                         Itemstring       string
30326                         Glow             int8
30327                         MaxBreath        uint16  // Player only.
30328                         EyeHeight        float32 // Player only.
30329                         ZoomFOV          float32 // in degrees. Player only.
30330                         UseTextureAlpha  bool
30331                         DmgTextureMod    Texture // suffix
30332                         Shaded           bool
30333                         ShowOnMinimap    bool
30334                         NametagBG        color.NRGBA
30335                 }))(obj)).BackfaceCull
30336                 switch n := read8(r); n {
30337                 case 0:
30338                         *p = false
30339                 case 1:
30340                         *p = true
30341                 default:
30342                         chk(fmt.Errorf("invalid bool: %d", n))
30343                 }
30344
30345         }
30346         var local354 []uint8
30347         var local355 uint16
30348         {
30349                 p := &local355
30350                 *p = read16(r)
30351         }
30352         (local354) = make([]uint8, local355)
30353         {
30354                 _, err := io.ReadFull(r, (local354)[:])
30355                 chk(err)
30356         }
30357         ((*(*(struct {
30358                 MaxHP            uint16 // Player only.
30359                 CollideWithNodes bool
30360                 Weight           float32 // deprecated
30361                 ColBox, SelBox   Box
30362                 Pointable        bool
30363                 Visual           string
30364                 VisualSize       [3]float32
30365                 Textures         []Texture
30366                 SpriteSheetSize  [2]int16 // in sprites.
30367                 SpritePos        [2]int16 // in sprite sheet.
30368                 Visible          bool
30369                 MakeFootstepSnds bool
30370                 RotateSpeed      float32 // in radians per second.
30371                 Mesh             string
30372                 Colors           []color.NRGBA
30373                 CollideWithAOs   bool
30374                 StepHeight       float32
30375                 FaceRotateDir    bool
30376                 FaceRotateDirOff float32 // in degrees.
30377                 BackfaceCull     bool
30378                 Nametag          string
30379                 NametagColor     color.NRGBA
30380                 FaceRotateSpeed  float32 // in degrees per second.
30381                 Infotext         string
30382                 Itemstring       string
30383                 Glow             int8
30384                 MaxBreath        uint16  // Player only.
30385                 EyeHeight        float32 // Player only.
30386                 ZoomFOV          float32 // in degrees. Player only.
30387                 UseTextureAlpha  bool
30388                 DmgTextureMod    Texture // suffix
30389                 Shaded           bool
30390                 ShowOnMinimap    bool
30391                 NametagBG        color.NRGBA
30392         }))(obj)).Nametag) = string(local354)
30393         {
30394                 p := &(*(*(struct {
30395                         MaxHP            uint16 // Player only.
30396                         CollideWithNodes bool
30397                         Weight           float32 // deprecated
30398                         ColBox, SelBox   Box
30399                         Pointable        bool
30400                         Visual           string
30401                         VisualSize       [3]float32
30402                         Textures         []Texture
30403                         SpriteSheetSize  [2]int16 // in sprites.
30404                         SpritePos        [2]int16 // in sprite sheet.
30405                         Visible          bool
30406                         MakeFootstepSnds bool
30407                         RotateSpeed      float32 // in radians per second.
30408                         Mesh             string
30409                         Colors           []color.NRGBA
30410                         CollideWithAOs   bool
30411                         StepHeight       float32
30412                         FaceRotateDir    bool
30413                         FaceRotateDirOff float32 // in degrees.
30414                         BackfaceCull     bool
30415                         Nametag          string
30416                         NametagColor     color.NRGBA
30417                         FaceRotateSpeed  float32 // in degrees per second.
30418                         Infotext         string
30419                         Itemstring       string
30420                         Glow             int8
30421                         MaxBreath        uint16  // Player only.
30422                         EyeHeight        float32 // Player only.
30423                         ZoomFOV          float32 // in degrees. Player only.
30424                         UseTextureAlpha  bool
30425                         DmgTextureMod    Texture // suffix
30426                         Shaded           bool
30427                         ShowOnMinimap    bool
30428                         NametagBG        color.NRGBA
30429                 }))(obj)).NametagColor
30430                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30431
30432         }
30433         {
30434                 p := &(*(*(struct {
30435                         MaxHP            uint16 // Player only.
30436                         CollideWithNodes bool
30437                         Weight           float32 // deprecated
30438                         ColBox, SelBox   Box
30439                         Pointable        bool
30440                         Visual           string
30441                         VisualSize       [3]float32
30442                         Textures         []Texture
30443                         SpriteSheetSize  [2]int16 // in sprites.
30444                         SpritePos        [2]int16 // in sprite sheet.
30445                         Visible          bool
30446                         MakeFootstepSnds bool
30447                         RotateSpeed      float32 // in radians per second.
30448                         Mesh             string
30449                         Colors           []color.NRGBA
30450                         CollideWithAOs   bool
30451                         StepHeight       float32
30452                         FaceRotateDir    bool
30453                         FaceRotateDirOff float32 // in degrees.
30454                         BackfaceCull     bool
30455                         Nametag          string
30456                         NametagColor     color.NRGBA
30457                         FaceRotateSpeed  float32 // in degrees per second.
30458                         Infotext         string
30459                         Itemstring       string
30460                         Glow             int8
30461                         MaxBreath        uint16  // Player only.
30462                         EyeHeight        float32 // Player only.
30463                         ZoomFOV          float32 // in degrees. Player only.
30464                         UseTextureAlpha  bool
30465                         DmgTextureMod    Texture // suffix
30466                         Shaded           bool
30467                         ShowOnMinimap    bool
30468                         NametagBG        color.NRGBA
30469                 }))(obj)).FaceRotateSpeed
30470                 *p = math.Float32frombits(read32(r))
30471         }
30472         var local356 []uint8
30473         var local357 uint16
30474         {
30475                 p := &local357
30476                 *p = read16(r)
30477         }
30478         (local356) = make([]uint8, local357)
30479         {
30480                 _, err := io.ReadFull(r, (local356)[:])
30481                 chk(err)
30482         }
30483         ((*(*(struct {
30484                 MaxHP            uint16 // Player only.
30485                 CollideWithNodes bool
30486                 Weight           float32 // deprecated
30487                 ColBox, SelBox   Box
30488                 Pointable        bool
30489                 Visual           string
30490                 VisualSize       [3]float32
30491                 Textures         []Texture
30492                 SpriteSheetSize  [2]int16 // in sprites.
30493                 SpritePos        [2]int16 // in sprite sheet.
30494                 Visible          bool
30495                 MakeFootstepSnds bool
30496                 RotateSpeed      float32 // in radians per second.
30497                 Mesh             string
30498                 Colors           []color.NRGBA
30499                 CollideWithAOs   bool
30500                 StepHeight       float32
30501                 FaceRotateDir    bool
30502                 FaceRotateDirOff float32 // in degrees.
30503                 BackfaceCull     bool
30504                 Nametag          string
30505                 NametagColor     color.NRGBA
30506                 FaceRotateSpeed  float32 // in degrees per second.
30507                 Infotext         string
30508                 Itemstring       string
30509                 Glow             int8
30510                 MaxBreath        uint16  // Player only.
30511                 EyeHeight        float32 // Player only.
30512                 ZoomFOV          float32 // in degrees. Player only.
30513                 UseTextureAlpha  bool
30514                 DmgTextureMod    Texture // suffix
30515                 Shaded           bool
30516                 ShowOnMinimap    bool
30517                 NametagBG        color.NRGBA
30518         }))(obj)).Infotext) = string(local356)
30519         var local358 []uint8
30520         var local359 uint16
30521         {
30522                 p := &local359
30523                 *p = read16(r)
30524         }
30525         (local358) = make([]uint8, local359)
30526         {
30527                 _, err := io.ReadFull(r, (local358)[:])
30528                 chk(err)
30529         }
30530         ((*(*(struct {
30531                 MaxHP            uint16 // Player only.
30532                 CollideWithNodes bool
30533                 Weight           float32 // deprecated
30534                 ColBox, SelBox   Box
30535                 Pointable        bool
30536                 Visual           string
30537                 VisualSize       [3]float32
30538                 Textures         []Texture
30539                 SpriteSheetSize  [2]int16 // in sprites.
30540                 SpritePos        [2]int16 // in sprite sheet.
30541                 Visible          bool
30542                 MakeFootstepSnds bool
30543                 RotateSpeed      float32 // in radians per second.
30544                 Mesh             string
30545                 Colors           []color.NRGBA
30546                 CollideWithAOs   bool
30547                 StepHeight       float32
30548                 FaceRotateDir    bool
30549                 FaceRotateDirOff float32 // in degrees.
30550                 BackfaceCull     bool
30551                 Nametag          string
30552                 NametagColor     color.NRGBA
30553                 FaceRotateSpeed  float32 // in degrees per second.
30554                 Infotext         string
30555                 Itemstring       string
30556                 Glow             int8
30557                 MaxBreath        uint16  // Player only.
30558                 EyeHeight        float32 // Player only.
30559                 ZoomFOV          float32 // in degrees. Player only.
30560                 UseTextureAlpha  bool
30561                 DmgTextureMod    Texture // suffix
30562                 Shaded           bool
30563                 ShowOnMinimap    bool
30564                 NametagBG        color.NRGBA
30565         }))(obj)).Itemstring) = string(local358)
30566         {
30567                 p := &(*(*(struct {
30568                         MaxHP            uint16 // Player only.
30569                         CollideWithNodes bool
30570                         Weight           float32 // deprecated
30571                         ColBox, SelBox   Box
30572                         Pointable        bool
30573                         Visual           string
30574                         VisualSize       [3]float32
30575                         Textures         []Texture
30576                         SpriteSheetSize  [2]int16 // in sprites.
30577                         SpritePos        [2]int16 // in sprite sheet.
30578                         Visible          bool
30579                         MakeFootstepSnds bool
30580                         RotateSpeed      float32 // in radians per second.
30581                         Mesh             string
30582                         Colors           []color.NRGBA
30583                         CollideWithAOs   bool
30584                         StepHeight       float32
30585                         FaceRotateDir    bool
30586                         FaceRotateDirOff float32 // in degrees.
30587                         BackfaceCull     bool
30588                         Nametag          string
30589                         NametagColor     color.NRGBA
30590                         FaceRotateSpeed  float32 // in degrees per second.
30591                         Infotext         string
30592                         Itemstring       string
30593                         Glow             int8
30594                         MaxBreath        uint16  // Player only.
30595                         EyeHeight        float32 // Player only.
30596                         ZoomFOV          float32 // in degrees. Player only.
30597                         UseTextureAlpha  bool
30598                         DmgTextureMod    Texture // suffix
30599                         Shaded           bool
30600                         ShowOnMinimap    bool
30601                         NametagBG        color.NRGBA
30602                 }))(obj)).Glow
30603                 *p = int8(read8(r))
30604         }
30605         {
30606                 p := &(*(*(struct {
30607                         MaxHP            uint16 // Player only.
30608                         CollideWithNodes bool
30609                         Weight           float32 // deprecated
30610                         ColBox, SelBox   Box
30611                         Pointable        bool
30612                         Visual           string
30613                         VisualSize       [3]float32
30614                         Textures         []Texture
30615                         SpriteSheetSize  [2]int16 // in sprites.
30616                         SpritePos        [2]int16 // in sprite sheet.
30617                         Visible          bool
30618                         MakeFootstepSnds bool
30619                         RotateSpeed      float32 // in radians per second.
30620                         Mesh             string
30621                         Colors           []color.NRGBA
30622                         CollideWithAOs   bool
30623                         StepHeight       float32
30624                         FaceRotateDir    bool
30625                         FaceRotateDirOff float32 // in degrees.
30626                         BackfaceCull     bool
30627                         Nametag          string
30628                         NametagColor     color.NRGBA
30629                         FaceRotateSpeed  float32 // in degrees per second.
30630                         Infotext         string
30631                         Itemstring       string
30632                         Glow             int8
30633                         MaxBreath        uint16  // Player only.
30634                         EyeHeight        float32 // Player only.
30635                         ZoomFOV          float32 // in degrees. Player only.
30636                         UseTextureAlpha  bool
30637                         DmgTextureMod    Texture // suffix
30638                         Shaded           bool
30639                         ShowOnMinimap    bool
30640                         NametagBG        color.NRGBA
30641                 }))(obj)).MaxBreath
30642                 *p = read16(r)
30643         }
30644         {
30645                 p := &(*(*(struct {
30646                         MaxHP            uint16 // Player only.
30647                         CollideWithNodes bool
30648                         Weight           float32 // deprecated
30649                         ColBox, SelBox   Box
30650                         Pointable        bool
30651                         Visual           string
30652                         VisualSize       [3]float32
30653                         Textures         []Texture
30654                         SpriteSheetSize  [2]int16 // in sprites.
30655                         SpritePos        [2]int16 // in sprite sheet.
30656                         Visible          bool
30657                         MakeFootstepSnds bool
30658                         RotateSpeed      float32 // in radians per second.
30659                         Mesh             string
30660                         Colors           []color.NRGBA
30661                         CollideWithAOs   bool
30662                         StepHeight       float32
30663                         FaceRotateDir    bool
30664                         FaceRotateDirOff float32 // in degrees.
30665                         BackfaceCull     bool
30666                         Nametag          string
30667                         NametagColor     color.NRGBA
30668                         FaceRotateSpeed  float32 // in degrees per second.
30669                         Infotext         string
30670                         Itemstring       string
30671                         Glow             int8
30672                         MaxBreath        uint16  // Player only.
30673                         EyeHeight        float32 // Player only.
30674                         ZoomFOV          float32 // in degrees. Player only.
30675                         UseTextureAlpha  bool
30676                         DmgTextureMod    Texture // suffix
30677                         Shaded           bool
30678                         ShowOnMinimap    bool
30679                         NametagBG        color.NRGBA
30680                 }))(obj)).EyeHeight
30681                 *p = math.Float32frombits(read32(r))
30682         }
30683         {
30684                 p := &(*(*(struct {
30685                         MaxHP            uint16 // Player only.
30686                         CollideWithNodes bool
30687                         Weight           float32 // deprecated
30688                         ColBox, SelBox   Box
30689                         Pointable        bool
30690                         Visual           string
30691                         VisualSize       [3]float32
30692                         Textures         []Texture
30693                         SpriteSheetSize  [2]int16 // in sprites.
30694                         SpritePos        [2]int16 // in sprite sheet.
30695                         Visible          bool
30696                         MakeFootstepSnds bool
30697                         RotateSpeed      float32 // in radians per second.
30698                         Mesh             string
30699                         Colors           []color.NRGBA
30700                         CollideWithAOs   bool
30701                         StepHeight       float32
30702                         FaceRotateDir    bool
30703                         FaceRotateDirOff float32 // in degrees.
30704                         BackfaceCull     bool
30705                         Nametag          string
30706                         NametagColor     color.NRGBA
30707                         FaceRotateSpeed  float32 // in degrees per second.
30708                         Infotext         string
30709                         Itemstring       string
30710                         Glow             int8
30711                         MaxBreath        uint16  // Player only.
30712                         EyeHeight        float32 // Player only.
30713                         ZoomFOV          float32 // in degrees. Player only.
30714                         UseTextureAlpha  bool
30715                         DmgTextureMod    Texture // suffix
30716                         Shaded           bool
30717                         ShowOnMinimap    bool
30718                         NametagBG        color.NRGBA
30719                 }))(obj)).ZoomFOV
30720                 *p = math.Float32frombits(read32(r))
30721         }
30722         {
30723                 p := &(*(*(struct {
30724                         MaxHP            uint16 // Player only.
30725                         CollideWithNodes bool
30726                         Weight           float32 // deprecated
30727                         ColBox, SelBox   Box
30728                         Pointable        bool
30729                         Visual           string
30730                         VisualSize       [3]float32
30731                         Textures         []Texture
30732                         SpriteSheetSize  [2]int16 // in sprites.
30733                         SpritePos        [2]int16 // in sprite sheet.
30734                         Visible          bool
30735                         MakeFootstepSnds bool
30736                         RotateSpeed      float32 // in radians per second.
30737                         Mesh             string
30738                         Colors           []color.NRGBA
30739                         CollideWithAOs   bool
30740                         StepHeight       float32
30741                         FaceRotateDir    bool
30742                         FaceRotateDirOff float32 // in degrees.
30743                         BackfaceCull     bool
30744                         Nametag          string
30745                         NametagColor     color.NRGBA
30746                         FaceRotateSpeed  float32 // in degrees per second.
30747                         Infotext         string
30748                         Itemstring       string
30749                         Glow             int8
30750                         MaxBreath        uint16  // Player only.
30751                         EyeHeight        float32 // Player only.
30752                         ZoomFOV          float32 // in degrees. Player only.
30753                         UseTextureAlpha  bool
30754                         DmgTextureMod    Texture // suffix
30755                         Shaded           bool
30756                         ShowOnMinimap    bool
30757                         NametagBG        color.NRGBA
30758                 }))(obj)).UseTextureAlpha
30759                 switch n := read8(r); n {
30760                 case 0:
30761                         *p = false
30762                 case 1:
30763                         *p = true
30764                 default:
30765                         chk(fmt.Errorf("invalid bool: %d", n))
30766                 }
30767
30768         }
30769         if err := pcall(func() {
30770                 ((*(*(struct {
30771                         MaxHP            uint16 // Player only.
30772                         CollideWithNodes bool
30773                         Weight           float32 // deprecated
30774                         ColBox, SelBox   Box
30775                         Pointable        bool
30776                         Visual           string
30777                         VisualSize       [3]float32
30778                         Textures         []Texture
30779                         SpriteSheetSize  [2]int16 // in sprites.
30780                         SpritePos        [2]int16 // in sprite sheet.
30781                         Visible          bool
30782                         MakeFootstepSnds bool
30783                         RotateSpeed      float32 // in radians per second.
30784                         Mesh             string
30785                         Colors           []color.NRGBA
30786                         CollideWithAOs   bool
30787                         StepHeight       float32
30788                         FaceRotateDir    bool
30789                         FaceRotateDirOff float32 // in degrees.
30790                         BackfaceCull     bool
30791                         Nametag          string
30792                         NametagColor     color.NRGBA
30793                         FaceRotateSpeed  float32 // in degrees per second.
30794                         Infotext         string
30795                         Itemstring       string
30796                         Glow             int8
30797                         MaxBreath        uint16  // Player only.
30798                         EyeHeight        float32 // Player only.
30799                         ZoomFOV          float32 // in degrees. Player only.
30800                         UseTextureAlpha  bool
30801                         DmgTextureMod    Texture // suffix
30802                         Shaded           bool
30803                         ShowOnMinimap    bool
30804                         NametagBG        color.NRGBA
30805                 }))(obj)).DmgTextureMod).deserialize(r)
30806         }); err != nil {
30807                 if err == io.EOF {
30808                         chk(io.EOF)
30809                 }
30810                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
30811         }
30812         {
30813                 p := &(*(*(struct {
30814                         MaxHP            uint16 // Player only.
30815                         CollideWithNodes bool
30816                         Weight           float32 // deprecated
30817                         ColBox, SelBox   Box
30818                         Pointable        bool
30819                         Visual           string
30820                         VisualSize       [3]float32
30821                         Textures         []Texture
30822                         SpriteSheetSize  [2]int16 // in sprites.
30823                         SpritePos        [2]int16 // in sprite sheet.
30824                         Visible          bool
30825                         MakeFootstepSnds bool
30826                         RotateSpeed      float32 // in radians per second.
30827                         Mesh             string
30828                         Colors           []color.NRGBA
30829                         CollideWithAOs   bool
30830                         StepHeight       float32
30831                         FaceRotateDir    bool
30832                         FaceRotateDirOff float32 // in degrees.
30833                         BackfaceCull     bool
30834                         Nametag          string
30835                         NametagColor     color.NRGBA
30836                         FaceRotateSpeed  float32 // in degrees per second.
30837                         Infotext         string
30838                         Itemstring       string
30839                         Glow             int8
30840                         MaxBreath        uint16  // Player only.
30841                         EyeHeight        float32 // Player only.
30842                         ZoomFOV          float32 // in degrees. Player only.
30843                         UseTextureAlpha  bool
30844                         DmgTextureMod    Texture // suffix
30845                         Shaded           bool
30846                         ShowOnMinimap    bool
30847                         NametagBG        color.NRGBA
30848                 }))(obj)).Shaded
30849                 switch n := read8(r); n {
30850                 case 0:
30851                         *p = false
30852                 case 1:
30853                         *p = true
30854                 default:
30855                         chk(fmt.Errorf("invalid bool: %d", n))
30856                 }
30857
30858         }
30859         {
30860                 p := &(*(*(struct {
30861                         MaxHP            uint16 // Player only.
30862                         CollideWithNodes bool
30863                         Weight           float32 // deprecated
30864                         ColBox, SelBox   Box
30865                         Pointable        bool
30866                         Visual           string
30867                         VisualSize       [3]float32
30868                         Textures         []Texture
30869                         SpriteSheetSize  [2]int16 // in sprites.
30870                         SpritePos        [2]int16 // in sprite sheet.
30871                         Visible          bool
30872                         MakeFootstepSnds bool
30873                         RotateSpeed      float32 // in radians per second.
30874                         Mesh             string
30875                         Colors           []color.NRGBA
30876                         CollideWithAOs   bool
30877                         StepHeight       float32
30878                         FaceRotateDir    bool
30879                         FaceRotateDirOff float32 // in degrees.
30880                         BackfaceCull     bool
30881                         Nametag          string
30882                         NametagColor     color.NRGBA
30883                         FaceRotateSpeed  float32 // in degrees per second.
30884                         Infotext         string
30885                         Itemstring       string
30886                         Glow             int8
30887                         MaxBreath        uint16  // Player only.
30888                         EyeHeight        float32 // Player only.
30889                         ZoomFOV          float32 // in degrees. Player only.
30890                         UseTextureAlpha  bool
30891                         DmgTextureMod    Texture // suffix
30892                         Shaded           bool
30893                         ShowOnMinimap    bool
30894                         NametagBG        color.NRGBA
30895                 }))(obj)).ShowOnMinimap
30896                 switch n := read8(r); n {
30897                 case 0:
30898                         *p = false
30899                 case 1:
30900                         *p = true
30901                 default:
30902                         chk(fmt.Errorf("invalid bool: %d", n))
30903                 }
30904
30905         }
30906         {
30907                 p := &(*(*(struct {
30908                         MaxHP            uint16 // Player only.
30909                         CollideWithNodes bool
30910                         Weight           float32 // deprecated
30911                         ColBox, SelBox   Box
30912                         Pointable        bool
30913                         Visual           string
30914                         VisualSize       [3]float32
30915                         Textures         []Texture
30916                         SpriteSheetSize  [2]int16 // in sprites.
30917                         SpritePos        [2]int16 // in sprite sheet.
30918                         Visible          bool
30919                         MakeFootstepSnds bool
30920                         RotateSpeed      float32 // in radians per second.
30921                         Mesh             string
30922                         Colors           []color.NRGBA
30923                         CollideWithAOs   bool
30924                         StepHeight       float32
30925                         FaceRotateDir    bool
30926                         FaceRotateDirOff float32 // in degrees.
30927                         BackfaceCull     bool
30928                         Nametag          string
30929                         NametagColor     color.NRGBA
30930                         FaceRotateSpeed  float32 // in degrees per second.
30931                         Infotext         string
30932                         Itemstring       string
30933                         Glow             int8
30934                         MaxBreath        uint16  // Player only.
30935                         EyeHeight        float32 // Player only.
30936                         ZoomFOV          float32 // in degrees. Player only.
30937                         UseTextureAlpha  bool
30938                         DmgTextureMod    Texture // suffix
30939                         Shaded           bool
30940                         ShowOnMinimap    bool
30941                         NametagBG        color.NRGBA
30942                 }))(obj)).NametagBG
30943                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30944
30945         }
30946 }
30947
30948 func (obj *AOPos) serialize(w io.Writer) {
30949         if err := pcall(func() {
30950                 ((*(*(struct {
30951                         Pos
30952                         Vel, Acc Vec
30953                         Rot      [3]float32
30954
30955                         Interpolate    bool
30956                         End            bool
30957                         UpdateInterval float32
30958                 }))(obj)).Pos).serialize(w)
30959         }); err != nil {
30960                 if err == io.EOF {
30961                         chk(io.EOF)
30962                 }
30963                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
30964         }
30965         if err := pcall(func() {
30966                 ((*(*(struct {
30967                         Pos
30968                         Vel, Acc Vec
30969                         Rot      [3]float32
30970
30971                         Interpolate    bool
30972                         End            bool
30973                         UpdateInterval float32
30974                 }))(obj)).Vel).serialize(w)
30975         }); err != nil {
30976                 if err == io.EOF {
30977                         chk(io.EOF)
30978                 }
30979                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30980         }
30981         if err := pcall(func() {
30982                 ((*(*(struct {
30983                         Pos
30984                         Vel, Acc Vec
30985                         Rot      [3]float32
30986
30987                         Interpolate    bool
30988                         End            bool
30989                         UpdateInterval float32
30990                 }))(obj)).Acc).serialize(w)
30991         }); err != nil {
30992                 if err == io.EOF {
30993                         chk(io.EOF)
30994                 }
30995                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30996         }
30997         for local360 := range (*(*(struct {
30998                 Pos
30999                 Vel, Acc Vec
31000                 Rot      [3]float32
31001
31002                 Interpolate    bool
31003                 End            bool
31004                 UpdateInterval float32
31005         }))(obj)).Rot {
31006                 {
31007                         x := ((*(*(struct {
31008                                 Pos
31009                                 Vel, Acc Vec
31010                                 Rot      [3]float32
31011
31012                                 Interpolate    bool
31013                                 End            bool
31014                                 UpdateInterval float32
31015                         }))(obj)).Rot)[local360]
31016                         write32(w, math.Float32bits(x))
31017                 }
31018         }
31019         {
31020                 x := (*(*(struct {
31021                         Pos
31022                         Vel, Acc Vec
31023                         Rot      [3]float32
31024
31025                         Interpolate    bool
31026                         End            bool
31027                         UpdateInterval float32
31028                 }))(obj)).Interpolate
31029                 if x {
31030                         write8(w, 1)
31031                 } else {
31032                         write8(w, 0)
31033                 }
31034
31035         }
31036         {
31037                 x := (*(*(struct {
31038                         Pos
31039                         Vel, Acc Vec
31040                         Rot      [3]float32
31041
31042                         Interpolate    bool
31043                         End            bool
31044                         UpdateInterval float32
31045                 }))(obj)).End
31046                 if x {
31047                         write8(w, 1)
31048                 } else {
31049                         write8(w, 0)
31050                 }
31051
31052         }
31053         {
31054                 x := (*(*(struct {
31055                         Pos
31056                         Vel, Acc Vec
31057                         Rot      [3]float32
31058
31059                         Interpolate    bool
31060                         End            bool
31061                         UpdateInterval float32
31062                 }))(obj)).UpdateInterval
31063                 write32(w, math.Float32bits(x))
31064         }
31065 }
31066
31067 func (obj *AOPos) deserialize(r io.Reader) {
31068         if err := pcall(func() {
31069                 ((*(*(struct {
31070                         Pos
31071                         Vel, Acc Vec
31072                         Rot      [3]float32
31073
31074                         Interpolate    bool
31075                         End            bool
31076                         UpdateInterval float32
31077                 }))(obj)).Pos).deserialize(r)
31078         }); err != nil {
31079                 if err == io.EOF {
31080                         chk(io.EOF)
31081                 }
31082                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
31083         }
31084         if err := pcall(func() {
31085                 ((*(*(struct {
31086                         Pos
31087                         Vel, Acc Vec
31088                         Rot      [3]float32
31089
31090                         Interpolate    bool
31091                         End            bool
31092                         UpdateInterval float32
31093                 }))(obj)).Vel).deserialize(r)
31094         }); err != nil {
31095                 if err == io.EOF {
31096                         chk(io.EOF)
31097                 }
31098                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31099         }
31100         if err := pcall(func() {
31101                 ((*(*(struct {
31102                         Pos
31103                         Vel, Acc Vec
31104                         Rot      [3]float32
31105
31106                         Interpolate    bool
31107                         End            bool
31108                         UpdateInterval float32
31109                 }))(obj)).Acc).deserialize(r)
31110         }); err != nil {
31111                 if err == io.EOF {
31112                         chk(io.EOF)
31113                 }
31114                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31115         }
31116         for local361 := range (*(*(struct {
31117                 Pos
31118                 Vel, Acc Vec
31119                 Rot      [3]float32
31120
31121                 Interpolate    bool
31122                 End            bool
31123                 UpdateInterval float32
31124         }))(obj)).Rot {
31125                 {
31126                         p := &((*(*(struct {
31127                                 Pos
31128                                 Vel, Acc Vec
31129                                 Rot      [3]float32
31130
31131                                 Interpolate    bool
31132                                 End            bool
31133                                 UpdateInterval float32
31134                         }))(obj)).Rot)[local361]
31135                         *p = math.Float32frombits(read32(r))
31136                 }
31137         }
31138         {
31139                 p := &(*(*(struct {
31140                         Pos
31141                         Vel, Acc Vec
31142                         Rot      [3]float32
31143
31144                         Interpolate    bool
31145                         End            bool
31146                         UpdateInterval float32
31147                 }))(obj)).Interpolate
31148                 switch n := read8(r); n {
31149                 case 0:
31150                         *p = false
31151                 case 1:
31152                         *p = true
31153                 default:
31154                         chk(fmt.Errorf("invalid bool: %d", n))
31155                 }
31156
31157         }
31158         {
31159                 p := &(*(*(struct {
31160                         Pos
31161                         Vel, Acc Vec
31162                         Rot      [3]float32
31163
31164                         Interpolate    bool
31165                         End            bool
31166                         UpdateInterval float32
31167                 }))(obj)).End
31168                 switch n := read8(r); n {
31169                 case 0:
31170                         *p = false
31171                 case 1:
31172                         *p = true
31173                 default:
31174                         chk(fmt.Errorf("invalid bool: %d", n))
31175                 }
31176
31177         }
31178         {
31179                 p := &(*(*(struct {
31180                         Pos
31181                         Vel, Acc Vec
31182                         Rot      [3]float32
31183
31184                         Interpolate    bool
31185                         End            bool
31186                         UpdateInterval float32
31187                 }))(obj)).UpdateInterval
31188                 *p = math.Float32frombits(read32(r))
31189         }
31190 }
31191
31192 func (obj *AOSprite) serialize(w io.Writer) {
31193         for local362 := range (*(*(struct {
31194                 Frame0          [2]int16
31195                 Frames          uint16
31196                 FrameDuration   float32
31197                 ViewAngleFrames bool
31198         }))(obj)).Frame0 {
31199                 {
31200                         x := ((*(*(struct {
31201                                 Frame0          [2]int16
31202                                 Frames          uint16
31203                                 FrameDuration   float32
31204                                 ViewAngleFrames bool
31205                         }))(obj)).Frame0)[local362]
31206                         write16(w, uint16(x))
31207                 }
31208         }
31209         {
31210                 x := (*(*(struct {
31211                         Frame0          [2]int16
31212                         Frames          uint16
31213                         FrameDuration   float32
31214                         ViewAngleFrames bool
31215                 }))(obj)).Frames
31216                 write16(w, uint16(x))
31217         }
31218         {
31219                 x := (*(*(struct {
31220                         Frame0          [2]int16
31221                         Frames          uint16
31222                         FrameDuration   float32
31223                         ViewAngleFrames bool
31224                 }))(obj)).FrameDuration
31225                 write32(w, math.Float32bits(x))
31226         }
31227         {
31228                 x := (*(*(struct {
31229                         Frame0          [2]int16
31230                         Frames          uint16
31231                         FrameDuration   float32
31232                         ViewAngleFrames bool
31233                 }))(obj)).ViewAngleFrames
31234                 if x {
31235                         write8(w, 1)
31236                 } else {
31237                         write8(w, 0)
31238                 }
31239
31240         }
31241 }
31242
31243 func (obj *AOSprite) deserialize(r io.Reader) {
31244         for local363 := range (*(*(struct {
31245                 Frame0          [2]int16
31246                 Frames          uint16
31247                 FrameDuration   float32
31248                 ViewAngleFrames bool
31249         }))(obj)).Frame0 {
31250                 {
31251                         p := &((*(*(struct {
31252                                 Frame0          [2]int16
31253                                 Frames          uint16
31254                                 FrameDuration   float32
31255                                 ViewAngleFrames bool
31256                         }))(obj)).Frame0)[local363]
31257                         *p = int16(read16(r))
31258                 }
31259         }
31260         {
31261                 p := &(*(*(struct {
31262                         Frame0          [2]int16
31263                         Frames          uint16
31264                         FrameDuration   float32
31265                         ViewAngleFrames bool
31266                 }))(obj)).Frames
31267                 *p = read16(r)
31268         }
31269         {
31270                 p := &(*(*(struct {
31271                         Frame0          [2]int16
31272                         Frames          uint16
31273                         FrameDuration   float32
31274                         ViewAngleFrames bool
31275                 }))(obj)).FrameDuration
31276                 *p = math.Float32frombits(read32(r))
31277         }
31278         {
31279                 p := &(*(*(struct {
31280                         Frame0          [2]int16
31281                         Frames          uint16
31282                         FrameDuration   float32
31283                         ViewAngleFrames bool
31284                 }))(obj)).ViewAngleFrames
31285                 switch n := read8(r); n {
31286                 case 0:
31287                         *p = false
31288                 case 1:
31289                         *p = true
31290                 default:
31291                         chk(fmt.Errorf("invalid bool: %d", n))
31292                 }
31293
31294         }
31295 }
31296
31297 func (obj *Group) serialize(w io.Writer) {
31298         if len(([]byte((*(*(struct {
31299                 Name   string
31300                 Rating int16
31301         }))(obj)).Name))) > math.MaxUint16 {
31302                 chk(ErrTooLong)
31303         }
31304         {
31305                 x := uint16(len(([]byte((*(*(struct {
31306                         Name   string
31307                         Rating int16
31308                 }))(obj)).Name))))
31309                 write16(w, uint16(x))
31310         }
31311         {
31312                 _, err := w.Write(([]byte((*(*(struct {
31313                         Name   string
31314                         Rating int16
31315                 }))(obj)).Name))[:])
31316                 chk(err)
31317         }
31318         {
31319                 x := (*(*(struct {
31320                         Name   string
31321                         Rating int16
31322                 }))(obj)).Rating
31323                 write16(w, uint16(x))
31324         }
31325 }
31326
31327 func (obj *Group) deserialize(r io.Reader) {
31328         var local364 []uint8
31329         var local365 uint16
31330         {
31331                 p := &local365
31332                 *p = read16(r)
31333         }
31334         (local364) = make([]uint8, local365)
31335         {
31336                 _, err := io.ReadFull(r, (local364)[:])
31337                 chk(err)
31338         }
31339         ((*(*(struct {
31340                 Name   string
31341                 Rating int16
31342         }))(obj)).Name) = string(local364)
31343         {
31344                 p := &(*(*(struct {
31345                         Name   string
31346                         Rating int16
31347                 }))(obj)).Rating
31348                 *p = int16(read16(r))
31349         }
31350 }
31351
31352 func (obj *AOAnim) serialize(w io.Writer) {
31353         for local366 := range (*(*(struct {
31354                 Frames [2]int32
31355                 Speed  float32
31356                 Blend  float32
31357                 NoLoop bool
31358         }))(obj)).Frames {
31359                 {
31360                         x := ((*(*(struct {
31361                                 Frames [2]int32
31362                                 Speed  float32
31363                                 Blend  float32
31364                                 NoLoop bool
31365                         }))(obj)).Frames)[local366]
31366                         write32(w, uint32(x))
31367                 }
31368         }
31369         {
31370                 x := (*(*(struct {
31371                         Frames [2]int32
31372                         Speed  float32
31373                         Blend  float32
31374                         NoLoop bool
31375                 }))(obj)).Speed
31376                 write32(w, math.Float32bits(x))
31377         }
31378         {
31379                 x := (*(*(struct {
31380                         Frames [2]int32
31381                         Speed  float32
31382                         Blend  float32
31383                         NoLoop bool
31384                 }))(obj)).Blend
31385                 write32(w, math.Float32bits(x))
31386         }
31387         {
31388                 x := (*(*(struct {
31389                         Frames [2]int32
31390                         Speed  float32
31391                         Blend  float32
31392                         NoLoop bool
31393                 }))(obj)).NoLoop
31394                 if x {
31395                         write8(w, 1)
31396                 } else {
31397                         write8(w, 0)
31398                 }
31399
31400         }
31401 }
31402
31403 func (obj *AOAnim) deserialize(r io.Reader) {
31404         for local367 := range (*(*(struct {
31405                 Frames [2]int32
31406                 Speed  float32
31407                 Blend  float32
31408                 NoLoop bool
31409         }))(obj)).Frames {
31410                 {
31411                         p := &((*(*(struct {
31412                                 Frames [2]int32
31413                                 Speed  float32
31414                                 Blend  float32
31415                                 NoLoop bool
31416                         }))(obj)).Frames)[local367]
31417                         *p = int32(read32(r))
31418                 }
31419         }
31420         {
31421                 p := &(*(*(struct {
31422                         Frames [2]int32
31423                         Speed  float32
31424                         Blend  float32
31425                         NoLoop bool
31426                 }))(obj)).Speed
31427                 *p = math.Float32frombits(read32(r))
31428         }
31429         {
31430                 p := &(*(*(struct {
31431                         Frames [2]int32
31432                         Speed  float32
31433                         Blend  float32
31434                         NoLoop bool
31435                 }))(obj)).Blend
31436                 *p = math.Float32frombits(read32(r))
31437         }
31438         {
31439                 p := &(*(*(struct {
31440                         Frames [2]int32
31441                         Speed  float32
31442                         Blend  float32
31443                         NoLoop bool
31444                 }))(obj)).NoLoop
31445                 switch n := read8(r); n {
31446                 case 0:
31447                         *p = false
31448                 case 1:
31449                         *p = true
31450                 default:
31451                         chk(fmt.Errorf("invalid bool: %d", n))
31452                 }
31453
31454         }
31455 }
31456
31457 func (obj *AOBonePos) serialize(w io.Writer) {
31458         if err := pcall(func() {
31459                 ((*(*(struct {
31460                         Pos Vec
31461                         Rot [3]float32
31462                 }))(obj)).Pos).serialize(w)
31463         }); err != nil {
31464                 if err == io.EOF {
31465                         chk(io.EOF)
31466                 }
31467                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31468         }
31469         for local368 := range (*(*(struct {
31470                 Pos Vec
31471                 Rot [3]float32
31472         }))(obj)).Rot {
31473                 {
31474                         x := ((*(*(struct {
31475                                 Pos Vec
31476                                 Rot [3]float32
31477                         }))(obj)).Rot)[local368]
31478                         write32(w, math.Float32bits(x))
31479                 }
31480         }
31481 }
31482
31483 func (obj *AOBonePos) deserialize(r io.Reader) {
31484         if err := pcall(func() {
31485                 ((*(*(struct {
31486                         Pos Vec
31487                         Rot [3]float32
31488                 }))(obj)).Pos).deserialize(r)
31489         }); err != nil {
31490                 if err == io.EOF {
31491                         chk(io.EOF)
31492                 }
31493                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31494         }
31495         for local369 := range (*(*(struct {
31496                 Pos Vec
31497                 Rot [3]float32
31498         }))(obj)).Rot {
31499                 {
31500                         p := &((*(*(struct {
31501                                 Pos Vec
31502                                 Rot [3]float32
31503                         }))(obj)).Rot)[local369]
31504                         *p = math.Float32frombits(read32(r))
31505                 }
31506         }
31507 }
31508
31509 func (obj *AOAttach) serialize(w io.Writer) {
31510         if err := pcall(func() {
31511                 ((*(*(struct {
31512                         ParentID     AOID
31513                         Bone         string
31514                         Pos          Vec
31515                         Rot          [3]float32
31516                         ForceVisible bool
31517                 }))(obj)).ParentID).serialize(w)
31518         }); err != nil {
31519                 if err == io.EOF {
31520                         chk(io.EOF)
31521                 }
31522                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
31523         }
31524         if len(([]byte((*(*(struct {
31525                 ParentID     AOID
31526                 Bone         string
31527                 Pos          Vec
31528                 Rot          [3]float32
31529                 ForceVisible bool
31530         }))(obj)).Bone))) > math.MaxUint16 {
31531                 chk(ErrTooLong)
31532         }
31533         {
31534                 x := uint16(len(([]byte((*(*(struct {
31535                         ParentID     AOID
31536                         Bone         string
31537                         Pos          Vec
31538                         Rot          [3]float32
31539                         ForceVisible bool
31540                 }))(obj)).Bone))))
31541                 write16(w, uint16(x))
31542         }
31543         {
31544                 _, err := w.Write(([]byte((*(*(struct {
31545                         ParentID     AOID
31546                         Bone         string
31547                         Pos          Vec
31548                         Rot          [3]float32
31549                         ForceVisible bool
31550                 }))(obj)).Bone))[:])
31551                 chk(err)
31552         }
31553         if err := pcall(func() {
31554                 ((*(*(struct {
31555                         ParentID     AOID
31556                         Bone         string
31557                         Pos          Vec
31558                         Rot          [3]float32
31559                         ForceVisible bool
31560                 }))(obj)).Pos).serialize(w)
31561         }); err != nil {
31562                 if err == io.EOF {
31563                         chk(io.EOF)
31564                 }
31565                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31566         }
31567         for local370 := range (*(*(struct {
31568                 ParentID     AOID
31569                 Bone         string
31570                 Pos          Vec
31571                 Rot          [3]float32
31572                 ForceVisible bool
31573         }))(obj)).Rot {
31574                 {
31575                         x := ((*(*(struct {
31576                                 ParentID     AOID
31577                                 Bone         string
31578                                 Pos          Vec
31579                                 Rot          [3]float32
31580                                 ForceVisible bool
31581                         }))(obj)).Rot)[local370]
31582                         write32(w, math.Float32bits(x))
31583                 }
31584         }
31585         {
31586                 x := (*(*(struct {
31587                         ParentID     AOID
31588                         Bone         string
31589                         Pos          Vec
31590                         Rot          [3]float32
31591                         ForceVisible bool
31592                 }))(obj)).ForceVisible
31593                 if x {
31594                         write8(w, 1)
31595                 } else {
31596                         write8(w, 0)
31597                 }
31598
31599         }
31600 }
31601
31602 func (obj *AOAttach) deserialize(r io.Reader) {
31603         if err := pcall(func() {
31604                 ((*(*(struct {
31605                         ParentID     AOID
31606                         Bone         string
31607                         Pos          Vec
31608                         Rot          [3]float32
31609                         ForceVisible bool
31610                 }))(obj)).ParentID).deserialize(r)
31611         }); err != nil {
31612                 if err == io.EOF {
31613                         chk(io.EOF)
31614                 }
31615                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
31616         }
31617         var local371 []uint8
31618         var local372 uint16
31619         {
31620                 p := &local372
31621                 *p = read16(r)
31622         }
31623         (local371) = make([]uint8, local372)
31624         {
31625                 _, err := io.ReadFull(r, (local371)[:])
31626                 chk(err)
31627         }
31628         ((*(*(struct {
31629                 ParentID     AOID
31630                 Bone         string
31631                 Pos          Vec
31632                 Rot          [3]float32
31633                 ForceVisible bool
31634         }))(obj)).Bone) = string(local371)
31635         if err := pcall(func() {
31636                 ((*(*(struct {
31637                         ParentID     AOID
31638                         Bone         string
31639                         Pos          Vec
31640                         Rot          [3]float32
31641                         ForceVisible bool
31642                 }))(obj)).Pos).deserialize(r)
31643         }); err != nil {
31644                 if err == io.EOF {
31645                         chk(io.EOF)
31646                 }
31647                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31648         }
31649         for local373 := range (*(*(struct {
31650                 ParentID     AOID
31651                 Bone         string
31652                 Pos          Vec
31653                 Rot          [3]float32
31654                 ForceVisible bool
31655         }))(obj)).Rot {
31656                 {
31657                         p := &((*(*(struct {
31658                                 ParentID     AOID
31659                                 Bone         string
31660                                 Pos          Vec
31661                                 Rot          [3]float32
31662                                 ForceVisible bool
31663                         }))(obj)).Rot)[local373]
31664                         *p = math.Float32frombits(read32(r))
31665                 }
31666         }
31667         {
31668                 p := &(*(*(struct {
31669                         ParentID     AOID
31670                         Bone         string
31671                         Pos          Vec
31672                         Rot          [3]float32
31673                         ForceVisible bool
31674                 }))(obj)).ForceVisible
31675                 switch n := read8(r); n {
31676                 case 0:
31677                         *p = false
31678                 case 1:
31679                         *p = true
31680                 default:
31681                         chk(fmt.Errorf("invalid bool: %d", n))
31682                 }
31683
31684         }
31685 }
31686
31687 func (obj *AOPhysOverride) serialize(w io.Writer) {
31688         {
31689                 x := (*(*(struct {
31690                         Walk, Jump, Gravity float32
31691
31692                         // Player only.
31693                         NoSneak, NoSneakGlitch, OldSneak bool
31694                 }))(obj)).Walk
31695                 write32(w, math.Float32bits(x))
31696         }
31697         {
31698                 x := (*(*(struct {
31699                         Walk, Jump, Gravity float32
31700
31701                         // Player only.
31702                         NoSneak, NoSneakGlitch, OldSneak bool
31703                 }))(obj)).Jump
31704                 write32(w, math.Float32bits(x))
31705         }
31706         {
31707                 x := (*(*(struct {
31708                         Walk, Jump, Gravity float32
31709
31710                         // Player only.
31711                         NoSneak, NoSneakGlitch, OldSneak bool
31712                 }))(obj)).Gravity
31713                 write32(w, math.Float32bits(x))
31714         }
31715         {
31716                 x := (*(*(struct {
31717                         Walk, Jump, Gravity float32
31718
31719                         // Player only.
31720                         NoSneak, NoSneakGlitch, OldSneak bool
31721                 }))(obj)).NoSneak
31722                 if x {
31723                         write8(w, 1)
31724                 } else {
31725                         write8(w, 0)
31726                 }
31727
31728         }
31729         {
31730                 x := (*(*(struct {
31731                         Walk, Jump, Gravity float32
31732
31733                         // Player only.
31734                         NoSneak, NoSneakGlitch, OldSneak bool
31735                 }))(obj)).NoSneakGlitch
31736                 if x {
31737                         write8(w, 1)
31738                 } else {
31739                         write8(w, 0)
31740                 }
31741
31742         }
31743         {
31744                 x := (*(*(struct {
31745                         Walk, Jump, Gravity float32
31746
31747                         // Player only.
31748                         NoSneak, NoSneakGlitch, OldSneak bool
31749                 }))(obj)).OldSneak
31750                 if x {
31751                         write8(w, 1)
31752                 } else {
31753                         write8(w, 0)
31754                 }
31755
31756         }
31757 }
31758
31759 func (obj *AOPhysOverride) deserialize(r io.Reader) {
31760         {
31761                 p := &(*(*(struct {
31762                         Walk, Jump, Gravity float32
31763
31764                         // Player only.
31765                         NoSneak, NoSneakGlitch, OldSneak bool
31766                 }))(obj)).Walk
31767                 *p = math.Float32frombits(read32(r))
31768         }
31769         {
31770                 p := &(*(*(struct {
31771                         Walk, Jump, Gravity float32
31772
31773                         // Player only.
31774                         NoSneak, NoSneakGlitch, OldSneak bool
31775                 }))(obj)).Jump
31776                 *p = math.Float32frombits(read32(r))
31777         }
31778         {
31779                 p := &(*(*(struct {
31780                         Walk, Jump, Gravity float32
31781
31782                         // Player only.
31783                         NoSneak, NoSneakGlitch, OldSneak bool
31784                 }))(obj)).Gravity
31785                 *p = math.Float32frombits(read32(r))
31786         }
31787         {
31788                 p := &(*(*(struct {
31789                         Walk, Jump, Gravity float32
31790
31791                         // Player only.
31792                         NoSneak, NoSneakGlitch, OldSneak bool
31793                 }))(obj)).NoSneak
31794                 switch n := read8(r); n {
31795                 case 0:
31796                         *p = false
31797                 case 1:
31798                         *p = true
31799                 default:
31800                         chk(fmt.Errorf("invalid bool: %d", n))
31801                 }
31802
31803         }
31804         {
31805                 p := &(*(*(struct {
31806                         Walk, Jump, Gravity float32
31807
31808                         // Player only.
31809                         NoSneak, NoSneakGlitch, OldSneak bool
31810                 }))(obj)).NoSneakGlitch
31811                 switch n := read8(r); n {
31812                 case 0:
31813                         *p = false
31814                 case 1:
31815                         *p = true
31816                 default:
31817                         chk(fmt.Errorf("invalid bool: %d", n))
31818                 }
31819
31820         }
31821         {
31822                 p := &(*(*(struct {
31823                         Walk, Jump, Gravity float32
31824
31825                         // Player only.
31826                         NoSneak, NoSneakGlitch, OldSneak bool
31827                 }))(obj)).OldSneak
31828                 switch n := read8(r); n {
31829                 case 0:
31830                         *p = false
31831                 case 1:
31832                         *p = true
31833                 default:
31834                         chk(fmt.Errorf("invalid bool: %d", n))
31835                 }
31836
31837         }
31838 }
31839
31840 func (obj *aoType) serialize(w io.Writer) {
31841         {
31842                 x := *(*(uint8))(obj)
31843                 write8(w, uint8(x))
31844         }
31845 }
31846
31847 func (obj *aoType) deserialize(r io.Reader) {
31848         {
31849                 p := &*(*(uint8))(obj)
31850                 *p = read8(r)
31851         }
31852 }
31853
31854 func (obj *NodeMetaField) serialize(w io.Writer) {
31855         if err := pcall(func() {
31856                 ((*(*(struct {
31857                         Field
31858                         Private bool
31859                 }))(obj)).Field).serialize(w)
31860         }); err != nil {
31861                 if err == io.EOF {
31862                         chk(io.EOF)
31863                 }
31864                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
31865         }
31866         {
31867                 x := (*(*(struct {
31868                         Field
31869                         Private bool
31870                 }))(obj)).Private
31871                 if x {
31872                         write8(w, 1)
31873                 } else {
31874                         write8(w, 0)
31875                 }
31876
31877         }
31878 }
31879
31880 func (obj *NodeMetaField) deserialize(r io.Reader) {
31881         if err := pcall(func() {
31882                 ((*(*(struct {
31883                         Field
31884                         Private bool
31885                 }))(obj)).Field).deserialize(r)
31886         }); err != nil {
31887                 if err == io.EOF {
31888                         chk(io.EOF)
31889                 }
31890                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
31891         }
31892         {
31893                 p := &(*(*(struct {
31894                         Field
31895                         Private bool
31896                 }))(obj)).Private
31897                 switch n := read8(r); n {
31898                 case 0:
31899                         *p = false
31900                 case 1:
31901                         *p = true
31902                 default:
31903                         chk(fmt.Errorf("invalid bool: %d", n))
31904                 }
31905
31906         }
31907 }
31908
31909 func (obj *MinimapType) serialize(w io.Writer) {
31910         {
31911                 x := *(*(uint16))(obj)
31912                 write16(w, uint16(x))
31913         }
31914 }
31915
31916 func (obj *MinimapType) deserialize(r io.Reader) {
31917         {
31918                 p := &*(*(uint16))(obj)
31919                 *p = read16(r)
31920         }
31921 }
31922
31923 func (obj *Param1Type) serialize(w io.Writer) {
31924         {
31925                 x := *(*(uint8))(obj)
31926                 write8(w, uint8(x))
31927         }
31928 }
31929
31930 func (obj *Param1Type) deserialize(r io.Reader) {
31931         {
31932                 p := &*(*(uint8))(obj)
31933                 *p = read8(r)
31934         }
31935 }
31936
31937 func (obj *Param2Type) serialize(w io.Writer) {
31938         {
31939                 x := *(*(uint8))(obj)
31940                 write8(w, uint8(x))
31941         }
31942 }
31943
31944 func (obj *Param2Type) deserialize(r io.Reader) {
31945         {
31946                 p := &*(*(uint8))(obj)
31947                 *p = read8(r)
31948         }
31949 }
31950
31951 func (obj *DrawType) serialize(w io.Writer) {
31952         {
31953                 x := *(*(uint8))(obj)
31954                 write8(w, uint8(x))
31955         }
31956 }
31957
31958 func (obj *DrawType) deserialize(r io.Reader) {
31959         {
31960                 p := &*(*(uint8))(obj)
31961                 *p = read8(r)
31962         }
31963 }
31964
31965 func (obj *TileDef) serialize(w io.Writer) {
31966         {
31967                 local374 := uint8(6)
31968                 {
31969                         x := local374
31970                         write8(w, uint8(x))
31971                 }
31972         }
31973         if err := pcall(func() {
31974                 ((*(*(struct {
31975                         Texture
31976                         Anim  TileAnim
31977                         Flags TileFlags
31978
31979                         //mt:if %s.Flags&TileColor != 0
31980                         R, G, B uint8
31981
31982                         //mt:if %s.Flags&TileScale != 0
31983                         Scale uint8
31984
31985                         //mt:if %s.Flags&TileAlign != 0
31986                         Align AlignType
31987                 }))(obj)).Texture).serialize(w)
31988         }); err != nil {
31989                 if err == io.EOF {
31990                         chk(io.EOF)
31991                 }
31992                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
31993         }
31994         if err := pcall(func() {
31995                 ((*(*(struct {
31996                         Texture
31997                         Anim  TileAnim
31998                         Flags TileFlags
31999
32000                         //mt:if %s.Flags&TileColor != 0
32001                         R, G, B uint8
32002
32003                         //mt:if %s.Flags&TileScale != 0
32004                         Scale uint8
32005
32006                         //mt:if %s.Flags&TileAlign != 0
32007                         Align AlignType
32008                 }))(obj)).Anim).serialize(w)
32009         }); err != nil {
32010                 if err == io.EOF {
32011                         chk(io.EOF)
32012                 }
32013                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32014         }
32015         if err := pcall(func() {
32016                 ((*(*(struct {
32017                         Texture
32018                         Anim  TileAnim
32019                         Flags TileFlags
32020
32021                         //mt:if %s.Flags&TileColor != 0
32022                         R, G, B uint8
32023
32024                         //mt:if %s.Flags&TileScale != 0
32025                         Scale uint8
32026
32027                         //mt:if %s.Flags&TileAlign != 0
32028                         Align AlignType
32029                 }))(obj)).Flags).serialize(w)
32030         }); err != nil {
32031                 if err == io.EOF {
32032                         chk(io.EOF)
32033                 }
32034                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32035         }
32036         if (*(*(struct {
32037                 Texture
32038                 Anim  TileAnim
32039                 Flags TileFlags
32040
32041                 //mt:if %s.Flags&TileColor != 0
32042                 R, G, B uint8
32043
32044                 //mt:if %s.Flags&TileScale != 0
32045                 Scale uint8
32046
32047                 //mt:if %s.Flags&TileAlign != 0
32048                 Align AlignType
32049         }))(obj)).Flags&TileColor != 0 {
32050                 {
32051                         x := (*(*(struct {
32052                                 Texture
32053                                 Anim  TileAnim
32054                                 Flags TileFlags
32055
32056                                 //mt:if %s.Flags&TileColor != 0
32057                                 R, G, B uint8
32058
32059                                 //mt:if %s.Flags&TileScale != 0
32060                                 Scale uint8
32061
32062                                 //mt:if %s.Flags&TileAlign != 0
32063                                 Align AlignType
32064                         }))(obj)).R
32065                         write8(w, uint8(x))
32066                 }
32067                 {
32068                         x := (*(*(struct {
32069                                 Texture
32070                                 Anim  TileAnim
32071                                 Flags TileFlags
32072
32073                                 //mt:if %s.Flags&TileColor != 0
32074                                 R, G, B uint8
32075
32076                                 //mt:if %s.Flags&TileScale != 0
32077                                 Scale uint8
32078
32079                                 //mt:if %s.Flags&TileAlign != 0
32080                                 Align AlignType
32081                         }))(obj)).G
32082                         write8(w, uint8(x))
32083                 }
32084                 {
32085                         x := (*(*(struct {
32086                                 Texture
32087                                 Anim  TileAnim
32088                                 Flags TileFlags
32089
32090                                 //mt:if %s.Flags&TileColor != 0
32091                                 R, G, B uint8
32092
32093                                 //mt:if %s.Flags&TileScale != 0
32094                                 Scale uint8
32095
32096                                 //mt:if %s.Flags&TileAlign != 0
32097                                 Align AlignType
32098                         }))(obj)).B
32099                         write8(w, uint8(x))
32100                 }
32101         }
32102         if (*(*(struct {
32103                 Texture
32104                 Anim  TileAnim
32105                 Flags TileFlags
32106
32107                 //mt:if %s.Flags&TileColor != 0
32108                 R, G, B uint8
32109
32110                 //mt:if %s.Flags&TileScale != 0
32111                 Scale uint8
32112
32113                 //mt:if %s.Flags&TileAlign != 0
32114                 Align AlignType
32115         }))(obj)).Flags&TileScale != 0 {
32116                 {
32117                         x := (*(*(struct {
32118                                 Texture
32119                                 Anim  TileAnim
32120                                 Flags TileFlags
32121
32122                                 //mt:if %s.Flags&TileColor != 0
32123                                 R, G, B uint8
32124
32125                                 //mt:if %s.Flags&TileScale != 0
32126                                 Scale uint8
32127
32128                                 //mt:if %s.Flags&TileAlign != 0
32129                                 Align AlignType
32130                         }))(obj)).Scale
32131                         write8(w, uint8(x))
32132                 }
32133         }
32134         if (*(*(struct {
32135                 Texture
32136                 Anim  TileAnim
32137                 Flags TileFlags
32138
32139                 //mt:if %s.Flags&TileColor != 0
32140                 R, G, B uint8
32141
32142                 //mt:if %s.Flags&TileScale != 0
32143                 Scale uint8
32144
32145                 //mt:if %s.Flags&TileAlign != 0
32146                 Align AlignType
32147         }))(obj)).Flags&TileAlign != 0 {
32148                 if err := pcall(func() {
32149                         ((*(*(struct {
32150                                 Texture
32151                                 Anim  TileAnim
32152                                 Flags TileFlags
32153
32154                                 //mt:if %s.Flags&TileColor != 0
32155                                 R, G, B uint8
32156
32157                                 //mt:if %s.Flags&TileScale != 0
32158                                 Scale uint8
32159
32160                                 //mt:if %s.Flags&TileAlign != 0
32161                                 Align AlignType
32162                         }))(obj)).Align).serialize(w)
32163                 }); err != nil {
32164                         if err == io.EOF {
32165                                 chk(io.EOF)
32166                         }
32167                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32168                 }
32169         }
32170 }
32171
32172 func (obj *TileDef) deserialize(r io.Reader) {
32173         {
32174                 var local375 uint8
32175                 local376 := uint8(6)
32176                 {
32177                         p := &local375
32178                         *p = read8(r)
32179                 }
32180                 if local375 != local376 {
32181                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local375))
32182                 }
32183         }
32184         if err := pcall(func() {
32185                 ((*(*(struct {
32186                         Texture
32187                         Anim  TileAnim
32188                         Flags TileFlags
32189
32190                         //mt:if %s.Flags&TileColor != 0
32191                         R, G, B uint8
32192
32193                         //mt:if %s.Flags&TileScale != 0
32194                         Scale uint8
32195
32196                         //mt:if %s.Flags&TileAlign != 0
32197                         Align AlignType
32198                 }))(obj)).Texture).deserialize(r)
32199         }); err != nil {
32200                 if err == io.EOF {
32201                         chk(io.EOF)
32202                 }
32203                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
32204         }
32205         if err := pcall(func() {
32206                 ((*(*(struct {
32207                         Texture
32208                         Anim  TileAnim
32209                         Flags TileFlags
32210
32211                         //mt:if %s.Flags&TileColor != 0
32212                         R, G, B uint8
32213
32214                         //mt:if %s.Flags&TileScale != 0
32215                         Scale uint8
32216
32217                         //mt:if %s.Flags&TileAlign != 0
32218                         Align AlignType
32219                 }))(obj)).Anim).deserialize(r)
32220         }); err != nil {
32221                 if err == io.EOF {
32222                         chk(io.EOF)
32223                 }
32224                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32225         }
32226         if err := pcall(func() {
32227                 ((*(*(struct {
32228                         Texture
32229                         Anim  TileAnim
32230                         Flags TileFlags
32231
32232                         //mt:if %s.Flags&TileColor != 0
32233                         R, G, B uint8
32234
32235                         //mt:if %s.Flags&TileScale != 0
32236                         Scale uint8
32237
32238                         //mt:if %s.Flags&TileAlign != 0
32239                         Align AlignType
32240                 }))(obj)).Flags).deserialize(r)
32241         }); err != nil {
32242                 if err == io.EOF {
32243                         chk(io.EOF)
32244                 }
32245                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32246         }
32247         if (*(*(struct {
32248                 Texture
32249                 Anim  TileAnim
32250                 Flags TileFlags
32251
32252                 //mt:if %s.Flags&TileColor != 0
32253                 R, G, B uint8
32254
32255                 //mt:if %s.Flags&TileScale != 0
32256                 Scale uint8
32257
32258                 //mt:if %s.Flags&TileAlign != 0
32259                 Align AlignType
32260         }))(obj)).Flags&TileColor != 0 {
32261                 {
32262                         p := &(*(*(struct {
32263                                 Texture
32264                                 Anim  TileAnim
32265                                 Flags TileFlags
32266
32267                                 //mt:if %s.Flags&TileColor != 0
32268                                 R, G, B uint8
32269
32270                                 //mt:if %s.Flags&TileScale != 0
32271                                 Scale uint8
32272
32273                                 //mt:if %s.Flags&TileAlign != 0
32274                                 Align AlignType
32275                         }))(obj)).R
32276                         *p = read8(r)
32277                 }
32278                 {
32279                         p := &(*(*(struct {
32280                                 Texture
32281                                 Anim  TileAnim
32282                                 Flags TileFlags
32283
32284                                 //mt:if %s.Flags&TileColor != 0
32285                                 R, G, B uint8
32286
32287                                 //mt:if %s.Flags&TileScale != 0
32288                                 Scale uint8
32289
32290                                 //mt:if %s.Flags&TileAlign != 0
32291                                 Align AlignType
32292                         }))(obj)).G
32293                         *p = read8(r)
32294                 }
32295                 {
32296                         p := &(*(*(struct {
32297                                 Texture
32298                                 Anim  TileAnim
32299                                 Flags TileFlags
32300
32301                                 //mt:if %s.Flags&TileColor != 0
32302                                 R, G, B uint8
32303
32304                                 //mt:if %s.Flags&TileScale != 0
32305                                 Scale uint8
32306
32307                                 //mt:if %s.Flags&TileAlign != 0
32308                                 Align AlignType
32309                         }))(obj)).B
32310                         *p = read8(r)
32311                 }
32312         }
32313         if (*(*(struct {
32314                 Texture
32315                 Anim  TileAnim
32316                 Flags TileFlags
32317
32318                 //mt:if %s.Flags&TileColor != 0
32319                 R, G, B uint8
32320
32321                 //mt:if %s.Flags&TileScale != 0
32322                 Scale uint8
32323
32324                 //mt:if %s.Flags&TileAlign != 0
32325                 Align AlignType
32326         }))(obj)).Flags&TileScale != 0 {
32327                 {
32328                         p := &(*(*(struct {
32329                                 Texture
32330                                 Anim  TileAnim
32331                                 Flags TileFlags
32332
32333                                 //mt:if %s.Flags&TileColor != 0
32334                                 R, G, B uint8
32335
32336                                 //mt:if %s.Flags&TileScale != 0
32337                                 Scale uint8
32338
32339                                 //mt:if %s.Flags&TileAlign != 0
32340                                 Align AlignType
32341                         }))(obj)).Scale
32342                         *p = read8(r)
32343                 }
32344         }
32345         if (*(*(struct {
32346                 Texture
32347                 Anim  TileAnim
32348                 Flags TileFlags
32349
32350                 //mt:if %s.Flags&TileColor != 0
32351                 R, G, B uint8
32352
32353                 //mt:if %s.Flags&TileScale != 0
32354                 Scale uint8
32355
32356                 //mt:if %s.Flags&TileAlign != 0
32357                 Align AlignType
32358         }))(obj)).Flags&TileAlign != 0 {
32359                 if err := pcall(func() {
32360                         ((*(*(struct {
32361                                 Texture
32362                                 Anim  TileAnim
32363                                 Flags TileFlags
32364
32365                                 //mt:if %s.Flags&TileColor != 0
32366                                 R, G, B uint8
32367
32368                                 //mt:if %s.Flags&TileScale != 0
32369                                 Scale uint8
32370
32371                                 //mt:if %s.Flags&TileAlign != 0
32372                                 Align AlignType
32373                         }))(obj)).Align).deserialize(r)
32374                 }); err != nil {
32375                         if err == io.EOF {
32376                                 chk(io.EOF)
32377                         }
32378                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32379                 }
32380         }
32381 }
32382
32383 func (obj *WaveType) serialize(w io.Writer) {
32384         {
32385                 x := *(*(uint8))(obj)
32386                 write8(w, uint8(x))
32387         }
32388 }
32389
32390 func (obj *WaveType) deserialize(r io.Reader) {
32391         {
32392                 p := &*(*(uint8))(obj)
32393                 *p = read8(r)
32394         }
32395 }
32396
32397 func (obj *LiquidType) serialize(w io.Writer) {
32398         {
32399                 x := *(*(uint8))(obj)
32400                 write8(w, uint8(x))
32401         }
32402 }
32403
32404 func (obj *LiquidType) deserialize(r io.Reader) {
32405         {
32406                 p := &*(*(uint8))(obj)
32407                 *p = read8(r)
32408         }
32409 }
32410
32411 func (obj *NodeBox) serialize(w io.Writer) {
32412         {
32413                 local377 := uint8(6)
32414                 {
32415                         x := local377
32416                         write8(w, uint8(x))
32417                 }
32418         }
32419         if err := pcall(func() {
32420                 ((*(*(struct {
32421                         Type NodeBoxType
32422
32423                         //mt:if %s.Type == MountedBox
32424                         WallTop, WallBot, WallSides Box
32425
32426                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32427                         Fixed []Box
32428
32429                         //mt:if %s.Type == ConnectedBox
32430                         ConnDirs, DiscoDirs  DirBoxes
32431                         DiscoAll, DiscoSides []Box
32432                 }))(obj)).Type).serialize(w)
32433         }); err != nil {
32434                 if err == io.EOF {
32435                         chk(io.EOF)
32436                 }
32437                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
32438         }
32439         if !((*(*(struct {
32440                 Type NodeBoxType
32441
32442                 //mt:if %s.Type == MountedBox
32443                 WallTop, WallBot, WallSides Box
32444
32445                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32446                 Fixed []Box
32447
32448                 //mt:if %s.Type == ConnectedBox
32449                 ConnDirs, DiscoDirs  DirBoxes
32450                 DiscoAll, DiscoSides []Box
32451         }))(obj)).Type < maxBox) {
32452                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32453         }
32454         if (*(*(struct {
32455                 Type NodeBoxType
32456
32457                 //mt:if %s.Type == MountedBox
32458                 WallTop, WallBot, WallSides Box
32459
32460                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32461                 Fixed []Box
32462
32463                 //mt:if %s.Type == ConnectedBox
32464                 ConnDirs, DiscoDirs  DirBoxes
32465                 DiscoAll, DiscoSides []Box
32466         }))(obj)).Type == MountedBox {
32467                 if err := pcall(func() {
32468                         ((*(*(struct {
32469                                 Type NodeBoxType
32470
32471                                 //mt:if %s.Type == MountedBox
32472                                 WallTop, WallBot, WallSides Box
32473
32474                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32475                                 Fixed []Box
32476
32477                                 //mt:if %s.Type == ConnectedBox
32478                                 ConnDirs, DiscoDirs  DirBoxes
32479                                 DiscoAll, DiscoSides []Box
32480                         }))(obj)).WallTop).serialize(w)
32481                 }); err != nil {
32482                         if err == io.EOF {
32483                                 chk(io.EOF)
32484                         }
32485                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32486                 }
32487                 if err := pcall(func() {
32488                         ((*(*(struct {
32489                                 Type NodeBoxType
32490
32491                                 //mt:if %s.Type == MountedBox
32492                                 WallTop, WallBot, WallSides Box
32493
32494                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32495                                 Fixed []Box
32496
32497                                 //mt:if %s.Type == ConnectedBox
32498                                 ConnDirs, DiscoDirs  DirBoxes
32499                                 DiscoAll, DiscoSides []Box
32500                         }))(obj)).WallBot).serialize(w)
32501                 }); err != nil {
32502                         if err == io.EOF {
32503                                 chk(io.EOF)
32504                         }
32505                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32506                 }
32507                 if err := pcall(func() {
32508                         ((*(*(struct {
32509                                 Type NodeBoxType
32510
32511                                 //mt:if %s.Type == MountedBox
32512                                 WallTop, WallBot, WallSides Box
32513
32514                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32515                                 Fixed []Box
32516
32517                                 //mt:if %s.Type == ConnectedBox
32518                                 ConnDirs, DiscoDirs  DirBoxes
32519                                 DiscoAll, DiscoSides []Box
32520                         }))(obj)).WallSides).serialize(w)
32521                 }); err != nil {
32522                         if err == io.EOF {
32523                                 chk(io.EOF)
32524                         }
32525                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32526                 }
32527         }
32528         if t := (*(*(struct {
32529                 Type NodeBoxType
32530
32531                 //mt:if %s.Type == MountedBox
32532                 WallTop, WallBot, WallSides Box
32533
32534                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32535                 Fixed []Box
32536
32537                 //mt:if %s.Type == ConnectedBox
32538                 ConnDirs, DiscoDirs  DirBoxes
32539                 DiscoAll, DiscoSides []Box
32540         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32541                 if len(((*(*(struct {
32542                         Type NodeBoxType
32543
32544                         //mt:if %s.Type == MountedBox
32545                         WallTop, WallBot, WallSides Box
32546
32547                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32548                         Fixed []Box
32549
32550                         //mt:if %s.Type == ConnectedBox
32551                         ConnDirs, DiscoDirs  DirBoxes
32552                         DiscoAll, DiscoSides []Box
32553                 }))(obj)).Fixed)) > math.MaxUint16 {
32554                         chk(ErrTooLong)
32555                 }
32556                 {
32557                         x := uint16(len(((*(*(struct {
32558                                 Type NodeBoxType
32559
32560                                 //mt:if %s.Type == MountedBox
32561                                 WallTop, WallBot, WallSides Box
32562
32563                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32564                                 Fixed []Box
32565
32566                                 //mt:if %s.Type == ConnectedBox
32567                                 ConnDirs, DiscoDirs  DirBoxes
32568                                 DiscoAll, DiscoSides []Box
32569                         }))(obj)).Fixed)))
32570                         write16(w, uint16(x))
32571                 }
32572                 for local378 := range (*(*(struct {
32573                         Type NodeBoxType
32574
32575                         //mt:if %s.Type == MountedBox
32576                         WallTop, WallBot, WallSides Box
32577
32578                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32579                         Fixed []Box
32580
32581                         //mt:if %s.Type == ConnectedBox
32582                         ConnDirs, DiscoDirs  DirBoxes
32583                         DiscoAll, DiscoSides []Box
32584                 }))(obj)).Fixed {
32585                         if err := pcall(func() {
32586                                 (((*(*(struct {
32587                                         Type NodeBoxType
32588
32589                                         //mt:if %s.Type == MountedBox
32590                                         WallTop, WallBot, WallSides Box
32591
32592                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32593                                         Fixed []Box
32594
32595                                         //mt:if %s.Type == ConnectedBox
32596                                         ConnDirs, DiscoDirs  DirBoxes
32597                                         DiscoAll, DiscoSides []Box
32598                                 }))(obj)).Fixed)[local378]).serialize(w)
32599                         }); err != nil {
32600                                 if err == io.EOF {
32601                                         chk(io.EOF)
32602                                 }
32603                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32604                         }
32605                 }
32606         }
32607         if (*(*(struct {
32608                 Type NodeBoxType
32609
32610                 //mt:if %s.Type == MountedBox
32611                 WallTop, WallBot, WallSides Box
32612
32613                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32614                 Fixed []Box
32615
32616                 //mt:if %s.Type == ConnectedBox
32617                 ConnDirs, DiscoDirs  DirBoxes
32618                 DiscoAll, DiscoSides []Box
32619         }))(obj)).Type == ConnectedBox {
32620                 if err := pcall(func() {
32621                         ((*(*(struct {
32622                                 Type NodeBoxType
32623
32624                                 //mt:if %s.Type == MountedBox
32625                                 WallTop, WallBot, WallSides Box
32626
32627                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32628                                 Fixed []Box
32629
32630                                 //mt:if %s.Type == ConnectedBox
32631                                 ConnDirs, DiscoDirs  DirBoxes
32632                                 DiscoAll, DiscoSides []Box
32633                         }))(obj)).ConnDirs).serialize(w)
32634                 }); err != nil {
32635                         if err == io.EOF {
32636                                 chk(io.EOF)
32637                         }
32638                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32639                 }
32640                 if err := pcall(func() {
32641                         ((*(*(struct {
32642                                 Type NodeBoxType
32643
32644                                 //mt:if %s.Type == MountedBox
32645                                 WallTop, WallBot, WallSides Box
32646
32647                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32648                                 Fixed []Box
32649
32650                                 //mt:if %s.Type == ConnectedBox
32651                                 ConnDirs, DiscoDirs  DirBoxes
32652                                 DiscoAll, DiscoSides []Box
32653                         }))(obj)).DiscoDirs).serialize(w)
32654                 }); err != nil {
32655                         if err == io.EOF {
32656                                 chk(io.EOF)
32657                         }
32658                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32659                 }
32660                 if len(((*(*(struct {
32661                         Type NodeBoxType
32662
32663                         //mt:if %s.Type == MountedBox
32664                         WallTop, WallBot, WallSides Box
32665
32666                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32667                         Fixed []Box
32668
32669                         //mt:if %s.Type == ConnectedBox
32670                         ConnDirs, DiscoDirs  DirBoxes
32671                         DiscoAll, DiscoSides []Box
32672                 }))(obj)).DiscoAll)) > math.MaxUint16 {
32673                         chk(ErrTooLong)
32674                 }
32675                 {
32676                         x := uint16(len(((*(*(struct {
32677                                 Type NodeBoxType
32678
32679                                 //mt:if %s.Type == MountedBox
32680                                 WallTop, WallBot, WallSides Box
32681
32682                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32683                                 Fixed []Box
32684
32685                                 //mt:if %s.Type == ConnectedBox
32686                                 ConnDirs, DiscoDirs  DirBoxes
32687                                 DiscoAll, DiscoSides []Box
32688                         }))(obj)).DiscoAll)))
32689                         write16(w, uint16(x))
32690                 }
32691                 for local379 := range (*(*(struct {
32692                         Type NodeBoxType
32693
32694                         //mt:if %s.Type == MountedBox
32695                         WallTop, WallBot, WallSides Box
32696
32697                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32698                         Fixed []Box
32699
32700                         //mt:if %s.Type == ConnectedBox
32701                         ConnDirs, DiscoDirs  DirBoxes
32702                         DiscoAll, DiscoSides []Box
32703                 }))(obj)).DiscoAll {
32704                         if err := pcall(func() {
32705                                 (((*(*(struct {
32706                                         Type NodeBoxType
32707
32708                                         //mt:if %s.Type == MountedBox
32709                                         WallTop, WallBot, WallSides Box
32710
32711                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32712                                         Fixed []Box
32713
32714                                         //mt:if %s.Type == ConnectedBox
32715                                         ConnDirs, DiscoDirs  DirBoxes
32716                                         DiscoAll, DiscoSides []Box
32717                                 }))(obj)).DiscoAll)[local379]).serialize(w)
32718                         }); err != nil {
32719                                 if err == io.EOF {
32720                                         chk(io.EOF)
32721                                 }
32722                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32723                         }
32724                 }
32725                 if len(((*(*(struct {
32726                         Type NodeBoxType
32727
32728                         //mt:if %s.Type == MountedBox
32729                         WallTop, WallBot, WallSides Box
32730
32731                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32732                         Fixed []Box
32733
32734                         //mt:if %s.Type == ConnectedBox
32735                         ConnDirs, DiscoDirs  DirBoxes
32736                         DiscoAll, DiscoSides []Box
32737                 }))(obj)).DiscoSides)) > math.MaxUint16 {
32738                         chk(ErrTooLong)
32739                 }
32740                 {
32741                         x := uint16(len(((*(*(struct {
32742                                 Type NodeBoxType
32743
32744                                 //mt:if %s.Type == MountedBox
32745                                 WallTop, WallBot, WallSides Box
32746
32747                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32748                                 Fixed []Box
32749
32750                                 //mt:if %s.Type == ConnectedBox
32751                                 ConnDirs, DiscoDirs  DirBoxes
32752                                 DiscoAll, DiscoSides []Box
32753                         }))(obj)).DiscoSides)))
32754                         write16(w, uint16(x))
32755                 }
32756                 for local380 := range (*(*(struct {
32757                         Type NodeBoxType
32758
32759                         //mt:if %s.Type == MountedBox
32760                         WallTop, WallBot, WallSides Box
32761
32762                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32763                         Fixed []Box
32764
32765                         //mt:if %s.Type == ConnectedBox
32766                         ConnDirs, DiscoDirs  DirBoxes
32767                         DiscoAll, DiscoSides []Box
32768                 }))(obj)).DiscoSides {
32769                         if err := pcall(func() {
32770                                 (((*(*(struct {
32771                                         Type NodeBoxType
32772
32773                                         //mt:if %s.Type == MountedBox
32774                                         WallTop, WallBot, WallSides Box
32775
32776                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32777                                         Fixed []Box
32778
32779                                         //mt:if %s.Type == ConnectedBox
32780                                         ConnDirs, DiscoDirs  DirBoxes
32781                                         DiscoAll, DiscoSides []Box
32782                                 }))(obj)).DiscoSides)[local380]).serialize(w)
32783                         }); err != nil {
32784                                 if err == io.EOF {
32785                                         chk(io.EOF)
32786                                 }
32787                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32788                         }
32789                 }
32790         }
32791 }
32792
32793 func (obj *NodeBox) deserialize(r io.Reader) {
32794         {
32795                 var local381 uint8
32796                 local382 := uint8(6)
32797                 {
32798                         p := &local381
32799                         *p = read8(r)
32800                 }
32801                 if local381 != local382 {
32802                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local381))
32803                 }
32804         }
32805         if err := pcall(func() {
32806                 ((*(*(struct {
32807                         Type NodeBoxType
32808
32809                         //mt:if %s.Type == MountedBox
32810                         WallTop, WallBot, WallSides Box
32811
32812                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32813                         Fixed []Box
32814
32815                         //mt:if %s.Type == ConnectedBox
32816                         ConnDirs, DiscoDirs  DirBoxes
32817                         DiscoAll, DiscoSides []Box
32818                 }))(obj)).Type).deserialize(r)
32819         }); err != nil {
32820                 if err == io.EOF {
32821                         chk(io.EOF)
32822                 }
32823                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
32824         }
32825         if !((*(*(struct {
32826                 Type NodeBoxType
32827
32828                 //mt:if %s.Type == MountedBox
32829                 WallTop, WallBot, WallSides Box
32830
32831                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32832                 Fixed []Box
32833
32834                 //mt:if %s.Type == ConnectedBox
32835                 ConnDirs, DiscoDirs  DirBoxes
32836                 DiscoAll, DiscoSides []Box
32837         }))(obj)).Type < maxBox) {
32838                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32839         }
32840         if (*(*(struct {
32841                 Type NodeBoxType
32842
32843                 //mt:if %s.Type == MountedBox
32844                 WallTop, WallBot, WallSides Box
32845
32846                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32847                 Fixed []Box
32848
32849                 //mt:if %s.Type == ConnectedBox
32850                 ConnDirs, DiscoDirs  DirBoxes
32851                 DiscoAll, DiscoSides []Box
32852         }))(obj)).Type == MountedBox {
32853                 if err := pcall(func() {
32854                         ((*(*(struct {
32855                                 Type NodeBoxType
32856
32857                                 //mt:if %s.Type == MountedBox
32858                                 WallTop, WallBot, WallSides Box
32859
32860                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32861                                 Fixed []Box
32862
32863                                 //mt:if %s.Type == ConnectedBox
32864                                 ConnDirs, DiscoDirs  DirBoxes
32865                                 DiscoAll, DiscoSides []Box
32866                         }))(obj)).WallTop).deserialize(r)
32867                 }); err != nil {
32868                         if err == io.EOF {
32869                                 chk(io.EOF)
32870                         }
32871                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32872                 }
32873                 if err := pcall(func() {
32874                         ((*(*(struct {
32875                                 Type NodeBoxType
32876
32877                                 //mt:if %s.Type == MountedBox
32878                                 WallTop, WallBot, WallSides Box
32879
32880                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32881                                 Fixed []Box
32882
32883                                 //mt:if %s.Type == ConnectedBox
32884                                 ConnDirs, DiscoDirs  DirBoxes
32885                                 DiscoAll, DiscoSides []Box
32886                         }))(obj)).WallBot).deserialize(r)
32887                 }); err != nil {
32888                         if err == io.EOF {
32889                                 chk(io.EOF)
32890                         }
32891                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32892                 }
32893                 if err := pcall(func() {
32894                         ((*(*(struct {
32895                                 Type NodeBoxType
32896
32897                                 //mt:if %s.Type == MountedBox
32898                                 WallTop, WallBot, WallSides Box
32899
32900                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32901                                 Fixed []Box
32902
32903                                 //mt:if %s.Type == ConnectedBox
32904                                 ConnDirs, DiscoDirs  DirBoxes
32905                                 DiscoAll, DiscoSides []Box
32906                         }))(obj)).WallSides).deserialize(r)
32907                 }); err != nil {
32908                         if err == io.EOF {
32909                                 chk(io.EOF)
32910                         }
32911                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32912                 }
32913         }
32914         if t := (*(*(struct {
32915                 Type NodeBoxType
32916
32917                 //mt:if %s.Type == MountedBox
32918                 WallTop, WallBot, WallSides Box
32919
32920                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32921                 Fixed []Box
32922
32923                 //mt:if %s.Type == ConnectedBox
32924                 ConnDirs, DiscoDirs  DirBoxes
32925                 DiscoAll, DiscoSides []Box
32926         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32927                 var local383 uint16
32928                 {
32929                         p := &local383
32930                         *p = read16(r)
32931                 }
32932                 ((*(*(struct {
32933                         Type NodeBoxType
32934
32935                         //mt:if %s.Type == MountedBox
32936                         WallTop, WallBot, WallSides Box
32937
32938                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32939                         Fixed []Box
32940
32941                         //mt:if %s.Type == ConnectedBox
32942                         ConnDirs, DiscoDirs  DirBoxes
32943                         DiscoAll, DiscoSides []Box
32944                 }))(obj)).Fixed) = make([]Box, local383)
32945                 for local384 := range (*(*(struct {
32946                         Type NodeBoxType
32947
32948                         //mt:if %s.Type == MountedBox
32949                         WallTop, WallBot, WallSides Box
32950
32951                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32952                         Fixed []Box
32953
32954                         //mt:if %s.Type == ConnectedBox
32955                         ConnDirs, DiscoDirs  DirBoxes
32956                         DiscoAll, DiscoSides []Box
32957                 }))(obj)).Fixed {
32958                         if err := pcall(func() {
32959                                 (((*(*(struct {
32960                                         Type NodeBoxType
32961
32962                                         //mt:if %s.Type == MountedBox
32963                                         WallTop, WallBot, WallSides Box
32964
32965                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32966                                         Fixed []Box
32967
32968                                         //mt:if %s.Type == ConnectedBox
32969                                         ConnDirs, DiscoDirs  DirBoxes
32970                                         DiscoAll, DiscoSides []Box
32971                                 }))(obj)).Fixed)[local384]).deserialize(r)
32972                         }); err != nil {
32973                                 if err == io.EOF {
32974                                         chk(io.EOF)
32975                                 }
32976                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32977                         }
32978                 }
32979         }
32980         if (*(*(struct {
32981                 Type NodeBoxType
32982
32983                 //mt:if %s.Type == MountedBox
32984                 WallTop, WallBot, WallSides Box
32985
32986                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32987                 Fixed []Box
32988
32989                 //mt:if %s.Type == ConnectedBox
32990                 ConnDirs, DiscoDirs  DirBoxes
32991                 DiscoAll, DiscoSides []Box
32992         }))(obj)).Type == ConnectedBox {
32993                 if err := pcall(func() {
32994                         ((*(*(struct {
32995                                 Type NodeBoxType
32996
32997                                 //mt:if %s.Type == MountedBox
32998                                 WallTop, WallBot, WallSides Box
32999
33000                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33001                                 Fixed []Box
33002
33003                                 //mt:if %s.Type == ConnectedBox
33004                                 ConnDirs, DiscoDirs  DirBoxes
33005                                 DiscoAll, DiscoSides []Box
33006                         }))(obj)).ConnDirs).deserialize(r)
33007                 }); err != nil {
33008                         if err == io.EOF {
33009                                 chk(io.EOF)
33010                         }
33011                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33012                 }
33013                 if err := pcall(func() {
33014                         ((*(*(struct {
33015                                 Type NodeBoxType
33016
33017                                 //mt:if %s.Type == MountedBox
33018                                 WallTop, WallBot, WallSides Box
33019
33020                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33021                                 Fixed []Box
33022
33023                                 //mt:if %s.Type == ConnectedBox
33024                                 ConnDirs, DiscoDirs  DirBoxes
33025                                 DiscoAll, DiscoSides []Box
33026                         }))(obj)).DiscoDirs).deserialize(r)
33027                 }); err != nil {
33028                         if err == io.EOF {
33029                                 chk(io.EOF)
33030                         }
33031                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33032                 }
33033                 var local385 uint16
33034                 {
33035                         p := &local385
33036                         *p = read16(r)
33037                 }
33038                 ((*(*(struct {
33039                         Type NodeBoxType
33040
33041                         //mt:if %s.Type == MountedBox
33042                         WallTop, WallBot, WallSides Box
33043
33044                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33045                         Fixed []Box
33046
33047                         //mt:if %s.Type == ConnectedBox
33048                         ConnDirs, DiscoDirs  DirBoxes
33049                         DiscoAll, DiscoSides []Box
33050                 }))(obj)).DiscoAll) = make([]Box, local385)
33051                 for local386 := range (*(*(struct {
33052                         Type NodeBoxType
33053
33054                         //mt:if %s.Type == MountedBox
33055                         WallTop, WallBot, WallSides Box
33056
33057                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33058                         Fixed []Box
33059
33060                         //mt:if %s.Type == ConnectedBox
33061                         ConnDirs, DiscoDirs  DirBoxes
33062                         DiscoAll, DiscoSides []Box
33063                 }))(obj)).DiscoAll {
33064                         if err := pcall(func() {
33065                                 (((*(*(struct {
33066                                         Type NodeBoxType
33067
33068                                         //mt:if %s.Type == MountedBox
33069                                         WallTop, WallBot, WallSides Box
33070
33071                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33072                                         Fixed []Box
33073
33074                                         //mt:if %s.Type == ConnectedBox
33075                                         ConnDirs, DiscoDirs  DirBoxes
33076                                         DiscoAll, DiscoSides []Box
33077                                 }))(obj)).DiscoAll)[local386]).deserialize(r)
33078                         }); err != nil {
33079                                 if err == io.EOF {
33080                                         chk(io.EOF)
33081                                 }
33082                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33083                         }
33084                 }
33085                 var local387 uint16
33086                 {
33087                         p := &local387
33088                         *p = read16(r)
33089                 }
33090                 ((*(*(struct {
33091                         Type NodeBoxType
33092
33093                         //mt:if %s.Type == MountedBox
33094                         WallTop, WallBot, WallSides Box
33095
33096                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33097                         Fixed []Box
33098
33099                         //mt:if %s.Type == ConnectedBox
33100                         ConnDirs, DiscoDirs  DirBoxes
33101                         DiscoAll, DiscoSides []Box
33102                 }))(obj)).DiscoSides) = make([]Box, local387)
33103                 for local388 := range (*(*(struct {
33104                         Type NodeBoxType
33105
33106                         //mt:if %s.Type == MountedBox
33107                         WallTop, WallBot, WallSides Box
33108
33109                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33110                         Fixed []Box
33111
33112                         //mt:if %s.Type == ConnectedBox
33113                         ConnDirs, DiscoDirs  DirBoxes
33114                         DiscoAll, DiscoSides []Box
33115                 }))(obj)).DiscoSides {
33116                         if err := pcall(func() {
33117                                 (((*(*(struct {
33118                                         Type NodeBoxType
33119
33120                                         //mt:if %s.Type == MountedBox
33121                                         WallTop, WallBot, WallSides Box
33122
33123                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33124                                         Fixed []Box
33125
33126                                         //mt:if %s.Type == ConnectedBox
33127                                         ConnDirs, DiscoDirs  DirBoxes
33128                                         DiscoAll, DiscoSides []Box
33129                                 }))(obj)).DiscoSides)[local388]).deserialize(r)
33130                         }); err != nil {
33131                                 if err == io.EOF {
33132                                         chk(io.EOF)
33133                                 }
33134                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33135                         }
33136                 }
33137         }
33138 }
33139
33140 func (obj *SoundDef) serialize(w io.Writer) {
33141         if len(([]byte((*(*(struct {
33142                 Name              string
33143                 Gain, Pitch, Fade float32
33144         }))(obj)).Name))) > math.MaxUint16 {
33145                 chk(ErrTooLong)
33146         }
33147         {
33148                 x := uint16(len(([]byte((*(*(struct {
33149                         Name              string
33150                         Gain, Pitch, Fade float32
33151                 }))(obj)).Name))))
33152                 write16(w, uint16(x))
33153         }
33154         {
33155                 _, err := w.Write(([]byte((*(*(struct {
33156                         Name              string
33157                         Gain, Pitch, Fade float32
33158                 }))(obj)).Name))[:])
33159                 chk(err)
33160         }
33161         {
33162                 x := (*(*(struct {
33163                         Name              string
33164                         Gain, Pitch, Fade float32
33165                 }))(obj)).Gain
33166                 write32(w, math.Float32bits(x))
33167         }
33168         {
33169                 x := (*(*(struct {
33170                         Name              string
33171                         Gain, Pitch, Fade float32
33172                 }))(obj)).Pitch
33173                 write32(w, math.Float32bits(x))
33174         }
33175         {
33176                 x := (*(*(struct {
33177                         Name              string
33178                         Gain, Pitch, Fade float32
33179                 }))(obj)).Fade
33180                 write32(w, math.Float32bits(x))
33181         }
33182 }
33183
33184 func (obj *SoundDef) deserialize(r io.Reader) {
33185         var local389 []uint8
33186         var local390 uint16
33187         {
33188                 p := &local390
33189                 *p = read16(r)
33190         }
33191         (local389) = make([]uint8, local390)
33192         {
33193                 _, err := io.ReadFull(r, (local389)[:])
33194                 chk(err)
33195         }
33196         ((*(*(struct {
33197                 Name              string
33198                 Gain, Pitch, Fade float32
33199         }))(obj)).Name) = string(local389)
33200         {
33201                 p := &(*(*(struct {
33202                         Name              string
33203                         Gain, Pitch, Fade float32
33204                 }))(obj)).Gain
33205                 *p = math.Float32frombits(read32(r))
33206         }
33207         {
33208                 p := &(*(*(struct {
33209                         Name              string
33210                         Gain, Pitch, Fade float32
33211                 }))(obj)).Pitch
33212                 *p = math.Float32frombits(read32(r))
33213         }
33214         {
33215                 p := &(*(*(struct {
33216                         Name              string
33217                         Gain, Pitch, Fade float32
33218                 }))(obj)).Fade
33219                 *p = math.Float32frombits(read32(r))
33220         }
33221 }
33222
33223 func (obj *AlphaUse) serialize(w io.Writer) {
33224         {
33225                 x := *(*(uint8))(obj)
33226                 write8(w, uint8(x))
33227         }
33228 }
33229
33230 func (obj *AlphaUse) deserialize(r io.Reader) {
33231         {
33232                 p := &*(*(uint8))(obj)
33233                 *p = read8(r)
33234         }
33235 }
33236
33237 func (obj *Keys) serialize(w io.Writer) {
33238         {
33239                 x := *(*(uint32))(obj)
33240                 write32(w, uint32(x))
33241         }
33242 }
33243
33244 func (obj *Keys) deserialize(r io.Reader) {
33245         {
33246                 p := &*(*(uint32))(obj)
33247                 *p = read32(r)
33248         }
33249 }
33250
33251 func (obj *MapBlkFlags) serialize(w io.Writer) {
33252         {
33253                 x := *(*(uint8))(obj)
33254                 write8(w, uint8(x))
33255         }
33256 }
33257
33258 func (obj *MapBlkFlags) deserialize(r io.Reader) {
33259         {
33260                 p := &*(*(uint8))(obj)
33261                 *p = read8(r)
33262         }
33263 }
33264
33265 func (obj *LitFromBlks) serialize(w io.Writer) {
33266         {
33267                 x := *(*(uint16))(obj)
33268                 write16(w, uint16(x))
33269         }
33270 }
33271
33272 func (obj *LitFromBlks) deserialize(r io.Reader) {
33273         {
33274                 p := &*(*(uint16))(obj)
33275                 *p = read16(r)
33276         }
33277 }
33278
33279 func (obj *AOInitData) serialize(w io.Writer) {
33280         {
33281                 local391 := uint8(1)
33282                 {
33283                         x := local391
33284                         write8(w, uint8(x))
33285                 }
33286         }
33287         if len(([]byte((*(*(struct {
33288
33289                 // For players.
33290                 Name     string
33291                 IsPlayer bool
33292
33293                 ID AOID
33294
33295                 Pos
33296                 Rot [3]float32
33297
33298                 HP uint16
33299
33300                 // See (de)serialize.fmt.
33301                 Msgs []AOMsg
33302         }))(obj)).Name))) > math.MaxUint16 {
33303                 chk(ErrTooLong)
33304         }
33305         {
33306                 x := uint16(len(([]byte((*(*(struct {
33307
33308                         // For players.
33309                         Name     string
33310                         IsPlayer bool
33311
33312                         ID AOID
33313
33314                         Pos
33315                         Rot [3]float32
33316
33317                         HP uint16
33318
33319                         // See (de)serialize.fmt.
33320                         Msgs []AOMsg
33321                 }))(obj)).Name))))
33322                 write16(w, uint16(x))
33323         }
33324         {
33325                 _, err := w.Write(([]byte((*(*(struct {
33326
33327                         // For players.
33328                         Name     string
33329                         IsPlayer bool
33330
33331                         ID AOID
33332
33333                         Pos
33334                         Rot [3]float32
33335
33336                         HP uint16
33337
33338                         // See (de)serialize.fmt.
33339                         Msgs []AOMsg
33340                 }))(obj)).Name))[:])
33341                 chk(err)
33342         }
33343         {
33344                 x := (*(*(struct {
33345
33346                         // For players.
33347                         Name     string
33348                         IsPlayer bool
33349
33350                         ID AOID
33351
33352                         Pos
33353                         Rot [3]float32
33354
33355                         HP uint16
33356
33357                         // See (de)serialize.fmt.
33358                         Msgs []AOMsg
33359                 }))(obj)).IsPlayer
33360                 if x {
33361                         write8(w, 1)
33362                 } else {
33363                         write8(w, 0)
33364                 }
33365
33366         }
33367         if err := pcall(func() {
33368                 ((*(*(struct {
33369
33370                         // For players.
33371                         Name     string
33372                         IsPlayer bool
33373
33374                         ID AOID
33375
33376                         Pos
33377                         Rot [3]float32
33378
33379                         HP uint16
33380
33381                         // See (de)serialize.fmt.
33382                         Msgs []AOMsg
33383                 }))(obj)).ID).serialize(w)
33384         }); err != nil {
33385                 if err == io.EOF {
33386                         chk(io.EOF)
33387                 }
33388                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
33389         }
33390         if err := pcall(func() {
33391                 ((*(*(struct {
33392
33393                         // For players.
33394                         Name     string
33395                         IsPlayer bool
33396
33397                         ID AOID
33398
33399                         Pos
33400                         Rot [3]float32
33401
33402                         HP uint16
33403
33404                         // See (de)serialize.fmt.
33405                         Msgs []AOMsg
33406                 }))(obj)).Pos).serialize(w)
33407         }); err != nil {
33408                 if err == io.EOF {
33409                         chk(io.EOF)
33410                 }
33411                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
33412         }
33413         for local392 := range (*(*(struct {
33414
33415                 // For players.
33416                 Name     string
33417                 IsPlayer bool
33418
33419                 ID AOID
33420
33421                 Pos
33422                 Rot [3]float32
33423
33424                 HP uint16
33425
33426                 // See (de)serialize.fmt.
33427                 Msgs []AOMsg
33428         }))(obj)).Rot {
33429                 {
33430                         x := ((*(*(struct {
33431
33432                                 // For players.
33433                                 Name     string
33434                                 IsPlayer bool
33435
33436                                 ID AOID
33437
33438                                 Pos
33439                                 Rot [3]float32
33440
33441                                 HP uint16
33442
33443                                 // See (de)serialize.fmt.
33444                                 Msgs []AOMsg
33445                         }))(obj)).Rot)[local392]
33446                         write32(w, math.Float32bits(x))
33447                 }
33448         }
33449         {
33450                 x := (*(*(struct {
33451
33452                         // For players.
33453                         Name     string
33454                         IsPlayer bool
33455
33456                         ID AOID
33457
33458                         Pos
33459                         Rot [3]float32
33460
33461                         HP uint16
33462
33463                         // See (de)serialize.fmt.
33464                         Msgs []AOMsg
33465                 }))(obj)).HP
33466                 write16(w, uint16(x))
33467         }
33468         {
33469                 x := (*(*(struct {
33470
33471                         // For players.
33472                         Name     string
33473                         IsPlayer bool
33474
33475                         ID AOID
33476
33477                         Pos
33478                         Rot [3]float32
33479
33480                         HP uint16
33481
33482                         // See (de)serialize.fmt.
33483                         Msgs []AOMsg
33484                 }))(obj)).Msgs
33485                 { // For AOInitData.Msgs.
33486                         if len(x) > math.MaxUint8 {
33487                                 chk(ErrTooLong)
33488                         }
33489                         write8(w, uint8(len(x)))
33490                         for _, msg := range x {
33491                                 var b bytes.Buffer
33492                                 chk(writeAOMsg(&b, msg))
33493                                 if b.Len() > math.MaxUint32 {
33494                                         chk(ErrTooLong)
33495                                 }
33496                                 write32(w, uint32(b.Len()))
33497                                 _, err := b.WriteTo(w)
33498                                 chk(err)
33499                         }
33500                 }
33501
33502         }
33503 }
33504
33505 func (obj *AOInitData) deserialize(r io.Reader) {
33506         {
33507                 var local393 uint8
33508                 local394 := uint8(1)
33509                 {
33510                         p := &local393
33511                         *p = read8(r)
33512                 }
33513                 if local393 != local394 {
33514                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local393))
33515                 }
33516         }
33517         var local395 []uint8
33518         var local396 uint16
33519         {
33520                 p := &local396
33521                 *p = read16(r)
33522         }
33523         (local395) = make([]uint8, local396)
33524         {
33525                 _, err := io.ReadFull(r, (local395)[:])
33526                 chk(err)
33527         }
33528         ((*(*(struct {
33529
33530                 // For players.
33531                 Name     string
33532                 IsPlayer bool
33533
33534                 ID AOID
33535
33536                 Pos
33537                 Rot [3]float32
33538
33539                 HP uint16
33540
33541                 // See (de)serialize.fmt.
33542                 Msgs []AOMsg
33543         }))(obj)).Name) = string(local395)
33544         {
33545                 p := &(*(*(struct {
33546
33547                         // For players.
33548                         Name     string
33549                         IsPlayer bool
33550
33551                         ID AOID
33552
33553                         Pos
33554                         Rot [3]float32
33555
33556                         HP uint16
33557
33558                         // See (de)serialize.fmt.
33559                         Msgs []AOMsg
33560                 }))(obj)).IsPlayer
33561                 switch n := read8(r); n {
33562                 case 0:
33563                         *p = false
33564                 case 1:
33565                         *p = true
33566                 default:
33567                         chk(fmt.Errorf("invalid bool: %d", n))
33568                 }
33569
33570         }
33571         if err := pcall(func() {
33572                 ((*(*(struct {
33573
33574                         // For players.
33575                         Name     string
33576                         IsPlayer bool
33577
33578                         ID AOID
33579
33580                         Pos
33581                         Rot [3]float32
33582
33583                         HP uint16
33584
33585                         // See (de)serialize.fmt.
33586                         Msgs []AOMsg
33587                 }))(obj)).ID).deserialize(r)
33588         }); err != nil {
33589                 if err == io.EOF {
33590                         chk(io.EOF)
33591                 }
33592                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
33593         }
33594         if err := pcall(func() {
33595                 ((*(*(struct {
33596
33597                         // For players.
33598                         Name     string
33599                         IsPlayer bool
33600
33601                         ID AOID
33602
33603                         Pos
33604                         Rot [3]float32
33605
33606                         HP uint16
33607
33608                         // See (de)serialize.fmt.
33609                         Msgs []AOMsg
33610                 }))(obj)).Pos).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.Pos", err))
33616         }
33617         for local397 := range (*(*(struct {
33618
33619                 // For players.
33620                 Name     string
33621                 IsPlayer bool
33622
33623                 ID AOID
33624
33625                 Pos
33626                 Rot [3]float32
33627
33628                 HP uint16
33629
33630                 // See (de)serialize.fmt.
33631                 Msgs []AOMsg
33632         }))(obj)).Rot {
33633                 {
33634                         p := &((*(*(struct {
33635
33636                                 // For players.
33637                                 Name     string
33638                                 IsPlayer bool
33639
33640                                 ID AOID
33641
33642                                 Pos
33643                                 Rot [3]float32
33644
33645                                 HP uint16
33646
33647                                 // See (de)serialize.fmt.
33648                                 Msgs []AOMsg
33649                         }))(obj)).Rot)[local397]
33650                         *p = math.Float32frombits(read32(r))
33651                 }
33652         }
33653         {
33654                 p := &(*(*(struct {
33655
33656                         // For players.
33657                         Name     string
33658                         IsPlayer bool
33659
33660                         ID AOID
33661
33662                         Pos
33663                         Rot [3]float32
33664
33665                         HP uint16
33666
33667                         // See (de)serialize.fmt.
33668                         Msgs []AOMsg
33669                 }))(obj)).HP
33670                 *p = read16(r)
33671         }
33672         {
33673                 p := &(*(*(struct {
33674
33675                         // For players.
33676                         Name     string
33677                         IsPlayer bool
33678
33679                         ID AOID
33680
33681                         Pos
33682                         Rot [3]float32
33683
33684                         HP uint16
33685
33686                         // See (de)serialize.fmt.
33687                         Msgs []AOMsg
33688                 }))(obj)).Msgs
33689                 { // For AOInitData.Msgs.
33690                         *p = make([]AOMsg, read8(r))
33691                         for i := range *p {
33692                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
33693                                 msg, err := readAOMsg(r)
33694                                 chk(err)
33695                                 (*p)[i] = msg
33696                                 if r.N > 0 {
33697                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
33698                                 }
33699                         }
33700                 }
33701
33702         }
33703 }
33704
33705 func (obj *ItemType) serialize(w io.Writer) {
33706         {
33707                 x := *(*(uint8))(obj)
33708                 write8(w, uint8(x))
33709         }
33710 }
33711
33712 func (obj *ItemType) deserialize(r io.Reader) {
33713         {
33714                 p := &*(*(uint8))(obj)
33715                 *p = read8(r)
33716         }
33717 }
33718
33719 func (obj *ToolCaps) serialize(w io.Writer) {
33720         if _ = (*(*(struct {
33721                 //mt:if _ = %s; false
33722                 NonNil bool
33723
33724                 AttackCooldown float32
33725                 MaxDropLvl     int16
33726
33727                 //mt:len32
33728                 GroupCaps []ToolGroupCap
33729
33730                 //mt:len32
33731                 DmgGroups []Group
33732
33733                 //mt:32tou16
33734                 PunchUses int32
33735         }))(obj)); false {
33736                 {
33737                         x := (*(*(struct {
33738                                 //mt:if _ = %s; false
33739                                 NonNil bool
33740
33741                                 AttackCooldown float32
33742                                 MaxDropLvl     int16
33743
33744                                 //mt:len32
33745                                 GroupCaps []ToolGroupCap
33746
33747                                 //mt:len32
33748                                 DmgGroups []Group
33749
33750                                 //mt:32tou16
33751                                 PunchUses int32
33752                         }))(obj)).NonNil
33753                         if x {
33754                                 write8(w, 1)
33755                         } else {
33756                                 write8(w, 0)
33757                         }
33758
33759                 }
33760         }
33761         {
33762                 ow := w
33763                 w := new(bytes.Buffer)
33764                 /*
33765                    if r.N > 0 { (*(*(struct {
33766                         //mt:if _ = %s; false
33767                         NonNil  bool
33768
33769                         AttackCooldown  float32
33770                         MaxDropLvl      int16
33771
33772                         //mt:len32
33773                         GroupCaps       []ToolGroupCap
33774
33775                         //mt:len32
33776                         DmgGroups       []Group
33777
33778                         //mt:32tou16
33779                         PunchUses       int32
33780                    }))(obj)).NonNil = true}; /**/{
33781                         if (*(*(struct {
33782                                 //mt:if _ = %s; false
33783                                 NonNil bool
33784
33785                                 AttackCooldown float32
33786                                 MaxDropLvl     int16
33787
33788                                 //mt:len32
33789                                 GroupCaps []ToolGroupCap
33790
33791                                 //mt:len32
33792                                 DmgGroups []Group
33793
33794                                 //mt:32tou16
33795                                 PunchUses int32
33796                         }))(obj)).NonNil {
33797                                 {
33798                                         local398 := uint8(5)
33799                                         {
33800                                                 x := local398
33801                                                 write8(w, uint8(x))
33802                                         }
33803                                 }
33804                                 {
33805                                         x := (*(*(struct {
33806                                                 //mt:if _ = %s; false
33807                                                 NonNil bool
33808
33809                                                 AttackCooldown float32
33810                                                 MaxDropLvl     int16
33811
33812                                                 //mt:len32
33813                                                 GroupCaps []ToolGroupCap
33814
33815                                                 //mt:len32
33816                                                 DmgGroups []Group
33817
33818                                                 //mt:32tou16
33819                                                 PunchUses int32
33820                                         }))(obj)).AttackCooldown
33821                                         write32(w, math.Float32bits(x))
33822                                 }
33823                                 {
33824                                         x := (*(*(struct {
33825                                                 //mt:if _ = %s; false
33826                                                 NonNil bool
33827
33828                                                 AttackCooldown float32
33829                                                 MaxDropLvl     int16
33830
33831                                                 //mt:len32
33832                                                 GroupCaps []ToolGroupCap
33833
33834                                                 //mt:len32
33835                                                 DmgGroups []Group
33836
33837                                                 //mt:32tou16
33838                                                 PunchUses int32
33839                                         }))(obj)).MaxDropLvl
33840                                         write16(w, uint16(x))
33841                                 }
33842                                 if len(((*(*(struct {
33843                                         //mt:if _ = %s; false
33844                                         NonNil bool
33845
33846                                         AttackCooldown float32
33847                                         MaxDropLvl     int16
33848
33849                                         //mt:len32
33850                                         GroupCaps []ToolGroupCap
33851
33852                                         //mt:len32
33853                                         DmgGroups []Group
33854
33855                                         //mt:32tou16
33856                                         PunchUses int32
33857                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
33858                                         chk(ErrTooLong)
33859                                 }
33860                                 {
33861                                         x := uint32(len(((*(*(struct {
33862                                                 //mt:if _ = %s; false
33863                                                 NonNil bool
33864
33865                                                 AttackCooldown float32
33866                                                 MaxDropLvl     int16
33867
33868                                                 //mt:len32
33869                                                 GroupCaps []ToolGroupCap
33870
33871                                                 //mt:len32
33872                                                 DmgGroups []Group
33873
33874                                                 //mt:32tou16
33875                                                 PunchUses int32
33876                                         }))(obj)).GroupCaps)))
33877                                         write32(w, uint32(x))
33878                                 }
33879                                 for local399 := range (*(*(struct {
33880                                         //mt:if _ = %s; false
33881                                         NonNil bool
33882
33883                                         AttackCooldown float32
33884                                         MaxDropLvl     int16
33885
33886                                         //mt:len32
33887                                         GroupCaps []ToolGroupCap
33888
33889                                         //mt:len32
33890                                         DmgGroups []Group
33891
33892                                         //mt:32tou16
33893                                         PunchUses int32
33894                                 }))(obj)).GroupCaps {
33895                                         if err := pcall(func() {
33896                                                 (((*(*(struct {
33897                                                         //mt:if _ = %s; false
33898                                                         NonNil bool
33899
33900                                                         AttackCooldown float32
33901                                                         MaxDropLvl     int16
33902
33903                                                         //mt:len32
33904                                                         GroupCaps []ToolGroupCap
33905
33906                                                         //mt:len32
33907                                                         DmgGroups []Group
33908
33909                                                         //mt:32tou16
33910                                                         PunchUses int32
33911                                                 }))(obj)).GroupCaps)[local399]).serialize(w)
33912                                         }); err != nil {
33913                                                 if err == io.EOF {
33914                                                         chk(io.EOF)
33915                                                 }
33916                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
33917                                         }
33918                                 }
33919                                 if len(((*(*(struct {
33920                                         //mt:if _ = %s; false
33921                                         NonNil bool
33922
33923                                         AttackCooldown float32
33924                                         MaxDropLvl     int16
33925
33926                                         //mt:len32
33927                                         GroupCaps []ToolGroupCap
33928
33929                                         //mt:len32
33930                                         DmgGroups []Group
33931
33932                                         //mt:32tou16
33933                                         PunchUses int32
33934                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
33935                                         chk(ErrTooLong)
33936                                 }
33937                                 {
33938                                         x := uint32(len(((*(*(struct {
33939                                                 //mt:if _ = %s; false
33940                                                 NonNil bool
33941
33942                                                 AttackCooldown float32
33943                                                 MaxDropLvl     int16
33944
33945                                                 //mt:len32
33946                                                 GroupCaps []ToolGroupCap
33947
33948                                                 //mt:len32
33949                                                 DmgGroups []Group
33950
33951                                                 //mt:32tou16
33952                                                 PunchUses int32
33953                                         }))(obj)).DmgGroups)))
33954                                         write32(w, uint32(x))
33955                                 }
33956                                 for local400 := range (*(*(struct {
33957                                         //mt:if _ = %s; false
33958                                         NonNil bool
33959
33960                                         AttackCooldown float32
33961                                         MaxDropLvl     int16
33962
33963                                         //mt:len32
33964                                         GroupCaps []ToolGroupCap
33965
33966                                         //mt:len32
33967                                         DmgGroups []Group
33968
33969                                         //mt:32tou16
33970                                         PunchUses int32
33971                                 }))(obj)).DmgGroups {
33972                                         if err := pcall(func() {
33973                                                 (((*(*(struct {
33974                                                         //mt:if _ = %s; false
33975                                                         NonNil bool
33976
33977                                                         AttackCooldown float32
33978                                                         MaxDropLvl     int16
33979
33980                                                         //mt:len32
33981                                                         GroupCaps []ToolGroupCap
33982
33983                                                         //mt:len32
33984                                                         DmgGroups []Group
33985
33986                                                         //mt:32tou16
33987                                                         PunchUses int32
33988                                                 }))(obj)).DmgGroups)[local400]).serialize(w)
33989                                         }); err != nil {
33990                                                 if err == io.EOF {
33991                                                         chk(io.EOF)
33992                                                 }
33993                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
33994                                         }
33995                                 }
33996                                 {
33997                                         x := uint16((*(*(struct {
33998                                                 //mt:if _ = %s; false
33999                                                 NonNil bool
34000
34001                                                 AttackCooldown float32
34002                                                 MaxDropLvl     int16
34003
34004                                                 //mt:len32
34005                                                 GroupCaps []ToolGroupCap
34006
34007                                                 //mt:len32
34008                                                 DmgGroups []Group
34009
34010                                                 //mt:32tou16
34011                                                 PunchUses int32
34012                                         }))(obj)).PunchUses)
34013                                         write16(w, uint16(x))
34014                                 }
34015                         }
34016                 }
34017                 {
34018                         buf := w
34019                         w := ow
34020                         if len((buf.Bytes())) > math.MaxUint16 {
34021                                 chk(ErrTooLong)
34022                         }
34023                         {
34024                                 x := uint16(len((buf.Bytes())))
34025                                 write16(w, uint16(x))
34026                         }
34027                         {
34028                                 _, err := w.Write((buf.Bytes())[:])
34029                                 chk(err)
34030                         }
34031                 }
34032         }
34033 }
34034
34035 func (obj *ToolCaps) deserialize(r io.Reader) {
34036         if _ = (*(*(struct {
34037                 //mt:if _ = %s; false
34038                 NonNil bool
34039
34040                 AttackCooldown float32
34041                 MaxDropLvl     int16
34042
34043                 //mt:len32
34044                 GroupCaps []ToolGroupCap
34045
34046                 //mt:len32
34047                 DmgGroups []Group
34048
34049                 //mt:32tou16
34050                 PunchUses int32
34051         }))(obj)); false {
34052                 {
34053                         p := &(*(*(struct {
34054                                 //mt:if _ = %s; false
34055                                 NonNil bool
34056
34057                                 AttackCooldown float32
34058                                 MaxDropLvl     int16
34059
34060                                 //mt:len32
34061                                 GroupCaps []ToolGroupCap
34062
34063                                 //mt:len32
34064                                 DmgGroups []Group
34065
34066                                 //mt:32tou16
34067                                 PunchUses int32
34068                         }))(obj)).NonNil
34069                         switch n := read8(r); n {
34070                         case 0:
34071                                 *p = false
34072                         case 1:
34073                                 *p = true
34074                         default:
34075                                 chk(fmt.Errorf("invalid bool: %d", n))
34076                         }
34077
34078                 }
34079         }
34080         {
34081                 var n uint16
34082                 {
34083                         p := &n
34084                         *p = read16(r)
34085                 }
34086                 r := &io.LimitedReader{R: r, N: int64(n)}
34087                 if r.N > 0 {
34088                         (*(*(struct {
34089                                 //mt:if _ = %s; false
34090                                 NonNil bool
34091
34092                                 AttackCooldown float32
34093                                 MaxDropLvl     int16
34094
34095                                 //mt:len32
34096                                 GroupCaps []ToolGroupCap
34097
34098                                 //mt:len32
34099                                 DmgGroups []Group
34100
34101                                 //mt:32tou16
34102                                 PunchUses int32
34103                         }))(obj)).NonNil = true
34104                 } /**/
34105                 {
34106                         if (*(*(struct {
34107                                 //mt:if _ = %s; false
34108                                 NonNil bool
34109
34110                                 AttackCooldown float32
34111                                 MaxDropLvl     int16
34112
34113                                 //mt:len32
34114                                 GroupCaps []ToolGroupCap
34115
34116                                 //mt:len32
34117                                 DmgGroups []Group
34118
34119                                 //mt:32tou16
34120                                 PunchUses int32
34121                         }))(obj)).NonNil {
34122                                 {
34123                                         var local401 uint8
34124                                         local402 := uint8(5)
34125                                         {
34126                                                 p := &local401
34127                                                 *p = read8(r)
34128                                         }
34129                                         if local401 != local402 {
34130                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local401))
34131                                         }
34132                                 }
34133                                 {
34134                                         p := &(*(*(struct {
34135                                                 //mt:if _ = %s; false
34136                                                 NonNil bool
34137
34138                                                 AttackCooldown float32
34139                                                 MaxDropLvl     int16
34140
34141                                                 //mt:len32
34142                                                 GroupCaps []ToolGroupCap
34143
34144                                                 //mt:len32
34145                                                 DmgGroups []Group
34146
34147                                                 //mt:32tou16
34148                                                 PunchUses int32
34149                                         }))(obj)).AttackCooldown
34150                                         *p = math.Float32frombits(read32(r))
34151                                 }
34152                                 {
34153                                         p := &(*(*(struct {
34154                                                 //mt:if _ = %s; false
34155                                                 NonNil bool
34156
34157                                                 AttackCooldown float32
34158                                                 MaxDropLvl     int16
34159
34160                                                 //mt:len32
34161                                                 GroupCaps []ToolGroupCap
34162
34163                                                 //mt:len32
34164                                                 DmgGroups []Group
34165
34166                                                 //mt:32tou16
34167                                                 PunchUses int32
34168                                         }))(obj)).MaxDropLvl
34169                                         *p = int16(read16(r))
34170                                 }
34171                                 var local403 uint32
34172                                 {
34173                                         p := &local403
34174                                         *p = read32(r)
34175                                 }
34176                                 ((*(*(struct {
34177                                         //mt:if _ = %s; false
34178                                         NonNil bool
34179
34180                                         AttackCooldown float32
34181                                         MaxDropLvl     int16
34182
34183                                         //mt:len32
34184                                         GroupCaps []ToolGroupCap
34185
34186                                         //mt:len32
34187                                         DmgGroups []Group
34188
34189                                         //mt:32tou16
34190                                         PunchUses int32
34191                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local403)
34192                                 for local404 := range (*(*(struct {
34193                                         //mt:if _ = %s; false
34194                                         NonNil bool
34195
34196                                         AttackCooldown float32
34197                                         MaxDropLvl     int16
34198
34199                                         //mt:len32
34200                                         GroupCaps []ToolGroupCap
34201
34202                                         //mt:len32
34203                                         DmgGroups []Group
34204
34205                                         //mt:32tou16
34206                                         PunchUses int32
34207                                 }))(obj)).GroupCaps {
34208                                         if err := pcall(func() {
34209                                                 (((*(*(struct {
34210                                                         //mt:if _ = %s; false
34211                                                         NonNil bool
34212
34213                                                         AttackCooldown float32
34214                                                         MaxDropLvl     int16
34215
34216                                                         //mt:len32
34217                                                         GroupCaps []ToolGroupCap
34218
34219                                                         //mt:len32
34220                                                         DmgGroups []Group
34221
34222                                                         //mt:32tou16
34223                                                         PunchUses int32
34224                                                 }))(obj)).GroupCaps)[local404]).deserialize(r)
34225                                         }); err != nil {
34226                                                 if err == io.EOF {
34227                                                         chk(io.EOF)
34228                                                 }
34229                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
34230                                         }
34231                                 }
34232                                 var local405 uint32
34233                                 {
34234                                         p := &local405
34235                                         *p = read32(r)
34236                                 }
34237                                 ((*(*(struct {
34238                                         //mt:if _ = %s; false
34239                                         NonNil bool
34240
34241                                         AttackCooldown float32
34242                                         MaxDropLvl     int16
34243
34244                                         //mt:len32
34245                                         GroupCaps []ToolGroupCap
34246
34247                                         //mt:len32
34248                                         DmgGroups []Group
34249
34250                                         //mt:32tou16
34251                                         PunchUses int32
34252                                 }))(obj)).DmgGroups) = make([]Group, local405)
34253                                 for local406 := range (*(*(struct {
34254                                         //mt:if _ = %s; false
34255                                         NonNil bool
34256
34257                                         AttackCooldown float32
34258                                         MaxDropLvl     int16
34259
34260                                         //mt:len32
34261                                         GroupCaps []ToolGroupCap
34262
34263                                         //mt:len32
34264                                         DmgGroups []Group
34265
34266                                         //mt:32tou16
34267                                         PunchUses int32
34268                                 }))(obj)).DmgGroups {
34269                                         if err := pcall(func() {
34270                                                 (((*(*(struct {
34271                                                         //mt:if _ = %s; false
34272                                                         NonNil bool
34273
34274                                                         AttackCooldown float32
34275                                                         MaxDropLvl     int16
34276
34277                                                         //mt:len32
34278                                                         GroupCaps []ToolGroupCap
34279
34280                                                         //mt:len32
34281                                                         DmgGroups []Group
34282
34283                                                         //mt:32tou16
34284                                                         PunchUses int32
34285                                                 }))(obj)).DmgGroups)[local406]).deserialize(r)
34286                                         }); err != nil {
34287                                                 if err == io.EOF {
34288                                                         chk(io.EOF)
34289                                                 }
34290                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
34291                                         }
34292                                 }
34293                                 var local407 uint16
34294                                 {
34295                                         p := &local407
34296                                         *p = read16(r)
34297                                 }
34298                                 (*(*(struct {
34299                                         //mt:if _ = %s; false
34300                                         NonNil bool
34301
34302                                         AttackCooldown float32
34303                                         MaxDropLvl     int16
34304
34305                                         //mt:len32
34306                                         GroupCaps []ToolGroupCap
34307
34308                                         //mt:len32
34309                                         DmgGroups []Group
34310
34311                                         //mt:32tou16
34312                                         PunchUses int32
34313                                 }))(obj)).PunchUses = int32(local407)
34314                         }
34315                 }
34316                 if r.N > 0 {
34317                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34318                 }
34319         }
34320 }
34321
34322 func (obj *AnimType) serialize(w io.Writer) {
34323         {
34324                 x := *(*(uint8))(obj)
34325                 write8(w, uint8(x))
34326         }
34327 }
34328
34329 func (obj *AnimType) deserialize(r io.Reader) {
34330         {
34331                 p := &*(*(uint8))(obj)
34332                 *p = read8(r)
34333         }
34334 }
34335
34336 func (obj *HUDType) serialize(w io.Writer) {
34337         {
34338                 x := *(*(uint8))(obj)
34339                 write8(w, uint8(x))
34340         }
34341 }
34342
34343 func (obj *HUDType) deserialize(r io.Reader) {
34344         {
34345                 p := &*(*(uint8))(obj)
34346                 *p = read8(r)
34347         }
34348 }
34349
34350 func (obj *Box) serialize(w io.Writer) {
34351         for local408 := range *(*([2]Vec))(obj) {
34352                 if err := pcall(func() {
34353                         ((*(*([2]Vec))(obj))[local408]).serialize(w)
34354                 }); err != nil {
34355                         if err == io.EOF {
34356                                 chk(io.EOF)
34357                         }
34358                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34359                 }
34360         }
34361 }
34362
34363 func (obj *Box) deserialize(r io.Reader) {
34364         for local409 := range *(*([2]Vec))(obj) {
34365                 if err := pcall(func() {
34366                         ((*(*([2]Vec))(obj))[local409]).deserialize(r)
34367                 }); err != nil {
34368                         if err == io.EOF {
34369                                 chk(io.EOF)
34370                         }
34371                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34372                 }
34373         }
34374 }
34375
34376 func (obj *TileFlags) serialize(w io.Writer) {
34377         {
34378                 x := *(*(uint16))(obj)
34379                 write16(w, uint16(x))
34380         }
34381 }
34382
34383 func (obj *TileFlags) deserialize(r io.Reader) {
34384         {
34385                 p := &*(*(uint16))(obj)
34386                 *p = read16(r)
34387         }
34388 }
34389
34390 func (obj *AlignType) serialize(w io.Writer) {
34391         {
34392                 x := *(*(uint8))(obj)
34393                 write8(w, uint8(x))
34394         }
34395 }
34396
34397 func (obj *AlignType) deserialize(r io.Reader) {
34398         {
34399                 p := &*(*(uint8))(obj)
34400                 *p = read8(r)
34401         }
34402 }
34403
34404 func (obj *NodeBoxType) serialize(w io.Writer) {
34405         {
34406                 x := *(*(uint8))(obj)
34407                 write8(w, uint8(x))
34408         }
34409 }
34410
34411 func (obj *NodeBoxType) deserialize(r io.Reader) {
34412         {
34413                 p := &*(*(uint8))(obj)
34414                 *p = read8(r)
34415         }
34416 }
34417
34418 func (obj *DirBoxes) serialize(w io.Writer) {
34419         if len(((*(*(struct {
34420                 Top, Bot                 []Box
34421                 Front, Left, Back, Right []Box
34422         }))(obj)).Top)) > math.MaxUint16 {
34423                 chk(ErrTooLong)
34424         }
34425         {
34426                 x := uint16(len(((*(*(struct {
34427                         Top, Bot                 []Box
34428                         Front, Left, Back, Right []Box
34429                 }))(obj)).Top)))
34430                 write16(w, uint16(x))
34431         }
34432         for local410 := range (*(*(struct {
34433                 Top, Bot                 []Box
34434                 Front, Left, Back, Right []Box
34435         }))(obj)).Top {
34436                 if err := pcall(func() {
34437                         (((*(*(struct {
34438                                 Top, Bot                 []Box
34439                                 Front, Left, Back, Right []Box
34440                         }))(obj)).Top)[local410]).serialize(w)
34441                 }); err != nil {
34442                         if err == io.EOF {
34443                                 chk(io.EOF)
34444                         }
34445                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34446                 }
34447         }
34448         if len(((*(*(struct {
34449                 Top, Bot                 []Box
34450                 Front, Left, Back, Right []Box
34451         }))(obj)).Bot)) > math.MaxUint16 {
34452                 chk(ErrTooLong)
34453         }
34454         {
34455                 x := uint16(len(((*(*(struct {
34456                         Top, Bot                 []Box
34457                         Front, Left, Back, Right []Box
34458                 }))(obj)).Bot)))
34459                 write16(w, uint16(x))
34460         }
34461         for local411 := range (*(*(struct {
34462                 Top, Bot                 []Box
34463                 Front, Left, Back, Right []Box
34464         }))(obj)).Bot {
34465                 if err := pcall(func() {
34466                         (((*(*(struct {
34467                                 Top, Bot                 []Box
34468                                 Front, Left, Back, Right []Box
34469                         }))(obj)).Bot)[local411]).serialize(w)
34470                 }); err != nil {
34471                         if err == io.EOF {
34472                                 chk(io.EOF)
34473                         }
34474                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34475                 }
34476         }
34477         if len(((*(*(struct {
34478                 Top, Bot                 []Box
34479                 Front, Left, Back, Right []Box
34480         }))(obj)).Front)) > math.MaxUint16 {
34481                 chk(ErrTooLong)
34482         }
34483         {
34484                 x := uint16(len(((*(*(struct {
34485                         Top, Bot                 []Box
34486                         Front, Left, Back, Right []Box
34487                 }))(obj)).Front)))
34488                 write16(w, uint16(x))
34489         }
34490         for local412 := range (*(*(struct {
34491                 Top, Bot                 []Box
34492                 Front, Left, Back, Right []Box
34493         }))(obj)).Front {
34494                 if err := pcall(func() {
34495                         (((*(*(struct {
34496                                 Top, Bot                 []Box
34497                                 Front, Left, Back, Right []Box
34498                         }))(obj)).Front)[local412]).serialize(w)
34499                 }); err != nil {
34500                         if err == io.EOF {
34501                                 chk(io.EOF)
34502                         }
34503                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34504                 }
34505         }
34506         if len(((*(*(struct {
34507                 Top, Bot                 []Box
34508                 Front, Left, Back, Right []Box
34509         }))(obj)).Left)) > math.MaxUint16 {
34510                 chk(ErrTooLong)
34511         }
34512         {
34513                 x := uint16(len(((*(*(struct {
34514                         Top, Bot                 []Box
34515                         Front, Left, Back, Right []Box
34516                 }))(obj)).Left)))
34517                 write16(w, uint16(x))
34518         }
34519         for local413 := range (*(*(struct {
34520                 Top, Bot                 []Box
34521                 Front, Left, Back, Right []Box
34522         }))(obj)).Left {
34523                 if err := pcall(func() {
34524                         (((*(*(struct {
34525                                 Top, Bot                 []Box
34526                                 Front, Left, Back, Right []Box
34527                         }))(obj)).Left)[local413]).serialize(w)
34528                 }); err != nil {
34529                         if err == io.EOF {
34530                                 chk(io.EOF)
34531                         }
34532                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34533                 }
34534         }
34535         if len(((*(*(struct {
34536                 Top, Bot                 []Box
34537                 Front, Left, Back, Right []Box
34538         }))(obj)).Back)) > math.MaxUint16 {
34539                 chk(ErrTooLong)
34540         }
34541         {
34542                 x := uint16(len(((*(*(struct {
34543                         Top, Bot                 []Box
34544                         Front, Left, Back, Right []Box
34545                 }))(obj)).Back)))
34546                 write16(w, uint16(x))
34547         }
34548         for local414 := range (*(*(struct {
34549                 Top, Bot                 []Box
34550                 Front, Left, Back, Right []Box
34551         }))(obj)).Back {
34552                 if err := pcall(func() {
34553                         (((*(*(struct {
34554                                 Top, Bot                 []Box
34555                                 Front, Left, Back, Right []Box
34556                         }))(obj)).Back)[local414]).serialize(w)
34557                 }); err != nil {
34558                         if err == io.EOF {
34559                                 chk(io.EOF)
34560                         }
34561                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34562                 }
34563         }
34564         if len(((*(*(struct {
34565                 Top, Bot                 []Box
34566                 Front, Left, Back, Right []Box
34567         }))(obj)).Right)) > math.MaxUint16 {
34568                 chk(ErrTooLong)
34569         }
34570         {
34571                 x := uint16(len(((*(*(struct {
34572                         Top, Bot                 []Box
34573                         Front, Left, Back, Right []Box
34574                 }))(obj)).Right)))
34575                 write16(w, uint16(x))
34576         }
34577         for local415 := range (*(*(struct {
34578                 Top, Bot                 []Box
34579                 Front, Left, Back, Right []Box
34580         }))(obj)).Right {
34581                 if err := pcall(func() {
34582                         (((*(*(struct {
34583                                 Top, Bot                 []Box
34584                                 Front, Left, Back, Right []Box
34585                         }))(obj)).Right)[local415]).serialize(w)
34586                 }); err != nil {
34587                         if err == io.EOF {
34588                                 chk(io.EOF)
34589                         }
34590                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34591                 }
34592         }
34593 }
34594
34595 func (obj *DirBoxes) deserialize(r io.Reader) {
34596         var local416 uint16
34597         {
34598                 p := &local416
34599                 *p = read16(r)
34600         }
34601         ((*(*(struct {
34602                 Top, Bot                 []Box
34603                 Front, Left, Back, Right []Box
34604         }))(obj)).Top) = make([]Box, local416)
34605         for local417 := range (*(*(struct {
34606                 Top, Bot                 []Box
34607                 Front, Left, Back, Right []Box
34608         }))(obj)).Top {
34609                 if err := pcall(func() {
34610                         (((*(*(struct {
34611                                 Top, Bot                 []Box
34612                                 Front, Left, Back, Right []Box
34613                         }))(obj)).Top)[local417]).deserialize(r)
34614                 }); err != nil {
34615                         if err == io.EOF {
34616                                 chk(io.EOF)
34617                         }
34618                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34619                 }
34620         }
34621         var local418 uint16
34622         {
34623                 p := &local418
34624                 *p = read16(r)
34625         }
34626         ((*(*(struct {
34627                 Top, Bot                 []Box
34628                 Front, Left, Back, Right []Box
34629         }))(obj)).Bot) = make([]Box, local418)
34630         for local419 := range (*(*(struct {
34631                 Top, Bot                 []Box
34632                 Front, Left, Back, Right []Box
34633         }))(obj)).Bot {
34634                 if err := pcall(func() {
34635                         (((*(*(struct {
34636                                 Top, Bot                 []Box
34637                                 Front, Left, Back, Right []Box
34638                         }))(obj)).Bot)[local419]).deserialize(r)
34639                 }); err != nil {
34640                         if err == io.EOF {
34641                                 chk(io.EOF)
34642                         }
34643                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34644                 }
34645         }
34646         var local420 uint16
34647         {
34648                 p := &local420
34649                 *p = read16(r)
34650         }
34651         ((*(*(struct {
34652                 Top, Bot                 []Box
34653                 Front, Left, Back, Right []Box
34654         }))(obj)).Front) = make([]Box, local420)
34655         for local421 := range (*(*(struct {
34656                 Top, Bot                 []Box
34657                 Front, Left, Back, Right []Box
34658         }))(obj)).Front {
34659                 if err := pcall(func() {
34660                         (((*(*(struct {
34661                                 Top, Bot                 []Box
34662                                 Front, Left, Back, Right []Box
34663                         }))(obj)).Front)[local421]).deserialize(r)
34664                 }); err != nil {
34665                         if err == io.EOF {
34666                                 chk(io.EOF)
34667                         }
34668                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34669                 }
34670         }
34671         var local422 uint16
34672         {
34673                 p := &local422
34674                 *p = read16(r)
34675         }
34676         ((*(*(struct {
34677                 Top, Bot                 []Box
34678                 Front, Left, Back, Right []Box
34679         }))(obj)).Left) = make([]Box, local422)
34680         for local423 := range (*(*(struct {
34681                 Top, Bot                 []Box
34682                 Front, Left, Back, Right []Box
34683         }))(obj)).Left {
34684                 if err := pcall(func() {
34685                         (((*(*(struct {
34686                                 Top, Bot                 []Box
34687                                 Front, Left, Back, Right []Box
34688                         }))(obj)).Left)[local423]).deserialize(r)
34689                 }); err != nil {
34690                         if err == io.EOF {
34691                                 chk(io.EOF)
34692                         }
34693                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34694                 }
34695         }
34696         var local424 uint16
34697         {
34698                 p := &local424
34699                 *p = read16(r)
34700         }
34701         ((*(*(struct {
34702                 Top, Bot                 []Box
34703                 Front, Left, Back, Right []Box
34704         }))(obj)).Back) = make([]Box, local424)
34705         for local425 := range (*(*(struct {
34706                 Top, Bot                 []Box
34707                 Front, Left, Back, Right []Box
34708         }))(obj)).Back {
34709                 if err := pcall(func() {
34710                         (((*(*(struct {
34711                                 Top, Bot                 []Box
34712                                 Front, Left, Back, Right []Box
34713                         }))(obj)).Back)[local425]).deserialize(r)
34714                 }); err != nil {
34715                         if err == io.EOF {
34716                                 chk(io.EOF)
34717                         }
34718                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34719                 }
34720         }
34721         var local426 uint16
34722         {
34723                 p := &local426
34724                 *p = read16(r)
34725         }
34726         ((*(*(struct {
34727                 Top, Bot                 []Box
34728                 Front, Left, Back, Right []Box
34729         }))(obj)).Right) = make([]Box, local426)
34730         for local427 := range (*(*(struct {
34731                 Top, Bot                 []Box
34732                 Front, Left, Back, Right []Box
34733         }))(obj)).Right {
34734                 if err := pcall(func() {
34735                         (((*(*(struct {
34736                                 Top, Bot                 []Box
34737                                 Front, Left, Back, Right []Box
34738                         }))(obj)).Right)[local427]).deserialize(r)
34739                 }); err != nil {
34740                         if err == io.EOF {
34741                                 chk(io.EOF)
34742                         }
34743                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34744                 }
34745         }
34746 }
34747
34748 func (obj *ToolGroupCap) serialize(w io.Writer) {
34749         if len(([]byte((*(*(struct {
34750                 Name string
34751
34752                 //mt:32to16
34753                 Uses int32
34754
34755                 MaxLvl int16
34756
34757                 //mt:len32
34758                 Times []DigTime
34759         }))(obj)).Name))) > math.MaxUint16 {
34760                 chk(ErrTooLong)
34761         }
34762         {
34763                 x := uint16(len(([]byte((*(*(struct {
34764                         Name string
34765
34766                         //mt:32to16
34767                         Uses int32
34768
34769                         MaxLvl int16
34770
34771                         //mt:len32
34772                         Times []DigTime
34773                 }))(obj)).Name))))
34774                 write16(w, uint16(x))
34775         }
34776         {
34777                 _, err := w.Write(([]byte((*(*(struct {
34778                         Name string
34779
34780                         //mt:32to16
34781                         Uses int32
34782
34783                         MaxLvl int16
34784
34785                         //mt:len32
34786                         Times []DigTime
34787                 }))(obj)).Name))[:])
34788                 chk(err)
34789         }
34790         {
34791                 x := int16((*(*(struct {
34792                         Name string
34793
34794                         //mt:32to16
34795                         Uses int32
34796
34797                         MaxLvl int16
34798
34799                         //mt:len32
34800                         Times []DigTime
34801                 }))(obj)).Uses)
34802                 write16(w, uint16(x))
34803         }
34804         {
34805                 x := (*(*(struct {
34806                         Name string
34807
34808                         //mt:32to16
34809                         Uses int32
34810
34811                         MaxLvl int16
34812
34813                         //mt:len32
34814                         Times []DigTime
34815                 }))(obj)).MaxLvl
34816                 write16(w, uint16(x))
34817         }
34818         if len(((*(*(struct {
34819                 Name string
34820
34821                 //mt:32to16
34822                 Uses int32
34823
34824                 MaxLvl int16
34825
34826                 //mt:len32
34827                 Times []DigTime
34828         }))(obj)).Times)) > math.MaxUint32 {
34829                 chk(ErrTooLong)
34830         }
34831         {
34832                 x := uint32(len(((*(*(struct {
34833                         Name string
34834
34835                         //mt:32to16
34836                         Uses int32
34837
34838                         MaxLvl int16
34839
34840                         //mt:len32
34841                         Times []DigTime
34842                 }))(obj)).Times)))
34843                 write32(w, uint32(x))
34844         }
34845         for local428 := range (*(*(struct {
34846                 Name string
34847
34848                 //mt:32to16
34849                 Uses int32
34850
34851                 MaxLvl int16
34852
34853                 //mt:len32
34854                 Times []DigTime
34855         }))(obj)).Times {
34856                 if err := pcall(func() {
34857                         (((*(*(struct {
34858                                 Name string
34859
34860                                 //mt:32to16
34861                                 Uses int32
34862
34863                                 MaxLvl int16
34864
34865                                 //mt:len32
34866                                 Times []DigTime
34867                         }))(obj)).Times)[local428]).serialize(w)
34868                 }); err != nil {
34869                         if err == io.EOF {
34870                                 chk(io.EOF)
34871                         }
34872                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34873                 }
34874         }
34875 }
34876
34877 func (obj *ToolGroupCap) deserialize(r io.Reader) {
34878         var local429 []uint8
34879         var local430 uint16
34880         {
34881                 p := &local430
34882                 *p = read16(r)
34883         }
34884         (local429) = make([]uint8, local430)
34885         {
34886                 _, err := io.ReadFull(r, (local429)[:])
34887                 chk(err)
34888         }
34889         ((*(*(struct {
34890                 Name string
34891
34892                 //mt:32to16
34893                 Uses int32
34894
34895                 MaxLvl int16
34896
34897                 //mt:len32
34898                 Times []DigTime
34899         }))(obj)).Name) = string(local429)
34900         var local431 int16
34901         {
34902                 p := &local431
34903                 *p = int16(read16(r))
34904         }
34905         (*(*(struct {
34906                 Name string
34907
34908                 //mt:32to16
34909                 Uses int32
34910
34911                 MaxLvl int16
34912
34913                 //mt:len32
34914                 Times []DigTime
34915         }))(obj)).Uses = int32(local431)
34916         {
34917                 p := &(*(*(struct {
34918                         Name string
34919
34920                         //mt:32to16
34921                         Uses int32
34922
34923                         MaxLvl int16
34924
34925                         //mt:len32
34926                         Times []DigTime
34927                 }))(obj)).MaxLvl
34928                 *p = int16(read16(r))
34929         }
34930         var local432 uint32
34931         {
34932                 p := &local432
34933                 *p = read32(r)
34934         }
34935         ((*(*(struct {
34936                 Name string
34937
34938                 //mt:32to16
34939                 Uses int32
34940
34941                 MaxLvl int16
34942
34943                 //mt:len32
34944                 Times []DigTime
34945         }))(obj)).Times) = make([]DigTime, local432)
34946         for local433 := range (*(*(struct {
34947                 Name string
34948
34949                 //mt:32to16
34950                 Uses int32
34951
34952                 MaxLvl int16
34953
34954                 //mt:len32
34955                 Times []DigTime
34956         }))(obj)).Times {
34957                 if err := pcall(func() {
34958                         (((*(*(struct {
34959                                 Name string
34960
34961                                 //mt:32to16
34962                                 Uses int32
34963
34964                                 MaxLvl int16
34965
34966                                 //mt:len32
34967                                 Times []DigTime
34968                         }))(obj)).Times)[local433]).deserialize(r)
34969                 }); err != nil {
34970                         if err == io.EOF {
34971                                 chk(io.EOF)
34972                         }
34973                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34974                 }
34975         }
34976 }
34977
34978 func (obj *DigTime) serialize(w io.Writer) {
34979         {
34980                 x := (*(*(struct {
34981                         Rating int16
34982                         Time   float32
34983                 }))(obj)).Rating
34984                 write16(w, uint16(x))
34985         }
34986         {
34987                 x := (*(*(struct {
34988                         Rating int16
34989                         Time   float32
34990                 }))(obj)).Time
34991                 write32(w, math.Float32bits(x))
34992         }
34993 }
34994
34995 func (obj *DigTime) deserialize(r io.Reader) {
34996         {
34997                 p := &(*(*(struct {
34998                         Rating int16
34999                         Time   float32
35000                 }))(obj)).Rating
35001                 *p = int16(read16(r))
35002         }
35003         {
35004                 p := &(*(*(struct {
35005                         Rating int16
35006                         Time   float32
35007                 }))(obj)).Time
35008                 *p = math.Float32frombits(read32(r))
35009         }
35010 }