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         "github.com/klauspost/compress/zstd"
  18 )
  19
  20 func write8(w io.Writer, x uint8) {
  21         _, err := w.Write([]byte{x})
  22         chk(err)
  23 }
  24
  25 func write16(w io.Writer, x uint16) {
  26         buf := make([]byte, 2)
  27         be.PutUint16(buf, x)
  28         _, err := w.Write(buf)
  29         chk(err)
  30 }
  31
  32 func write32(w io.Writer, x uint32) {
  33         buf := make([]byte, 4)
  34         be.PutUint32(buf, x)
  35         _, err := w.Write(buf)
  36         chk(err)
  37 }
  38
  39 func write64(w io.Writer, x uint64) {
  40         buf := make([]byte, 8)
  41         be.PutUint64(buf, x)
  42         _, err := w.Write(buf)
  43         chk(err)
  44 }
  45
  46 func readBuf(r io.Reader, n int) []byte {
  47         buf := make([]byte, n)
  48         _, err := io.ReadFull(r, buf)
  49         chk(err)
  50         return buf
  51 }
  52
  53 func read8(r io.Reader) uint8   { return readBuf(r, 1)[0] }
  54 func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  55 func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  56 func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  57
  58 func (obj *ToSrvNil) serialize(w io.Writer) {
  59 }
  60
  61 func (obj *ToSrvNil) deserialize(r io.Reader) {
  62 }
  63
  64 func (obj *ToSrvInit) serialize(w io.Writer) {
  65         {
  66                 x := (*(*(struct {
  67                         SerializeVer             uint8
  68                         SupportedCompression     CompressionModes
  69                         MinProtoVer, MaxProtoVer uint16
  70                         PlayerName               string
  71
  72                         //mt:opt
  73                         SendFullItemMeta bool
  74                 }))(obj)).SerializeVer
  75                 write8(w, uint8(x))
  76         }
  77         if err := pcall(func() {
  78                 ((*(*(struct {
  79                         SerializeVer             uint8
  80                         SupportedCompression     CompressionModes
  81                         MinProtoVer, MaxProtoVer uint16
  82                         PlayerName               string
  83
  84                         //mt:opt
  85                         SendFullItemMeta bool
  86                 }))(obj)).SupportedCompression).serialize(w)
  87         }); err != nil {
  88                 if err == io.EOF {
  89                         chk(io.EOF)
  90                 }
  91                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
  92         }
  93         {
  94                 x := (*(*(struct {
  95                         SerializeVer             uint8
  96                         SupportedCompression     CompressionModes
  97                         MinProtoVer, MaxProtoVer uint16
  98                         PlayerName               string
  99
 100                         //mt:opt
 101                         SendFullItemMeta bool
 102                 }))(obj)).MinProtoVer
 103                 write16(w, uint16(x))
 104         }
 105         {
 106                 x := (*(*(struct {
 107                         SerializeVer             uint8
 108                         SupportedCompression     CompressionModes
 109                         MinProtoVer, MaxProtoVer uint16
 110                         PlayerName               string
 111
 112                         //mt:opt
 113                         SendFullItemMeta bool
 114                 }))(obj)).MaxProtoVer
 115                 write16(w, uint16(x))
 116         }
 117         if len(([]byte((*(*(struct {
 118                 SerializeVer             uint8
 119                 SupportedCompression     CompressionModes
 120                 MinProtoVer, MaxProtoVer uint16
 121                 PlayerName               string
 122
 123                 //mt:opt
 124                 SendFullItemMeta bool
 125         }))(obj)).PlayerName))) > math.MaxUint16 {
 126                 chk(ErrTooLong)
 127         }
 128         {
 129                 x := uint16(len(([]byte((*(*(struct {
 130                         SerializeVer             uint8
 131                         SupportedCompression     CompressionModes
 132                         MinProtoVer, MaxProtoVer uint16
 133                         PlayerName               string
 134
 135                         //mt:opt
 136                         SendFullItemMeta bool
 137                 }))(obj)).PlayerName))))
 138                 write16(w, uint16(x))
 139         }
 140         {
 141                 _, err := w.Write(([]byte((*(*(struct {
 142                         SerializeVer             uint8
 143                         SupportedCompression     CompressionModes
 144                         MinProtoVer, MaxProtoVer uint16
 145                         PlayerName               string
 146
 147                         //mt:opt
 148                         SendFullItemMeta bool
 149                 }))(obj)).PlayerName))[:])
 150                 chk(err)
 151         }
 152         if err := pcall(func() {
 153                 {
 154                         x := (*(*(struct {
 155                                 SerializeVer             uint8
 156                                 SupportedCompression     CompressionModes
 157                                 MinProtoVer, MaxProtoVer uint16
 158                                 PlayerName               string
 159
 160                                 //mt:opt
 161                                 SendFullItemMeta bool
 162                         }))(obj)).SendFullItemMeta
 163                         if x {
 164                                 write8(w, 1)
 165                         } else {
 166                                 write8(w, 0)
 167                         }
 168
 169                 }
 170         }); err != nil && err != io.EOF {
 171                 chk(err)
 172         }
 173 }
 174
 175 func (obj *ToSrvInit) deserialize(r io.Reader) {
 176         {
 177                 p := &(*(*(struct {
 178                         SerializeVer             uint8
 179                         SupportedCompression     CompressionModes
 180                         MinProtoVer, MaxProtoVer uint16
 181                         PlayerName               string
 182
 183                         //mt:opt
 184                         SendFullItemMeta bool
 185                 }))(obj)).SerializeVer
 186                 *p = read8(r)
 187         }
 188         if err := pcall(func() {
 189                 ((*(*(struct {
 190                         SerializeVer             uint8
 191                         SupportedCompression     CompressionModes
 192                         MinProtoVer, MaxProtoVer uint16
 193                         PlayerName               string
 194
 195                         //mt:opt
 196                         SendFullItemMeta bool
 197                 }))(obj)).SupportedCompression).deserialize(r)
 198         }); err != nil {
 199                 if err == io.EOF {
 200                         chk(io.EOF)
 201                 }
 202                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
 203         }
 204         {
 205                 p := &(*(*(struct {
 206                         SerializeVer             uint8
 207                         SupportedCompression     CompressionModes
 208                         MinProtoVer, MaxProtoVer uint16
 209                         PlayerName               string
 210
 211                         //mt:opt
 212                         SendFullItemMeta bool
 213                 }))(obj)).MinProtoVer
 214                 *p = read16(r)
 215         }
 216         {
 217                 p := &(*(*(struct {
 218                         SerializeVer             uint8
 219                         SupportedCompression     CompressionModes
 220                         MinProtoVer, MaxProtoVer uint16
 221                         PlayerName               string
 222
 223                         //mt:opt
 224                         SendFullItemMeta bool
 225                 }))(obj)).MaxProtoVer
 226                 *p = read16(r)
 227         }
 228         var local1 []uint8
 229         var local2 uint16
 230         {
 231                 p := &local2
 232                 *p = read16(r)
 233         }
 234         (local1) = make([]uint8, local2)
 235         {
 236                 _, err := io.ReadFull(r, (local1)[:])
 237                 chk(err)
 238         }
 239         ((*(*(struct {
 240                 SerializeVer             uint8
 241                 SupportedCompression     CompressionModes
 242                 MinProtoVer, MaxProtoVer uint16
 243                 PlayerName               string
 244
 245                 //mt:opt
 246                 SendFullItemMeta bool
 247         }))(obj)).PlayerName) = string(local1)
 248         if err := pcall(func() {
 249                 {
 250                         p := &(*(*(struct {
 251                                 SerializeVer             uint8
 252                                 SupportedCompression     CompressionModes
 253                                 MinProtoVer, MaxProtoVer uint16
 254                                 PlayerName               string
 255
 256                                 //mt:opt
 257                                 SendFullItemMeta bool
 258                         }))(obj)).SendFullItemMeta
 259                         switch n := read8(r); n {
 260                         case 0:
 261                                 *p = false
 262                         case 1:
 263                                 *p = true
 264                         default:
 265                                 chk(fmt.Errorf("invalid bool: %d", n))
 266                         }
 267
 268                 }
 269         }); err != nil && err != io.EOF {
 270                 chk(err)
 271         }
 272 }
 273
 274 func (obj *ToSrvInit2) serialize(w io.Writer) {
 275         if len(([]byte((*(*(struct {
 276                 Lang string
 277         }))(obj)).Lang))) > math.MaxUint16 {
 278                 chk(ErrTooLong)
 279         }
 280         {
 281                 x := uint16(len(([]byte((*(*(struct {
 282                         Lang string
 283                 }))(obj)).Lang))))
 284                 write16(w, uint16(x))
 285         }
 286         {
 287                 _, err := w.Write(([]byte((*(*(struct {
 288                         Lang string
 289                 }))(obj)).Lang))[:])
 290                 chk(err)
 291         }
 292 }
 293
 294 func (obj *ToSrvInit2) deserialize(r io.Reader) {
 295         var local3 []uint8
 296         var local4 uint16
 297         {
 298                 p := &local4
 299                 *p = read16(r)
 300         }
 301         (local3) = make([]uint8, local4)
 302         {
 303                 _, err := io.ReadFull(r, (local3)[:])
 304                 chk(err)
 305         }
 306         ((*(*(struct {
 307                 Lang string
 308         }))(obj)).Lang) = string(local3)
 309 }
 310
 311 func (obj *ToSrvJoinModChan) serialize(w io.Writer) {
 312         if len(([]byte((*(*(struct {
 313                 Channel string
 314         }))(obj)).Channel))) > math.MaxUint16 {
 315                 chk(ErrTooLong)
 316         }
 317         {
 318                 x := uint16(len(([]byte((*(*(struct {
 319                         Channel string
 320                 }))(obj)).Channel))))
 321                 write16(w, uint16(x))
 322         }
 323         {
 324                 _, err := w.Write(([]byte((*(*(struct {
 325                         Channel string
 326                 }))(obj)).Channel))[:])
 327                 chk(err)
 328         }
 329 }
 330
 331 func (obj *ToSrvJoinModChan) deserialize(r io.Reader) {
 332         var local5 []uint8
 333         var local6 uint16
 334         {
 335                 p := &local6
 336                 *p = read16(r)
 337         }
 338         (local5) = make([]uint8, local6)
 339         {
 340                 _, err := io.ReadFull(r, (local5)[:])
 341                 chk(err)
 342         }
 343         ((*(*(struct {
 344                 Channel string
 345         }))(obj)).Channel) = string(local5)
 346 }
 347
 348 func (obj *ToSrvLeaveModChan) serialize(w io.Writer) {
 349         if len(([]byte((*(*(struct {
 350                 Channel string
 351         }))(obj)).Channel))) > math.MaxUint16 {
 352                 chk(ErrTooLong)
 353         }
 354         {
 355                 x := uint16(len(([]byte((*(*(struct {
 356                         Channel string
 357                 }))(obj)).Channel))))
 358                 write16(w, uint16(x))
 359         }
 360         {
 361                 _, err := w.Write(([]byte((*(*(struct {
 362                         Channel string
 363                 }))(obj)).Channel))[:])
 364                 chk(err)
 365         }
 366 }
 367
 368 func (obj *ToSrvLeaveModChan) deserialize(r io.Reader) {
 369         var local7 []uint8
 370         var local8 uint16
 371         {
 372                 p := &local8
 373                 *p = read16(r)
 374         }
 375         (local7) = make([]uint8, local8)
 376         {
 377                 _, err := io.ReadFull(r, (local7)[:])
 378                 chk(err)
 379         }
 380         ((*(*(struct {
 381                 Channel string
 382         }))(obj)).Channel) = string(local7)
 383 }
 384
 385 func (obj *ToSrvMsgModChan) serialize(w io.Writer) {
 386         if len(([]byte((*(*(struct {
 387                 Channel string
 388                 Msg     string
 389         }))(obj)).Channel))) > math.MaxUint16 {
 390                 chk(ErrTooLong)
 391         }
 392         {
 393                 x := uint16(len(([]byte((*(*(struct {
 394                         Channel string
 395                         Msg     string
 396                 }))(obj)).Channel))))
 397                 write16(w, uint16(x))
 398         }
 399         {
 400                 _, err := w.Write(([]byte((*(*(struct {
 401                         Channel string
 402                         Msg     string
 403                 }))(obj)).Channel))[:])
 404                 chk(err)
 405         }
 406         if len(([]byte((*(*(struct {
 407                 Channel string
 408                 Msg     string
 409         }))(obj)).Msg))) > math.MaxUint16 {
 410                 chk(ErrTooLong)
 411         }
 412         {
 413                 x := uint16(len(([]byte((*(*(struct {
 414                         Channel string
 415                         Msg     string
 416                 }))(obj)).Msg))))
 417                 write16(w, uint16(x))
 418         }
 419         {
 420                 _, err := w.Write(([]byte((*(*(struct {
 421                         Channel string
 422                         Msg     string
 423                 }))(obj)).Msg))[:])
 424                 chk(err)
 425         }
 426 }
 427
 428 func (obj *ToSrvMsgModChan) deserialize(r io.Reader) {
 429         var local9 []uint8
 430         var local10 uint16
 431         {
 432                 p := &local10
 433                 *p = read16(r)
 434         }
 435         (local9) = make([]uint8, local10)
 436         {
 437                 _, err := io.ReadFull(r, (local9)[:])
 438                 chk(err)
 439         }
 440         ((*(*(struct {
 441                 Channel string
 442                 Msg     string
 443         }))(obj)).Channel) = string(local9)
 444         var local11 []uint8
 445         var local12 uint16
 446         {
 447                 p := &local12
 448                 *p = read16(r)
 449         }
 450         (local11) = make([]uint8, local12)
 451         {
 452                 _, err := io.ReadFull(r, (local11)[:])
 453                 chk(err)
 454         }
 455         ((*(*(struct {
 456                 Channel string
 457                 Msg     string
 458         }))(obj)).Msg) = string(local11)
 459 }
 460
 461 func (obj *ToSrvPlayerPos) serialize(w io.Writer) {
 462         if err := pcall(func() {
 463                 ((*(*(struct {
 464                         Pos PlayerPos
 465                 }))(obj)).Pos).serialize(w)
 466         }); err != nil {
 467                 if err == io.EOF {
 468                         chk(io.EOF)
 469                 }
 470                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 471         }
 472 }
 473
 474 func (obj *ToSrvPlayerPos) deserialize(r io.Reader) {
 475         if err := pcall(func() {
 476                 ((*(*(struct {
 477                         Pos PlayerPos
 478                 }))(obj)).Pos).deserialize(r)
 479         }); err != nil {
 480                 if err == io.EOF {
 481                         chk(io.EOF)
 482                 }
 483                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 484         }
 485 }
 486
 487 func (obj *ToSrvGotBlks) serialize(w io.Writer) {
 488         if len(((*(*(struct {
 489                 //mt:len8
 490                 Blks [][3]int16
 491         }))(obj)).Blks)) > math.MaxUint8 {
 492                 chk(ErrTooLong)
 493         }
 494         {
 495                 x := uint8(len(((*(*(struct {
 496                         //mt:len8
 497                         Blks [][3]int16
 498                 }))(obj)).Blks)))
 499                 write8(w, uint8(x))
 500         }
 501         for local13 := range (*(*(struct {
 502                 //mt:len8
 503                 Blks [][3]int16
 504         }))(obj)).Blks {
 505                 for local14 := range ((*(*(struct {
 506                         //mt:len8
 507                         Blks [][3]int16
 508                 }))(obj)).Blks)[local13] {
 509                         {
 510                                 x := (((*(*(struct {
 511                                         //mt:len8
 512                                         Blks [][3]int16
 513                                 }))(obj)).Blks)[local13])[local14]
 514                                 write16(w, uint16(x))
 515                         }
 516                 }
 517         }
 518 }
 519
 520 func (obj *ToSrvGotBlks) deserialize(r io.Reader) {
 521         var local15 uint8
 522         {
 523                 p := &local15
 524                 *p = read8(r)
 525         }
 526         ((*(*(struct {
 527                 //mt:len8
 528                 Blks [][3]int16
 529         }))(obj)).Blks) = make([][3]int16, local15)
 530         for local16 := range (*(*(struct {
 531                 //mt:len8
 532                 Blks [][3]int16
 533         }))(obj)).Blks {
 534                 for local17 := range ((*(*(struct {
 535                         //mt:len8
 536                         Blks [][3]int16
 537                 }))(obj)).Blks)[local16] {
 538                         {
 539                                 p := &(((*(*(struct {
 540                                         //mt:len8
 541                                         Blks [][3]int16
 542                                 }))(obj)).Blks)[local16])[local17]
 543                                 *p = int16(read16(r))
 544                         }
 545                 }
 546         }
 547 }
 548
 549 func (obj *ToSrvDeletedBlks) serialize(w io.Writer) {
 550         if len(((*(*(struct {
 551                 //mt:len8
 552                 Blks [][3]int16
 553         }))(obj)).Blks)) > math.MaxUint8 {
 554                 chk(ErrTooLong)
 555         }
 556         {
 557                 x := uint8(len(((*(*(struct {
 558                         //mt:len8
 559                         Blks [][3]int16
 560                 }))(obj)).Blks)))
 561                 write8(w, uint8(x))
 562         }
 563         for local18 := range (*(*(struct {
 564                 //mt:len8
 565                 Blks [][3]int16
 566         }))(obj)).Blks {
 567                 for local19 := range ((*(*(struct {
 568                         //mt:len8
 569                         Blks [][3]int16
 570                 }))(obj)).Blks)[local18] {
 571                         {
 572                                 x := (((*(*(struct {
 573                                         //mt:len8
 574                                         Blks [][3]int16
 575                                 }))(obj)).Blks)[local18])[local19]
 576                                 write16(w, uint16(x))
 577                         }
 578                 }
 579         }
 580 }
 581
 582 func (obj *ToSrvDeletedBlks) deserialize(r io.Reader) {
 583         var local20 uint8
 584         {
 585                 p := &local20
 586                 *p = read8(r)
 587         }
 588         ((*(*(struct {
 589                 //mt:len8
 590                 Blks [][3]int16
 591         }))(obj)).Blks) = make([][3]int16, local20)
 592         for local21 := range (*(*(struct {
 593                 //mt:len8
 594                 Blks [][3]int16
 595         }))(obj)).Blks {
 596                 for local22 := range ((*(*(struct {
 597                         //mt:len8
 598                         Blks [][3]int16
 599                 }))(obj)).Blks)[local21] {
 600                         {
 601                                 p := &(((*(*(struct {
 602                                         //mt:len8
 603                                         Blks [][3]int16
 604                                 }))(obj)).Blks)[local21])[local22]
 605                                 *p = int16(read16(r))
 606                         }
 607                 }
 608         }
 609 }
 610
 611 func (obj *ToSrvInvAction) serialize(w io.Writer) {
 612         {
 613                 _, err := w.Write(([]byte((*(*(struct {
 614                         //mt:raw
 615                         Action string
 616                 }))(obj)).Action))[:])
 617                 chk(err)
 618         }
 619 }
 620
 621 func (obj *ToSrvInvAction) deserialize(r io.Reader) {
 622         var local23 []uint8
 623         {
 624                 var err error
 625                 (local23), err = io.ReadAll(r)
 626                 chk(err)
 627         }
 628         ((*(*(struct {
 629                 //mt:raw
 630                 Action string
 631         }))(obj)).Action) = string(local23)
 632 }
 633
 634 func (obj *ToSrvChatMsg) serialize(w io.Writer) {
 635         local24 := utf16.Encode([]rune((*(*(struct {
 636                 //mt:utf16
 637                 Msg string
 638         }))(obj)).Msg))
 639         if len((local24)) > math.MaxUint16 {
 640                 chk(ErrTooLong)
 641         }
 642         {
 643                 x := uint16(len((local24)))
 644                 write16(w, uint16(x))
 645         }
 646         for local25 := range local24 {
 647                 {
 648                         x := (local24)[local25]
 649                         write16(w, uint16(x))
 650                 }
 651         }
 652 }
 653
 654 func (obj *ToSrvChatMsg) deserialize(r io.Reader) {
 655         var local26 []uint16
 656         var local27 uint16
 657         {
 658                 p := &local27
 659                 *p = read16(r)
 660         }
 661         (local26) = make([]uint16, local27)
 662         for local28 := range local26 {
 663                 {
 664                         p := &(local26)[local28]
 665                         *p = read16(r)
 666                 }
 667         }
 668         (*(*(struct {
 669                 //mt:utf16
 670                 Msg string
 671         }))(obj)).Msg = string(utf16.Decode(local26))
 672 }
 673
 674 func (obj *ToSrvFallDmg) serialize(w io.Writer) {
 675         {
 676                 x := (*(*(struct {
 677                         Amount uint16
 678                 }))(obj)).Amount
 679                 write16(w, uint16(x))
 680         }
 681 }
 682
 683 func (obj *ToSrvFallDmg) deserialize(r io.Reader) {
 684         {
 685                 p := &(*(*(struct {
 686                         Amount uint16
 687                 }))(obj)).Amount
 688                 *p = read16(r)
 689         }
 690 }
 691
 692 func (obj *ToSrvSelectItem) serialize(w io.Writer) {
 693         {
 694                 x := (*(*(struct {
 695                         Slot uint16
 696                 }))(obj)).Slot
 697                 write16(w, uint16(x))
 698         }
 699 }
 700
 701 func (obj *ToSrvSelectItem) deserialize(r io.Reader) {
 702         {
 703                 p := &(*(*(struct {
 704                         Slot uint16
 705                 }))(obj)).Slot
 706                 *p = read16(r)
 707         }
 708 }
 709
 710 func (obj *ToSrvRespawn) serialize(w io.Writer) {
 711 }
 712
 713 func (obj *ToSrvRespawn) deserialize(r io.Reader) {
 714 }
 715
 716 func (obj *ToSrvInteract) serialize(w io.Writer) {
 717         if err := pcall(func() {
 718                 ((*(*(struct {
 719                         Action   Interaction
 720                         ItemSlot uint16
 721                         //mt:lenhdr 32
 722                         Pointed PointedThing
 723                         //mt:end
 724                         Pos PlayerPos
 725                 }))(obj)).Action).serialize(w)
 726         }); err != nil {
 727                 if err == io.EOF {
 728                         chk(io.EOF)
 729                 }
 730                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Interaction", err))
 731         }
 732         {
 733                 x := (*(*(struct {
 734                         Action   Interaction
 735                         ItemSlot uint16
 736                         //mt:lenhdr 32
 737                         Pointed PointedThing
 738                         //mt:end
 739                         Pos PlayerPos
 740                 }))(obj)).ItemSlot
 741                 write16(w, uint16(x))
 742         }
 743         {
 744                 ow := w
 745                 w := new(bytes.Buffer)
 746                 {
 747                         x := (*(*(struct {
 748                                 Action   Interaction
 749                                 ItemSlot uint16
 750                                 //mt:lenhdr 32
 751                                 Pointed PointedThing
 752                                 //mt:end
 753                                 Pos PlayerPos
 754                         }))(obj)).Pointed
 755                         chk(writePointedThing(w, x))
 756
 757                 }
 758                 {
 759                         buf := w
 760                         w := ow
 761                         if len((buf.Bytes())) > math.MaxUint32 {
 762                                 chk(ErrTooLong)
 763                         }
 764                         {
 765                                 x := uint32(len((buf.Bytes())))
 766                                 write32(w, uint32(x))
 767                         }
 768                         {
 769                                 _, err := w.Write((buf.Bytes())[:])
 770                                 chk(err)
 771                         }
 772                 }
 773         }
 774         if err := pcall(func() {
 775                 ((*(*(struct {
 776                         Action   Interaction
 777                         ItemSlot uint16
 778                         //mt:lenhdr 32
 779                         Pointed PointedThing
 780                         //mt:end
 781                         Pos PlayerPos
 782                 }))(obj)).Pos).serialize(w)
 783         }); err != nil {
 784                 if err == io.EOF {
 785                         chk(io.EOF)
 786                 }
 787                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 788         }
 789 }
 790
 791 func (obj *ToSrvInteract) deserialize(r io.Reader) {
 792         if err := pcall(func() {
 793                 ((*(*(struct {
 794                         Action   Interaction
 795                         ItemSlot uint16
 796                         //mt:lenhdr 32
 797                         Pointed PointedThing
 798                         //mt:end
 799                         Pos PlayerPos
 800                 }))(obj)).Action).deserialize(r)
 801         }); err != nil {
 802                 if err == io.EOF {
 803                         chk(io.EOF)
 804                 }
 805                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Interaction", err))
 806         }
 807         {
 808                 p := &(*(*(struct {
 809                         Action   Interaction
 810                         ItemSlot uint16
 811                         //mt:lenhdr 32
 812                         Pointed PointedThing
 813                         //mt:end
 814                         Pos PlayerPos
 815                 }))(obj)).ItemSlot
 816                 *p = read16(r)
 817         }
 818         {
 819                 var n uint32
 820                 {
 821                         p := &n
 822                         *p = read32(r)
 823                 }
 824                 r := &io.LimitedReader{R: r, N: int64(n)}
 825                 {
 826                         p := &(*(*(struct {
 827                                 Action   Interaction
 828                                 ItemSlot uint16
 829                                 //mt:lenhdr 32
 830                                 Pointed PointedThing
 831                                 //mt:end
 832                                 Pos PlayerPos
 833                         }))(obj)).Pointed
 834                         {
 835                                 var err error
 836                                 *p, err = readPointedThing(r)
 837                                 chk(err)
 838                         }
 839
 840                 }
 841                 if r.N > 0 {
 842                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 843                 }
 844         }
 845         if err := pcall(func() {
 846                 ((*(*(struct {
 847                         Action   Interaction
 848                         ItemSlot uint16
 849                         //mt:lenhdr 32
 850                         Pointed PointedThing
 851                         //mt:end
 852                         Pos PlayerPos
 853                 }))(obj)).Pos).deserialize(r)
 854         }); err != nil {
 855                 if err == io.EOF {
 856                         chk(io.EOF)
 857                 }
 858                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerPos", err))
 859         }
 860 }
 861
 862 func (obj *ToSrvRemovedSounds) serialize(w io.Writer) {
 863         if len(((*(*(struct {
 864                 IDs []SoundID
 865         }))(obj)).IDs)) > math.MaxUint16 {
 866                 chk(ErrTooLong)
 867         }
 868         {
 869                 x := uint16(len(((*(*(struct {
 870                         IDs []SoundID
 871                 }))(obj)).IDs)))
 872                 write16(w, uint16(x))
 873         }
 874         for local29 := range (*(*(struct {
 875                 IDs []SoundID
 876         }))(obj)).IDs {
 877                 if err := pcall(func() {
 878                         (((*(*(struct {
 879                                 IDs []SoundID
 880                         }))(obj)).IDs)[local29]).serialize(w)
 881                 }); err != nil {
 882                         if err == io.EOF {
 883                                 chk(io.EOF)
 884                         }
 885                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
 886                 }
 887         }
 888 }
 889
 890 func (obj *ToSrvRemovedSounds) deserialize(r io.Reader) {
 891         var local30 uint16
 892         {
 893                 p := &local30
 894                 *p = read16(r)
 895         }
 896         ((*(*(struct {
 897                 IDs []SoundID
 898         }))(obj)).IDs) = make([]SoundID, local30)
 899         for local31 := range (*(*(struct {
 900                 IDs []SoundID
 901         }))(obj)).IDs {
 902                 if err := pcall(func() {
 903                         (((*(*(struct {
 904                                 IDs []SoundID
 905                         }))(obj)).IDs)[local31]).deserialize(r)
 906                 }); err != nil {
 907                         if err == io.EOF {
 908                                 chk(io.EOF)
 909                         }
 910                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
 911                 }
 912         }
 913 }
 914
 915 func (obj *ToSrvNodeMetaFields) serialize(w io.Writer) {
 916         for local32 := range (*(*(struct {
 917                 Pos      [3]int16
 918                 Formname string
 919                 Fields   []Field
 920         }))(obj)).Pos {
 921                 {
 922                         x := ((*(*(struct {
 923                                 Pos      [3]int16
 924                                 Formname string
 925                                 Fields   []Field
 926                         }))(obj)).Pos)[local32]
 927                         write16(w, uint16(x))
 928                 }
 929         }
 930         if len(([]byte((*(*(struct {
 931                 Pos      [3]int16
 932                 Formname string
 933                 Fields   []Field
 934         }))(obj)).Formname))) > math.MaxUint16 {
 935                 chk(ErrTooLong)
 936         }
 937         {
 938                 x := uint16(len(([]byte((*(*(struct {
 939                         Pos      [3]int16
 940                         Formname string
 941                         Fields   []Field
 942                 }))(obj)).Formname))))
 943                 write16(w, uint16(x))
 944         }
 945         {
 946                 _, err := w.Write(([]byte((*(*(struct {
 947                         Pos      [3]int16
 948                         Formname string
 949                         Fields   []Field
 950                 }))(obj)).Formname))[:])
 951                 chk(err)
 952         }
 953         if len(((*(*(struct {
 954                 Pos      [3]int16
 955                 Formname string
 956                 Fields   []Field
 957         }))(obj)).Fields)) > math.MaxUint16 {
 958                 chk(ErrTooLong)
 959         }
 960         {
 961                 x := uint16(len(((*(*(struct {
 962                         Pos      [3]int16
 963                         Formname string
 964                         Fields   []Field
 965                 }))(obj)).Fields)))
 966                 write16(w, uint16(x))
 967         }
 968         for local33 := range (*(*(struct {
 969                 Pos      [3]int16
 970                 Formname string
 971                 Fields   []Field
 972         }))(obj)).Fields {
 973                 if err := pcall(func() {
 974                         (((*(*(struct {
 975                                 Pos      [3]int16
 976                                 Formname string
 977                                 Fields   []Field
 978                         }))(obj)).Fields)[local33]).serialize(w)
 979                 }); err != nil {
 980                         if err == io.EOF {
 981                                 chk(io.EOF)
 982                         }
 983                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
 984                 }
 985         }
 986 }
 987
 988 func (obj *ToSrvNodeMetaFields) deserialize(r io.Reader) {
 989         for local34 := range (*(*(struct {
 990                 Pos      [3]int16
 991                 Formname string
 992                 Fields   []Field
 993         }))(obj)).Pos {
 994                 {
 995                         p := &((*(*(struct {
 996                                 Pos      [3]int16
 997                                 Formname string
 998                                 Fields   []Field
 999                         }))(obj)).Pos)[local34]
1000                         *p = int16(read16(r))
1001                 }
1002         }
1003         var local35 []uint8
1004         var local36 uint16
1005         {
1006                 p := &local36
1007                 *p = read16(r)
1008         }
1009         (local35) = make([]uint8, local36)
1010         {
1011                 _, err := io.ReadFull(r, (local35)[:])
1012                 chk(err)
1013         }
1014         ((*(*(struct {
1015                 Pos      [3]int16
1016                 Formname string
1017                 Fields   []Field
1018         }))(obj)).Formname) = string(local35)
1019         var local37 uint16
1020         {
1021                 p := &local37
1022                 *p = read16(r)
1023         }
1024         ((*(*(struct {
1025                 Pos      [3]int16
1026                 Formname string
1027                 Fields   []Field
1028         }))(obj)).Fields) = make([]Field, local37)
1029         for local38 := range (*(*(struct {
1030                 Pos      [3]int16
1031                 Formname string
1032                 Fields   []Field
1033         }))(obj)).Fields {
1034                 if err := pcall(func() {
1035                         (((*(*(struct {
1036                                 Pos      [3]int16
1037                                 Formname string
1038                                 Fields   []Field
1039                         }))(obj)).Fields)[local38]).deserialize(r)
1040                 }); err != nil {
1041                         if err == io.EOF {
1042                                 chk(io.EOF)
1043                         }
1044                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1045                 }
1046         }
1047 }
1048
1049 func (obj *ToSrvInvFields) serialize(w io.Writer) {
1050         if len(([]byte((*(*(struct {
1051                 Formname string
1052                 Fields   []Field
1053         }))(obj)).Formname))) > math.MaxUint16 {
1054                 chk(ErrTooLong)
1055         }
1056         {
1057                 x := uint16(len(([]byte((*(*(struct {
1058                         Formname string
1059                         Fields   []Field
1060                 }))(obj)).Formname))))
1061                 write16(w, uint16(x))
1062         }
1063         {
1064                 _, err := w.Write(([]byte((*(*(struct {
1065                         Formname string
1066                         Fields   []Field
1067                 }))(obj)).Formname))[:])
1068                 chk(err)
1069         }
1070         if len(((*(*(struct {
1071                 Formname string
1072                 Fields   []Field
1073         }))(obj)).Fields)) > math.MaxUint16 {
1074                 chk(ErrTooLong)
1075         }
1076         {
1077                 x := uint16(len(((*(*(struct {
1078                         Formname string
1079                         Fields   []Field
1080                 }))(obj)).Fields)))
1081                 write16(w, uint16(x))
1082         }
1083         for local39 := range (*(*(struct {
1084                 Formname string
1085                 Fields   []Field
1086         }))(obj)).Fields {
1087                 if err := pcall(func() {
1088                         (((*(*(struct {
1089                                 Formname string
1090                                 Fields   []Field
1091                         }))(obj)).Fields)[local39]).serialize(w)
1092                 }); err != nil {
1093                         if err == io.EOF {
1094                                 chk(io.EOF)
1095                         }
1096                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1097                 }
1098         }
1099 }
1100
1101 func (obj *ToSrvInvFields) deserialize(r io.Reader) {
1102         var local40 []uint8
1103         var local41 uint16
1104         {
1105                 p := &local41
1106                 *p = read16(r)
1107         }
1108         (local40) = make([]uint8, local41)
1109         {
1110                 _, err := io.ReadFull(r, (local40)[:])
1111                 chk(err)
1112         }
1113         ((*(*(struct {
1114                 Formname string
1115                 Fields   []Field
1116         }))(obj)).Formname) = string(local40)
1117         var local42 uint16
1118         {
1119                 p := &local42
1120                 *p = read16(r)
1121         }
1122         ((*(*(struct {
1123                 Formname string
1124                 Fields   []Field
1125         }))(obj)).Fields) = make([]Field, local42)
1126         for local43 := range (*(*(struct {
1127                 Formname string
1128                 Fields   []Field
1129         }))(obj)).Fields {
1130                 if err := pcall(func() {
1131                         (((*(*(struct {
1132                                 Formname string
1133                                 Fields   []Field
1134                         }))(obj)).Fields)[local43]).deserialize(r)
1135                 }); err != nil {
1136                         if err == io.EOF {
1137                                 chk(io.EOF)
1138                         }
1139                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
1140                 }
1141         }
1142 }
1143
1144 func (obj *ToSrvReqMedia) serialize(w io.Writer) {
1145         if len(((*(*(struct {
1146                 Filenames []string
1147         }))(obj)).Filenames)) > math.MaxUint16 {
1148                 chk(ErrTooLong)
1149         }
1150         {
1151                 x := uint16(len(((*(*(struct {
1152                         Filenames []string
1153                 }))(obj)).Filenames)))
1154                 write16(w, uint16(x))
1155         }
1156         for local44 := range (*(*(struct {
1157                 Filenames []string
1158         }))(obj)).Filenames {
1159                 if len(([]byte(((*(*(struct {
1160                         Filenames []string
1161                 }))(obj)).Filenames)[local44]))) > math.MaxUint16 {
1162                         chk(ErrTooLong)
1163                 }
1164                 {
1165                         x := uint16(len(([]byte(((*(*(struct {
1166                                 Filenames []string
1167                         }))(obj)).Filenames)[local44]))))
1168                         write16(w, uint16(x))
1169                 }
1170                 {
1171                         _, err := w.Write(([]byte(((*(*(struct {
1172                                 Filenames []string
1173                         }))(obj)).Filenames)[local44]))[:])
1174                         chk(err)
1175                 }
1176         }
1177 }
1178
1179 func (obj *ToSrvReqMedia) deserialize(r io.Reader) {
1180         var local45 uint16
1181         {
1182                 p := &local45
1183                 *p = read16(r)
1184         }
1185         ((*(*(struct {
1186                 Filenames []string
1187         }))(obj)).Filenames) = make([]string, local45)
1188         for local46 := range (*(*(struct {
1189                 Filenames []string
1190         }))(obj)).Filenames {
1191                 var local47 []uint8
1192                 var local48 uint16
1193                 {
1194                         p := &local48
1195                         *p = read16(r)
1196                 }
1197                 (local47) = make([]uint8, local48)
1198                 {
1199                         _, err := io.ReadFull(r, (local47)[:])
1200                         chk(err)
1201                 }
1202                 (((*(*(struct {
1203                         Filenames []string
1204                 }))(obj)).Filenames)[local46]) = string(local47)
1205         }
1206 }
1207
1208 func (obj *ToSrvCltReady) serialize(w io.Writer) {
1209         {
1210                 x := (*(*(struct {
1211                         // Version information.
1212                         Major, Minor, Patch uint8
1213                         Reserved            uint8
1214                         Version             string
1215                         Formspec            uint16
1216                 }))(obj)).Major
1217                 write8(w, uint8(x))
1218         }
1219         {
1220                 x := (*(*(struct {
1221                         // Version information.
1222                         Major, Minor, Patch uint8
1223                         Reserved            uint8
1224                         Version             string
1225                         Formspec            uint16
1226                 }))(obj)).Minor
1227                 write8(w, uint8(x))
1228         }
1229         {
1230                 x := (*(*(struct {
1231                         // Version information.
1232                         Major, Minor, Patch uint8
1233                         Reserved            uint8
1234                         Version             string
1235                         Formspec            uint16
1236                 }))(obj)).Patch
1237                 write8(w, uint8(x))
1238         }
1239         {
1240                 x := (*(*(struct {
1241                         // Version information.
1242                         Major, Minor, Patch uint8
1243                         Reserved            uint8
1244                         Version             string
1245                         Formspec            uint16
1246                 }))(obj)).Reserved
1247                 write8(w, uint8(x))
1248         }
1249         if len(([]byte((*(*(struct {
1250                 // Version information.
1251                 Major, Minor, Patch uint8
1252                 Reserved            uint8
1253                 Version             string
1254                 Formspec            uint16
1255         }))(obj)).Version))) > math.MaxUint16 {
1256                 chk(ErrTooLong)
1257         }
1258         {
1259                 x := uint16(len(([]byte((*(*(struct {
1260                         // Version information.
1261                         Major, Minor, Patch uint8
1262                         Reserved            uint8
1263                         Version             string
1264                         Formspec            uint16
1265                 }))(obj)).Version))))
1266                 write16(w, uint16(x))
1267         }
1268         {
1269                 _, err := w.Write(([]byte((*(*(struct {
1270                         // Version information.
1271                         Major, Minor, Patch uint8
1272                         Reserved            uint8
1273                         Version             string
1274                         Formspec            uint16
1275                 }))(obj)).Version))[:])
1276                 chk(err)
1277         }
1278         {
1279                 x := (*(*(struct {
1280                         // Version information.
1281                         Major, Minor, Patch uint8
1282                         Reserved            uint8
1283                         Version             string
1284                         Formspec            uint16
1285                 }))(obj)).Formspec
1286                 write16(w, uint16(x))
1287         }
1288 }
1289
1290 func (obj *ToSrvCltReady) deserialize(r io.Reader) {
1291         {
1292                 p := &(*(*(struct {
1293                         // Version information.
1294                         Major, Minor, Patch uint8
1295                         Reserved            uint8
1296                         Version             string
1297                         Formspec            uint16
1298                 }))(obj)).Major
1299                 *p = read8(r)
1300         }
1301         {
1302                 p := &(*(*(struct {
1303                         // Version information.
1304                         Major, Minor, Patch uint8
1305                         Reserved            uint8
1306                         Version             string
1307                         Formspec            uint16
1308                 }))(obj)).Minor
1309                 *p = read8(r)
1310         }
1311         {
1312                 p := &(*(*(struct {
1313                         // Version information.
1314                         Major, Minor, Patch uint8
1315                         Reserved            uint8
1316                         Version             string
1317                         Formspec            uint16
1318                 }))(obj)).Patch
1319                 *p = read8(r)
1320         }
1321         {
1322                 p := &(*(*(struct {
1323                         // Version information.
1324                         Major, Minor, Patch uint8
1325                         Reserved            uint8
1326                         Version             string
1327                         Formspec            uint16
1328                 }))(obj)).Reserved
1329                 *p = read8(r)
1330         }
1331         var local49 []uint8
1332         var local50 uint16
1333         {
1334                 p := &local50
1335                 *p = read16(r)
1336         }
1337         (local49) = make([]uint8, local50)
1338         {
1339                 _, err := io.ReadFull(r, (local49)[:])
1340                 chk(err)
1341         }
1342         ((*(*(struct {
1343                 // Version information.
1344                 Major, Minor, Patch uint8
1345                 Reserved            uint8
1346                 Version             string
1347                 Formspec            uint16
1348         }))(obj)).Version) = string(local49)
1349         {
1350                 p := &(*(*(struct {
1351                         // Version information.
1352                         Major, Minor, Patch uint8
1353                         Reserved            uint8
1354                         Version             string
1355                         Formspec            uint16
1356                 }))(obj)).Formspec
1357                 *p = read16(r)
1358         }
1359 }
1360
1361 func (obj *ToSrvFirstSRP) serialize(w io.Writer) {
1362         if len(((*(*(struct {
1363                 Salt        []byte
1364                 Verifier    []byte
1365                 EmptyPasswd bool
1366         }))(obj)).Salt)) > math.MaxUint16 {
1367                 chk(ErrTooLong)
1368         }
1369         {
1370                 x := uint16(len(((*(*(struct {
1371                         Salt        []byte
1372                         Verifier    []byte
1373                         EmptyPasswd bool
1374                 }))(obj)).Salt)))
1375                 write16(w, uint16(x))
1376         }
1377         {
1378                 _, err := w.Write(((*(*(struct {
1379                         Salt        []byte
1380                         Verifier    []byte
1381                         EmptyPasswd bool
1382                 }))(obj)).Salt)[:])
1383                 chk(err)
1384         }
1385         if len(((*(*(struct {
1386                 Salt        []byte
1387                 Verifier    []byte
1388                 EmptyPasswd bool
1389         }))(obj)).Verifier)) > math.MaxUint16 {
1390                 chk(ErrTooLong)
1391         }
1392         {
1393                 x := uint16(len(((*(*(struct {
1394                         Salt        []byte
1395                         Verifier    []byte
1396                         EmptyPasswd bool
1397                 }))(obj)).Verifier)))
1398                 write16(w, uint16(x))
1399         }
1400         {
1401                 _, err := w.Write(((*(*(struct {
1402                         Salt        []byte
1403                         Verifier    []byte
1404                         EmptyPasswd bool
1405                 }))(obj)).Verifier)[:])
1406                 chk(err)
1407         }
1408         {
1409                 x := (*(*(struct {
1410                         Salt        []byte
1411                         Verifier    []byte
1412                         EmptyPasswd bool
1413                 }))(obj)).EmptyPasswd
1414                 if x {
1415                         write8(w, 1)
1416                 } else {
1417                         write8(w, 0)
1418                 }
1419
1420         }
1421 }
1422
1423 func (obj *ToSrvFirstSRP) deserialize(r io.Reader) {
1424         var local51 uint16
1425         {
1426                 p := &local51
1427                 *p = read16(r)
1428         }
1429         ((*(*(struct {
1430                 Salt        []byte
1431                 Verifier    []byte
1432                 EmptyPasswd bool
1433         }))(obj)).Salt) = make([]byte, local51)
1434         {
1435                 _, err := io.ReadFull(r, ((*(*(struct {
1436                         Salt        []byte
1437                         Verifier    []byte
1438                         EmptyPasswd bool
1439                 }))(obj)).Salt)[:])
1440                 chk(err)
1441         }
1442         var local52 uint16
1443         {
1444                 p := &local52
1445                 *p = read16(r)
1446         }
1447         ((*(*(struct {
1448                 Salt        []byte
1449                 Verifier    []byte
1450                 EmptyPasswd bool
1451         }))(obj)).Verifier) = make([]byte, local52)
1452         {
1453                 _, err := io.ReadFull(r, ((*(*(struct {
1454                         Salt        []byte
1455                         Verifier    []byte
1456                         EmptyPasswd bool
1457                 }))(obj)).Verifier)[:])
1458                 chk(err)
1459         }
1460         {
1461                 p := &(*(*(struct {
1462                         Salt        []byte
1463                         Verifier    []byte
1464                         EmptyPasswd bool
1465                 }))(obj)).EmptyPasswd
1466                 switch n := read8(r); n {
1467                 case 0:
1468                         *p = false
1469                 case 1:
1470                         *p = true
1471                 default:
1472                         chk(fmt.Errorf("invalid bool: %d", n))
1473                 }
1474
1475         }
1476 }
1477
1478 func (obj *ToSrvSRPBytesA) serialize(w io.Writer) {
1479         if len(((*(*(struct {
1480                 A      []byte
1481                 NoSHA1 bool
1482         }))(obj)).A)) > math.MaxUint16 {
1483                 chk(ErrTooLong)
1484         }
1485         {
1486                 x := uint16(len(((*(*(struct {
1487                         A      []byte
1488                         NoSHA1 bool
1489                 }))(obj)).A)))
1490                 write16(w, uint16(x))
1491         }
1492         {
1493                 _, err := w.Write(((*(*(struct {
1494                         A      []byte
1495                         NoSHA1 bool
1496                 }))(obj)).A)[:])
1497                 chk(err)
1498         }
1499         {
1500                 x := (*(*(struct {
1501                         A      []byte
1502                         NoSHA1 bool
1503                 }))(obj)).NoSHA1
1504                 if x {
1505                         write8(w, 1)
1506                 } else {
1507                         write8(w, 0)
1508                 }
1509
1510         }
1511 }
1512
1513 func (obj *ToSrvSRPBytesA) deserialize(r io.Reader) {
1514         var local53 uint16
1515         {
1516                 p := &local53
1517                 *p = read16(r)
1518         }
1519         ((*(*(struct {
1520                 A      []byte
1521                 NoSHA1 bool
1522         }))(obj)).A) = make([]byte, local53)
1523         {
1524                 _, err := io.ReadFull(r, ((*(*(struct {
1525                         A      []byte
1526                         NoSHA1 bool
1527                 }))(obj)).A)[:])
1528                 chk(err)
1529         }
1530         {
1531                 p := &(*(*(struct {
1532                         A      []byte
1533                         NoSHA1 bool
1534                 }))(obj)).NoSHA1
1535                 switch n := read8(r); n {
1536                 case 0:
1537                         *p = false
1538                 case 1:
1539                         *p = true
1540                 default:
1541                         chk(fmt.Errorf("invalid bool: %d", n))
1542                 }
1543
1544         }
1545 }
1546
1547 func (obj *ToSrvSRPBytesM) serialize(w io.Writer) {
1548         if len(((*(*(struct {
1549                 M []byte
1550         }))(obj)).M)) > math.MaxUint16 {
1551                 chk(ErrTooLong)
1552         }
1553         {
1554                 x := uint16(len(((*(*(struct {
1555                         M []byte
1556                 }))(obj)).M)))
1557                 write16(w, uint16(x))
1558         }
1559         {
1560                 _, err := w.Write(((*(*(struct {
1561                         M []byte
1562                 }))(obj)).M)[:])
1563                 chk(err)
1564         }
1565 }
1566
1567 func (obj *ToSrvSRPBytesM) deserialize(r io.Reader) {
1568         var local54 uint16
1569         {
1570                 p := &local54
1571                 *p = read16(r)
1572         }
1573         ((*(*(struct {
1574                 M []byte
1575         }))(obj)).M) = make([]byte, local54)
1576         {
1577                 _, err := io.ReadFull(r, ((*(*(struct {
1578                         M []byte
1579                 }))(obj)).M)[:])
1580                 chk(err)
1581         }
1582 }
1583
1584 func (obj *ToCltHello) serialize(w io.Writer) {
1585         {
1586                 x := (*(*(struct {
1587                         SerializeVer uint8
1588                         Compression  CompressionModes
1589                         ProtoVer     uint16
1590                         AuthMethods
1591                         Username string
1592                 }))(obj)).SerializeVer
1593                 write8(w, uint8(x))
1594         }
1595         if err := pcall(func() {
1596                 ((*(*(struct {
1597                         SerializeVer uint8
1598                         Compression  CompressionModes
1599                         ProtoVer     uint16
1600                         AuthMethods
1601                         Username string
1602                 }))(obj)).Compression).serialize(w)
1603         }); err != nil {
1604                 if err == io.EOF {
1605                         chk(io.EOF)
1606                 }
1607                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
1608         }
1609         {
1610                 x := (*(*(struct {
1611                         SerializeVer uint8
1612                         Compression  CompressionModes
1613                         ProtoVer     uint16
1614                         AuthMethods
1615                         Username string
1616                 }))(obj)).ProtoVer
1617                 write16(w, uint16(x))
1618         }
1619         if err := pcall(func() {
1620                 ((*(*(struct {
1621                         SerializeVer uint8
1622                         Compression  CompressionModes
1623                         ProtoVer     uint16
1624                         AuthMethods
1625                         Username string
1626                 }))(obj)).AuthMethods).serialize(w)
1627         }); err != nil {
1628                 if err == io.EOF {
1629                         chk(io.EOF)
1630                 }
1631                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1632         }
1633         if len(([]byte((*(*(struct {
1634                 SerializeVer uint8
1635                 Compression  CompressionModes
1636                 ProtoVer     uint16
1637                 AuthMethods
1638                 Username string
1639         }))(obj)).Username))) > math.MaxUint16 {
1640                 chk(ErrTooLong)
1641         }
1642         {
1643                 x := uint16(len(([]byte((*(*(struct {
1644                         SerializeVer uint8
1645                         Compression  CompressionModes
1646                         ProtoVer     uint16
1647                         AuthMethods
1648                         Username string
1649                 }))(obj)).Username))))
1650                 write16(w, uint16(x))
1651         }
1652         {
1653                 _, err := w.Write(([]byte((*(*(struct {
1654                         SerializeVer uint8
1655                         Compression  CompressionModes
1656                         ProtoVer     uint16
1657                         AuthMethods
1658                         Username string
1659                 }))(obj)).Username))[:])
1660                 chk(err)
1661         }
1662 }
1663
1664 func (obj *ToCltHello) deserialize(r io.Reader) {
1665         {
1666                 p := &(*(*(struct {
1667                         SerializeVer uint8
1668                         Compression  CompressionModes
1669                         ProtoVer     uint16
1670                         AuthMethods
1671                         Username string
1672                 }))(obj)).SerializeVer
1673                 *p = read8(r)
1674         }
1675         if err := pcall(func() {
1676                 ((*(*(struct {
1677                         SerializeVer uint8
1678                         Compression  CompressionModes
1679                         ProtoVer     uint16
1680                         AuthMethods
1681                         Username string
1682                 }))(obj)).Compression).deserialize(r)
1683         }); err != nil {
1684                 if err == io.EOF {
1685                         chk(io.EOF)
1686                 }
1687                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CompressionModes", err))
1688         }
1689         {
1690                 p := &(*(*(struct {
1691                         SerializeVer uint8
1692                         Compression  CompressionModes
1693                         ProtoVer     uint16
1694                         AuthMethods
1695                         Username string
1696                 }))(obj)).ProtoVer
1697                 *p = read16(r)
1698         }
1699         if err := pcall(func() {
1700                 ((*(*(struct {
1701                         SerializeVer uint8
1702                         Compression  CompressionModes
1703                         ProtoVer     uint16
1704                         AuthMethods
1705                         Username string
1706                 }))(obj)).AuthMethods).deserialize(r)
1707         }); err != nil {
1708                 if err == io.EOF {
1709                         chk(io.EOF)
1710                 }
1711                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1712         }
1713         var local55 []uint8
1714         var local56 uint16
1715         {
1716                 p := &local56
1717                 *p = read16(r)
1718         }
1719         (local55) = make([]uint8, local56)
1720         {
1721                 _, err := io.ReadFull(r, (local55)[:])
1722                 chk(err)
1723         }
1724         ((*(*(struct {
1725                 SerializeVer uint8
1726                 Compression  CompressionModes
1727                 ProtoVer     uint16
1728                 AuthMethods
1729                 Username string
1730         }))(obj)).Username) = string(local55)
1731 }
1732
1733 func (obj *ToCltAcceptAuth) serialize(w io.Writer) {
1734         if err := pcall(func() {
1735                 ((*(*(struct {
1736                         // The client does the equivalent of
1737                         //      PlayerPos[1] -= 5
1738                         // before using PlayerPos.
1739                         PlayerPos Pos
1740
1741                         MapSeed         uint64
1742                         SendInterval    float32
1743                         SudoAuthMethods AuthMethods
1744                 }))(obj)).PlayerPos).serialize(w)
1745         }); err != nil {
1746                 if err == io.EOF {
1747                         chk(io.EOF)
1748                 }
1749                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
1750         }
1751         {
1752                 x := (*(*(struct {
1753                         // The client does the equivalent of
1754                         //      PlayerPos[1] -= 5
1755                         // before using PlayerPos.
1756                         PlayerPos Pos
1757
1758                         MapSeed         uint64
1759                         SendInterval    float32
1760                         SudoAuthMethods AuthMethods
1761                 }))(obj)).MapSeed
1762                 write64(w, uint64(x))
1763
1764         }
1765         {
1766                 x := (*(*(struct {
1767                         // The client does the equivalent of
1768                         //      PlayerPos[1] -= 5
1769                         // before using PlayerPos.
1770                         PlayerPos Pos
1771
1772                         MapSeed         uint64
1773                         SendInterval    float32
1774                         SudoAuthMethods AuthMethods
1775                 }))(obj)).SendInterval
1776                 write32(w, math.Float32bits(x))
1777         }
1778         if err := pcall(func() {
1779                 ((*(*(struct {
1780                         // The client does the equivalent of
1781                         //      PlayerPos[1] -= 5
1782                         // before using PlayerPos.
1783                         PlayerPos Pos
1784
1785                         MapSeed         uint64
1786                         SendInterval    float32
1787                         SudoAuthMethods AuthMethods
1788                 }))(obj)).SudoAuthMethods).serialize(w)
1789         }); err != nil {
1790                 if err == io.EOF {
1791                         chk(io.EOF)
1792                 }
1793                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1794         }
1795 }
1796
1797 func (obj *ToCltAcceptAuth) deserialize(r io.Reader) {
1798         if err := pcall(func() {
1799                 ((*(*(struct {
1800                         // The client does the equivalent of
1801                         //      PlayerPos[1] -= 5
1802                         // before using PlayerPos.
1803                         PlayerPos Pos
1804
1805                         MapSeed         uint64
1806                         SendInterval    float32
1807                         SudoAuthMethods AuthMethods
1808                 }))(obj)).PlayerPos).deserialize(r)
1809         }); err != nil {
1810                 if err == io.EOF {
1811                         chk(io.EOF)
1812                 }
1813                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
1814         }
1815         {
1816                 p := &(*(*(struct {
1817                         // The client does the equivalent of
1818                         //      PlayerPos[1] -= 5
1819                         // before using PlayerPos.
1820                         PlayerPos Pos
1821
1822                         MapSeed         uint64
1823                         SendInterval    float32
1824                         SudoAuthMethods AuthMethods
1825                 }))(obj)).MapSeed
1826                 *p = read64(r)
1827
1828         }
1829         {
1830                 p := &(*(*(struct {
1831                         // The client does the equivalent of
1832                         //      PlayerPos[1] -= 5
1833                         // before using PlayerPos.
1834                         PlayerPos Pos
1835
1836                         MapSeed         uint64
1837                         SendInterval    float32
1838                         SudoAuthMethods AuthMethods
1839                 }))(obj)).SendInterval
1840                 *p = math.Float32frombits(read32(r))
1841         }
1842         if err := pcall(func() {
1843                 ((*(*(struct {
1844                         // The client does the equivalent of
1845                         //      PlayerPos[1] -= 5
1846                         // before using PlayerPos.
1847                         PlayerPos Pos
1848
1849                         MapSeed         uint64
1850                         SendInterval    float32
1851                         SudoAuthMethods AuthMethods
1852                 }))(obj)).SudoAuthMethods).deserialize(r)
1853         }); err != nil {
1854                 if err == io.EOF {
1855                         chk(io.EOF)
1856                 }
1857                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1858         }
1859 }
1860
1861 func (obj *ToCltAcceptSudoMode) serialize(w io.Writer) {
1862         if err := pcall(func() {
1863                 ((*(*(struct {
1864                         SudoAuthMethods AuthMethods
1865                 }))(obj)).SudoAuthMethods).serialize(w)
1866         }); err != nil {
1867                 if err == io.EOF {
1868                         chk(io.EOF)
1869                 }
1870                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1871         }
1872         {
1873                 local57 := [15]byte{}
1874                 {
1875                         _, err := w.Write((local57)[:])
1876                         chk(err)
1877                 }
1878         }
1879 }
1880
1881 func (obj *ToCltAcceptSudoMode) deserialize(r io.Reader) {
1882         if err := pcall(func() {
1883                 ((*(*(struct {
1884                         SudoAuthMethods AuthMethods
1885                 }))(obj)).SudoAuthMethods).deserialize(r)
1886         }); err != nil {
1887                 if err == io.EOF {
1888                         chk(io.EOF)
1889                 }
1890                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AuthMethods", err))
1891         }
1892         {
1893                 var local58 [15]byte
1894                 local59 := [15]byte{}
1895                 {
1896                         _, err := io.ReadFull(r, (local58)[:])
1897                         chk(err)
1898                 }
1899                 if local58 != local59 {
1900                         chk(fmt.Errorf("const %v: %v", "[15]byte{}", local58))
1901                 }
1902         }
1903 }
1904
1905 func (obj *ToCltDenySudoMode) serialize(w io.Writer) {
1906 }
1907
1908 func (obj *ToCltDenySudoMode) deserialize(r io.Reader) {
1909 }
1910
1911 func (obj *ToCltKick) serialize(w io.Writer) {
1912         if err := pcall(func() {
1913                 ((*(*(struct {
1914                         Reason KickReason
1915
1916                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1917                         Custom string
1918
1919                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1920                         Reconnect bool
1921                 }))(obj)).Reason).serialize(w)
1922         }); err != nil {
1923                 if err == io.EOF {
1924                         chk(io.EOF)
1925                 }
1926                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.KickReason", err))
1927         }
1928         if !((*(*(struct {
1929                 Reason KickReason
1930
1931                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1932                 Custom string
1933
1934                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1935                 Reconnect bool
1936         }))(obj)).Reason < maxKickReason) {
1937                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
1938         }
1939         if dr := (*(*(struct {
1940                 Reason KickReason
1941
1942                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1943                 Custom string
1944
1945                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1946                 Reconnect bool
1947         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
1948                 if len(([]byte((*(*(struct {
1949                         Reason KickReason
1950
1951                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1952                         Custom string
1953
1954                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1955                         Reconnect bool
1956                 }))(obj)).Custom))) > math.MaxUint16 {
1957                         chk(ErrTooLong)
1958                 }
1959                 {
1960                         x := uint16(len(([]byte((*(*(struct {
1961                                 Reason KickReason
1962
1963                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1964                                 Custom string
1965
1966                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1967                                 Reconnect bool
1968                         }))(obj)).Custom))))
1969                         write16(w, uint16(x))
1970                 }
1971                 {
1972                         _, err := w.Write(([]byte((*(*(struct {
1973                                 Reason KickReason
1974
1975                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1976                                 Custom string
1977
1978                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1979                                 Reconnect bool
1980                         }))(obj)).Custom))[:])
1981                         chk(err)
1982                 }
1983         }
1984         if dr := (*(*(struct {
1985                 Reason KickReason
1986
1987                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1988                 Custom string
1989
1990                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1991                 Reconnect bool
1992         }))(obj)).Reason; dr == Shutdown || dr == Crash {
1993                 {
1994                         x := (*(*(struct {
1995                                 Reason KickReason
1996
1997                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1998                                 Custom string
1999
2000                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2001                                 Reconnect bool
2002                         }))(obj)).Reconnect
2003                         if x {
2004                                 write8(w, 1)
2005                         } else {
2006                                 write8(w, 0)
2007                         }
2008
2009                 }
2010         }
2011 }
2012
2013 func (obj *ToCltKick) deserialize(r io.Reader) {
2014         if err := pcall(func() {
2015                 ((*(*(struct {
2016                         Reason KickReason
2017
2018                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2019                         Custom string
2020
2021                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2022                         Reconnect bool
2023                 }))(obj)).Reason).deserialize(r)
2024         }); err != nil {
2025                 if err == io.EOF {
2026                         chk(io.EOF)
2027                 }
2028                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.KickReason", err))
2029         }
2030         if !((*(*(struct {
2031                 Reason KickReason
2032
2033                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2034                 Custom string
2035
2036                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2037                 Reconnect bool
2038         }))(obj)).Reason < maxKickReason) {
2039                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
2040         }
2041         if dr := (*(*(struct {
2042                 Reason KickReason
2043
2044                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2045                 Custom string
2046
2047                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2048                 Reconnect bool
2049         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
2050                 var local60 []uint8
2051                 var local61 uint16
2052                 {
2053                         p := &local61
2054                         *p = read16(r)
2055                 }
2056                 (local60) = make([]uint8, local61)
2057                 {
2058                         _, err := io.ReadFull(r, (local60)[:])
2059                         chk(err)
2060                 }
2061                 ((*(*(struct {
2062                         Reason KickReason
2063
2064                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2065                         Custom string
2066
2067                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2068                         Reconnect bool
2069                 }))(obj)).Custom) = string(local60)
2070         }
2071         if dr := (*(*(struct {
2072                 Reason KickReason
2073
2074                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2075                 Custom string
2076
2077                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2078                 Reconnect bool
2079         }))(obj)).Reason; dr == Shutdown || dr == Crash {
2080                 {
2081                         p := &(*(*(struct {
2082                                 Reason KickReason
2083
2084                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2085                                 Custom string
2086
2087                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2088                                 Reconnect bool
2089                         }))(obj)).Reconnect
2090                         switch n := read8(r); n {
2091                         case 0:
2092                                 *p = false
2093                         case 1:
2094                                 *p = true
2095                         default:
2096                                 chk(fmt.Errorf("invalid bool: %d", n))
2097                         }
2098
2099                 }
2100         }
2101 }
2102
2103 func (obj *ToCltBlkData) serialize(w io.Writer) {
2104         for local62 := range (*(*(struct {
2105                 Blkpos [3]int16
2106                 Blk    MapBlk
2107         }))(obj)).Blkpos {
2108                 {
2109                         x := ((*(*(struct {
2110                                 Blkpos [3]int16
2111                                 Blk    MapBlk
2112                         }))(obj)).Blkpos)[local62]
2113                         write16(w, uint16(x))
2114                 }
2115         }
2116         if err := pcall(func() {
2117                 ((*(*(struct {
2118                         Blkpos [3]int16
2119                         Blk    MapBlk
2120                 }))(obj)).Blk).serialize(w)
2121         }); err != nil {
2122                 if err == io.EOF {
2123                         chk(io.EOF)
2124                 }
2125                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlk", err))
2126         }
2127 }
2128
2129 func (obj *ToCltBlkData) deserialize(r io.Reader) {
2130         for local63 := range (*(*(struct {
2131                 Blkpos [3]int16
2132                 Blk    MapBlk
2133         }))(obj)).Blkpos {
2134                 {
2135                         p := &((*(*(struct {
2136                                 Blkpos [3]int16
2137                                 Blk    MapBlk
2138                         }))(obj)).Blkpos)[local63]
2139                         *p = int16(read16(r))
2140                 }
2141         }
2142         if err := pcall(func() {
2143                 ((*(*(struct {
2144                         Blkpos [3]int16
2145                         Blk    MapBlk
2146                 }))(obj)).Blk).deserialize(r)
2147         }); err != nil {
2148                 if err == io.EOF {
2149                         chk(io.EOF)
2150                 }
2151                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlk", err))
2152         }
2153 }
2154
2155 func (obj *ToCltAddNode) serialize(w io.Writer) {
2156         for local64 := range (*(*(struct {
2157                 Pos [3]int16
2158                 Node
2159                 KeepMeta bool
2160         }))(obj)).Pos {
2161                 {
2162                         x := ((*(*(struct {
2163                                 Pos [3]int16
2164                                 Node
2165                                 KeepMeta bool
2166                         }))(obj)).Pos)[local64]
2167                         write16(w, uint16(x))
2168                 }
2169         }
2170         if err := pcall(func() {
2171                 ((*(*(struct {
2172                         Pos [3]int16
2173                         Node
2174                         KeepMeta bool
2175                 }))(obj)).Node).serialize(w)
2176         }); err != nil {
2177                 if err == io.EOF {
2178                         chk(io.EOF)
2179                 }
2180                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Node", err))
2181         }
2182         {
2183                 x := (*(*(struct {
2184                         Pos [3]int16
2185                         Node
2186                         KeepMeta bool
2187                 }))(obj)).KeepMeta
2188                 if x {
2189                         write8(w, 1)
2190                 } else {
2191                         write8(w, 0)
2192                 }
2193
2194         }
2195 }
2196
2197 func (obj *ToCltAddNode) deserialize(r io.Reader) {
2198         for local65 := range (*(*(struct {
2199                 Pos [3]int16
2200                 Node
2201                 KeepMeta bool
2202         }))(obj)).Pos {
2203                 {
2204                         p := &((*(*(struct {
2205                                 Pos [3]int16
2206                                 Node
2207                                 KeepMeta bool
2208                         }))(obj)).Pos)[local65]
2209                         *p = int16(read16(r))
2210                 }
2211         }
2212         if err := pcall(func() {
2213                 ((*(*(struct {
2214                         Pos [3]int16
2215                         Node
2216                         KeepMeta bool
2217                 }))(obj)).Node).deserialize(r)
2218         }); err != nil {
2219                 if err == io.EOF {
2220                         chk(io.EOF)
2221                 }
2222                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Node", err))
2223         }
2224         {
2225                 p := &(*(*(struct {
2226                         Pos [3]int16
2227                         Node
2228                         KeepMeta bool
2229                 }))(obj)).KeepMeta
2230                 switch n := read8(r); n {
2231                 case 0:
2232                         *p = false
2233                 case 1:
2234                         *p = true
2235                 default:
2236                         chk(fmt.Errorf("invalid bool: %d", n))
2237                 }
2238
2239         }
2240 }
2241
2242 func (obj *ToCltRemoveNode) serialize(w io.Writer) {
2243         for local66 := range (*(*(struct {
2244                 Pos [3]int16
2245         }))(obj)).Pos {
2246                 {
2247                         x := ((*(*(struct {
2248                                 Pos [3]int16
2249                         }))(obj)).Pos)[local66]
2250                         write16(w, uint16(x))
2251                 }
2252         }
2253 }
2254
2255 func (obj *ToCltRemoveNode) deserialize(r io.Reader) {
2256         for local67 := range (*(*(struct {
2257                 Pos [3]int16
2258         }))(obj)).Pos {
2259                 {
2260                         p := &((*(*(struct {
2261                                 Pos [3]int16
2262                         }))(obj)).Pos)[local67]
2263                         *p = int16(read16(r))
2264                 }
2265         }
2266 }
2267
2268 func (obj *ToCltInv) serialize(w io.Writer) {
2269         {
2270                 _, err := w.Write(([]byte((*(*(struct {
2271                         //mt:raw
2272                         Inv string
2273                 }))(obj)).Inv))[:])
2274                 chk(err)
2275         }
2276 }
2277
2278 func (obj *ToCltInv) deserialize(r io.Reader) {
2279         var local68 []uint8
2280         {
2281                 var err error
2282                 (local68), err = io.ReadAll(r)
2283                 chk(err)
2284         }
2285         ((*(*(struct {
2286                 //mt:raw
2287                 Inv string
2288         }))(obj)).Inv) = string(local68)
2289 }
2290
2291 func (obj *ToCltTimeOfDay) serialize(w io.Writer) {
2292         {
2293                 x := (*(*(struct {
2294                         Time  uint16  // %24000
2295                         Speed float32 // Speed times faster than real time
2296                 }))(obj)).Time
2297                 write16(w, uint16(x))
2298         }
2299         {
2300                 x := (*(*(struct {
2301                         Time  uint16  // %24000
2302                         Speed float32 // Speed times faster than real time
2303                 }))(obj)).Speed
2304                 write32(w, math.Float32bits(x))
2305         }
2306 }
2307
2308 func (obj *ToCltTimeOfDay) deserialize(r io.Reader) {
2309         {
2310                 p := &(*(*(struct {
2311                         Time  uint16  // %24000
2312                         Speed float32 // Speed times faster than real time
2313                 }))(obj)).Time
2314                 *p = read16(r)
2315         }
2316         {
2317                 p := &(*(*(struct {
2318                         Time  uint16  // %24000
2319                         Speed float32 // Speed times faster than real time
2320                 }))(obj)).Speed
2321                 *p = math.Float32frombits(read32(r))
2322         }
2323 }
2324
2325 func (obj *ToCltCSMRestrictionFlags) serialize(w io.Writer) {
2326         if err := pcall(func() {
2327                 ((*(*(struct {
2328                         Flags CSMRestrictionFlags
2329
2330                         // MapRange is the maximum distance from the player CSMs can read the map
2331                         // if Flags&LimitMapRange != 0.
2332                         MapRange uint32
2333                 }))(obj)).Flags).serialize(w)
2334         }); err != nil {
2335                 if err == io.EOF {
2336                         chk(io.EOF)
2337                 }
2338                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CSMRestrictionFlags", err))
2339         }
2340         {
2341                 x := (*(*(struct {
2342                         Flags CSMRestrictionFlags
2343
2344                         // MapRange is the maximum distance from the player CSMs can read the map
2345                         // if Flags&LimitMapRange != 0.
2346                         MapRange uint32
2347                 }))(obj)).MapRange
2348                 write32(w, uint32(x))
2349         }
2350 }
2351
2352 func (obj *ToCltCSMRestrictionFlags) deserialize(r io.Reader) {
2353         if err := pcall(func() {
2354                 ((*(*(struct {
2355                         Flags CSMRestrictionFlags
2356
2357                         // MapRange is the maximum distance from the player CSMs can read the map
2358                         // if Flags&LimitMapRange != 0.
2359                         MapRange uint32
2360                 }))(obj)).Flags).deserialize(r)
2361         }); err != nil {
2362                 if err == io.EOF {
2363                         chk(io.EOF)
2364                 }
2365                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.CSMRestrictionFlags", err))
2366         }
2367         {
2368                 p := &(*(*(struct {
2369                         Flags CSMRestrictionFlags
2370
2371                         // MapRange is the maximum distance from the player CSMs can read the map
2372                         // if Flags&LimitMapRange != 0.
2373                         MapRange uint32
2374                 }))(obj)).MapRange
2375                 *p = read32(r)
2376         }
2377 }
2378
2379 func (obj *ToCltAddPlayerVel) serialize(w io.Writer) {
2380         if err := pcall(func() {
2381                 ((*(*(struct {
2382                         Vel Vec
2383                 }))(obj)).Vel).serialize(w)
2384         }); err != nil {
2385                 if err == io.EOF {
2386                         chk(io.EOF)
2387                 }
2388                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
2389         }
2390 }
2391
2392 func (obj *ToCltAddPlayerVel) deserialize(r io.Reader) {
2393         if err := pcall(func() {
2394                 ((*(*(struct {
2395                         Vel Vec
2396                 }))(obj)).Vel).deserialize(r)
2397         }); err != nil {
2398                 if err == io.EOF {
2399                         chk(io.EOF)
2400                 }
2401                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
2402         }
2403 }
2404
2405 func (obj *ToCltMediaPush) serialize(w io.Writer) {
2406         {
2407                 local69 := uint16(sha1.Size)
2408                 {
2409                         x := local69
2410                         write16(w, uint16(x))
2411                 }
2412         }
2413         {
2414                 _, err := w.Write(((*(*(struct {
2415                         //mt:const uint16(sha1.Size)
2416                         SHA1        [sha1.Size]byte
2417                         Filename    string
2418                         ShouldCache bool
2419
2420                         //mt:len32
2421                         Data []byte
2422                 }))(obj)).SHA1)[:])
2423                 chk(err)
2424         }
2425         if len(([]byte((*(*(struct {
2426                 //mt:const uint16(sha1.Size)
2427                 SHA1        [sha1.Size]byte
2428                 Filename    string
2429                 ShouldCache bool
2430
2431                 //mt:len32
2432                 Data []byte
2433         }))(obj)).Filename))) > math.MaxUint16 {
2434                 chk(ErrTooLong)
2435         }
2436         {
2437                 x := uint16(len(([]byte((*(*(struct {
2438                         //mt:const uint16(sha1.Size)
2439                         SHA1        [sha1.Size]byte
2440                         Filename    string
2441                         ShouldCache bool
2442
2443                         //mt:len32
2444                         Data []byte
2445                 }))(obj)).Filename))))
2446                 write16(w, uint16(x))
2447         }
2448         {
2449                 _, err := w.Write(([]byte((*(*(struct {
2450                         //mt:const uint16(sha1.Size)
2451                         SHA1        [sha1.Size]byte
2452                         Filename    string
2453                         ShouldCache bool
2454
2455                         //mt:len32
2456                         Data []byte
2457                 }))(obj)).Filename))[:])
2458                 chk(err)
2459         }
2460         {
2461                 x := (*(*(struct {
2462                         //mt:const uint16(sha1.Size)
2463                         SHA1        [sha1.Size]byte
2464                         Filename    string
2465                         ShouldCache bool
2466
2467                         //mt:len32
2468                         Data []byte
2469                 }))(obj)).ShouldCache
2470                 if x {
2471                         write8(w, 1)
2472                 } else {
2473                         write8(w, 0)
2474                 }
2475
2476         }
2477         if len(((*(*(struct {
2478                 //mt:const uint16(sha1.Size)
2479                 SHA1        [sha1.Size]byte
2480                 Filename    string
2481                 ShouldCache bool
2482
2483                 //mt:len32
2484                 Data []byte
2485         }))(obj)).Data)) > math.MaxUint32 {
2486                 chk(ErrTooLong)
2487         }
2488         {
2489                 x := uint32(len(((*(*(struct {
2490                         //mt:const uint16(sha1.Size)
2491                         SHA1        [sha1.Size]byte
2492                         Filename    string
2493                         ShouldCache bool
2494
2495                         //mt:len32
2496                         Data []byte
2497                 }))(obj)).Data)))
2498                 write32(w, uint32(x))
2499         }
2500         {
2501                 _, err := w.Write(((*(*(struct {
2502                         //mt:const uint16(sha1.Size)
2503                         SHA1        [sha1.Size]byte
2504                         Filename    string
2505                         ShouldCache bool
2506
2507                         //mt:len32
2508                         Data []byte
2509                 }))(obj)).Data)[:])
2510                 chk(err)
2511         }
2512 }
2513
2514 func (obj *ToCltMediaPush) deserialize(r io.Reader) {
2515         {
2516                 var local70 uint16
2517                 local71 := uint16(sha1.Size)
2518                 {
2519                         p := &local70
2520                         *p = read16(r)
2521                 }
2522                 if local70 != local71 {
2523                         chk(fmt.Errorf("const %v: %v", "uint16(sha1.Size)", local70))
2524                 }
2525         }
2526         {
2527                 _, err := io.ReadFull(r, ((*(*(struct {
2528                         //mt:const uint16(sha1.Size)
2529                         SHA1        [sha1.Size]byte
2530                         Filename    string
2531                         ShouldCache bool
2532
2533                         //mt:len32
2534                         Data []byte
2535                 }))(obj)).SHA1)[:])
2536                 chk(err)
2537         }
2538         var local72 []uint8
2539         var local73 uint16
2540         {
2541                 p := &local73
2542                 *p = read16(r)
2543         }
2544         (local72) = make([]uint8, local73)
2545         {
2546                 _, err := io.ReadFull(r, (local72)[:])
2547                 chk(err)
2548         }
2549         ((*(*(struct {
2550                 //mt:const uint16(sha1.Size)
2551                 SHA1        [sha1.Size]byte
2552                 Filename    string
2553                 ShouldCache bool
2554
2555                 //mt:len32
2556                 Data []byte
2557         }))(obj)).Filename) = string(local72)
2558         {
2559                 p := &(*(*(struct {
2560                         //mt:const uint16(sha1.Size)
2561                         SHA1        [sha1.Size]byte
2562                         Filename    string
2563                         ShouldCache bool
2564
2565                         //mt:len32
2566                         Data []byte
2567                 }))(obj)).ShouldCache
2568                 switch n := read8(r); n {
2569                 case 0:
2570                         *p = false
2571                 case 1:
2572                         *p = true
2573                 default:
2574                         chk(fmt.Errorf("invalid bool: %d", n))
2575                 }
2576
2577         }
2578         var local74 uint32
2579         {
2580                 p := &local74
2581                 *p = read32(r)
2582         }
2583         ((*(*(struct {
2584                 //mt:const uint16(sha1.Size)
2585                 SHA1        [sha1.Size]byte
2586                 Filename    string
2587                 ShouldCache bool
2588
2589                 //mt:len32
2590                 Data []byte
2591         }))(obj)).Data) = make([]byte, local74)
2592         {
2593                 _, err := io.ReadFull(r, ((*(*(struct {
2594                         //mt:const uint16(sha1.Size)
2595                         SHA1        [sha1.Size]byte
2596                         Filename    string
2597                         ShouldCache bool
2598
2599                         //mt:len32
2600                         Data []byte
2601                 }))(obj)).Data)[:])
2602                 chk(err)
2603         }
2604 }
2605
2606 func (obj *ToCltChatMsg) serialize(w io.Writer) {
2607         {
2608                 local75 := uint8(1)
2609                 {
2610                         x := local75
2611                         write8(w, uint8(x))
2612                 }
2613         }
2614         if err := pcall(func() {
2615                 ((*(*(struct {
2616                         Type ChatMsgType
2617
2618                         //mt:utf16
2619                         Sender, Text string
2620
2621                         Timestamp int64 // Unix time.
2622                 }))(obj)).Type).serialize(w)
2623         }); err != nil {
2624                 if err == io.EOF {
2625                         chk(io.EOF)
2626                 }
2627                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
2628         }
2629         local76 := utf16.Encode([]rune((*(*(struct {
2630                 Type ChatMsgType
2631
2632                 //mt:utf16
2633                 Sender, Text string
2634
2635                 Timestamp int64 // Unix time.
2636         }))(obj)).Sender))
2637         if len((local76)) > math.MaxUint16 {
2638                 chk(ErrTooLong)
2639         }
2640         {
2641                 x := uint16(len((local76)))
2642                 write16(w, uint16(x))
2643         }
2644         for local77 := range local76 {
2645                 {
2646                         x := (local76)[local77]
2647                         write16(w, uint16(x))
2648                 }
2649         }
2650         local78 := utf16.Encode([]rune((*(*(struct {
2651                 Type ChatMsgType
2652
2653                 //mt:utf16
2654                 Sender, Text string
2655
2656                 Timestamp int64 // Unix time.
2657         }))(obj)).Text))
2658         if len((local78)) > math.MaxUint16 {
2659                 chk(ErrTooLong)
2660         }
2661         {
2662                 x := uint16(len((local78)))
2663                 write16(w, uint16(x))
2664         }
2665         for local79 := range local78 {
2666                 {
2667                         x := (local78)[local79]
2668                         write16(w, uint16(x))
2669                 }
2670         }
2671         {
2672                 x := (*(*(struct {
2673                         Type ChatMsgType
2674
2675                         //mt:utf16
2676                         Sender, Text string
2677
2678                         Timestamp int64 // Unix time.
2679                 }))(obj)).Timestamp
2680                 write64(w, uint64(x))
2681
2682         }
2683 }
2684
2685 func (obj *ToCltChatMsg) deserialize(r io.Reader) {
2686         {
2687                 var local80 uint8
2688                 local81 := uint8(1)
2689                 {
2690                         p := &local80
2691                         *p = read8(r)
2692                 }
2693                 if local80 != local81 {
2694                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local80))
2695                 }
2696         }
2697         if err := pcall(func() {
2698                 ((*(*(struct {
2699                         Type ChatMsgType
2700
2701                         //mt:utf16
2702                         Sender, Text string
2703
2704                         Timestamp int64 // Unix time.
2705                 }))(obj)).Type).deserialize(r)
2706         }); err != nil {
2707                 if err == io.EOF {
2708                         chk(io.EOF)
2709                 }
2710                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
2711         }
2712         var local82 []uint16
2713         var local83 uint16
2714         {
2715                 p := &local83
2716                 *p = read16(r)
2717         }
2718         (local82) = make([]uint16, local83)
2719         for local84 := range local82 {
2720                 {
2721                         p := &(local82)[local84]
2722                         *p = read16(r)
2723                 }
2724         }
2725         (*(*(struct {
2726                 Type ChatMsgType
2727
2728                 //mt:utf16
2729                 Sender, Text string
2730
2731                 Timestamp int64 // Unix time.
2732         }))(obj)).Sender = string(utf16.Decode(local82))
2733         var local85 []uint16
2734         var local86 uint16
2735         {
2736                 p := &local86
2737                 *p = read16(r)
2738         }
2739         (local85) = make([]uint16, local86)
2740         for local87 := range local85 {
2741                 {
2742                         p := &(local85)[local87]
2743                         *p = read16(r)
2744                 }
2745         }
2746         (*(*(struct {
2747                 Type ChatMsgType
2748
2749                 //mt:utf16
2750                 Sender, Text string
2751
2752                 Timestamp int64 // Unix time.
2753         }))(obj)).Text = string(utf16.Decode(local85))
2754         {
2755                 p := &(*(*(struct {
2756                         Type ChatMsgType
2757
2758                         //mt:utf16
2759                         Sender, Text string
2760
2761                         Timestamp int64 // Unix time.
2762                 }))(obj)).Timestamp
2763                 *p = int64(read64(r))
2764
2765         }
2766 }
2767
2768 func (obj *ToCltAORmAdd) serialize(w io.Writer) {
2769         if len(((*(*(struct {
2770                 Remove []AOID
2771                 Add    []AOAdd
2772         }))(obj)).Remove)) > math.MaxUint16 {
2773                 chk(ErrTooLong)
2774         }
2775         {
2776                 x := uint16(len(((*(*(struct {
2777                         Remove []AOID
2778                         Add    []AOAdd
2779                 }))(obj)).Remove)))
2780                 write16(w, uint16(x))
2781         }
2782         for local88 := range (*(*(struct {
2783                 Remove []AOID
2784                 Add    []AOAdd
2785         }))(obj)).Remove {
2786                 if err := pcall(func() {
2787                         (((*(*(struct {
2788                                 Remove []AOID
2789                                 Add    []AOAdd
2790                         }))(obj)).Remove)[local88]).serialize(w)
2791                 }); err != nil {
2792                         if err == io.EOF {
2793                                 chk(io.EOF)
2794                         }
2795                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2796                 }
2797         }
2798         if len(((*(*(struct {
2799                 Remove []AOID
2800                 Add    []AOAdd
2801         }))(obj)).Add)) > math.MaxUint16 {
2802                 chk(ErrTooLong)
2803         }
2804         {
2805                 x := uint16(len(((*(*(struct {
2806                         Remove []AOID
2807                         Add    []AOAdd
2808                 }))(obj)).Add)))
2809                 write16(w, uint16(x))
2810         }
2811         for local89 := range (*(*(struct {
2812                 Remove []AOID
2813                 Add    []AOAdd
2814         }))(obj)).Add {
2815                 if err := pcall(func() {
2816                         (((*(*(struct {
2817                                 Remove []AOID
2818                                 Add    []AOAdd
2819                         }))(obj)).Add)[local89]).serialize(w)
2820                 }); err != nil {
2821                         if err == io.EOF {
2822                                 chk(io.EOF)
2823                         }
2824                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAdd", err))
2825                 }
2826         }
2827 }
2828
2829 func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
2830         var local90 uint16
2831         {
2832                 p := &local90
2833                 *p = read16(r)
2834         }
2835         ((*(*(struct {
2836                 Remove []AOID
2837                 Add    []AOAdd
2838         }))(obj)).Remove) = make([]AOID, local90)
2839         for local91 := range (*(*(struct {
2840                 Remove []AOID
2841                 Add    []AOAdd
2842         }))(obj)).Remove {
2843                 if err := pcall(func() {
2844                         (((*(*(struct {
2845                                 Remove []AOID
2846                                 Add    []AOAdd
2847                         }))(obj)).Remove)[local91]).deserialize(r)
2848                 }); err != nil {
2849                         if err == io.EOF {
2850                                 chk(io.EOF)
2851                         }
2852                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
2853                 }
2854         }
2855         var local92 uint16
2856         {
2857                 p := &local92
2858                 *p = read16(r)
2859         }
2860         ((*(*(struct {
2861                 Remove []AOID
2862                 Add    []AOAdd
2863         }))(obj)).Add) = make([]AOAdd, local92)
2864         for local93 := range (*(*(struct {
2865                 Remove []AOID
2866                 Add    []AOAdd
2867         }))(obj)).Add {
2868                 if err := pcall(func() {
2869                         (((*(*(struct {
2870                                 Remove []AOID
2871                                 Add    []AOAdd
2872                         }))(obj)).Add)[local93]).deserialize(r)
2873                 }); err != nil {
2874                         if err == io.EOF {
2875                                 chk(io.EOF)
2876                         }
2877                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAdd", err))
2878                 }
2879         }
2880 }
2881
2882 func (obj *ToCltAOMsgs) serialize(w io.Writer) {
2883         for local94 := range (*(*(struct {
2884                 //mt:raw
2885                 Msgs []IDAOMsg
2886         }))(obj)).Msgs {
2887                 if err := pcall(func() {
2888                         (((*(*(struct {
2889                                 //mt:raw
2890                                 Msgs []IDAOMsg
2891                         }))(obj)).Msgs)[local94]).serialize(w)
2892                 }); err != nil {
2893                         if err == io.EOF {
2894                                 chk(io.EOF)
2895                         }
2896                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.IDAOMsg", err))
2897                 }
2898         }
2899 }
2900
2901 func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
2902         for {
2903                 var local95 IDAOMsg
2904                 err := pcall(func() {
2905                         if err := pcall(func() {
2906                                 (local95).deserialize(r)
2907                         }); err != nil {
2908                                 if err == io.EOF {
2909                                         chk(io.EOF)
2910                                 }
2911                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.IDAOMsg", err))
2912                         }
2913                 })
2914                 if err == io.EOF {
2915                         break
2916                 }
2917                 ((*(*(struct {
2918                         //mt:raw
2919                         Msgs []IDAOMsg
2920                 }))(obj)).Msgs) = append(((*(*(struct {
2921                         //mt:raw
2922                         Msgs []IDAOMsg
2923                 }))(obj)).Msgs), local95)
2924                 chk(err)
2925         }
2926 }
2927
2928 func (obj *ToCltHP) serialize(w io.Writer) {
2929         {
2930                 x := (*(*(struct {
2931                         HP uint16
2932                 }))(obj)).HP
2933                 write16(w, uint16(x))
2934         }
2935 }
2936
2937 func (obj *ToCltHP) deserialize(r io.Reader) {
2938         {
2939                 p := &(*(*(struct {
2940                         HP uint16
2941                 }))(obj)).HP
2942                 *p = read16(r)
2943         }
2944 }
2945
2946 func (obj *ToCltMovePlayer) serialize(w io.Writer) {
2947         if err := pcall(func() {
2948                 ((*(*(struct {
2949                         Pos
2950                         Pitch, Yaw float32
2951                 }))(obj)).Pos).serialize(w)
2952         }); err != nil {
2953                 if err == io.EOF {
2954                         chk(io.EOF)
2955                 }
2956                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
2957         }
2958         {
2959                 x := (*(*(struct {
2960                         Pos
2961                         Pitch, Yaw float32
2962                 }))(obj)).Pitch
2963                 write32(w, math.Float32bits(x))
2964         }
2965         {
2966                 x := (*(*(struct {
2967                         Pos
2968                         Pitch, Yaw float32
2969                 }))(obj)).Yaw
2970                 write32(w, math.Float32bits(x))
2971         }
2972 }
2973
2974 func (obj *ToCltMovePlayer) deserialize(r io.Reader) {
2975         if err := pcall(func() {
2976                 ((*(*(struct {
2977                         Pos
2978                         Pitch, Yaw float32
2979                 }))(obj)).Pos).deserialize(r)
2980         }); err != nil {
2981                 if err == io.EOF {
2982                         chk(io.EOF)
2983                 }
2984                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
2985         }
2986         {
2987                 p := &(*(*(struct {
2988                         Pos
2989                         Pitch, Yaw float32
2990                 }))(obj)).Pitch
2991                 *p = math.Float32frombits(read32(r))
2992         }
2993         {
2994                 p := &(*(*(struct {
2995                         Pos
2996                         Pitch, Yaw float32
2997                 }))(obj)).Yaw
2998                 *p = math.Float32frombits(read32(r))
2999         }
3000 }
3001
3002 func (obj *ToCltLegacyKick) serialize(w io.Writer) {
3003         local96 := utf16.Encode([]rune((*(*(struct {
3004                 //mt:utf16
3005                 Reason string
3006         }))(obj)).Reason))
3007         if len((local96)) > math.MaxUint16 {
3008                 chk(ErrTooLong)
3009         }
3010         {
3011                 x := uint16(len((local96)))
3012                 write16(w, uint16(x))
3013         }
3014         for local97 := range local96 {
3015                 {
3016                         x := (local96)[local97]
3017                         write16(w, uint16(x))
3018                 }
3019         }
3020 }
3021
3022 func (obj *ToCltLegacyKick) deserialize(r io.Reader) {
3023         var local98 []uint16
3024         var local99 uint16
3025         {
3026                 p := &local99
3027                 *p = read16(r)
3028         }
3029         (local98) = make([]uint16, local99)
3030         for local100 := range local98 {
3031                 {
3032                         p := &(local98)[local100]
3033                         *p = read16(r)
3034                 }
3035         }
3036         (*(*(struct {
3037                 //mt:utf16
3038                 Reason string
3039         }))(obj)).Reason = string(utf16.Decode(local98))
3040 }
3041
3042 func (obj *ToCltFOV) serialize(w io.Writer) {
3043         {
3044                 x := (*(*(struct {
3045                         FOV            float32
3046                         Multiplier     bool
3047                         TransitionTime float32
3048                 }))(obj)).FOV
3049                 write32(w, math.Float32bits(x))
3050         }
3051         {
3052                 x := (*(*(struct {
3053                         FOV            float32
3054                         Multiplier     bool
3055                         TransitionTime float32
3056                 }))(obj)).Multiplier
3057                 if x {
3058                         write8(w, 1)
3059                 } else {
3060                         write8(w, 0)
3061                 }
3062
3063         }
3064         {
3065                 x := (*(*(struct {
3066                         FOV            float32
3067                         Multiplier     bool
3068                         TransitionTime float32
3069                 }))(obj)).TransitionTime
3070                 write32(w, math.Float32bits(x))
3071         }
3072 }
3073
3074 func (obj *ToCltFOV) deserialize(r io.Reader) {
3075         {
3076                 p := &(*(*(struct {
3077                         FOV            float32
3078                         Multiplier     bool
3079                         TransitionTime float32
3080                 }))(obj)).FOV
3081                 *p = math.Float32frombits(read32(r))
3082         }
3083         {
3084                 p := &(*(*(struct {
3085                         FOV            float32
3086                         Multiplier     bool
3087                         TransitionTime float32
3088                 }))(obj)).Multiplier
3089                 switch n := read8(r); n {
3090                 case 0:
3091                         *p = false
3092                 case 1:
3093                         *p = true
3094                 default:
3095                         chk(fmt.Errorf("invalid bool: %d", n))
3096                 }
3097
3098         }
3099         {
3100                 p := &(*(*(struct {
3101                         FOV            float32
3102                         Multiplier     bool
3103                         TransitionTime float32
3104                 }))(obj)).TransitionTime
3105                 *p = math.Float32frombits(read32(r))
3106         }
3107 }
3108
3109 func (obj *ToCltDeathScreen) serialize(w io.Writer) {
3110         {
3111                 x := (*(*(struct {
3112                         PointCam bool
3113                         PointAt  Pos
3114                 }))(obj)).PointCam
3115                 if x {
3116                         write8(w, 1)
3117                 } else {
3118                         write8(w, 0)
3119                 }
3120
3121         }
3122         if err := pcall(func() {
3123                 ((*(*(struct {
3124                         PointCam bool
3125                         PointAt  Pos
3126                 }))(obj)).PointAt).serialize(w)
3127         }); err != nil {
3128                 if err == io.EOF {
3129                         chk(io.EOF)
3130                 }
3131                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3132         }
3133 }
3134
3135 func (obj *ToCltDeathScreen) deserialize(r io.Reader) {
3136         {
3137                 p := &(*(*(struct {
3138                         PointCam bool
3139                         PointAt  Pos
3140                 }))(obj)).PointCam
3141                 switch n := read8(r); n {
3142                 case 0:
3143                         *p = false
3144                 case 1:
3145                         *p = true
3146                 default:
3147                         chk(fmt.Errorf("invalid bool: %d", n))
3148                 }
3149
3150         }
3151         if err := pcall(func() {
3152                 ((*(*(struct {
3153                         PointCam bool
3154                         PointAt  Pos
3155                 }))(obj)).PointAt).deserialize(r)
3156         }); err != nil {
3157                 if err == io.EOF {
3158                         chk(io.EOF)
3159                 }
3160                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
3161         }
3162 }
3163
3164 func (obj *ToCltMedia) serialize(w io.Writer) {
3165         {
3166                 x := (*(*(struct {
3167                         // N is the total number of ToCltMedia packets.
3168                         // I is the index of this packet.
3169                         N, I uint16
3170
3171                         //mt:len32
3172                         Files []struct {
3173                                 Name string
3174
3175                                 //mt:len32
3176                                 Data []byte
3177                         }
3178                 }))(obj)).N
3179                 write16(w, uint16(x))
3180         }
3181         {
3182                 x := (*(*(struct {
3183                         // N is the total number of ToCltMedia packets.
3184                         // I is the index of this packet.
3185                         N, I uint16
3186
3187                         //mt:len32
3188                         Files []struct {
3189                                 Name string
3190
3191                                 //mt:len32
3192                                 Data []byte
3193                         }
3194                 }))(obj)).I
3195                 write16(w, uint16(x))
3196         }
3197         if len(((*(*(struct {
3198                 // N is the total number of ToCltMedia packets.
3199                 // I is the index of this packet.
3200                 N, I uint16
3201
3202                 //mt:len32
3203                 Files []struct {
3204                         Name string
3205
3206                         //mt:len32
3207                         Data []byte
3208                 }
3209         }))(obj)).Files)) > math.MaxUint32 {
3210                 chk(ErrTooLong)
3211         }
3212         {
3213                 x := uint32(len(((*(*(struct {
3214                         // N is the total number of ToCltMedia packets.
3215                         // I is the index of this packet.
3216                         N, I uint16
3217
3218                         //mt:len32
3219                         Files []struct {
3220                                 Name string
3221
3222                                 //mt:len32
3223                                 Data []byte
3224                         }
3225                 }))(obj)).Files)))
3226                 write32(w, uint32(x))
3227         }
3228         for local101 := range (*(*(struct {
3229                 // N is the total number of ToCltMedia packets.
3230                 // I is the index of this packet.
3231                 N, I uint16
3232
3233                 //mt:len32
3234                 Files []struct {
3235                         Name string
3236
3237                         //mt:len32
3238                         Data []byte
3239                 }
3240         }))(obj)).Files {
3241                 if len(([]byte((((*(*(struct {
3242                         // N is the total number of ToCltMedia packets.
3243                         // I is the index of this packet.
3244                         N, I uint16
3245
3246                         //mt:len32
3247                         Files []struct {
3248                                 Name string
3249
3250                                 //mt:len32
3251                                 Data []byte
3252                         }
3253                 }))(obj)).Files)[local101]).Name))) > math.MaxUint16 {
3254                         chk(ErrTooLong)
3255                 }
3256                 {
3257                         x := uint16(len(([]byte((((*(*(struct {
3258                                 // N is the total number of ToCltMedia packets.
3259                                 // I is the index of this packet.
3260                                 N, I uint16
3261
3262                                 //mt:len32
3263                                 Files []struct {
3264                                         Name string
3265
3266                                         //mt:len32
3267                                         Data []byte
3268                                 }
3269                         }))(obj)).Files)[local101]).Name))))
3270                         write16(w, uint16(x))
3271                 }
3272                 {
3273                         _, err := w.Write(([]byte((((*(*(struct {
3274                                 // N is the total number of ToCltMedia packets.
3275                                 // I is the index of this packet.
3276                                 N, I uint16
3277
3278                                 //mt:len32
3279                                 Files []struct {
3280                                         Name string
3281
3282                                         //mt:len32
3283                                         Data []byte
3284                                 }
3285                         }))(obj)).Files)[local101]).Name))[:])
3286                         chk(err)
3287                 }
3288                 if len(((((*(*(struct {
3289                         // N is the total number of ToCltMedia packets.
3290                         // I is the index of this packet.
3291                         N, I uint16
3292
3293                         //mt:len32
3294                         Files []struct {
3295                                 Name string
3296
3297                                 //mt:len32
3298                                 Data []byte
3299                         }
3300                 }))(obj)).Files)[local101]).Data)) > math.MaxUint32 {
3301                         chk(ErrTooLong)
3302                 }
3303                 {
3304                         x := uint32(len(((((*(*(struct {
3305                                 // N is the total number of ToCltMedia packets.
3306                                 // I is the index of this packet.
3307                                 N, I uint16
3308
3309                                 //mt:len32
3310                                 Files []struct {
3311                                         Name string
3312
3313                                         //mt:len32
3314                                         Data []byte
3315                                 }
3316                         }))(obj)).Files)[local101]).Data)))
3317                         write32(w, uint32(x))
3318                 }
3319                 {
3320                         _, err := w.Write(((((*(*(struct {
3321                                 // N is the total number of ToCltMedia packets.
3322                                 // I is the index of this packet.
3323                                 N, I uint16
3324
3325                                 //mt:len32
3326                                 Files []struct {
3327                                         Name string
3328
3329                                         //mt:len32
3330                                         Data []byte
3331                                 }
3332                         }))(obj)).Files)[local101]).Data)[:])
3333                         chk(err)
3334                 }
3335         }
3336 }
3337
3338 func (obj *ToCltMedia) deserialize(r io.Reader) {
3339         {
3340                 p := &(*(*(struct {
3341                         // N is the total number of ToCltMedia packets.
3342                         // I is the index of this packet.
3343                         N, I uint16
3344
3345                         //mt:len32
3346                         Files []struct {
3347                                 Name string
3348
3349                                 //mt:len32
3350                                 Data []byte
3351                         }
3352                 }))(obj)).N
3353                 *p = read16(r)
3354         }
3355         {
3356                 p := &(*(*(struct {
3357                         // N is the total number of ToCltMedia packets.
3358                         // I is the index of this packet.
3359                         N, I uint16
3360
3361                         //mt:len32
3362                         Files []struct {
3363                                 Name string
3364
3365                                 //mt:len32
3366                                 Data []byte
3367                         }
3368                 }))(obj)).I
3369                 *p = read16(r)
3370         }
3371         var local102 uint32
3372         {
3373                 p := &local102
3374                 *p = read32(r)
3375         }
3376         ((*(*(struct {
3377                 // N is the total number of ToCltMedia packets.
3378                 // I is the index of this packet.
3379                 N, I uint16
3380
3381                 //mt:len32
3382                 Files []struct {
3383                         Name string
3384
3385                         //mt:len32
3386                         Data []byte
3387                 }
3388         }))(obj)).Files) = make([]struct {
3389                 Name string
3390                 Data []byte
3391         }, local102)
3392         for local103 := range (*(*(struct {
3393                 // N is the total number of ToCltMedia packets.
3394                 // I is the index of this packet.
3395                 N, I uint16
3396
3397                 //mt:len32
3398                 Files []struct {
3399                         Name string
3400
3401                         //mt:len32
3402                         Data []byte
3403                 }
3404         }))(obj)).Files {
3405                 var local104 []uint8
3406                 var local105 uint16
3407                 {
3408                         p := &local105
3409                         *p = read16(r)
3410                 }
3411                 (local104) = make([]uint8, local105)
3412                 {
3413                         _, err := io.ReadFull(r, (local104)[:])
3414                         chk(err)
3415                 }
3416                 ((((*(*(struct {
3417                         // N is the total number of ToCltMedia packets.
3418                         // I is the index of this packet.
3419                         N, I uint16
3420
3421                         //mt:len32
3422                         Files []struct {
3423                                 Name string
3424
3425                                 //mt:len32
3426                                 Data []byte
3427                         }
3428                 }))(obj)).Files)[local103]).Name) = string(local104)
3429                 var local106 uint32
3430                 {
3431                         p := &local106
3432                         *p = read32(r)
3433                 }
3434                 ((((*(*(struct {
3435                         // N is the total number of ToCltMedia packets.
3436                         // I is the index of this packet.
3437                         N, I uint16
3438
3439                         //mt:len32
3440                         Files []struct {
3441                                 Name string
3442
3443                                 //mt:len32
3444                                 Data []byte
3445                         }
3446                 }))(obj)).Files)[local103]).Data) = make([]byte, local106)
3447                 {
3448                         _, err := io.ReadFull(r, ((((*(*(struct {
3449                                 // N is the total number of ToCltMedia packets.
3450                                 // I is the index of this packet.
3451                                 N, I uint16
3452
3453                                 //mt:len32
3454                                 Files []struct {
3455                                         Name string
3456
3457                                         //mt:len32
3458                                         Data []byte
3459                                 }
3460                         }))(obj)).Files)[local103]).Data)[:])
3461                         chk(err)
3462                 }
3463         }
3464 }
3465
3466 func (obj *ToCltNodeDefs) serialize(w io.Writer) {
3467         {
3468                 ow := w
3469                 w := new(bytes.Buffer)
3470                 {
3471                         w := zlib.NewWriter(w)
3472                         {
3473                                 local107 := uint8(1)
3474                                 {
3475                                         x := local107
3476                                         write8(w, uint8(x))
3477                                 }
3478                         }
3479                         {
3480                                 x := (*(*(struct {
3481
3482                                         // See (de)serialize.fmt.
3483                                         Defs []NodeDef
3484                                 }))(obj)).Defs
3485                                 { // For ToCltNodeDefs.Defs.
3486                                         if len(x) > math.MaxUint16 {
3487                                                 chk(ErrTooLong)
3488                                         }
3489                                         write16(w, uint16(len(x)))
3490                                         var b bytes.Buffer
3491                                         for i := range x {
3492                                                 x[i].serialize(&b)
3493                                         }
3494                                         if b.Len() > math.MaxUint32 {
3495                                                 chk(ErrTooLong)
3496                                         }
3497                                         write32(w, uint32(b.Len()))
3498                                         _, err := b.WriteTo(w)
3499                                         chk(err)
3500                                 }
3501                         }
3502                         chk(w.Close())
3503                 }
3504                 {
3505                         buf := w
3506                         w := ow
3507                         if len((buf.Bytes())) > math.MaxUint32 {
3508                                 chk(ErrTooLong)
3509                         }
3510                         {
3511                                 x := uint32(len((buf.Bytes())))
3512                                 write32(w, uint32(x))
3513                         }
3514                         {
3515                                 _, err := w.Write((buf.Bytes())[:])
3516                                 chk(err)
3517                         }
3518                 }
3519         }
3520 }
3521
3522 func (obj *ToCltNodeDefs) deserialize(r io.Reader) {
3523         {
3524                 var n uint32
3525                 {
3526                         p := &n
3527                         *p = read32(r)
3528                 }
3529                 r := &io.LimitedReader{R: r, N: int64(n)}
3530                 {
3531                         r, err := zlib.NewReader(byteReader{r})
3532                         chk(err)
3533                         {
3534                                 var local108 uint8
3535                                 local109 := uint8(1)
3536                                 {
3537                                         p := &local108
3538                                         *p = read8(r)
3539                                 }
3540                                 if local108 != local109 {
3541                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local108))
3542                                 }
3543                         }
3544                         {
3545                                 p := &(*(*(struct {
3546
3547                                         // See (de)serialize.fmt.
3548                                         Defs []NodeDef
3549                                 }))(obj)).Defs
3550                                 { // For ToCltNodeDefs.Defs.
3551                                         *p = make([]NodeDef, read16(r))
3552                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3553                                         for i := range *p {
3554                                                 (*p)[i].deserialize(r)
3555                                         }
3556                                         if r.N > 0 {
3557                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3558                                         }
3559                                 }
3560                         }
3561                         chk(r.Close())
3562                 }
3563                 if r.N > 0 {
3564                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3565                 }
3566         }
3567 }
3568
3569 func (obj *ToCltAnnounceMedia) serialize(w io.Writer) {
3570         if len(((*(*(struct {
3571                 Files []struct {
3572                         Name       string
3573                         Base64SHA1 string
3574                 }
3575                 URL string
3576         }))(obj)).Files)) > math.MaxUint16 {
3577                 chk(ErrTooLong)
3578         }
3579         {
3580                 x := uint16(len(((*(*(struct {
3581                         Files []struct {
3582                                 Name       string
3583                                 Base64SHA1 string
3584                         }
3585                         URL string
3586                 }))(obj)).Files)))
3587                 write16(w, uint16(x))
3588         }
3589         for local110 := range (*(*(struct {
3590                 Files []struct {
3591                         Name       string
3592                         Base64SHA1 string
3593                 }
3594                 URL string
3595         }))(obj)).Files {
3596                 if len(([]byte((((*(*(struct {
3597                         Files []struct {
3598                                 Name       string
3599                                 Base64SHA1 string
3600                         }
3601                         URL string
3602                 }))(obj)).Files)[local110]).Name))) > math.MaxUint16 {
3603                         chk(ErrTooLong)
3604                 }
3605                 {
3606                         x := uint16(len(([]byte((((*(*(struct {
3607                                 Files []struct {
3608                                         Name       string
3609                                         Base64SHA1 string
3610                                 }
3611                                 URL string
3612                         }))(obj)).Files)[local110]).Name))))
3613                         write16(w, uint16(x))
3614                 }
3615                 {
3616                         _, err := w.Write(([]byte((((*(*(struct {
3617                                 Files []struct {
3618                                         Name       string
3619                                         Base64SHA1 string
3620                                 }
3621                                 URL string
3622                         }))(obj)).Files)[local110]).Name))[:])
3623                         chk(err)
3624                 }
3625                 if len(([]byte((((*(*(struct {
3626                         Files []struct {
3627                                 Name       string
3628                                 Base64SHA1 string
3629                         }
3630                         URL string
3631                 }))(obj)).Files)[local110]).Base64SHA1))) > math.MaxUint16 {
3632                         chk(ErrTooLong)
3633                 }
3634                 {
3635                         x := uint16(len(([]byte((((*(*(struct {
3636                                 Files []struct {
3637                                         Name       string
3638                                         Base64SHA1 string
3639                                 }
3640                                 URL string
3641                         }))(obj)).Files)[local110]).Base64SHA1))))
3642                         write16(w, uint16(x))
3643                 }
3644                 {
3645                         _, err := w.Write(([]byte((((*(*(struct {
3646                                 Files []struct {
3647                                         Name       string
3648                                         Base64SHA1 string
3649                                 }
3650                                 URL string
3651                         }))(obj)).Files)[local110]).Base64SHA1))[:])
3652                         chk(err)
3653                 }
3654         }
3655         if len(([]byte((*(*(struct {
3656                 Files []struct {
3657                         Name       string
3658                         Base64SHA1 string
3659                 }
3660                 URL string
3661         }))(obj)).URL))) > math.MaxUint16 {
3662                 chk(ErrTooLong)
3663         }
3664         {
3665                 x := uint16(len(([]byte((*(*(struct {
3666                         Files []struct {
3667                                 Name       string
3668                                 Base64SHA1 string
3669                         }
3670                         URL string
3671                 }))(obj)).URL))))
3672                 write16(w, uint16(x))
3673         }
3674         {
3675                 _, err := w.Write(([]byte((*(*(struct {
3676                         Files []struct {
3677                                 Name       string
3678                                 Base64SHA1 string
3679                         }
3680                         URL string
3681                 }))(obj)).URL))[:])
3682                 chk(err)
3683         }
3684 }
3685
3686 func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
3687         var local111 uint16
3688         {
3689                 p := &local111
3690                 *p = read16(r)
3691         }
3692         ((*(*(struct {
3693                 Files []struct {
3694                         Name       string
3695                         Base64SHA1 string
3696                 }
3697                 URL string
3698         }))(obj)).Files) = make([]struct {
3699                 Name       string
3700                 Base64SHA1 string
3701         }, local111)
3702         for local112 := range (*(*(struct {
3703                 Files []struct {
3704                         Name       string
3705                         Base64SHA1 string
3706                 }
3707                 URL string
3708         }))(obj)).Files {
3709                 var local113 []uint8
3710                 var local114 uint16
3711                 {
3712                         p := &local114
3713                         *p = read16(r)
3714                 }
3715                 (local113) = make([]uint8, local114)
3716                 {
3717                         _, err := io.ReadFull(r, (local113)[:])
3718                         chk(err)
3719                 }
3720                 ((((*(*(struct {
3721                         Files []struct {
3722                                 Name       string
3723                                 Base64SHA1 string
3724                         }
3725                         URL string
3726                 }))(obj)).Files)[local112]).Name) = string(local113)
3727                 var local115 []uint8
3728                 var local116 uint16
3729                 {
3730                         p := &local116
3731                         *p = read16(r)
3732                 }
3733                 (local115) = make([]uint8, local116)
3734                 {
3735                         _, err := io.ReadFull(r, (local115)[:])
3736                         chk(err)
3737                 }
3738                 ((((*(*(struct {
3739                         Files []struct {
3740                                 Name       string
3741                                 Base64SHA1 string
3742                         }
3743                         URL string
3744                 }))(obj)).Files)[local112]).Base64SHA1) = string(local115)
3745         }
3746         var local117 []uint8
3747         var local118 uint16
3748         {
3749                 p := &local118
3750                 *p = read16(r)
3751         }
3752         (local117) = make([]uint8, local118)
3753         {
3754                 _, err := io.ReadFull(r, (local117)[:])
3755                 chk(err)
3756         }
3757         ((*(*(struct {
3758                 Files []struct {
3759                         Name       string
3760                         Base64SHA1 string
3761                 }
3762                 URL string
3763         }))(obj)).URL) = string(local117)
3764 }
3765
3766 func (obj *ToCltItemDefs) serialize(w io.Writer) {
3767         {
3768                 ow := w
3769                 w := new(bytes.Buffer)
3770                 {
3771                         w := zlib.NewWriter(w)
3772                         {
3773                                 local119 := uint8(0)
3774                                 {
3775                                         x := local119
3776                                         write8(w, uint8(x))
3777                                 }
3778                         }
3779                         if len(((*(*(struct {
3780                                 Defs    []ItemDef
3781                                 Aliases []struct{ Alias, Orig string }
3782                         }))(obj)).Defs)) > math.MaxUint16 {
3783                                 chk(ErrTooLong)
3784                         }
3785                         {
3786                                 x := uint16(len(((*(*(struct {
3787                                         Defs    []ItemDef
3788                                         Aliases []struct{ Alias, Orig string }
3789                                 }))(obj)).Defs)))
3790                                 write16(w, uint16(x))
3791                         }
3792                         for local120 := range (*(*(struct {
3793                                 Defs    []ItemDef
3794                                 Aliases []struct{ Alias, Orig string }
3795                         }))(obj)).Defs {
3796                                 if err := pcall(func() {
3797                                         (((*(*(struct {
3798                                                 Defs    []ItemDef
3799                                                 Aliases []struct{ Alias, Orig string }
3800                                         }))(obj)).Defs)[local120]).serialize(w)
3801                                 }); err != nil {
3802                                         if err == io.EOF {
3803                                                 chk(io.EOF)
3804                                         }
3805                                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
3806                                 }
3807                         }
3808                         if len(((*(*(struct {
3809                                 Defs    []ItemDef
3810                                 Aliases []struct{ Alias, Orig string }
3811                         }))(obj)).Aliases)) > math.MaxUint16 {
3812                                 chk(ErrTooLong)
3813                         }
3814                         {
3815                                 x := uint16(len(((*(*(struct {
3816                                         Defs    []ItemDef
3817                                         Aliases []struct{ Alias, Orig string }
3818                                 }))(obj)).Aliases)))
3819                                 write16(w, uint16(x))
3820                         }
3821                         for local121 := range (*(*(struct {
3822                                 Defs    []ItemDef
3823                                 Aliases []struct{ Alias, Orig string }
3824                         }))(obj)).Aliases {
3825                                 if len(([]byte((((*(*(struct {
3826                                         Defs    []ItemDef
3827                                         Aliases []struct{ Alias, Orig string }
3828                                 }))(obj)).Aliases)[local121]).Alias))) > math.MaxUint16 {
3829                                         chk(ErrTooLong)
3830                                 }
3831                                 {
3832                                         x := uint16(len(([]byte((((*(*(struct {
3833                                                 Defs    []ItemDef
3834                                                 Aliases []struct{ Alias, Orig string }
3835                                         }))(obj)).Aliases)[local121]).Alias))))
3836                                         write16(w, uint16(x))
3837                                 }
3838                                 {
3839                                         _, err := w.Write(([]byte((((*(*(struct {
3840                                                 Defs    []ItemDef
3841                                                 Aliases []struct{ Alias, Orig string }
3842                                         }))(obj)).Aliases)[local121]).Alias))[:])
3843                                         chk(err)
3844                                 }
3845                                 if len(([]byte((((*(*(struct {
3846                                         Defs    []ItemDef
3847                                         Aliases []struct{ Alias, Orig string }
3848                                 }))(obj)).Aliases)[local121]).Orig))) > math.MaxUint16 {
3849                                         chk(ErrTooLong)
3850                                 }
3851                                 {
3852                                         x := uint16(len(([]byte((((*(*(struct {
3853                                                 Defs    []ItemDef
3854                                                 Aliases []struct{ Alias, Orig string }
3855                                         }))(obj)).Aliases)[local121]).Orig))))
3856                                         write16(w, uint16(x))
3857                                 }
3858                                 {
3859                                         _, err := w.Write(([]byte((((*(*(struct {
3860                                                 Defs    []ItemDef
3861                                                 Aliases []struct{ Alias, Orig string }
3862                                         }))(obj)).Aliases)[local121]).Orig))[:])
3863                                         chk(err)
3864                                 }
3865                         }
3866                         chk(w.Close())
3867                 }
3868                 {
3869                         buf := w
3870                         w := ow
3871                         if len((buf.Bytes())) > math.MaxUint32 {
3872                                 chk(ErrTooLong)
3873                         }
3874                         {
3875                                 x := uint32(len((buf.Bytes())))
3876                                 write32(w, uint32(x))
3877                         }
3878                         {
3879                                 _, err := w.Write((buf.Bytes())[:])
3880                                 chk(err)
3881                         }
3882                 }
3883         }
3884 }
3885
3886 func (obj *ToCltItemDefs) deserialize(r io.Reader) {
3887         {
3888                 var n uint32
3889                 {
3890                         p := &n
3891                         *p = read32(r)
3892                 }
3893                 r := &io.LimitedReader{R: r, N: int64(n)}
3894                 {
3895                         r, err := zlib.NewReader(byteReader{r})
3896                         chk(err)
3897                         {
3898                                 var local122 uint8
3899                                 local123 := uint8(0)
3900                                 {
3901                                         p := &local122
3902                                         *p = read8(r)
3903                                 }
3904                                 if local122 != local123 {
3905                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local122))
3906                                 }
3907                         }
3908                         var local124 uint16
3909                         {
3910                                 p := &local124
3911                                 *p = read16(r)
3912                         }
3913                         ((*(*(struct {
3914                                 Defs    []ItemDef
3915                                 Aliases []struct{ Alias, Orig string }
3916                         }))(obj)).Defs) = make([]ItemDef, local124)
3917                         for local125 := range (*(*(struct {
3918                                 Defs    []ItemDef
3919                                 Aliases []struct{ Alias, Orig string }
3920                         }))(obj)).Defs {
3921                                 if err := pcall(func() {
3922                                         (((*(*(struct {
3923                                                 Defs    []ItemDef
3924                                                 Aliases []struct{ Alias, Orig string }
3925                                         }))(obj)).Defs)[local125]).deserialize(r)
3926                                 }); err != nil {
3927                                         if err == io.EOF {
3928                                                 chk(io.EOF)
3929                                         }
3930                                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
3931                                 }
3932                         }
3933                         var local126 uint16
3934                         {
3935                                 p := &local126
3936                                 *p = read16(r)
3937                         }
3938                         ((*(*(struct {
3939                                 Defs    []ItemDef
3940                                 Aliases []struct{ Alias, Orig string }
3941                         }))(obj)).Aliases) = make([]struct {
3942                                 Alias string
3943                                 Orig  string
3944                         }, local126)
3945                         for local127 := range (*(*(struct {
3946                                 Defs    []ItemDef
3947                                 Aliases []struct{ Alias, Orig string }
3948                         }))(obj)).Aliases {
3949                                 var local128 []uint8
3950                                 var local129 uint16
3951                                 {
3952                                         p := &local129
3953                                         *p = read16(r)
3954                                 }
3955                                 (local128) = make([]uint8, local129)
3956                                 {
3957                                         _, err := io.ReadFull(r, (local128)[:])
3958                                         chk(err)
3959                                 }
3960                                 ((((*(*(struct {
3961                                         Defs    []ItemDef
3962                                         Aliases []struct{ Alias, Orig string }
3963                                 }))(obj)).Aliases)[local127]).Alias) = string(local128)
3964                                 var local130 []uint8
3965                                 var local131 uint16
3966                                 {
3967                                         p := &local131
3968                                         *p = read16(r)
3969                                 }
3970                                 (local130) = make([]uint8, local131)
3971                                 {
3972                                         _, err := io.ReadFull(r, (local130)[:])
3973                                         chk(err)
3974                                 }
3975                                 ((((*(*(struct {
3976                                         Defs    []ItemDef
3977                                         Aliases []struct{ Alias, Orig string }
3978                                 }))(obj)).Aliases)[local127]).Orig) = string(local130)
3979                         }
3980                         chk(r.Close())
3981                 }
3982                 if r.N > 0 {
3983                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3984                 }
3985         }
3986 }
3987
3988 func (obj *ToCltPlaySound) serialize(w io.Writer) {
3989         if err := pcall(func() {
3990                 ((*(*(struct {
3991                         ID      SoundID
3992                         Name    string
3993                         Gain    float32
3994                         SrcType SoundSrcType
3995                         Pos
3996                         SrcAOID   AOID
3997                         Loop      bool
3998                         Fade      float32
3999                         Pitch     float32
4000                         Ephemeral bool
4001                 }))(obj)).ID).serialize(w)
4002         }); err != nil {
4003                 if err == io.EOF {
4004                         chk(io.EOF)
4005                 }
4006                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4007         }
4008         if len(([]byte((*(*(struct {
4009                 ID      SoundID
4010                 Name    string
4011                 Gain    float32
4012                 SrcType SoundSrcType
4013                 Pos
4014                 SrcAOID   AOID
4015                 Loop      bool
4016                 Fade      float32
4017                 Pitch     float32
4018                 Ephemeral bool
4019         }))(obj)).Name))) > math.MaxUint16 {
4020                 chk(ErrTooLong)
4021         }
4022         {
4023                 x := uint16(len(([]byte((*(*(struct {
4024                         ID      SoundID
4025                         Name    string
4026                         Gain    float32
4027                         SrcType SoundSrcType
4028                         Pos
4029                         SrcAOID   AOID
4030                         Loop      bool
4031                         Fade      float32
4032                         Pitch     float32
4033                         Ephemeral bool
4034                 }))(obj)).Name))))
4035                 write16(w, uint16(x))
4036         }
4037         {
4038                 _, err := w.Write(([]byte((*(*(struct {
4039                         ID      SoundID
4040                         Name    string
4041                         Gain    float32
4042                         SrcType SoundSrcType
4043                         Pos
4044                         SrcAOID   AOID
4045                         Loop      bool
4046                         Fade      float32
4047                         Pitch     float32
4048                         Ephemeral bool
4049                 }))(obj)).Name))[:])
4050                 chk(err)
4051         }
4052         {
4053                 x := (*(*(struct {
4054                         ID      SoundID
4055                         Name    string
4056                         Gain    float32
4057                         SrcType SoundSrcType
4058                         Pos
4059                         SrcAOID   AOID
4060                         Loop      bool
4061                         Fade      float32
4062                         Pitch     float32
4063                         Ephemeral bool
4064                 }))(obj)).Gain
4065                 write32(w, math.Float32bits(x))
4066         }
4067         if err := pcall(func() {
4068                 ((*(*(struct {
4069                         ID      SoundID
4070                         Name    string
4071                         Gain    float32
4072                         SrcType SoundSrcType
4073                         Pos
4074                         SrcAOID   AOID
4075                         Loop      bool
4076                         Fade      float32
4077                         Pitch     float32
4078                         Ephemeral bool
4079                 }))(obj)).SrcType).serialize(w)
4080         }); err != nil {
4081                 if err == io.EOF {
4082                         chk(io.EOF)
4083                 }
4084                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundSrcType", err))
4085         }
4086         if err := pcall(func() {
4087                 ((*(*(struct {
4088                         ID      SoundID
4089                         Name    string
4090                         Gain    float32
4091                         SrcType SoundSrcType
4092                         Pos
4093                         SrcAOID   AOID
4094                         Loop      bool
4095                         Fade      float32
4096                         Pitch     float32
4097                         Ephemeral bool
4098                 }))(obj)).Pos).serialize(w)
4099         }); err != nil {
4100                 if err == io.EOF {
4101                         chk(io.EOF)
4102                 }
4103                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
4104         }
4105         if err := pcall(func() {
4106                 ((*(*(struct {
4107                         ID      SoundID
4108                         Name    string
4109                         Gain    float32
4110                         SrcType SoundSrcType
4111                         Pos
4112                         SrcAOID   AOID
4113                         Loop      bool
4114                         Fade      float32
4115                         Pitch     float32
4116                         Ephemeral bool
4117                 }))(obj)).SrcAOID).serialize(w)
4118         }); err != nil {
4119                 if err == io.EOF {
4120                         chk(io.EOF)
4121                 }
4122                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
4123         }
4124         {
4125                 x := (*(*(struct {
4126                         ID      SoundID
4127                         Name    string
4128                         Gain    float32
4129                         SrcType SoundSrcType
4130                         Pos
4131                         SrcAOID   AOID
4132                         Loop      bool
4133                         Fade      float32
4134                         Pitch     float32
4135                         Ephemeral bool
4136                 }))(obj)).Loop
4137                 if x {
4138                         write8(w, 1)
4139                 } else {
4140                         write8(w, 0)
4141                 }
4142
4143         }
4144         {
4145                 x := (*(*(struct {
4146                         ID      SoundID
4147                         Name    string
4148                         Gain    float32
4149                         SrcType SoundSrcType
4150                         Pos
4151                         SrcAOID   AOID
4152                         Loop      bool
4153                         Fade      float32
4154                         Pitch     float32
4155                         Ephemeral bool
4156                 }))(obj)).Fade
4157                 write32(w, math.Float32bits(x))
4158         }
4159         {
4160                 x := (*(*(struct {
4161                         ID      SoundID
4162                         Name    string
4163                         Gain    float32
4164                         SrcType SoundSrcType
4165                         Pos
4166                         SrcAOID   AOID
4167                         Loop      bool
4168                         Fade      float32
4169                         Pitch     float32
4170                         Ephemeral bool
4171                 }))(obj)).Pitch
4172                 write32(w, math.Float32bits(x))
4173         }
4174         {
4175                 x := (*(*(struct {
4176                         ID      SoundID
4177                         Name    string
4178                         Gain    float32
4179                         SrcType SoundSrcType
4180                         Pos
4181                         SrcAOID   AOID
4182                         Loop      bool
4183                         Fade      float32
4184                         Pitch     float32
4185                         Ephemeral bool
4186                 }))(obj)).Ephemeral
4187                 if x {
4188                         write8(w, 1)
4189                 } else {
4190                         write8(w, 0)
4191                 }
4192
4193         }
4194 }
4195
4196 func (obj *ToCltPlaySound) deserialize(r io.Reader) {
4197         if err := pcall(func() {
4198                 ((*(*(struct {
4199                         ID      SoundID
4200                         Name    string
4201                         Gain    float32
4202                         SrcType SoundSrcType
4203                         Pos
4204                         SrcAOID   AOID
4205                         Loop      bool
4206                         Fade      float32
4207                         Pitch     float32
4208                         Ephemeral bool
4209                 }))(obj)).ID).deserialize(r)
4210         }); err != nil {
4211                 if err == io.EOF {
4212                         chk(io.EOF)
4213                 }
4214                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4215         }
4216         var local132 []uint8
4217         var local133 uint16
4218         {
4219                 p := &local133
4220                 *p = read16(r)
4221         }
4222         (local132) = make([]uint8, local133)
4223         {
4224                 _, err := io.ReadFull(r, (local132)[:])
4225                 chk(err)
4226         }
4227         ((*(*(struct {
4228                 ID      SoundID
4229                 Name    string
4230                 Gain    float32
4231                 SrcType SoundSrcType
4232                 Pos
4233                 SrcAOID   AOID
4234                 Loop      bool
4235                 Fade      float32
4236                 Pitch     float32
4237                 Ephemeral bool
4238         }))(obj)).Name) = string(local132)
4239         {
4240                 p := &(*(*(struct {
4241                         ID      SoundID
4242                         Name    string
4243                         Gain    float32
4244                         SrcType SoundSrcType
4245                         Pos
4246                         SrcAOID   AOID
4247                         Loop      bool
4248                         Fade      float32
4249                         Pitch     float32
4250                         Ephemeral bool
4251                 }))(obj)).Gain
4252                 *p = math.Float32frombits(read32(r))
4253         }
4254         if err := pcall(func() {
4255                 ((*(*(struct {
4256                         ID      SoundID
4257                         Name    string
4258                         Gain    float32
4259                         SrcType SoundSrcType
4260                         Pos
4261                         SrcAOID   AOID
4262                         Loop      bool
4263                         Fade      float32
4264                         Pitch     float32
4265                         Ephemeral bool
4266                 }))(obj)).SrcType).deserialize(r)
4267         }); err != nil {
4268                 if err == io.EOF {
4269                         chk(io.EOF)
4270                 }
4271                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundSrcType", err))
4272         }
4273         if err := pcall(func() {
4274                 ((*(*(struct {
4275                         ID      SoundID
4276                         Name    string
4277                         Gain    float32
4278                         SrcType SoundSrcType
4279                         Pos
4280                         SrcAOID   AOID
4281                         Loop      bool
4282                         Fade      float32
4283                         Pitch     float32
4284                         Ephemeral bool
4285                 }))(obj)).Pos).deserialize(r)
4286         }); err != nil {
4287                 if err == io.EOF {
4288                         chk(io.EOF)
4289                 }
4290                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
4291         }
4292         if err := pcall(func() {
4293                 ((*(*(struct {
4294                         ID      SoundID
4295                         Name    string
4296                         Gain    float32
4297                         SrcType SoundSrcType
4298                         Pos
4299                         SrcAOID   AOID
4300                         Loop      bool
4301                         Fade      float32
4302                         Pitch     float32
4303                         Ephemeral bool
4304                 }))(obj)).SrcAOID).deserialize(r)
4305         }); err != nil {
4306                 if err == io.EOF {
4307                         chk(io.EOF)
4308                 }
4309                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
4310         }
4311         {
4312                 p := &(*(*(struct {
4313                         ID      SoundID
4314                         Name    string
4315                         Gain    float32
4316                         SrcType SoundSrcType
4317                         Pos
4318                         SrcAOID   AOID
4319                         Loop      bool
4320                         Fade      float32
4321                         Pitch     float32
4322                         Ephemeral bool
4323                 }))(obj)).Loop
4324                 switch n := read8(r); n {
4325                 case 0:
4326                         *p = false
4327                 case 1:
4328                         *p = true
4329                 default:
4330                         chk(fmt.Errorf("invalid bool: %d", n))
4331                 }
4332
4333         }
4334         {
4335                 p := &(*(*(struct {
4336                         ID      SoundID
4337                         Name    string
4338                         Gain    float32
4339                         SrcType SoundSrcType
4340                         Pos
4341                         SrcAOID   AOID
4342                         Loop      bool
4343                         Fade      float32
4344                         Pitch     float32
4345                         Ephemeral bool
4346                 }))(obj)).Fade
4347                 *p = math.Float32frombits(read32(r))
4348         }
4349         {
4350                 p := &(*(*(struct {
4351                         ID      SoundID
4352                         Name    string
4353                         Gain    float32
4354                         SrcType SoundSrcType
4355                         Pos
4356                         SrcAOID   AOID
4357                         Loop      bool
4358                         Fade      float32
4359                         Pitch     float32
4360                         Ephemeral bool
4361                 }))(obj)).Pitch
4362                 *p = math.Float32frombits(read32(r))
4363         }
4364         {
4365                 p := &(*(*(struct {
4366                         ID      SoundID
4367                         Name    string
4368                         Gain    float32
4369                         SrcType SoundSrcType
4370                         Pos
4371                         SrcAOID   AOID
4372                         Loop      bool
4373                         Fade      float32
4374                         Pitch     float32
4375                         Ephemeral bool
4376                 }))(obj)).Ephemeral
4377                 switch n := read8(r); n {
4378                 case 0:
4379                         *p = false
4380                 case 1:
4381                         *p = true
4382                 default:
4383                         chk(fmt.Errorf("invalid bool: %d", n))
4384                 }
4385
4386         }
4387 }
4388
4389 func (obj *ToCltStopSound) serialize(w io.Writer) {
4390         if err := pcall(func() {
4391                 ((*(*(struct {
4392                         ID SoundID
4393                 }))(obj)).ID).serialize(w)
4394         }); err != nil {
4395                 if err == io.EOF {
4396                         chk(io.EOF)
4397                 }
4398                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4399         }
4400 }
4401
4402 func (obj *ToCltStopSound) deserialize(r io.Reader) {
4403         if err := pcall(func() {
4404                 ((*(*(struct {
4405                         ID SoundID
4406                 }))(obj)).ID).deserialize(r)
4407         }); err != nil {
4408                 if err == io.EOF {
4409                         chk(io.EOF)
4410                 }
4411                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
4412         }
4413 }
4414
4415 func (obj *ToCltPrivs) serialize(w io.Writer) {
4416         if len(((*(*(struct {
4417                 Privs []string
4418         }))(obj)).Privs)) > math.MaxUint16 {
4419                 chk(ErrTooLong)
4420         }
4421         {
4422                 x := uint16(len(((*(*(struct {
4423                         Privs []string
4424                 }))(obj)).Privs)))
4425                 write16(w, uint16(x))
4426         }
4427         for local134 := range (*(*(struct {
4428                 Privs []string
4429         }))(obj)).Privs {
4430                 if len(([]byte(((*(*(struct {
4431                         Privs []string
4432                 }))(obj)).Privs)[local134]))) > math.MaxUint16 {
4433                         chk(ErrTooLong)
4434                 }
4435                 {
4436                         x := uint16(len(([]byte(((*(*(struct {
4437                                 Privs []string
4438                         }))(obj)).Privs)[local134]))))
4439                         write16(w, uint16(x))
4440                 }
4441                 {
4442                         _, err := w.Write(([]byte(((*(*(struct {
4443                                 Privs []string
4444                         }))(obj)).Privs)[local134]))[:])
4445                         chk(err)
4446                 }
4447         }
4448 }
4449
4450 func (obj *ToCltPrivs) deserialize(r io.Reader) {
4451         var local135 uint16
4452         {
4453                 p := &local135
4454                 *p = read16(r)
4455         }
4456         ((*(*(struct {
4457                 Privs []string
4458         }))(obj)).Privs) = make([]string, local135)
4459         for local136 := range (*(*(struct {
4460                 Privs []string
4461         }))(obj)).Privs {
4462                 var local137 []uint8
4463                 var local138 uint16
4464                 {
4465                         p := &local138
4466                         *p = read16(r)
4467                 }
4468                 (local137) = make([]uint8, local138)
4469                 {
4470                         _, err := io.ReadFull(r, (local137)[:])
4471                         chk(err)
4472                 }
4473                 (((*(*(struct {
4474                         Privs []string
4475                 }))(obj)).Privs)[local136]) = string(local137)
4476         }
4477 }
4478
4479 func (obj *ToCltInvFormspec) serialize(w io.Writer) {
4480         if len(([]byte((*(*(struct {
4481                 //mt:len32
4482                 Formspec string
4483         }))(obj)).Formspec))) > math.MaxUint32 {
4484                 chk(ErrTooLong)
4485         }
4486         {
4487                 x := uint32(len(([]byte((*(*(struct {
4488                         //mt:len32
4489                         Formspec string
4490                 }))(obj)).Formspec))))
4491                 write32(w, uint32(x))
4492         }
4493         {
4494                 _, err := w.Write(([]byte((*(*(struct {
4495                         //mt:len32
4496                         Formspec string
4497                 }))(obj)).Formspec))[:])
4498                 chk(err)
4499         }
4500 }
4501
4502 func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
4503         var local139 []uint8
4504         var local140 uint32
4505         {
4506                 p := &local140
4507                 *p = read32(r)
4508         }
4509         (local139) = make([]uint8, local140)
4510         {
4511                 _, err := io.ReadFull(r, (local139)[:])
4512                 chk(err)
4513         }
4514         ((*(*(struct {
4515                 //mt:len32
4516                 Formspec string
4517         }))(obj)).Formspec) = string(local139)
4518 }
4519
4520 func (obj *ToCltDetachedInv) serialize(w io.Writer) {
4521         if len(([]byte((*(*(struct {
4522                 Name string
4523                 Keep bool
4524                 Len  uint16 // deprecated
4525
4526                 //mt:raw
4527                 Inv string
4528         }))(obj)).Name))) > math.MaxUint16 {
4529                 chk(ErrTooLong)
4530         }
4531         {
4532                 x := uint16(len(([]byte((*(*(struct {
4533                         Name string
4534                         Keep bool
4535                         Len  uint16 // deprecated
4536
4537                         //mt:raw
4538                         Inv string
4539                 }))(obj)).Name))))
4540                 write16(w, uint16(x))
4541         }
4542         {
4543                 _, err := w.Write(([]byte((*(*(struct {
4544                         Name string
4545                         Keep bool
4546                         Len  uint16 // deprecated
4547
4548                         //mt:raw
4549                         Inv string
4550                 }))(obj)).Name))[:])
4551                 chk(err)
4552         }
4553         {
4554                 x := (*(*(struct {
4555                         Name string
4556                         Keep bool
4557                         Len  uint16 // deprecated
4558
4559                         //mt:raw
4560                         Inv string
4561                 }))(obj)).Keep
4562                 if x {
4563                         write8(w, 1)
4564                 } else {
4565                         write8(w, 0)
4566                 }
4567
4568         }
4569         {
4570                 x := (*(*(struct {
4571                         Name string
4572                         Keep bool
4573                         Len  uint16 // deprecated
4574
4575                         //mt:raw
4576                         Inv string
4577                 }))(obj)).Len
4578                 write16(w, uint16(x))
4579         }
4580         {
4581                 _, err := w.Write(([]byte((*(*(struct {
4582                         Name string
4583                         Keep bool
4584                         Len  uint16 // deprecated
4585
4586                         //mt:raw
4587                         Inv string
4588                 }))(obj)).Inv))[:])
4589                 chk(err)
4590         }
4591 }
4592
4593 func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
4594         var local141 []uint8
4595         var local142 uint16
4596         {
4597                 p := &local142
4598                 *p = read16(r)
4599         }
4600         (local141) = make([]uint8, local142)
4601         {
4602                 _, err := io.ReadFull(r, (local141)[:])
4603                 chk(err)
4604         }
4605         ((*(*(struct {
4606                 Name string
4607                 Keep bool
4608                 Len  uint16 // deprecated
4609
4610                 //mt:raw
4611                 Inv string
4612         }))(obj)).Name) = string(local141)
4613         {
4614                 p := &(*(*(struct {
4615                         Name string
4616                         Keep bool
4617                         Len  uint16 // deprecated
4618
4619                         //mt:raw
4620                         Inv string
4621                 }))(obj)).Keep
4622                 switch n := read8(r); n {
4623                 case 0:
4624                         *p = false
4625                 case 1:
4626                         *p = true
4627                 default:
4628                         chk(fmt.Errorf("invalid bool: %d", n))
4629                 }
4630
4631         }
4632         {
4633                 p := &(*(*(struct {
4634                         Name string
4635                         Keep bool
4636                         Len  uint16 // deprecated
4637
4638                         //mt:raw
4639                         Inv string
4640                 }))(obj)).Len
4641                 *p = read16(r)
4642         }
4643         var local143 []uint8
4644         {
4645                 var err error
4646                 (local143), err = io.ReadAll(r)
4647                 chk(err)
4648         }
4649         ((*(*(struct {
4650                 Name string
4651                 Keep bool
4652                 Len  uint16 // deprecated
4653
4654                 //mt:raw
4655                 Inv string
4656         }))(obj)).Inv) = string(local143)
4657 }
4658
4659 func (obj *ToCltShowFormspec) serialize(w io.Writer) {
4660         if len(([]byte((*(*(struct {
4661                 //mt:len32
4662                 Formspec string
4663
4664                 Formname string
4665         }))(obj)).Formspec))) > math.MaxUint32 {
4666                 chk(ErrTooLong)
4667         }
4668         {
4669                 x := uint32(len(([]byte((*(*(struct {
4670                         //mt:len32
4671                         Formspec string
4672
4673                         Formname string
4674                 }))(obj)).Formspec))))
4675                 write32(w, uint32(x))
4676         }
4677         {
4678                 _, err := w.Write(([]byte((*(*(struct {
4679                         //mt:len32
4680                         Formspec string
4681
4682                         Formname string
4683                 }))(obj)).Formspec))[:])
4684                 chk(err)
4685         }
4686         if len(([]byte((*(*(struct {
4687                 //mt:len32
4688                 Formspec string
4689
4690                 Formname string
4691         }))(obj)).Formname))) > math.MaxUint16 {
4692                 chk(ErrTooLong)
4693         }
4694         {
4695                 x := uint16(len(([]byte((*(*(struct {
4696                         //mt:len32
4697                         Formspec string
4698
4699                         Formname string
4700                 }))(obj)).Formname))))
4701                 write16(w, uint16(x))
4702         }
4703         {
4704                 _, err := w.Write(([]byte((*(*(struct {
4705                         //mt:len32
4706                         Formspec string
4707
4708                         Formname string
4709                 }))(obj)).Formname))[:])
4710                 chk(err)
4711         }
4712 }
4713
4714 func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
4715         var local144 []uint8
4716         var local145 uint32
4717         {
4718                 p := &local145
4719                 *p = read32(r)
4720         }
4721         (local144) = make([]uint8, local145)
4722         {
4723                 _, err := io.ReadFull(r, (local144)[:])
4724                 chk(err)
4725         }
4726         ((*(*(struct {
4727                 //mt:len32
4728                 Formspec string
4729
4730                 Formname string
4731         }))(obj)).Formspec) = string(local144)
4732         var local146 []uint8
4733         var local147 uint16
4734         {
4735                 p := &local147
4736                 *p = read16(r)
4737         }
4738         (local146) = make([]uint8, local147)
4739         {
4740                 _, err := io.ReadFull(r, (local146)[:])
4741                 chk(err)
4742         }
4743         ((*(*(struct {
4744                 //mt:len32
4745                 Formspec string
4746
4747                 Formname string
4748         }))(obj)).Formname) = string(local146)
4749 }
4750
4751 func (obj *ToCltMovement) serialize(w io.Writer) {
4752         {
4753                 x := (*(*(struct {
4754                         DefaultAccel, AirAccel, FastAccel,
4755                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4756                         Fluidity, Smoothing, Sink,
4757                         Gravity float32
4758                 }))(obj)).DefaultAccel
4759                 write32(w, math.Float32bits(x))
4760         }
4761         {
4762                 x := (*(*(struct {
4763                         DefaultAccel, AirAccel, FastAccel,
4764                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4765                         Fluidity, Smoothing, Sink,
4766                         Gravity float32
4767                 }))(obj)).AirAccel
4768                 write32(w, math.Float32bits(x))
4769         }
4770         {
4771                 x := (*(*(struct {
4772                         DefaultAccel, AirAccel, FastAccel,
4773                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4774                         Fluidity, Smoothing, Sink,
4775                         Gravity float32
4776                 }))(obj)).FastAccel
4777                 write32(w, math.Float32bits(x))
4778         }
4779         {
4780                 x := (*(*(struct {
4781                         DefaultAccel, AirAccel, FastAccel,
4782                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4783                         Fluidity, Smoothing, Sink,
4784                         Gravity float32
4785                 }))(obj)).WalkSpeed
4786                 write32(w, math.Float32bits(x))
4787         }
4788         {
4789                 x := (*(*(struct {
4790                         DefaultAccel, AirAccel, FastAccel,
4791                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4792                         Fluidity, Smoothing, Sink,
4793                         Gravity float32
4794                 }))(obj)).CrouchSpeed
4795                 write32(w, math.Float32bits(x))
4796         }
4797         {
4798                 x := (*(*(struct {
4799                         DefaultAccel, AirAccel, FastAccel,
4800                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4801                         Fluidity, Smoothing, Sink,
4802                         Gravity float32
4803                 }))(obj)).FastSpeed
4804                 write32(w, math.Float32bits(x))
4805         }
4806         {
4807                 x := (*(*(struct {
4808                         DefaultAccel, AirAccel, FastAccel,
4809                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4810                         Fluidity, Smoothing, Sink,
4811                         Gravity float32
4812                 }))(obj)).ClimbSpeed
4813                 write32(w, math.Float32bits(x))
4814         }
4815         {
4816                 x := (*(*(struct {
4817                         DefaultAccel, AirAccel, FastAccel,
4818                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4819                         Fluidity, Smoothing, Sink,
4820                         Gravity float32
4821                 }))(obj)).JumpSpeed
4822                 write32(w, math.Float32bits(x))
4823         }
4824         {
4825                 x := (*(*(struct {
4826                         DefaultAccel, AirAccel, FastAccel,
4827                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4828                         Fluidity, Smoothing, Sink,
4829                         Gravity float32
4830                 }))(obj)).Fluidity
4831                 write32(w, math.Float32bits(x))
4832         }
4833         {
4834                 x := (*(*(struct {
4835                         DefaultAccel, AirAccel, FastAccel,
4836                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4837                         Fluidity, Smoothing, Sink,
4838                         Gravity float32
4839                 }))(obj)).Smoothing
4840                 write32(w, math.Float32bits(x))
4841         }
4842         {
4843                 x := (*(*(struct {
4844                         DefaultAccel, AirAccel, FastAccel,
4845                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4846                         Fluidity, Smoothing, Sink,
4847                         Gravity float32
4848                 }))(obj)).Sink
4849                 write32(w, math.Float32bits(x))
4850         }
4851         {
4852                 x := (*(*(struct {
4853                         DefaultAccel, AirAccel, FastAccel,
4854                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4855                         Fluidity, Smoothing, Sink,
4856                         Gravity float32
4857                 }))(obj)).Gravity
4858                 write32(w, math.Float32bits(x))
4859         }
4860 }
4861
4862 func (obj *ToCltMovement) deserialize(r io.Reader) {
4863         {
4864                 p := &(*(*(struct {
4865                         DefaultAccel, AirAccel, FastAccel,
4866                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4867                         Fluidity, Smoothing, Sink,
4868                         Gravity float32
4869                 }))(obj)).DefaultAccel
4870                 *p = math.Float32frombits(read32(r))
4871         }
4872         {
4873                 p := &(*(*(struct {
4874                         DefaultAccel, AirAccel, FastAccel,
4875                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4876                         Fluidity, Smoothing, Sink,
4877                         Gravity float32
4878                 }))(obj)).AirAccel
4879                 *p = math.Float32frombits(read32(r))
4880         }
4881         {
4882                 p := &(*(*(struct {
4883                         DefaultAccel, AirAccel, FastAccel,
4884                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4885                         Fluidity, Smoothing, Sink,
4886                         Gravity float32
4887                 }))(obj)).FastAccel
4888                 *p = math.Float32frombits(read32(r))
4889         }
4890         {
4891                 p := &(*(*(struct {
4892                         DefaultAccel, AirAccel, FastAccel,
4893                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4894                         Fluidity, Smoothing, Sink,
4895                         Gravity float32
4896                 }))(obj)).WalkSpeed
4897                 *p = math.Float32frombits(read32(r))
4898         }
4899         {
4900                 p := &(*(*(struct {
4901                         DefaultAccel, AirAccel, FastAccel,
4902                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4903                         Fluidity, Smoothing, Sink,
4904                         Gravity float32
4905                 }))(obj)).CrouchSpeed
4906                 *p = math.Float32frombits(read32(r))
4907         }
4908         {
4909                 p := &(*(*(struct {
4910                         DefaultAccel, AirAccel, FastAccel,
4911                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4912                         Fluidity, Smoothing, Sink,
4913                         Gravity float32
4914                 }))(obj)).FastSpeed
4915                 *p = math.Float32frombits(read32(r))
4916         }
4917         {
4918                 p := &(*(*(struct {
4919                         DefaultAccel, AirAccel, FastAccel,
4920                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4921                         Fluidity, Smoothing, Sink,
4922                         Gravity float32
4923                 }))(obj)).ClimbSpeed
4924                 *p = math.Float32frombits(read32(r))
4925         }
4926         {
4927                 p := &(*(*(struct {
4928                         DefaultAccel, AirAccel, FastAccel,
4929                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4930                         Fluidity, Smoothing, Sink,
4931                         Gravity float32
4932                 }))(obj)).JumpSpeed
4933                 *p = math.Float32frombits(read32(r))
4934         }
4935         {
4936                 p := &(*(*(struct {
4937                         DefaultAccel, AirAccel, FastAccel,
4938                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4939                         Fluidity, Smoothing, Sink,
4940                         Gravity float32
4941                 }))(obj)).Fluidity
4942                 *p = math.Float32frombits(read32(r))
4943         }
4944         {
4945                 p := &(*(*(struct {
4946                         DefaultAccel, AirAccel, FastAccel,
4947                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4948                         Fluidity, Smoothing, Sink,
4949                         Gravity float32
4950                 }))(obj)).Smoothing
4951                 *p = math.Float32frombits(read32(r))
4952         }
4953         {
4954                 p := &(*(*(struct {
4955                         DefaultAccel, AirAccel, FastAccel,
4956                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4957                         Fluidity, Smoothing, Sink,
4958                         Gravity float32
4959                 }))(obj)).Sink
4960                 *p = math.Float32frombits(read32(r))
4961         }
4962         {
4963                 p := &(*(*(struct {
4964                         DefaultAccel, AirAccel, FastAccel,
4965                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4966                         Fluidity, Smoothing, Sink,
4967                         Gravity float32
4968                 }))(obj)).Gravity
4969                 *p = math.Float32frombits(read32(r))
4970         }
4971 }
4972
4973 func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
4974         for local148 := range (*(*(struct {
4975                 Pos, Vel, Acc  [3]float32
4976                 ExpirationTime float32 // in seconds.
4977                 Size           float32
4978                 Collide        bool
4979
4980                 //mt:len32
4981                 Texture
4982
4983                 Vertical    bool
4984                 CollisionRm bool
4985                 AnimParams  TileAnim
4986                 Glow        uint8
4987                 AOCollision bool
4988                 NodeParam0  Content
4989                 NodeParam2  uint8
4990                 NodeTile    uint8
4991         }))(obj)).Pos {
4992                 {
4993                         x := ((*(*(struct {
4994                                 Pos, Vel, Acc  [3]float32
4995                                 ExpirationTime float32 // in seconds.
4996                                 Size           float32
4997                                 Collide        bool
4998
4999                                 //mt:len32
5000                                 Texture
5001
5002                                 Vertical    bool
5003                                 CollisionRm bool
5004                                 AnimParams  TileAnim
5005                                 Glow        uint8
5006                                 AOCollision bool
5007                                 NodeParam0  Content
5008                                 NodeParam2  uint8
5009                                 NodeTile    uint8
5010                         }))(obj)).Pos)[local148]
5011                         write32(w, math.Float32bits(x))
5012                 }
5013         }
5014         for local149 := range (*(*(struct {
5015                 Pos, Vel, Acc  [3]float32
5016                 ExpirationTime float32 // in seconds.
5017                 Size           float32
5018                 Collide        bool
5019
5020                 //mt:len32
5021                 Texture
5022
5023                 Vertical    bool
5024                 CollisionRm bool
5025                 AnimParams  TileAnim
5026                 Glow        uint8
5027                 AOCollision bool
5028                 NodeParam0  Content
5029                 NodeParam2  uint8
5030                 NodeTile    uint8
5031         }))(obj)).Vel {
5032                 {
5033                         x := ((*(*(struct {
5034                                 Pos, Vel, Acc  [3]float32
5035                                 ExpirationTime float32 // in seconds.
5036                                 Size           float32
5037                                 Collide        bool
5038
5039                                 //mt:len32
5040                                 Texture
5041
5042                                 Vertical    bool
5043                                 CollisionRm bool
5044                                 AnimParams  TileAnim
5045                                 Glow        uint8
5046                                 AOCollision bool
5047                                 NodeParam0  Content
5048                                 NodeParam2  uint8
5049                                 NodeTile    uint8
5050                         }))(obj)).Vel)[local149]
5051                         write32(w, math.Float32bits(x))
5052                 }
5053         }
5054         for local150 := range (*(*(struct {
5055                 Pos, Vel, Acc  [3]float32
5056                 ExpirationTime float32 // in seconds.
5057                 Size           float32
5058                 Collide        bool
5059
5060                 //mt:len32
5061                 Texture
5062
5063                 Vertical    bool
5064                 CollisionRm bool
5065                 AnimParams  TileAnim
5066                 Glow        uint8
5067                 AOCollision bool
5068                 NodeParam0  Content
5069                 NodeParam2  uint8
5070                 NodeTile    uint8
5071         }))(obj)).Acc {
5072                 {
5073                         x := ((*(*(struct {
5074                                 Pos, Vel, Acc  [3]float32
5075                                 ExpirationTime float32 // in seconds.
5076                                 Size           float32
5077                                 Collide        bool
5078
5079                                 //mt:len32
5080                                 Texture
5081
5082                                 Vertical    bool
5083                                 CollisionRm bool
5084                                 AnimParams  TileAnim
5085                                 Glow        uint8
5086                                 AOCollision bool
5087                                 NodeParam0  Content
5088                                 NodeParam2  uint8
5089                                 NodeTile    uint8
5090                         }))(obj)).Acc)[local150]
5091                         write32(w, math.Float32bits(x))
5092                 }
5093         }
5094         {
5095                 x := (*(*(struct {
5096                         Pos, Vel, Acc  [3]float32
5097                         ExpirationTime float32 // in seconds.
5098                         Size           float32
5099                         Collide        bool
5100
5101                         //mt:len32
5102                         Texture
5103
5104                         Vertical    bool
5105                         CollisionRm bool
5106                         AnimParams  TileAnim
5107                         Glow        uint8
5108                         AOCollision bool
5109                         NodeParam0  Content
5110                         NodeParam2  uint8
5111                         NodeTile    uint8
5112                 }))(obj)).ExpirationTime
5113                 write32(w, math.Float32bits(x))
5114         }
5115         {
5116                 x := (*(*(struct {
5117                         Pos, Vel, Acc  [3]float32
5118                         ExpirationTime float32 // in seconds.
5119                         Size           float32
5120                         Collide        bool
5121
5122                         //mt:len32
5123                         Texture
5124
5125                         Vertical    bool
5126                         CollisionRm bool
5127                         AnimParams  TileAnim
5128                         Glow        uint8
5129                         AOCollision bool
5130                         NodeParam0  Content
5131                         NodeParam2  uint8
5132                         NodeTile    uint8
5133                 }))(obj)).Size
5134                 write32(w, math.Float32bits(x))
5135         }
5136         {
5137                 x := (*(*(struct {
5138                         Pos, Vel, Acc  [3]float32
5139                         ExpirationTime float32 // in seconds.
5140                         Size           float32
5141                         Collide        bool
5142
5143                         //mt:len32
5144                         Texture
5145
5146                         Vertical    bool
5147                         CollisionRm bool
5148                         AnimParams  TileAnim
5149                         Glow        uint8
5150                         AOCollision bool
5151                         NodeParam0  Content
5152                         NodeParam2  uint8
5153                         NodeTile    uint8
5154                 }))(obj)).Collide
5155                 if x {
5156                         write8(w, 1)
5157                 } else {
5158                         write8(w, 0)
5159                 }
5160
5161         }
5162         if len(([]byte(*(*string)(&((*(*(struct {
5163                 Pos, Vel, Acc  [3]float32
5164                 ExpirationTime float32 // in seconds.
5165                 Size           float32
5166                 Collide        bool
5167
5168                 //mt:len32
5169                 Texture
5170
5171                 Vertical    bool
5172                 CollisionRm bool
5173                 AnimParams  TileAnim
5174                 Glow        uint8
5175                 AOCollision bool
5176                 NodeParam0  Content
5177                 NodeParam2  uint8
5178                 NodeTile    uint8
5179         }))(obj)).Texture))))) > math.MaxUint32 {
5180                 chk(ErrTooLong)
5181         }
5182         {
5183                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5184                         Pos, Vel, Acc  [3]float32
5185                         ExpirationTime float32 // in seconds.
5186                         Size           float32
5187                         Collide        bool
5188
5189                         //mt:len32
5190                         Texture
5191
5192                         Vertical    bool
5193                         CollisionRm bool
5194                         AnimParams  TileAnim
5195                         Glow        uint8
5196                         AOCollision bool
5197                         NodeParam0  Content
5198                         NodeParam2  uint8
5199                         NodeTile    uint8
5200                 }))(obj)).Texture))))))
5201                 write32(w, uint32(x))
5202         }
5203         {
5204                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5205                         Pos, Vel, Acc  [3]float32
5206                         ExpirationTime float32 // in seconds.
5207                         Size           float32
5208                         Collide        bool
5209
5210                         //mt:len32
5211                         Texture
5212
5213                         Vertical    bool
5214                         CollisionRm bool
5215                         AnimParams  TileAnim
5216                         Glow        uint8
5217                         AOCollision bool
5218                         NodeParam0  Content
5219                         NodeParam2  uint8
5220                         NodeTile    uint8
5221                 }))(obj)).Texture))))[:])
5222                 chk(err)
5223         }
5224         {
5225                 x := (*(*(struct {
5226                         Pos, Vel, Acc  [3]float32
5227                         ExpirationTime float32 // in seconds.
5228                         Size           float32
5229                         Collide        bool
5230
5231                         //mt:len32
5232                         Texture
5233
5234                         Vertical    bool
5235                         CollisionRm bool
5236                         AnimParams  TileAnim
5237                         Glow        uint8
5238                         AOCollision bool
5239                         NodeParam0  Content
5240                         NodeParam2  uint8
5241                         NodeTile    uint8
5242                 }))(obj)).Vertical
5243                 if x {
5244                         write8(w, 1)
5245                 } else {
5246                         write8(w, 0)
5247                 }
5248
5249         }
5250         {
5251                 x := (*(*(struct {
5252                         Pos, Vel, Acc  [3]float32
5253                         ExpirationTime float32 // in seconds.
5254                         Size           float32
5255                         Collide        bool
5256
5257                         //mt:len32
5258                         Texture
5259
5260                         Vertical    bool
5261                         CollisionRm bool
5262                         AnimParams  TileAnim
5263                         Glow        uint8
5264                         AOCollision bool
5265                         NodeParam0  Content
5266                         NodeParam2  uint8
5267                         NodeTile    uint8
5268                 }))(obj)).CollisionRm
5269                 if x {
5270                         write8(w, 1)
5271                 } else {
5272                         write8(w, 0)
5273                 }
5274
5275         }
5276         if err := pcall(func() {
5277                 ((*(*(struct {
5278                         Pos, Vel, Acc  [3]float32
5279                         ExpirationTime float32 // in seconds.
5280                         Size           float32
5281                         Collide        bool
5282
5283                         //mt:len32
5284                         Texture
5285
5286                         Vertical    bool
5287                         CollisionRm bool
5288                         AnimParams  TileAnim
5289                         Glow        uint8
5290                         AOCollision bool
5291                         NodeParam0  Content
5292                         NodeParam2  uint8
5293                         NodeTile    uint8
5294                 }))(obj)).AnimParams).serialize(w)
5295         }); err != nil {
5296                 if err == io.EOF {
5297                         chk(io.EOF)
5298                 }
5299                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
5300         }
5301         {
5302                 x := (*(*(struct {
5303                         Pos, Vel, Acc  [3]float32
5304                         ExpirationTime float32 // in seconds.
5305                         Size           float32
5306                         Collide        bool
5307
5308                         //mt:len32
5309                         Texture
5310
5311                         Vertical    bool
5312                         CollisionRm bool
5313                         AnimParams  TileAnim
5314                         Glow        uint8
5315                         AOCollision bool
5316                         NodeParam0  Content
5317                         NodeParam2  uint8
5318                         NodeTile    uint8
5319                 }))(obj)).Glow
5320                 write8(w, uint8(x))
5321         }
5322         {
5323                 x := (*(*(struct {
5324                         Pos, Vel, Acc  [3]float32
5325                         ExpirationTime float32 // in seconds.
5326                         Size           float32
5327                         Collide        bool
5328
5329                         //mt:len32
5330                         Texture
5331
5332                         Vertical    bool
5333                         CollisionRm bool
5334                         AnimParams  TileAnim
5335                         Glow        uint8
5336                         AOCollision bool
5337                         NodeParam0  Content
5338                         NodeParam2  uint8
5339                         NodeTile    uint8
5340                 }))(obj)).AOCollision
5341                 if x {
5342                         write8(w, 1)
5343                 } else {
5344                         write8(w, 0)
5345                 }
5346
5347         }
5348         if err := pcall(func() {
5349                 ((*(*(struct {
5350                         Pos, Vel, Acc  [3]float32
5351                         ExpirationTime float32 // in seconds.
5352                         Size           float32
5353                         Collide        bool
5354
5355                         //mt:len32
5356                         Texture
5357
5358                         Vertical    bool
5359                         CollisionRm bool
5360                         AnimParams  TileAnim
5361                         Glow        uint8
5362                         AOCollision bool
5363                         NodeParam0  Content
5364                         NodeParam2  uint8
5365                         NodeTile    uint8
5366                 }))(obj)).NodeParam0).serialize(w)
5367         }); err != nil {
5368                 if err == io.EOF {
5369                         chk(io.EOF)
5370                 }
5371                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
5372         }
5373         {
5374                 x := (*(*(struct {
5375                         Pos, Vel, Acc  [3]float32
5376                         ExpirationTime float32 // in seconds.
5377                         Size           float32
5378                         Collide        bool
5379
5380                         //mt:len32
5381                         Texture
5382
5383                         Vertical    bool
5384                         CollisionRm bool
5385                         AnimParams  TileAnim
5386                         Glow        uint8
5387                         AOCollision bool
5388                         NodeParam0  Content
5389                         NodeParam2  uint8
5390                         NodeTile    uint8
5391                 }))(obj)).NodeParam2
5392                 write8(w, uint8(x))
5393         }
5394         {
5395                 x := (*(*(struct {
5396                         Pos, Vel, Acc  [3]float32
5397                         ExpirationTime float32 // in seconds.
5398                         Size           float32
5399                         Collide        bool
5400
5401                         //mt:len32
5402                         Texture
5403
5404                         Vertical    bool
5405                         CollisionRm bool
5406                         AnimParams  TileAnim
5407                         Glow        uint8
5408                         AOCollision bool
5409                         NodeParam0  Content
5410                         NodeParam2  uint8
5411                         NodeTile    uint8
5412                 }))(obj)).NodeTile
5413                 write8(w, uint8(x))
5414         }
5415 }
5416
5417 func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
5418         for local151 := range (*(*(struct {
5419                 Pos, Vel, Acc  [3]float32
5420                 ExpirationTime float32 // in seconds.
5421                 Size           float32
5422                 Collide        bool
5423
5424                 //mt:len32
5425                 Texture
5426
5427                 Vertical    bool
5428                 CollisionRm bool
5429                 AnimParams  TileAnim
5430                 Glow        uint8
5431                 AOCollision bool
5432                 NodeParam0  Content
5433                 NodeParam2  uint8
5434                 NodeTile    uint8
5435         }))(obj)).Pos {
5436                 {
5437                         p := &((*(*(struct {
5438                                 Pos, Vel, Acc  [3]float32
5439                                 ExpirationTime float32 // in seconds.
5440                                 Size           float32
5441                                 Collide        bool
5442
5443                                 //mt:len32
5444                                 Texture
5445
5446                                 Vertical    bool
5447                                 CollisionRm bool
5448                                 AnimParams  TileAnim
5449                                 Glow        uint8
5450                                 AOCollision bool
5451                                 NodeParam0  Content
5452                                 NodeParam2  uint8
5453                                 NodeTile    uint8
5454                         }))(obj)).Pos)[local151]
5455                         *p = math.Float32frombits(read32(r))
5456                 }
5457         }
5458         for local152 := range (*(*(struct {
5459                 Pos, Vel, Acc  [3]float32
5460                 ExpirationTime float32 // in seconds.
5461                 Size           float32
5462                 Collide        bool
5463
5464                 //mt:len32
5465                 Texture
5466
5467                 Vertical    bool
5468                 CollisionRm bool
5469                 AnimParams  TileAnim
5470                 Glow        uint8
5471                 AOCollision bool
5472                 NodeParam0  Content
5473                 NodeParam2  uint8
5474                 NodeTile    uint8
5475         }))(obj)).Vel {
5476                 {
5477                         p := &((*(*(struct {
5478                                 Pos, Vel, Acc  [3]float32
5479                                 ExpirationTime float32 // in seconds.
5480                                 Size           float32
5481                                 Collide        bool
5482
5483                                 //mt:len32
5484                                 Texture
5485
5486                                 Vertical    bool
5487                                 CollisionRm bool
5488                                 AnimParams  TileAnim
5489                                 Glow        uint8
5490                                 AOCollision bool
5491                                 NodeParam0  Content
5492                                 NodeParam2  uint8
5493                                 NodeTile    uint8
5494                         }))(obj)).Vel)[local152]
5495                         *p = math.Float32frombits(read32(r))
5496                 }
5497         }
5498         for local153 := range (*(*(struct {
5499                 Pos, Vel, Acc  [3]float32
5500                 ExpirationTime float32 // in seconds.
5501                 Size           float32
5502                 Collide        bool
5503
5504                 //mt:len32
5505                 Texture
5506
5507                 Vertical    bool
5508                 CollisionRm bool
5509                 AnimParams  TileAnim
5510                 Glow        uint8
5511                 AOCollision bool
5512                 NodeParam0  Content
5513                 NodeParam2  uint8
5514                 NodeTile    uint8
5515         }))(obj)).Acc {
5516                 {
5517                         p := &((*(*(struct {
5518                                 Pos, Vel, Acc  [3]float32
5519                                 ExpirationTime float32 // in seconds.
5520                                 Size           float32
5521                                 Collide        bool
5522
5523                                 //mt:len32
5524                                 Texture
5525
5526                                 Vertical    bool
5527                                 CollisionRm bool
5528                                 AnimParams  TileAnim
5529                                 Glow        uint8
5530                                 AOCollision bool
5531                                 NodeParam0  Content
5532                                 NodeParam2  uint8
5533                                 NodeTile    uint8
5534                         }))(obj)).Acc)[local153]
5535                         *p = math.Float32frombits(read32(r))
5536                 }
5537         }
5538         {
5539                 p := &(*(*(struct {
5540                         Pos, Vel, Acc  [3]float32
5541                         ExpirationTime float32 // in seconds.
5542                         Size           float32
5543                         Collide        bool
5544
5545                         //mt:len32
5546                         Texture
5547
5548                         Vertical    bool
5549                         CollisionRm bool
5550                         AnimParams  TileAnim
5551                         Glow        uint8
5552                         AOCollision bool
5553                         NodeParam0  Content
5554                         NodeParam2  uint8
5555                         NodeTile    uint8
5556                 }))(obj)).ExpirationTime
5557                 *p = math.Float32frombits(read32(r))
5558         }
5559         {
5560                 p := &(*(*(struct {
5561                         Pos, Vel, Acc  [3]float32
5562                         ExpirationTime float32 // in seconds.
5563                         Size           float32
5564                         Collide        bool
5565
5566                         //mt:len32
5567                         Texture
5568
5569                         Vertical    bool
5570                         CollisionRm bool
5571                         AnimParams  TileAnim
5572                         Glow        uint8
5573                         AOCollision bool
5574                         NodeParam0  Content
5575                         NodeParam2  uint8
5576                         NodeTile    uint8
5577                 }))(obj)).Size
5578                 *p = math.Float32frombits(read32(r))
5579         }
5580         {
5581                 p := &(*(*(struct {
5582                         Pos, Vel, Acc  [3]float32
5583                         ExpirationTime float32 // in seconds.
5584                         Size           float32
5585                         Collide        bool
5586
5587                         //mt:len32
5588                         Texture
5589
5590                         Vertical    bool
5591                         CollisionRm bool
5592                         AnimParams  TileAnim
5593                         Glow        uint8
5594                         AOCollision bool
5595                         NodeParam0  Content
5596                         NodeParam2  uint8
5597                         NodeTile    uint8
5598                 }))(obj)).Collide
5599                 switch n := read8(r); n {
5600                 case 0:
5601                         *p = false
5602                 case 1:
5603                         *p = true
5604                 default:
5605                         chk(fmt.Errorf("invalid bool: %d", n))
5606                 }
5607
5608         }
5609         var local154 []uint8
5610         var local155 uint32
5611         {
5612                 p := &local155
5613                 *p = read32(r)
5614         }
5615         (local154) = make([]uint8, local155)
5616         {
5617                 _, err := io.ReadFull(r, (local154)[:])
5618                 chk(err)
5619         }
5620         (*(*string)(&((*(*(struct {
5621                 Pos, Vel, Acc  [3]float32
5622                 ExpirationTime float32 // in seconds.
5623                 Size           float32
5624                 Collide        bool
5625
5626                 //mt:len32
5627                 Texture
5628
5629                 Vertical    bool
5630                 CollisionRm bool
5631                 AnimParams  TileAnim
5632                 Glow        uint8
5633                 AOCollision bool
5634                 NodeParam0  Content
5635                 NodeParam2  uint8
5636                 NodeTile    uint8
5637         }))(obj)).Texture))) = string(local154)
5638         {
5639                 p := &(*(*(struct {
5640                         Pos, Vel, Acc  [3]float32
5641                         ExpirationTime float32 // in seconds.
5642                         Size           float32
5643                         Collide        bool
5644
5645                         //mt:len32
5646                         Texture
5647
5648                         Vertical    bool
5649                         CollisionRm bool
5650                         AnimParams  TileAnim
5651                         Glow        uint8
5652                         AOCollision bool
5653                         NodeParam0  Content
5654                         NodeParam2  uint8
5655                         NodeTile    uint8
5656                 }))(obj)).Vertical
5657                 switch n := read8(r); n {
5658                 case 0:
5659                         *p = false
5660                 case 1:
5661                         *p = true
5662                 default:
5663                         chk(fmt.Errorf("invalid bool: %d", n))
5664                 }
5665
5666         }
5667         {
5668                 p := &(*(*(struct {
5669                         Pos, Vel, Acc  [3]float32
5670                         ExpirationTime float32 // in seconds.
5671                         Size           float32
5672                         Collide        bool
5673
5674                         //mt:len32
5675                         Texture
5676
5677                         Vertical    bool
5678                         CollisionRm bool
5679                         AnimParams  TileAnim
5680                         Glow        uint8
5681                         AOCollision bool
5682                         NodeParam0  Content
5683                         NodeParam2  uint8
5684                         NodeTile    uint8
5685                 }))(obj)).CollisionRm
5686                 switch n := read8(r); n {
5687                 case 0:
5688                         *p = false
5689                 case 1:
5690                         *p = true
5691                 default:
5692                         chk(fmt.Errorf("invalid bool: %d", n))
5693                 }
5694
5695         }
5696         if err := pcall(func() {
5697                 ((*(*(struct {
5698                         Pos, Vel, Acc  [3]float32
5699                         ExpirationTime float32 // in seconds.
5700                         Size           float32
5701                         Collide        bool
5702
5703                         //mt:len32
5704                         Texture
5705
5706                         Vertical    bool
5707                         CollisionRm bool
5708                         AnimParams  TileAnim
5709                         Glow        uint8
5710                         AOCollision bool
5711                         NodeParam0  Content
5712                         NodeParam2  uint8
5713                         NodeTile    uint8
5714                 }))(obj)).AnimParams).deserialize(r)
5715         }); err != nil {
5716                 if err == io.EOF {
5717                         chk(io.EOF)
5718                 }
5719                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
5720         }
5721         {
5722                 p := &(*(*(struct {
5723                         Pos, Vel, Acc  [3]float32
5724                         ExpirationTime float32 // in seconds.
5725                         Size           float32
5726                         Collide        bool
5727
5728                         //mt:len32
5729                         Texture
5730
5731                         Vertical    bool
5732                         CollisionRm bool
5733                         AnimParams  TileAnim
5734                         Glow        uint8
5735                         AOCollision bool
5736                         NodeParam0  Content
5737                         NodeParam2  uint8
5738                         NodeTile    uint8
5739                 }))(obj)).Glow
5740                 *p = read8(r)
5741         }
5742         {
5743                 p := &(*(*(struct {
5744                         Pos, Vel, Acc  [3]float32
5745                         ExpirationTime float32 // in seconds.
5746                         Size           float32
5747                         Collide        bool
5748
5749                         //mt:len32
5750                         Texture
5751
5752                         Vertical    bool
5753                         CollisionRm bool
5754                         AnimParams  TileAnim
5755                         Glow        uint8
5756                         AOCollision bool
5757                         NodeParam0  Content
5758                         NodeParam2  uint8
5759                         NodeTile    uint8
5760                 }))(obj)).AOCollision
5761                 switch n := read8(r); n {
5762                 case 0:
5763                         *p = false
5764                 case 1:
5765                         *p = true
5766                 default:
5767                         chk(fmt.Errorf("invalid bool: %d", n))
5768                 }
5769
5770         }
5771         if err := pcall(func() {
5772                 ((*(*(struct {
5773                         Pos, Vel, Acc  [3]float32
5774                         ExpirationTime float32 // in seconds.
5775                         Size           float32
5776                         Collide        bool
5777
5778                         //mt:len32
5779                         Texture
5780
5781                         Vertical    bool
5782                         CollisionRm bool
5783                         AnimParams  TileAnim
5784                         Glow        uint8
5785                         AOCollision bool
5786                         NodeParam0  Content
5787                         NodeParam2  uint8
5788                         NodeTile    uint8
5789                 }))(obj)).NodeParam0).deserialize(r)
5790         }); err != nil {
5791                 if err == io.EOF {
5792                         chk(io.EOF)
5793                 }
5794                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
5795         }
5796         {
5797                 p := &(*(*(struct {
5798                         Pos, Vel, Acc  [3]float32
5799                         ExpirationTime float32 // in seconds.
5800                         Size           float32
5801                         Collide        bool
5802
5803                         //mt:len32
5804                         Texture
5805
5806                         Vertical    bool
5807                         CollisionRm bool
5808                         AnimParams  TileAnim
5809                         Glow        uint8
5810                         AOCollision bool
5811                         NodeParam0  Content
5812                         NodeParam2  uint8
5813                         NodeTile    uint8
5814                 }))(obj)).NodeParam2
5815                 *p = read8(r)
5816         }
5817         {
5818                 p := &(*(*(struct {
5819                         Pos, Vel, Acc  [3]float32
5820                         ExpirationTime float32 // in seconds.
5821                         Size           float32
5822                         Collide        bool
5823
5824                         //mt:len32
5825                         Texture
5826
5827                         Vertical    bool
5828                         CollisionRm bool
5829                         AnimParams  TileAnim
5830                         Glow        uint8
5831                         AOCollision bool
5832                         NodeParam0  Content
5833                         NodeParam2  uint8
5834                         NodeTile    uint8
5835                 }))(obj)).NodeTile
5836                 *p = read8(r)
5837         }
5838 }
5839
5840 func (obj *ToCltAddParticleSpawner) serialize(w io.Writer) {
5841         {
5842                 x := (*(*(struct {
5843                         Amount         uint16
5844                         Duration       float32
5845                         Pos, Vel, Acc  [2][3]float32
5846                         ExpirationTime [2]float32 // in seconds.
5847                         Size           [2]float32
5848                         Collide        bool
5849
5850                         //mt:len32
5851                         Texture
5852
5853                         ID           ParticleSpawnerID
5854                         Vertical     bool
5855                         CollisionRm  bool
5856                         AttachedAOID AOID
5857                         AnimParams   TileAnim
5858                         Glow         uint8
5859                         AOCollision  bool
5860                         NodeParam0   Content
5861                         NodeParam2   uint8
5862                         NodeTile     uint8
5863                 }))(obj)).Amount
5864                 write16(w, uint16(x))
5865         }
5866         {
5867                 x := (*(*(struct {
5868                         Amount         uint16
5869                         Duration       float32
5870                         Pos, Vel, Acc  [2][3]float32
5871                         ExpirationTime [2]float32 // in seconds.
5872                         Size           [2]float32
5873                         Collide        bool
5874
5875                         //mt:len32
5876                         Texture
5877
5878                         ID           ParticleSpawnerID
5879                         Vertical     bool
5880                         CollisionRm  bool
5881                         AttachedAOID AOID
5882                         AnimParams   TileAnim
5883                         Glow         uint8
5884                         AOCollision  bool
5885                         NodeParam0   Content
5886                         NodeParam2   uint8
5887                         NodeTile     uint8
5888                 }))(obj)).Duration
5889                 write32(w, math.Float32bits(x))
5890         }
5891         for local156 := range (*(*(struct {
5892                 Amount         uint16
5893                 Duration       float32
5894                 Pos, Vel, Acc  [2][3]float32
5895                 ExpirationTime [2]float32 // in seconds.
5896                 Size           [2]float32
5897                 Collide        bool
5898
5899                 //mt:len32
5900                 Texture
5901
5902                 ID           ParticleSpawnerID
5903                 Vertical     bool
5904                 CollisionRm  bool
5905                 AttachedAOID AOID
5906                 AnimParams   TileAnim
5907                 Glow         uint8
5908                 AOCollision  bool
5909                 NodeParam0   Content
5910                 NodeParam2   uint8
5911                 NodeTile     uint8
5912         }))(obj)).Pos {
5913                 for local157 := range ((*(*(struct {
5914                         Amount         uint16
5915                         Duration       float32
5916                         Pos, Vel, Acc  [2][3]float32
5917                         ExpirationTime [2]float32 // in seconds.
5918                         Size           [2]float32
5919                         Collide        bool
5920
5921                         //mt:len32
5922                         Texture
5923
5924                         ID           ParticleSpawnerID
5925                         Vertical     bool
5926                         CollisionRm  bool
5927                         AttachedAOID AOID
5928                         AnimParams   TileAnim
5929                         Glow         uint8
5930                         AOCollision  bool
5931                         NodeParam0   Content
5932                         NodeParam2   uint8
5933                         NodeTile     uint8
5934                 }))(obj)).Pos)[local156] {
5935                         {
5936                                 x := (((*(*(struct {
5937                                         Amount         uint16
5938                                         Duration       float32
5939                                         Pos, Vel, Acc  [2][3]float32
5940                                         ExpirationTime [2]float32 // in seconds.
5941                                         Size           [2]float32
5942                                         Collide        bool
5943
5944                                         //mt:len32
5945                                         Texture
5946
5947                                         ID           ParticleSpawnerID
5948                                         Vertical     bool
5949                                         CollisionRm  bool
5950                                         AttachedAOID AOID
5951                                         AnimParams   TileAnim
5952                                         Glow         uint8
5953                                         AOCollision  bool
5954                                         NodeParam0   Content
5955                                         NodeParam2   uint8
5956                                         NodeTile     uint8
5957                                 }))(obj)).Pos)[local156])[local157]
5958                                 write32(w, math.Float32bits(x))
5959                         }
5960                 }
5961         }
5962         for local158 := range (*(*(struct {
5963                 Amount         uint16
5964                 Duration       float32
5965                 Pos, Vel, Acc  [2][3]float32
5966                 ExpirationTime [2]float32 // in seconds.
5967                 Size           [2]float32
5968                 Collide        bool
5969
5970                 //mt:len32
5971                 Texture
5972
5973                 ID           ParticleSpawnerID
5974                 Vertical     bool
5975                 CollisionRm  bool
5976                 AttachedAOID AOID
5977                 AnimParams   TileAnim
5978                 Glow         uint8
5979                 AOCollision  bool
5980                 NodeParam0   Content
5981                 NodeParam2   uint8
5982                 NodeTile     uint8
5983         }))(obj)).Vel {
5984                 for local159 := range ((*(*(struct {
5985                         Amount         uint16
5986                         Duration       float32
5987                         Pos, Vel, Acc  [2][3]float32
5988                         ExpirationTime [2]float32 // in seconds.
5989                         Size           [2]float32
5990                         Collide        bool
5991
5992                         //mt:len32
5993                         Texture
5994
5995                         ID           ParticleSpawnerID
5996                         Vertical     bool
5997                         CollisionRm  bool
5998                         AttachedAOID AOID
5999                         AnimParams   TileAnim
6000                         Glow         uint8
6001                         AOCollision  bool
6002                         NodeParam0   Content
6003                         NodeParam2   uint8
6004                         NodeTile     uint8
6005                 }))(obj)).Vel)[local158] {
6006                         {
6007                                 x := (((*(*(struct {
6008                                         Amount         uint16
6009                                         Duration       float32
6010                                         Pos, Vel, Acc  [2][3]float32
6011                                         ExpirationTime [2]float32 // in seconds.
6012                                         Size           [2]float32
6013                                         Collide        bool
6014
6015                                         //mt:len32
6016                                         Texture
6017
6018                                         ID           ParticleSpawnerID
6019                                         Vertical     bool
6020                                         CollisionRm  bool
6021                                         AttachedAOID AOID
6022                                         AnimParams   TileAnim
6023                                         Glow         uint8
6024                                         AOCollision  bool
6025                                         NodeParam0   Content
6026                                         NodeParam2   uint8
6027                                         NodeTile     uint8
6028                                 }))(obj)).Vel)[local158])[local159]
6029                                 write32(w, math.Float32bits(x))
6030                         }
6031                 }
6032         }
6033         for local160 := range (*(*(struct {
6034                 Amount         uint16
6035                 Duration       float32
6036                 Pos, Vel, Acc  [2][3]float32
6037                 ExpirationTime [2]float32 // in seconds.
6038                 Size           [2]float32
6039                 Collide        bool
6040
6041                 //mt:len32
6042                 Texture
6043
6044                 ID           ParticleSpawnerID
6045                 Vertical     bool
6046                 CollisionRm  bool
6047                 AttachedAOID AOID
6048                 AnimParams   TileAnim
6049                 Glow         uint8
6050                 AOCollision  bool
6051                 NodeParam0   Content
6052                 NodeParam2   uint8
6053                 NodeTile     uint8
6054         }))(obj)).Acc {
6055                 for local161 := range ((*(*(struct {
6056                         Amount         uint16
6057                         Duration       float32
6058                         Pos, Vel, Acc  [2][3]float32
6059                         ExpirationTime [2]float32 // in seconds.
6060                         Size           [2]float32
6061                         Collide        bool
6062
6063                         //mt:len32
6064                         Texture
6065
6066                         ID           ParticleSpawnerID
6067                         Vertical     bool
6068                         CollisionRm  bool
6069                         AttachedAOID AOID
6070                         AnimParams   TileAnim
6071                         Glow         uint8
6072                         AOCollision  bool
6073                         NodeParam0   Content
6074                         NodeParam2   uint8
6075                         NodeTile     uint8
6076                 }))(obj)).Acc)[local160] {
6077                         {
6078                                 x := (((*(*(struct {
6079                                         Amount         uint16
6080                                         Duration       float32
6081                                         Pos, Vel, Acc  [2][3]float32
6082                                         ExpirationTime [2]float32 // in seconds.
6083                                         Size           [2]float32
6084                                         Collide        bool
6085
6086                                         //mt:len32
6087                                         Texture
6088
6089                                         ID           ParticleSpawnerID
6090                                         Vertical     bool
6091                                         CollisionRm  bool
6092                                         AttachedAOID AOID
6093                                         AnimParams   TileAnim
6094                                         Glow         uint8
6095                                         AOCollision  bool
6096                                         NodeParam0   Content
6097                                         NodeParam2   uint8
6098                                         NodeTile     uint8
6099                                 }))(obj)).Acc)[local160])[local161]
6100                                 write32(w, math.Float32bits(x))
6101                         }
6102                 }
6103         }
6104         for local162 := range (*(*(struct {
6105                 Amount         uint16
6106                 Duration       float32
6107                 Pos, Vel, Acc  [2][3]float32
6108                 ExpirationTime [2]float32 // in seconds.
6109                 Size           [2]float32
6110                 Collide        bool
6111
6112                 //mt:len32
6113                 Texture
6114
6115                 ID           ParticleSpawnerID
6116                 Vertical     bool
6117                 CollisionRm  bool
6118                 AttachedAOID AOID
6119                 AnimParams   TileAnim
6120                 Glow         uint8
6121                 AOCollision  bool
6122                 NodeParam0   Content
6123                 NodeParam2   uint8
6124                 NodeTile     uint8
6125         }))(obj)).ExpirationTime {
6126                 {
6127                         x := ((*(*(struct {
6128                                 Amount         uint16
6129                                 Duration       float32
6130                                 Pos, Vel, Acc  [2][3]float32
6131                                 ExpirationTime [2]float32 // in seconds.
6132                                 Size           [2]float32
6133                                 Collide        bool
6134
6135                                 //mt:len32
6136                                 Texture
6137
6138                                 ID           ParticleSpawnerID
6139                                 Vertical     bool
6140                                 CollisionRm  bool
6141                                 AttachedAOID AOID
6142                                 AnimParams   TileAnim
6143                                 Glow         uint8
6144                                 AOCollision  bool
6145                                 NodeParam0   Content
6146                                 NodeParam2   uint8
6147                                 NodeTile     uint8
6148                         }))(obj)).ExpirationTime)[local162]
6149                         write32(w, math.Float32bits(x))
6150                 }
6151         }
6152         for local163 := range (*(*(struct {
6153                 Amount         uint16
6154                 Duration       float32
6155                 Pos, Vel, Acc  [2][3]float32
6156                 ExpirationTime [2]float32 // in seconds.
6157                 Size           [2]float32
6158                 Collide        bool
6159
6160                 //mt:len32
6161                 Texture
6162
6163                 ID           ParticleSpawnerID
6164                 Vertical     bool
6165                 CollisionRm  bool
6166                 AttachedAOID AOID
6167                 AnimParams   TileAnim
6168                 Glow         uint8
6169                 AOCollision  bool
6170                 NodeParam0   Content
6171                 NodeParam2   uint8
6172                 NodeTile     uint8
6173         }))(obj)).Size {
6174                 {
6175                         x := ((*(*(struct {
6176                                 Amount         uint16
6177                                 Duration       float32
6178                                 Pos, Vel, Acc  [2][3]float32
6179                                 ExpirationTime [2]float32 // in seconds.
6180                                 Size           [2]float32
6181                                 Collide        bool
6182
6183                                 //mt:len32
6184                                 Texture
6185
6186                                 ID           ParticleSpawnerID
6187                                 Vertical     bool
6188                                 CollisionRm  bool
6189                                 AttachedAOID AOID
6190                                 AnimParams   TileAnim
6191                                 Glow         uint8
6192                                 AOCollision  bool
6193                                 NodeParam0   Content
6194                                 NodeParam2   uint8
6195                                 NodeTile     uint8
6196                         }))(obj)).Size)[local163]
6197                         write32(w, math.Float32bits(x))
6198                 }
6199         }
6200         {
6201                 x := (*(*(struct {
6202                         Amount         uint16
6203                         Duration       float32
6204                         Pos, Vel, Acc  [2][3]float32
6205                         ExpirationTime [2]float32 // in seconds.
6206                         Size           [2]float32
6207                         Collide        bool
6208
6209                         //mt:len32
6210                         Texture
6211
6212                         ID           ParticleSpawnerID
6213                         Vertical     bool
6214                         CollisionRm  bool
6215                         AttachedAOID AOID
6216                         AnimParams   TileAnim
6217                         Glow         uint8
6218                         AOCollision  bool
6219                         NodeParam0   Content
6220                         NodeParam2   uint8
6221                         NodeTile     uint8
6222                 }))(obj)).Collide
6223                 if x {
6224                         write8(w, 1)
6225                 } else {
6226                         write8(w, 0)
6227                 }
6228
6229         }
6230         if len(([]byte(*(*string)(&((*(*(struct {
6231                 Amount         uint16
6232                 Duration       float32
6233                 Pos, Vel, Acc  [2][3]float32
6234                 ExpirationTime [2]float32 // in seconds.
6235                 Size           [2]float32
6236                 Collide        bool
6237
6238                 //mt:len32
6239                 Texture
6240
6241                 ID           ParticleSpawnerID
6242                 Vertical     bool
6243                 CollisionRm  bool
6244                 AttachedAOID AOID
6245                 AnimParams   TileAnim
6246                 Glow         uint8
6247                 AOCollision  bool
6248                 NodeParam0   Content
6249                 NodeParam2   uint8
6250                 NodeTile     uint8
6251         }))(obj)).Texture))))) > math.MaxUint32 {
6252                 chk(ErrTooLong)
6253         }
6254         {
6255                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6256                         Amount         uint16
6257                         Duration       float32
6258                         Pos, Vel, Acc  [2][3]float32
6259                         ExpirationTime [2]float32 // in seconds.
6260                         Size           [2]float32
6261                         Collide        bool
6262
6263                         //mt:len32
6264                         Texture
6265
6266                         ID           ParticleSpawnerID
6267                         Vertical     bool
6268                         CollisionRm  bool
6269                         AttachedAOID AOID
6270                         AnimParams   TileAnim
6271                         Glow         uint8
6272                         AOCollision  bool
6273                         NodeParam0   Content
6274                         NodeParam2   uint8
6275                         NodeTile     uint8
6276                 }))(obj)).Texture))))))
6277                 write32(w, uint32(x))
6278         }
6279         {
6280                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6281                         Amount         uint16
6282                         Duration       float32
6283                         Pos, Vel, Acc  [2][3]float32
6284                         ExpirationTime [2]float32 // in seconds.
6285                         Size           [2]float32
6286                         Collide        bool
6287
6288                         //mt:len32
6289                         Texture
6290
6291                         ID           ParticleSpawnerID
6292                         Vertical     bool
6293                         CollisionRm  bool
6294                         AttachedAOID AOID
6295                         AnimParams   TileAnim
6296                         Glow         uint8
6297                         AOCollision  bool
6298                         NodeParam0   Content
6299                         NodeParam2   uint8
6300                         NodeTile     uint8
6301                 }))(obj)).Texture))))[:])
6302                 chk(err)
6303         }
6304         if err := pcall(func() {
6305                 ((*(*(struct {
6306                         Amount         uint16
6307                         Duration       float32
6308                         Pos, Vel, Acc  [2][3]float32
6309                         ExpirationTime [2]float32 // in seconds.
6310                         Size           [2]float32
6311                         Collide        bool
6312
6313                         //mt:len32
6314                         Texture
6315
6316                         ID           ParticleSpawnerID
6317                         Vertical     bool
6318                         CollisionRm  bool
6319                         AttachedAOID AOID
6320                         AnimParams   TileAnim
6321                         Glow         uint8
6322                         AOCollision  bool
6323                         NodeParam0   Content
6324                         NodeParam2   uint8
6325                         NodeTile     uint8
6326                 }))(obj)).ID).serialize(w)
6327         }); err != nil {
6328                 if err == io.EOF {
6329                         chk(io.EOF)
6330                 }
6331                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
6332         }
6333         {
6334                 x := (*(*(struct {
6335                         Amount         uint16
6336                         Duration       float32
6337                         Pos, Vel, Acc  [2][3]float32
6338                         ExpirationTime [2]float32 // in seconds.
6339                         Size           [2]float32
6340                         Collide        bool
6341
6342                         //mt:len32
6343                         Texture
6344
6345                         ID           ParticleSpawnerID
6346                         Vertical     bool
6347                         CollisionRm  bool
6348                         AttachedAOID AOID
6349                         AnimParams   TileAnim
6350                         Glow         uint8
6351                         AOCollision  bool
6352                         NodeParam0   Content
6353                         NodeParam2   uint8
6354                         NodeTile     uint8
6355                 }))(obj)).Vertical
6356                 if x {
6357                         write8(w, 1)
6358                 } else {
6359                         write8(w, 0)
6360                 }
6361
6362         }
6363         {
6364                 x := (*(*(struct {
6365                         Amount         uint16
6366                         Duration       float32
6367                         Pos, Vel, Acc  [2][3]float32
6368                         ExpirationTime [2]float32 // in seconds.
6369                         Size           [2]float32
6370                         Collide        bool
6371
6372                         //mt:len32
6373                         Texture
6374
6375                         ID           ParticleSpawnerID
6376                         Vertical     bool
6377                         CollisionRm  bool
6378                         AttachedAOID AOID
6379                         AnimParams   TileAnim
6380                         Glow         uint8
6381                         AOCollision  bool
6382                         NodeParam0   Content
6383                         NodeParam2   uint8
6384                         NodeTile     uint8
6385                 }))(obj)).CollisionRm
6386                 if x {
6387                         write8(w, 1)
6388                 } else {
6389                         write8(w, 0)
6390                 }
6391
6392         }
6393         if err := pcall(func() {
6394                 ((*(*(struct {
6395                         Amount         uint16
6396                         Duration       float32
6397                         Pos, Vel, Acc  [2][3]float32
6398                         ExpirationTime [2]float32 // in seconds.
6399                         Size           [2]float32
6400                         Collide        bool
6401
6402                         //mt:len32
6403                         Texture
6404
6405                         ID           ParticleSpawnerID
6406                         Vertical     bool
6407                         CollisionRm  bool
6408                         AttachedAOID AOID
6409                         AnimParams   TileAnim
6410                         Glow         uint8
6411                         AOCollision  bool
6412                         NodeParam0   Content
6413                         NodeParam2   uint8
6414                         NodeTile     uint8
6415                 }))(obj)).AttachedAOID).serialize(w)
6416         }); err != nil {
6417                 if err == io.EOF {
6418                         chk(io.EOF)
6419                 }
6420                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
6421         }
6422         if err := pcall(func() {
6423                 ((*(*(struct {
6424                         Amount         uint16
6425                         Duration       float32
6426                         Pos, Vel, Acc  [2][3]float32
6427                         ExpirationTime [2]float32 // in seconds.
6428                         Size           [2]float32
6429                         Collide        bool
6430
6431                         //mt:len32
6432                         Texture
6433
6434                         ID           ParticleSpawnerID
6435                         Vertical     bool
6436                         CollisionRm  bool
6437                         AttachedAOID AOID
6438                         AnimParams   TileAnim
6439                         Glow         uint8
6440                         AOCollision  bool
6441                         NodeParam0   Content
6442                         NodeParam2   uint8
6443                         NodeTile     uint8
6444                 }))(obj)).AnimParams).serialize(w)
6445         }); err != nil {
6446                 if err == io.EOF {
6447                         chk(io.EOF)
6448                 }
6449                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
6450         }
6451         {
6452                 x := (*(*(struct {
6453                         Amount         uint16
6454                         Duration       float32
6455                         Pos, Vel, Acc  [2][3]float32
6456                         ExpirationTime [2]float32 // in seconds.
6457                         Size           [2]float32
6458                         Collide        bool
6459
6460                         //mt:len32
6461                         Texture
6462
6463                         ID           ParticleSpawnerID
6464                         Vertical     bool
6465                         CollisionRm  bool
6466                         AttachedAOID AOID
6467                         AnimParams   TileAnim
6468                         Glow         uint8
6469                         AOCollision  bool
6470                         NodeParam0   Content
6471                         NodeParam2   uint8
6472                         NodeTile     uint8
6473                 }))(obj)).Glow
6474                 write8(w, uint8(x))
6475         }
6476         {
6477                 x := (*(*(struct {
6478                         Amount         uint16
6479                         Duration       float32
6480                         Pos, Vel, Acc  [2][3]float32
6481                         ExpirationTime [2]float32 // in seconds.
6482                         Size           [2]float32
6483                         Collide        bool
6484
6485                         //mt:len32
6486                         Texture
6487
6488                         ID           ParticleSpawnerID
6489                         Vertical     bool
6490                         CollisionRm  bool
6491                         AttachedAOID AOID
6492                         AnimParams   TileAnim
6493                         Glow         uint8
6494                         AOCollision  bool
6495                         NodeParam0   Content
6496                         NodeParam2   uint8
6497                         NodeTile     uint8
6498                 }))(obj)).AOCollision
6499                 if x {
6500                         write8(w, 1)
6501                 } else {
6502                         write8(w, 0)
6503                 }
6504
6505         }
6506         if err := pcall(func() {
6507                 ((*(*(struct {
6508                         Amount         uint16
6509                         Duration       float32
6510                         Pos, Vel, Acc  [2][3]float32
6511                         ExpirationTime [2]float32 // in seconds.
6512                         Size           [2]float32
6513                         Collide        bool
6514
6515                         //mt:len32
6516                         Texture
6517
6518                         ID           ParticleSpawnerID
6519                         Vertical     bool
6520                         CollisionRm  bool
6521                         AttachedAOID AOID
6522                         AnimParams   TileAnim
6523                         Glow         uint8
6524                         AOCollision  bool
6525                         NodeParam0   Content
6526                         NodeParam2   uint8
6527                         NodeTile     uint8
6528                 }))(obj)).NodeParam0).serialize(w)
6529         }); err != nil {
6530                 if err == io.EOF {
6531                         chk(io.EOF)
6532                 }
6533                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
6534         }
6535         {
6536                 x := (*(*(struct {
6537                         Amount         uint16
6538                         Duration       float32
6539                         Pos, Vel, Acc  [2][3]float32
6540                         ExpirationTime [2]float32 // in seconds.
6541                         Size           [2]float32
6542                         Collide        bool
6543
6544                         //mt:len32
6545                         Texture
6546
6547                         ID           ParticleSpawnerID
6548                         Vertical     bool
6549                         CollisionRm  bool
6550                         AttachedAOID AOID
6551                         AnimParams   TileAnim
6552                         Glow         uint8
6553                         AOCollision  bool
6554                         NodeParam0   Content
6555                         NodeParam2   uint8
6556                         NodeTile     uint8
6557                 }))(obj)).NodeParam2
6558                 write8(w, uint8(x))
6559         }
6560         {
6561                 x := (*(*(struct {
6562                         Amount         uint16
6563                         Duration       float32
6564                         Pos, Vel, Acc  [2][3]float32
6565                         ExpirationTime [2]float32 // in seconds.
6566                         Size           [2]float32
6567                         Collide        bool
6568
6569                         //mt:len32
6570                         Texture
6571
6572                         ID           ParticleSpawnerID
6573                         Vertical     bool
6574                         CollisionRm  bool
6575                         AttachedAOID AOID
6576                         AnimParams   TileAnim
6577                         Glow         uint8
6578                         AOCollision  bool
6579                         NodeParam0   Content
6580                         NodeParam2   uint8
6581                         NodeTile     uint8
6582                 }))(obj)).NodeTile
6583                 write8(w, uint8(x))
6584         }
6585 }
6586
6587 func (obj *ToCltAddParticleSpawner) deserialize(r io.Reader) {
6588         {
6589                 p := &(*(*(struct {
6590                         Amount         uint16
6591                         Duration       float32
6592                         Pos, Vel, Acc  [2][3]float32
6593                         ExpirationTime [2]float32 // in seconds.
6594                         Size           [2]float32
6595                         Collide        bool
6596
6597                         //mt:len32
6598                         Texture
6599
6600                         ID           ParticleSpawnerID
6601                         Vertical     bool
6602                         CollisionRm  bool
6603                         AttachedAOID AOID
6604                         AnimParams   TileAnim
6605                         Glow         uint8
6606                         AOCollision  bool
6607                         NodeParam0   Content
6608                         NodeParam2   uint8
6609                         NodeTile     uint8
6610                 }))(obj)).Amount
6611                 *p = read16(r)
6612         }
6613         {
6614                 p := &(*(*(struct {
6615                         Amount         uint16
6616                         Duration       float32
6617                         Pos, Vel, Acc  [2][3]float32
6618                         ExpirationTime [2]float32 // in seconds.
6619                         Size           [2]float32
6620                         Collide        bool
6621
6622                         //mt:len32
6623                         Texture
6624
6625                         ID           ParticleSpawnerID
6626                         Vertical     bool
6627                         CollisionRm  bool
6628                         AttachedAOID AOID
6629                         AnimParams   TileAnim
6630                         Glow         uint8
6631                         AOCollision  bool
6632                         NodeParam0   Content
6633                         NodeParam2   uint8
6634                         NodeTile     uint8
6635                 }))(obj)).Duration
6636                 *p = math.Float32frombits(read32(r))
6637         }
6638         for local164 := range (*(*(struct {
6639                 Amount         uint16
6640                 Duration       float32
6641                 Pos, Vel, Acc  [2][3]float32
6642                 ExpirationTime [2]float32 // in seconds.
6643                 Size           [2]float32
6644                 Collide        bool
6645
6646                 //mt:len32
6647                 Texture
6648
6649                 ID           ParticleSpawnerID
6650                 Vertical     bool
6651                 CollisionRm  bool
6652                 AttachedAOID AOID
6653                 AnimParams   TileAnim
6654                 Glow         uint8
6655                 AOCollision  bool
6656                 NodeParam0   Content
6657                 NodeParam2   uint8
6658                 NodeTile     uint8
6659         }))(obj)).Pos {
6660                 for local165 := range ((*(*(struct {
6661                         Amount         uint16
6662                         Duration       float32
6663                         Pos, Vel, Acc  [2][3]float32
6664                         ExpirationTime [2]float32 // in seconds.
6665                         Size           [2]float32
6666                         Collide        bool
6667
6668                         //mt:len32
6669                         Texture
6670
6671                         ID           ParticleSpawnerID
6672                         Vertical     bool
6673                         CollisionRm  bool
6674                         AttachedAOID AOID
6675                         AnimParams   TileAnim
6676                         Glow         uint8
6677                         AOCollision  bool
6678                         NodeParam0   Content
6679                         NodeParam2   uint8
6680                         NodeTile     uint8
6681                 }))(obj)).Pos)[local164] {
6682                         {
6683                                 p := &(((*(*(struct {
6684                                         Amount         uint16
6685                                         Duration       float32
6686                                         Pos, Vel, Acc  [2][3]float32
6687                                         ExpirationTime [2]float32 // in seconds.
6688                                         Size           [2]float32
6689                                         Collide        bool
6690
6691                                         //mt:len32
6692                                         Texture
6693
6694                                         ID           ParticleSpawnerID
6695                                         Vertical     bool
6696                                         CollisionRm  bool
6697                                         AttachedAOID AOID
6698                                         AnimParams   TileAnim
6699                                         Glow         uint8
6700                                         AOCollision  bool
6701                                         NodeParam0   Content
6702                                         NodeParam2   uint8
6703                                         NodeTile     uint8
6704                                 }))(obj)).Pos)[local164])[local165]
6705                                 *p = math.Float32frombits(read32(r))
6706                         }
6707                 }
6708         }
6709         for local166 := range (*(*(struct {
6710                 Amount         uint16
6711                 Duration       float32
6712                 Pos, Vel, Acc  [2][3]float32
6713                 ExpirationTime [2]float32 // in seconds.
6714                 Size           [2]float32
6715                 Collide        bool
6716
6717                 //mt:len32
6718                 Texture
6719
6720                 ID           ParticleSpawnerID
6721                 Vertical     bool
6722                 CollisionRm  bool
6723                 AttachedAOID AOID
6724                 AnimParams   TileAnim
6725                 Glow         uint8
6726                 AOCollision  bool
6727                 NodeParam0   Content
6728                 NodeParam2   uint8
6729                 NodeTile     uint8
6730         }))(obj)).Vel {
6731                 for local167 := range ((*(*(struct {
6732                         Amount         uint16
6733                         Duration       float32
6734                         Pos, Vel, Acc  [2][3]float32
6735                         ExpirationTime [2]float32 // in seconds.
6736                         Size           [2]float32
6737                         Collide        bool
6738
6739                         //mt:len32
6740                         Texture
6741
6742                         ID           ParticleSpawnerID
6743                         Vertical     bool
6744                         CollisionRm  bool
6745                         AttachedAOID AOID
6746                         AnimParams   TileAnim
6747                         Glow         uint8
6748                         AOCollision  bool
6749                         NodeParam0   Content
6750                         NodeParam2   uint8
6751                         NodeTile     uint8
6752                 }))(obj)).Vel)[local166] {
6753                         {
6754                                 p := &(((*(*(struct {
6755                                         Amount         uint16
6756                                         Duration       float32
6757                                         Pos, Vel, Acc  [2][3]float32
6758                                         ExpirationTime [2]float32 // in seconds.
6759                                         Size           [2]float32
6760                                         Collide        bool
6761
6762                                         //mt:len32
6763                                         Texture
6764
6765                                         ID           ParticleSpawnerID
6766                                         Vertical     bool
6767                                         CollisionRm  bool
6768                                         AttachedAOID AOID
6769                                         AnimParams   TileAnim
6770                                         Glow         uint8
6771                                         AOCollision  bool
6772                                         NodeParam0   Content
6773                                         NodeParam2   uint8
6774                                         NodeTile     uint8
6775                                 }))(obj)).Vel)[local166])[local167]
6776                                 *p = math.Float32frombits(read32(r))
6777                         }
6778                 }
6779         }
6780         for local168 := range (*(*(struct {
6781                 Amount         uint16
6782                 Duration       float32
6783                 Pos, Vel, Acc  [2][3]float32
6784                 ExpirationTime [2]float32 // in seconds.
6785                 Size           [2]float32
6786                 Collide        bool
6787
6788                 //mt:len32
6789                 Texture
6790
6791                 ID           ParticleSpawnerID
6792                 Vertical     bool
6793                 CollisionRm  bool
6794                 AttachedAOID AOID
6795                 AnimParams   TileAnim
6796                 Glow         uint8
6797                 AOCollision  bool
6798                 NodeParam0   Content
6799                 NodeParam2   uint8
6800                 NodeTile     uint8
6801         }))(obj)).Acc {
6802                 for local169 := range ((*(*(struct {
6803                         Amount         uint16
6804                         Duration       float32
6805                         Pos, Vel, Acc  [2][3]float32
6806                         ExpirationTime [2]float32 // in seconds.
6807                         Size           [2]float32
6808                         Collide        bool
6809
6810                         //mt:len32
6811                         Texture
6812
6813                         ID           ParticleSpawnerID
6814                         Vertical     bool
6815                         CollisionRm  bool
6816                         AttachedAOID AOID
6817                         AnimParams   TileAnim
6818                         Glow         uint8
6819                         AOCollision  bool
6820                         NodeParam0   Content
6821                         NodeParam2   uint8
6822                         NodeTile     uint8
6823                 }))(obj)).Acc)[local168] {
6824                         {
6825                                 p := &(((*(*(struct {
6826                                         Amount         uint16
6827                                         Duration       float32
6828                                         Pos, Vel, Acc  [2][3]float32
6829                                         ExpirationTime [2]float32 // in seconds.
6830                                         Size           [2]float32
6831                                         Collide        bool
6832
6833                                         //mt:len32
6834                                         Texture
6835
6836                                         ID           ParticleSpawnerID
6837                                         Vertical     bool
6838                                         CollisionRm  bool
6839                                         AttachedAOID AOID
6840                                         AnimParams   TileAnim
6841                                         Glow         uint8
6842                                         AOCollision  bool
6843                                         NodeParam0   Content
6844                                         NodeParam2   uint8
6845                                         NodeTile     uint8
6846                                 }))(obj)).Acc)[local168])[local169]
6847                                 *p = math.Float32frombits(read32(r))
6848                         }
6849                 }
6850         }
6851         for local170 := range (*(*(struct {
6852                 Amount         uint16
6853                 Duration       float32
6854                 Pos, Vel, Acc  [2][3]float32
6855                 ExpirationTime [2]float32 // in seconds.
6856                 Size           [2]float32
6857                 Collide        bool
6858
6859                 //mt:len32
6860                 Texture
6861
6862                 ID           ParticleSpawnerID
6863                 Vertical     bool
6864                 CollisionRm  bool
6865                 AttachedAOID AOID
6866                 AnimParams   TileAnim
6867                 Glow         uint8
6868                 AOCollision  bool
6869                 NodeParam0   Content
6870                 NodeParam2   uint8
6871                 NodeTile     uint8
6872         }))(obj)).ExpirationTime {
6873                 {
6874                         p := &((*(*(struct {
6875                                 Amount         uint16
6876                                 Duration       float32
6877                                 Pos, Vel, Acc  [2][3]float32
6878                                 ExpirationTime [2]float32 // in seconds.
6879                                 Size           [2]float32
6880                                 Collide        bool
6881
6882                                 //mt:len32
6883                                 Texture
6884
6885                                 ID           ParticleSpawnerID
6886                                 Vertical     bool
6887                                 CollisionRm  bool
6888                                 AttachedAOID AOID
6889                                 AnimParams   TileAnim
6890                                 Glow         uint8
6891                                 AOCollision  bool
6892                                 NodeParam0   Content
6893                                 NodeParam2   uint8
6894                                 NodeTile     uint8
6895                         }))(obj)).ExpirationTime)[local170]
6896                         *p = math.Float32frombits(read32(r))
6897                 }
6898         }
6899         for local171 := range (*(*(struct {
6900                 Amount         uint16
6901                 Duration       float32
6902                 Pos, Vel, Acc  [2][3]float32
6903                 ExpirationTime [2]float32 // in seconds.
6904                 Size           [2]float32
6905                 Collide        bool
6906
6907                 //mt:len32
6908                 Texture
6909
6910                 ID           ParticleSpawnerID
6911                 Vertical     bool
6912                 CollisionRm  bool
6913                 AttachedAOID AOID
6914                 AnimParams   TileAnim
6915                 Glow         uint8
6916                 AOCollision  bool
6917                 NodeParam0   Content
6918                 NodeParam2   uint8
6919                 NodeTile     uint8
6920         }))(obj)).Size {
6921                 {
6922                         p := &((*(*(struct {
6923                                 Amount         uint16
6924                                 Duration       float32
6925                                 Pos, Vel, Acc  [2][3]float32
6926                                 ExpirationTime [2]float32 // in seconds.
6927                                 Size           [2]float32
6928                                 Collide        bool
6929
6930                                 //mt:len32
6931                                 Texture
6932
6933                                 ID           ParticleSpawnerID
6934                                 Vertical     bool
6935                                 CollisionRm  bool
6936                                 AttachedAOID AOID
6937                                 AnimParams   TileAnim
6938                                 Glow         uint8
6939                                 AOCollision  bool
6940                                 NodeParam0   Content
6941                                 NodeParam2   uint8
6942                                 NodeTile     uint8
6943                         }))(obj)).Size)[local171]
6944                         *p = math.Float32frombits(read32(r))
6945                 }
6946         }
6947         {
6948                 p := &(*(*(struct {
6949                         Amount         uint16
6950                         Duration       float32
6951                         Pos, Vel, Acc  [2][3]float32
6952                         ExpirationTime [2]float32 // in seconds.
6953                         Size           [2]float32
6954                         Collide        bool
6955
6956                         //mt:len32
6957                         Texture
6958
6959                         ID           ParticleSpawnerID
6960                         Vertical     bool
6961                         CollisionRm  bool
6962                         AttachedAOID AOID
6963                         AnimParams   TileAnim
6964                         Glow         uint8
6965                         AOCollision  bool
6966                         NodeParam0   Content
6967                         NodeParam2   uint8
6968                         NodeTile     uint8
6969                 }))(obj)).Collide
6970                 switch n := read8(r); n {
6971                 case 0:
6972                         *p = false
6973                 case 1:
6974                         *p = true
6975                 default:
6976                         chk(fmt.Errorf("invalid bool: %d", n))
6977                 }
6978
6979         }
6980         var local172 []uint8
6981         var local173 uint32
6982         {
6983                 p := &local173
6984                 *p = read32(r)
6985         }
6986         (local172) = make([]uint8, local173)
6987         {
6988                 _, err := io.ReadFull(r, (local172)[:])
6989                 chk(err)
6990         }
6991         (*(*string)(&((*(*(struct {
6992                 Amount         uint16
6993                 Duration       float32
6994                 Pos, Vel, Acc  [2][3]float32
6995                 ExpirationTime [2]float32 // in seconds.
6996                 Size           [2]float32
6997                 Collide        bool
6998
6999                 //mt:len32
7000                 Texture
7001
7002                 ID           ParticleSpawnerID
7003                 Vertical     bool
7004                 CollisionRm  bool
7005                 AttachedAOID AOID
7006                 AnimParams   TileAnim
7007                 Glow         uint8
7008                 AOCollision  bool
7009                 NodeParam0   Content
7010                 NodeParam2   uint8
7011                 NodeTile     uint8
7012         }))(obj)).Texture))) = string(local172)
7013         if err := pcall(func() {
7014                 ((*(*(struct {
7015                         Amount         uint16
7016                         Duration       float32
7017                         Pos, Vel, Acc  [2][3]float32
7018                         ExpirationTime [2]float32 // in seconds.
7019                         Size           [2]float32
7020                         Collide        bool
7021
7022                         //mt:len32
7023                         Texture
7024
7025                         ID           ParticleSpawnerID
7026                         Vertical     bool
7027                         CollisionRm  bool
7028                         AttachedAOID AOID
7029                         AnimParams   TileAnim
7030                         Glow         uint8
7031                         AOCollision  bool
7032                         NodeParam0   Content
7033                         NodeParam2   uint8
7034                         NodeTile     uint8
7035                 }))(obj)).ID).deserialize(r)
7036         }); err != nil {
7037                 if err == io.EOF {
7038                         chk(io.EOF)
7039                 }
7040                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
7041         }
7042         {
7043                 p := &(*(*(struct {
7044                         Amount         uint16
7045                         Duration       float32
7046                         Pos, Vel, Acc  [2][3]float32
7047                         ExpirationTime [2]float32 // in seconds.
7048                         Size           [2]float32
7049                         Collide        bool
7050
7051                         //mt:len32
7052                         Texture
7053
7054                         ID           ParticleSpawnerID
7055                         Vertical     bool
7056                         CollisionRm  bool
7057                         AttachedAOID AOID
7058                         AnimParams   TileAnim
7059                         Glow         uint8
7060                         AOCollision  bool
7061                         NodeParam0   Content
7062                         NodeParam2   uint8
7063                         NodeTile     uint8
7064                 }))(obj)).Vertical
7065                 switch n := read8(r); n {
7066                 case 0:
7067                         *p = false
7068                 case 1:
7069                         *p = true
7070                 default:
7071                         chk(fmt.Errorf("invalid bool: %d", n))
7072                 }
7073
7074         }
7075         {
7076                 p := &(*(*(struct {
7077                         Amount         uint16
7078                         Duration       float32
7079                         Pos, Vel, Acc  [2][3]float32
7080                         ExpirationTime [2]float32 // in seconds.
7081                         Size           [2]float32
7082                         Collide        bool
7083
7084                         //mt:len32
7085                         Texture
7086
7087                         ID           ParticleSpawnerID
7088                         Vertical     bool
7089                         CollisionRm  bool
7090                         AttachedAOID AOID
7091                         AnimParams   TileAnim
7092                         Glow         uint8
7093                         AOCollision  bool
7094                         NodeParam0   Content
7095                         NodeParam2   uint8
7096                         NodeTile     uint8
7097                 }))(obj)).CollisionRm
7098                 switch n := read8(r); n {
7099                 case 0:
7100                         *p = false
7101                 case 1:
7102                         *p = true
7103                 default:
7104                         chk(fmt.Errorf("invalid bool: %d", n))
7105                 }
7106
7107         }
7108         if err := pcall(func() {
7109                 ((*(*(struct {
7110                         Amount         uint16
7111                         Duration       float32
7112                         Pos, Vel, Acc  [2][3]float32
7113                         ExpirationTime [2]float32 // in seconds.
7114                         Size           [2]float32
7115                         Collide        bool
7116
7117                         //mt:len32
7118                         Texture
7119
7120                         ID           ParticleSpawnerID
7121                         Vertical     bool
7122                         CollisionRm  bool
7123                         AttachedAOID AOID
7124                         AnimParams   TileAnim
7125                         Glow         uint8
7126                         AOCollision  bool
7127                         NodeParam0   Content
7128                         NodeParam2   uint8
7129                         NodeTile     uint8
7130                 }))(obj)).AttachedAOID).deserialize(r)
7131         }); err != nil {
7132                 if err == io.EOF {
7133                         chk(io.EOF)
7134                 }
7135                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
7136         }
7137         if err := pcall(func() {
7138                 ((*(*(struct {
7139                         Amount         uint16
7140                         Duration       float32
7141                         Pos, Vel, Acc  [2][3]float32
7142                         ExpirationTime [2]float32 // in seconds.
7143                         Size           [2]float32
7144                         Collide        bool
7145
7146                         //mt:len32
7147                         Texture
7148
7149                         ID           ParticleSpawnerID
7150                         Vertical     bool
7151                         CollisionRm  bool
7152                         AttachedAOID AOID
7153                         AnimParams   TileAnim
7154                         Glow         uint8
7155                         AOCollision  bool
7156                         NodeParam0   Content
7157                         NodeParam2   uint8
7158                         NodeTile     uint8
7159                 }))(obj)).AnimParams).deserialize(r)
7160         }); err != nil {
7161                 if err == io.EOF {
7162                         chk(io.EOF)
7163                 }
7164                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
7165         }
7166         {
7167                 p := &(*(*(struct {
7168                         Amount         uint16
7169                         Duration       float32
7170                         Pos, Vel, Acc  [2][3]float32
7171                         ExpirationTime [2]float32 // in seconds.
7172                         Size           [2]float32
7173                         Collide        bool
7174
7175                         //mt:len32
7176                         Texture
7177
7178                         ID           ParticleSpawnerID
7179                         Vertical     bool
7180                         CollisionRm  bool
7181                         AttachedAOID AOID
7182                         AnimParams   TileAnim
7183                         Glow         uint8
7184                         AOCollision  bool
7185                         NodeParam0   Content
7186                         NodeParam2   uint8
7187                         NodeTile     uint8
7188                 }))(obj)).Glow
7189                 *p = read8(r)
7190         }
7191         {
7192                 p := &(*(*(struct {
7193                         Amount         uint16
7194                         Duration       float32
7195                         Pos, Vel, Acc  [2][3]float32
7196                         ExpirationTime [2]float32 // in seconds.
7197                         Size           [2]float32
7198                         Collide        bool
7199
7200                         //mt:len32
7201                         Texture
7202
7203                         ID           ParticleSpawnerID
7204                         Vertical     bool
7205                         CollisionRm  bool
7206                         AttachedAOID AOID
7207                         AnimParams   TileAnim
7208                         Glow         uint8
7209                         AOCollision  bool
7210                         NodeParam0   Content
7211                         NodeParam2   uint8
7212                         NodeTile     uint8
7213                 }))(obj)).AOCollision
7214                 switch n := read8(r); n {
7215                 case 0:
7216                         *p = false
7217                 case 1:
7218                         *p = true
7219                 default:
7220                         chk(fmt.Errorf("invalid bool: %d", n))
7221                 }
7222
7223         }
7224         if err := pcall(func() {
7225                 ((*(*(struct {
7226                         Amount         uint16
7227                         Duration       float32
7228                         Pos, Vel, Acc  [2][3]float32
7229                         ExpirationTime [2]float32 // in seconds.
7230                         Size           [2]float32
7231                         Collide        bool
7232
7233                         //mt:len32
7234                         Texture
7235
7236                         ID           ParticleSpawnerID
7237                         Vertical     bool
7238                         CollisionRm  bool
7239                         AttachedAOID AOID
7240                         AnimParams   TileAnim
7241                         Glow         uint8
7242                         AOCollision  bool
7243                         NodeParam0   Content
7244                         NodeParam2   uint8
7245                         NodeTile     uint8
7246                 }))(obj)).NodeParam0).deserialize(r)
7247         }); err != nil {
7248                 if err == io.EOF {
7249                         chk(io.EOF)
7250                 }
7251                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
7252         }
7253         {
7254                 p := &(*(*(struct {
7255                         Amount         uint16
7256                         Duration       float32
7257                         Pos, Vel, Acc  [2][3]float32
7258                         ExpirationTime [2]float32 // in seconds.
7259                         Size           [2]float32
7260                         Collide        bool
7261
7262                         //mt:len32
7263                         Texture
7264
7265                         ID           ParticleSpawnerID
7266                         Vertical     bool
7267                         CollisionRm  bool
7268                         AttachedAOID AOID
7269                         AnimParams   TileAnim
7270                         Glow         uint8
7271                         AOCollision  bool
7272                         NodeParam0   Content
7273                         NodeParam2   uint8
7274                         NodeTile     uint8
7275                 }))(obj)).NodeParam2
7276                 *p = read8(r)
7277         }
7278         {
7279                 p := &(*(*(struct {
7280                         Amount         uint16
7281                         Duration       float32
7282                         Pos, Vel, Acc  [2][3]float32
7283                         ExpirationTime [2]float32 // in seconds.
7284                         Size           [2]float32
7285                         Collide        bool
7286
7287                         //mt:len32
7288                         Texture
7289
7290                         ID           ParticleSpawnerID
7291                         Vertical     bool
7292                         CollisionRm  bool
7293                         AttachedAOID AOID
7294                         AnimParams   TileAnim
7295                         Glow         uint8
7296                         AOCollision  bool
7297                         NodeParam0   Content
7298                         NodeParam2   uint8
7299                         NodeTile     uint8
7300                 }))(obj)).NodeTile
7301                 *p = read8(r)
7302         }
7303 }
7304
7305 func (obj *ToCltAddHUD) serialize(w io.Writer) {
7306         if err := pcall(func() {
7307                 ((*(*(struct {
7308                         ID HUDID
7309                         HUD
7310                 }))(obj)).ID).serialize(w)
7311         }); err != nil {
7312                 if err == io.EOF {
7313                         chk(io.EOF)
7314                 }
7315                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7316         }
7317         if err := pcall(func() {
7318                 ((*(*(struct {
7319                         ID HUDID
7320                         HUD
7321                 }))(obj)).HUD).serialize(w)
7322         }); err != nil {
7323                 if err == io.EOF {
7324                         chk(io.EOF)
7325                 }
7326                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUD", err))
7327         }
7328 }
7329
7330 func (obj *ToCltAddHUD) deserialize(r io.Reader) {
7331         if err := pcall(func() {
7332                 ((*(*(struct {
7333                         ID HUDID
7334                         HUD
7335                 }))(obj)).ID).deserialize(r)
7336         }); err != nil {
7337                 if err == io.EOF {
7338                         chk(io.EOF)
7339                 }
7340                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7341         }
7342         if err := pcall(func() {
7343                 ((*(*(struct {
7344                         ID HUDID
7345                         HUD
7346                 }))(obj)).HUD).deserialize(r)
7347         }); err != nil {
7348                 if err == io.EOF {
7349                         chk(io.EOF)
7350                 }
7351                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUD", err))
7352         }
7353 }
7354
7355 func (obj *ToCltRmHUD) serialize(w io.Writer) {
7356         if err := pcall(func() {
7357                 ((*(*(struct {
7358                         ID HUDID
7359                 }))(obj)).ID).serialize(w)
7360         }); err != nil {
7361                 if err == io.EOF {
7362                         chk(io.EOF)
7363                 }
7364                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7365         }
7366 }
7367
7368 func (obj *ToCltRmHUD) deserialize(r io.Reader) {
7369         if err := pcall(func() {
7370                 ((*(*(struct {
7371                         ID HUDID
7372                 }))(obj)).ID).deserialize(r)
7373         }); err != nil {
7374                 if err == io.EOF {
7375                         chk(io.EOF)
7376                 }
7377                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7378         }
7379 }
7380
7381 func (obj *ToCltChangeHUD) serialize(w io.Writer) {
7382         if err := pcall(func() {
7383                 ((*(*(struct {
7384                         ID HUDID
7385
7386                         Field HUDField
7387
7388                         //mt:if %s.Field == HUDPos
7389                         Pos [2]float32
7390
7391                         //mt:if %s.Field == HUDName
7392                         Name string
7393
7394                         //mt:if %s.Field == HUDScale
7395                         Scale [2]float32
7396
7397                         //mt:if %s.Field == HUDText
7398                         Text string
7399
7400                         //mt:if %s.Field == HUDNumber
7401                         Number uint32
7402
7403                         //mt:if %s.Field == HUDItem
7404                         Item uint32
7405
7406                         //mt:if %s.Field == HUDDir
7407                         Dir uint32
7408
7409                         //mt:if %s.Field == HUDAlign
7410                         Align [2]float32
7411
7412                         //mt:if %s.Field == HUDOffset
7413                         Offset [2]float32
7414
7415                         //mt:if %s.Field == HUDWorldPos
7416                         WorldPos Pos
7417
7418                         //mt:if %s.Field == HUDSize
7419                         Size [2]int32
7420
7421                         //mt:if %s.Field == HUDZIndex
7422                         ZIndex int32
7423
7424                         //mt:if %s.Field == HUDText2
7425                         Text2 string
7426                 }))(obj)).ID).serialize(w)
7427         }); err != nil {
7428                 if err == io.EOF {
7429                         chk(io.EOF)
7430                 }
7431                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
7432         }
7433         if err := pcall(func() {
7434                 ((*(*(struct {
7435                         ID HUDID
7436
7437                         Field HUDField
7438
7439                         //mt:if %s.Field == HUDPos
7440                         Pos [2]float32
7441
7442                         //mt:if %s.Field == HUDName
7443                         Name string
7444
7445                         //mt:if %s.Field == HUDScale
7446                         Scale [2]float32
7447
7448                         //mt:if %s.Field == HUDText
7449                         Text string
7450
7451                         //mt:if %s.Field == HUDNumber
7452                         Number uint32
7453
7454                         //mt:if %s.Field == HUDItem
7455                         Item uint32
7456
7457                         //mt:if %s.Field == HUDDir
7458                         Dir uint32
7459
7460                         //mt:if %s.Field == HUDAlign
7461                         Align [2]float32
7462
7463                         //mt:if %s.Field == HUDOffset
7464                         Offset [2]float32
7465
7466                         //mt:if %s.Field == HUDWorldPos
7467                         WorldPos Pos
7468
7469                         //mt:if %s.Field == HUDSize
7470                         Size [2]int32
7471
7472                         //mt:if %s.Field == HUDZIndex
7473                         ZIndex int32
7474
7475                         //mt:if %s.Field == HUDText2
7476                         Text2 string
7477                 }))(obj)).Field).serialize(w)
7478         }); err != nil {
7479                 if err == io.EOF {
7480                         chk(io.EOF)
7481                 }
7482                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDField", err))
7483         }
7484         if !((*(*(struct {
7485                 ID HUDID
7486
7487                 Field HUDField
7488
7489                 //mt:if %s.Field == HUDPos
7490                 Pos [2]float32
7491
7492                 //mt:if %s.Field == HUDName
7493                 Name string
7494
7495                 //mt:if %s.Field == HUDScale
7496                 Scale [2]float32
7497
7498                 //mt:if %s.Field == HUDText
7499                 Text string
7500
7501                 //mt:if %s.Field == HUDNumber
7502                 Number uint32
7503
7504                 //mt:if %s.Field == HUDItem
7505                 Item uint32
7506
7507                 //mt:if %s.Field == HUDDir
7508                 Dir uint32
7509
7510                 //mt:if %s.Field == HUDAlign
7511                 Align [2]float32
7512
7513                 //mt:if %s.Field == HUDOffset
7514                 Offset [2]float32
7515
7516                 //mt:if %s.Field == HUDWorldPos
7517                 WorldPos Pos
7518
7519                 //mt:if %s.Field == HUDSize
7520                 Size [2]int32
7521
7522                 //mt:if %s.Field == HUDZIndex
7523                 ZIndex int32
7524
7525                 //mt:if %s.Field == HUDText2
7526                 Text2 string
7527         }))(obj)).Field < hudMax) {
7528                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7529         }
7530         if (*(*(struct {
7531                 ID HUDID
7532
7533                 Field HUDField
7534
7535                 //mt:if %s.Field == HUDPos
7536                 Pos [2]float32
7537
7538                 //mt:if %s.Field == HUDName
7539                 Name string
7540
7541                 //mt:if %s.Field == HUDScale
7542                 Scale [2]float32
7543
7544                 //mt:if %s.Field == HUDText
7545                 Text string
7546
7547                 //mt:if %s.Field == HUDNumber
7548                 Number uint32
7549
7550                 //mt:if %s.Field == HUDItem
7551                 Item uint32
7552
7553                 //mt:if %s.Field == HUDDir
7554                 Dir uint32
7555
7556                 //mt:if %s.Field == HUDAlign
7557                 Align [2]float32
7558
7559                 //mt:if %s.Field == HUDOffset
7560                 Offset [2]float32
7561
7562                 //mt:if %s.Field == HUDWorldPos
7563                 WorldPos Pos
7564
7565                 //mt:if %s.Field == HUDSize
7566                 Size [2]int32
7567
7568                 //mt:if %s.Field == HUDZIndex
7569                 ZIndex int32
7570
7571                 //mt:if %s.Field == HUDText2
7572                 Text2 string
7573         }))(obj)).Field == HUDPos {
7574                 for local174 := range (*(*(struct {
7575                         ID HUDID
7576
7577                         Field HUDField
7578
7579                         //mt:if %s.Field == HUDPos
7580                         Pos [2]float32
7581
7582                         //mt:if %s.Field == HUDName
7583                         Name string
7584
7585                         //mt:if %s.Field == HUDScale
7586                         Scale [2]float32
7587
7588                         //mt:if %s.Field == HUDText
7589                         Text string
7590
7591                         //mt:if %s.Field == HUDNumber
7592                         Number uint32
7593
7594                         //mt:if %s.Field == HUDItem
7595                         Item uint32
7596
7597                         //mt:if %s.Field == HUDDir
7598                         Dir uint32
7599
7600                         //mt:if %s.Field == HUDAlign
7601                         Align [2]float32
7602
7603                         //mt:if %s.Field == HUDOffset
7604                         Offset [2]float32
7605
7606                         //mt:if %s.Field == HUDWorldPos
7607                         WorldPos Pos
7608
7609                         //mt:if %s.Field == HUDSize
7610                         Size [2]int32
7611
7612                         //mt:if %s.Field == HUDZIndex
7613                         ZIndex int32
7614
7615                         //mt:if %s.Field == HUDText2
7616                         Text2 string
7617                 }))(obj)).Pos {
7618                         {
7619                                 x := ((*(*(struct {
7620                                         ID HUDID
7621
7622                                         Field HUDField
7623
7624                                         //mt:if %s.Field == HUDPos
7625                                         Pos [2]float32
7626
7627                                         //mt:if %s.Field == HUDName
7628                                         Name string
7629
7630                                         //mt:if %s.Field == HUDScale
7631                                         Scale [2]float32
7632
7633                                         //mt:if %s.Field == HUDText
7634                                         Text string
7635
7636                                         //mt:if %s.Field == HUDNumber
7637                                         Number uint32
7638
7639                                         //mt:if %s.Field == HUDItem
7640                                         Item uint32
7641
7642                                         //mt:if %s.Field == HUDDir
7643                                         Dir uint32
7644
7645                                         //mt:if %s.Field == HUDAlign
7646                                         Align [2]float32
7647
7648                                         //mt:if %s.Field == HUDOffset
7649                                         Offset [2]float32
7650
7651                                         //mt:if %s.Field == HUDWorldPos
7652                                         WorldPos Pos
7653
7654                                         //mt:if %s.Field == HUDSize
7655                                         Size [2]int32
7656
7657                                         //mt:if %s.Field == HUDZIndex
7658                                         ZIndex int32
7659
7660                                         //mt:if %s.Field == HUDText2
7661                                         Text2 string
7662                                 }))(obj)).Pos)[local174]
7663                                 write32(w, math.Float32bits(x))
7664                         }
7665                 }
7666         }
7667         if (*(*(struct {
7668                 ID HUDID
7669
7670                 Field HUDField
7671
7672                 //mt:if %s.Field == HUDPos
7673                 Pos [2]float32
7674
7675                 //mt:if %s.Field == HUDName
7676                 Name string
7677
7678                 //mt:if %s.Field == HUDScale
7679                 Scale [2]float32
7680
7681                 //mt:if %s.Field == HUDText
7682                 Text string
7683
7684                 //mt:if %s.Field == HUDNumber
7685                 Number uint32
7686
7687                 //mt:if %s.Field == HUDItem
7688                 Item uint32
7689
7690                 //mt:if %s.Field == HUDDir
7691                 Dir uint32
7692
7693                 //mt:if %s.Field == HUDAlign
7694                 Align [2]float32
7695
7696                 //mt:if %s.Field == HUDOffset
7697                 Offset [2]float32
7698
7699                 //mt:if %s.Field == HUDWorldPos
7700                 WorldPos Pos
7701
7702                 //mt:if %s.Field == HUDSize
7703                 Size [2]int32
7704
7705                 //mt:if %s.Field == HUDZIndex
7706                 ZIndex int32
7707
7708                 //mt:if %s.Field == HUDText2
7709                 Text2 string
7710         }))(obj)).Field == HUDName {
7711                 if len(([]byte((*(*(struct {
7712                         ID HUDID
7713
7714                         Field HUDField
7715
7716                         //mt:if %s.Field == HUDPos
7717                         Pos [2]float32
7718
7719                         //mt:if %s.Field == HUDName
7720                         Name string
7721
7722                         //mt:if %s.Field == HUDScale
7723                         Scale [2]float32
7724
7725                         //mt:if %s.Field == HUDText
7726                         Text string
7727
7728                         //mt:if %s.Field == HUDNumber
7729                         Number uint32
7730
7731                         //mt:if %s.Field == HUDItem
7732                         Item uint32
7733
7734                         //mt:if %s.Field == HUDDir
7735                         Dir uint32
7736
7737                         //mt:if %s.Field == HUDAlign
7738                         Align [2]float32
7739
7740                         //mt:if %s.Field == HUDOffset
7741                         Offset [2]float32
7742
7743                         //mt:if %s.Field == HUDWorldPos
7744                         WorldPos Pos
7745
7746                         //mt:if %s.Field == HUDSize
7747                         Size [2]int32
7748
7749                         //mt:if %s.Field == HUDZIndex
7750                         ZIndex int32
7751
7752                         //mt:if %s.Field == HUDText2
7753                         Text2 string
7754                 }))(obj)).Name))) > math.MaxUint16 {
7755                         chk(ErrTooLong)
7756                 }
7757                 {
7758                         x := uint16(len(([]byte((*(*(struct {
7759                                 ID HUDID
7760
7761                                 Field HUDField
7762
7763                                 //mt:if %s.Field == HUDPos
7764                                 Pos [2]float32
7765
7766                                 //mt:if %s.Field == HUDName
7767                                 Name string
7768
7769                                 //mt:if %s.Field == HUDScale
7770                                 Scale [2]float32
7771
7772                                 //mt:if %s.Field == HUDText
7773                                 Text string
7774
7775                                 //mt:if %s.Field == HUDNumber
7776                                 Number uint32
7777
7778                                 //mt:if %s.Field == HUDItem
7779                                 Item uint32
7780
7781                                 //mt:if %s.Field == HUDDir
7782                                 Dir uint32
7783
7784                                 //mt:if %s.Field == HUDAlign
7785                                 Align [2]float32
7786
7787                                 //mt:if %s.Field == HUDOffset
7788                                 Offset [2]float32
7789
7790                                 //mt:if %s.Field == HUDWorldPos
7791                                 WorldPos Pos
7792
7793                                 //mt:if %s.Field == HUDSize
7794                                 Size [2]int32
7795
7796                                 //mt:if %s.Field == HUDZIndex
7797                                 ZIndex int32
7798
7799                                 //mt:if %s.Field == HUDText2
7800                                 Text2 string
7801                         }))(obj)).Name))))
7802                         write16(w, uint16(x))
7803                 }
7804                 {
7805                         _, err := w.Write(([]byte((*(*(struct {
7806                                 ID HUDID
7807
7808                                 Field HUDField
7809
7810                                 //mt:if %s.Field == HUDPos
7811                                 Pos [2]float32
7812
7813                                 //mt:if %s.Field == HUDName
7814                                 Name string
7815
7816                                 //mt:if %s.Field == HUDScale
7817                                 Scale [2]float32
7818
7819                                 //mt:if %s.Field == HUDText
7820                                 Text string
7821
7822                                 //mt:if %s.Field == HUDNumber
7823                                 Number uint32
7824
7825                                 //mt:if %s.Field == HUDItem
7826                                 Item uint32
7827
7828                                 //mt:if %s.Field == HUDDir
7829                                 Dir uint32
7830
7831                                 //mt:if %s.Field == HUDAlign
7832                                 Align [2]float32
7833
7834                                 //mt:if %s.Field == HUDOffset
7835                                 Offset [2]float32
7836
7837                                 //mt:if %s.Field == HUDWorldPos
7838                                 WorldPos Pos
7839
7840                                 //mt:if %s.Field == HUDSize
7841                                 Size [2]int32
7842
7843                                 //mt:if %s.Field == HUDZIndex
7844                                 ZIndex int32
7845
7846                                 //mt:if %s.Field == HUDText2
7847                                 Text2 string
7848                         }))(obj)).Name))[:])
7849                         chk(err)
7850                 }
7851         }
7852         if (*(*(struct {
7853                 ID HUDID
7854
7855                 Field HUDField
7856
7857                 //mt:if %s.Field == HUDPos
7858                 Pos [2]float32
7859
7860                 //mt:if %s.Field == HUDName
7861                 Name string
7862
7863                 //mt:if %s.Field == HUDScale
7864                 Scale [2]float32
7865
7866                 //mt:if %s.Field == HUDText
7867                 Text string
7868
7869                 //mt:if %s.Field == HUDNumber
7870                 Number uint32
7871
7872                 //mt:if %s.Field == HUDItem
7873                 Item uint32
7874
7875                 //mt:if %s.Field == HUDDir
7876                 Dir uint32
7877
7878                 //mt:if %s.Field == HUDAlign
7879                 Align [2]float32
7880
7881                 //mt:if %s.Field == HUDOffset
7882                 Offset [2]float32
7883
7884                 //mt:if %s.Field == HUDWorldPos
7885                 WorldPos Pos
7886
7887                 //mt:if %s.Field == HUDSize
7888                 Size [2]int32
7889
7890                 //mt:if %s.Field == HUDZIndex
7891                 ZIndex int32
7892
7893                 //mt:if %s.Field == HUDText2
7894                 Text2 string
7895         }))(obj)).Field == HUDScale {
7896                 for local175 := range (*(*(struct {
7897                         ID HUDID
7898
7899                         Field HUDField
7900
7901                         //mt:if %s.Field == HUDPos
7902                         Pos [2]float32
7903
7904                         //mt:if %s.Field == HUDName
7905                         Name string
7906
7907                         //mt:if %s.Field == HUDScale
7908                         Scale [2]float32
7909
7910                         //mt:if %s.Field == HUDText
7911                         Text string
7912
7913                         //mt:if %s.Field == HUDNumber
7914                         Number uint32
7915
7916                         //mt:if %s.Field == HUDItem
7917                         Item uint32
7918
7919                         //mt:if %s.Field == HUDDir
7920                         Dir uint32
7921
7922                         //mt:if %s.Field == HUDAlign
7923                         Align [2]float32
7924
7925                         //mt:if %s.Field == HUDOffset
7926                         Offset [2]float32
7927
7928                         //mt:if %s.Field == HUDWorldPos
7929                         WorldPos Pos
7930
7931                         //mt:if %s.Field == HUDSize
7932                         Size [2]int32
7933
7934                         //mt:if %s.Field == HUDZIndex
7935                         ZIndex int32
7936
7937                         //mt:if %s.Field == HUDText2
7938                         Text2 string
7939                 }))(obj)).Scale {
7940                         {
7941                                 x := ((*(*(struct {
7942                                         ID HUDID
7943
7944                                         Field HUDField
7945
7946                                         //mt:if %s.Field == HUDPos
7947                                         Pos [2]float32
7948
7949                                         //mt:if %s.Field == HUDName
7950                                         Name string
7951
7952                                         //mt:if %s.Field == HUDScale
7953                                         Scale [2]float32
7954
7955                                         //mt:if %s.Field == HUDText
7956                                         Text string
7957
7958                                         //mt:if %s.Field == HUDNumber
7959                                         Number uint32
7960
7961                                         //mt:if %s.Field == HUDItem
7962                                         Item uint32
7963
7964                                         //mt:if %s.Field == HUDDir
7965                                         Dir uint32
7966
7967                                         //mt:if %s.Field == HUDAlign
7968                                         Align [2]float32
7969
7970                                         //mt:if %s.Field == HUDOffset
7971                                         Offset [2]float32
7972
7973                                         //mt:if %s.Field == HUDWorldPos
7974                                         WorldPos Pos
7975
7976                                         //mt:if %s.Field == HUDSize
7977                                         Size [2]int32
7978
7979                                         //mt:if %s.Field == HUDZIndex
7980                                         ZIndex int32
7981
7982                                         //mt:if %s.Field == HUDText2
7983                                         Text2 string
7984                                 }))(obj)).Scale)[local175]
7985                                 write32(w, math.Float32bits(x))
7986                         }
7987                 }
7988         }
7989         if (*(*(struct {
7990                 ID HUDID
7991
7992                 Field HUDField
7993
7994                 //mt:if %s.Field == HUDPos
7995                 Pos [2]float32
7996
7997                 //mt:if %s.Field == HUDName
7998                 Name string
7999
8000                 //mt:if %s.Field == HUDScale
8001                 Scale [2]float32
8002
8003                 //mt:if %s.Field == HUDText
8004                 Text string
8005
8006                 //mt:if %s.Field == HUDNumber
8007                 Number uint32
8008
8009                 //mt:if %s.Field == HUDItem
8010                 Item uint32
8011
8012                 //mt:if %s.Field == HUDDir
8013                 Dir uint32
8014
8015                 //mt:if %s.Field == HUDAlign
8016                 Align [2]float32
8017
8018                 //mt:if %s.Field == HUDOffset
8019                 Offset [2]float32
8020
8021                 //mt:if %s.Field == HUDWorldPos
8022                 WorldPos Pos
8023
8024                 //mt:if %s.Field == HUDSize
8025                 Size [2]int32
8026
8027                 //mt:if %s.Field == HUDZIndex
8028                 ZIndex int32
8029
8030                 //mt:if %s.Field == HUDText2
8031                 Text2 string
8032         }))(obj)).Field == HUDText {
8033                 if len(([]byte((*(*(struct {
8034                         ID HUDID
8035
8036                         Field HUDField
8037
8038                         //mt:if %s.Field == HUDPos
8039                         Pos [2]float32
8040
8041                         //mt:if %s.Field == HUDName
8042                         Name string
8043
8044                         //mt:if %s.Field == HUDScale
8045                         Scale [2]float32
8046
8047                         //mt:if %s.Field == HUDText
8048                         Text string
8049
8050                         //mt:if %s.Field == HUDNumber
8051                         Number uint32
8052
8053                         //mt:if %s.Field == HUDItem
8054                         Item uint32
8055
8056                         //mt:if %s.Field == HUDDir
8057                         Dir uint32
8058
8059                         //mt:if %s.Field == HUDAlign
8060                         Align [2]float32
8061
8062                         //mt:if %s.Field == HUDOffset
8063                         Offset [2]float32
8064
8065                         //mt:if %s.Field == HUDWorldPos
8066                         WorldPos Pos
8067
8068                         //mt:if %s.Field == HUDSize
8069                         Size [2]int32
8070
8071                         //mt:if %s.Field == HUDZIndex
8072                         ZIndex int32
8073
8074                         //mt:if %s.Field == HUDText2
8075                         Text2 string
8076                 }))(obj)).Text))) > math.MaxUint16 {
8077                         chk(ErrTooLong)
8078                 }
8079                 {
8080                         x := uint16(len(([]byte((*(*(struct {
8081                                 ID HUDID
8082
8083                                 Field HUDField
8084
8085                                 //mt:if %s.Field == HUDPos
8086                                 Pos [2]float32
8087
8088                                 //mt:if %s.Field == HUDName
8089                                 Name string
8090
8091                                 //mt:if %s.Field == HUDScale
8092                                 Scale [2]float32
8093
8094                                 //mt:if %s.Field == HUDText
8095                                 Text string
8096
8097                                 //mt:if %s.Field == HUDNumber
8098                                 Number uint32
8099
8100                                 //mt:if %s.Field == HUDItem
8101                                 Item uint32
8102
8103                                 //mt:if %s.Field == HUDDir
8104                                 Dir uint32
8105
8106                                 //mt:if %s.Field == HUDAlign
8107                                 Align [2]float32
8108
8109                                 //mt:if %s.Field == HUDOffset
8110                                 Offset [2]float32
8111
8112                                 //mt:if %s.Field == HUDWorldPos
8113                                 WorldPos Pos
8114
8115                                 //mt:if %s.Field == HUDSize
8116                                 Size [2]int32
8117
8118                                 //mt:if %s.Field == HUDZIndex
8119                                 ZIndex int32
8120
8121                                 //mt:if %s.Field == HUDText2
8122                                 Text2 string
8123                         }))(obj)).Text))))
8124                         write16(w, uint16(x))
8125                 }
8126                 {
8127                         _, err := w.Write(([]byte((*(*(struct {
8128                                 ID HUDID
8129
8130                                 Field HUDField
8131
8132                                 //mt:if %s.Field == HUDPos
8133                                 Pos [2]float32
8134
8135                                 //mt:if %s.Field == HUDName
8136                                 Name string
8137
8138                                 //mt:if %s.Field == HUDScale
8139                                 Scale [2]float32
8140
8141                                 //mt:if %s.Field == HUDText
8142                                 Text string
8143
8144                                 //mt:if %s.Field == HUDNumber
8145                                 Number uint32
8146
8147                                 //mt:if %s.Field == HUDItem
8148                                 Item uint32
8149
8150                                 //mt:if %s.Field == HUDDir
8151                                 Dir uint32
8152
8153                                 //mt:if %s.Field == HUDAlign
8154                                 Align [2]float32
8155
8156                                 //mt:if %s.Field == HUDOffset
8157                                 Offset [2]float32
8158
8159                                 //mt:if %s.Field == HUDWorldPos
8160                                 WorldPos Pos
8161
8162                                 //mt:if %s.Field == HUDSize
8163                                 Size [2]int32
8164
8165                                 //mt:if %s.Field == HUDZIndex
8166                                 ZIndex int32
8167
8168                                 //mt:if %s.Field == HUDText2
8169                                 Text2 string
8170                         }))(obj)).Text))[:])
8171                         chk(err)
8172                 }
8173         }
8174         if (*(*(struct {
8175                 ID HUDID
8176
8177                 Field HUDField
8178
8179                 //mt:if %s.Field == HUDPos
8180                 Pos [2]float32
8181
8182                 //mt:if %s.Field == HUDName
8183                 Name string
8184
8185                 //mt:if %s.Field == HUDScale
8186                 Scale [2]float32
8187
8188                 //mt:if %s.Field == HUDText
8189                 Text string
8190
8191                 //mt:if %s.Field == HUDNumber
8192                 Number uint32
8193
8194                 //mt:if %s.Field == HUDItem
8195                 Item uint32
8196
8197                 //mt:if %s.Field == HUDDir
8198                 Dir uint32
8199
8200                 //mt:if %s.Field == HUDAlign
8201                 Align [2]float32
8202
8203                 //mt:if %s.Field == HUDOffset
8204                 Offset [2]float32
8205
8206                 //mt:if %s.Field == HUDWorldPos
8207                 WorldPos Pos
8208
8209                 //mt:if %s.Field == HUDSize
8210                 Size [2]int32
8211
8212                 //mt:if %s.Field == HUDZIndex
8213                 ZIndex int32
8214
8215                 //mt:if %s.Field == HUDText2
8216                 Text2 string
8217         }))(obj)).Field == HUDNumber {
8218                 {
8219                         x := (*(*(struct {
8220                                 ID HUDID
8221
8222                                 Field HUDField
8223
8224                                 //mt:if %s.Field == HUDPos
8225                                 Pos [2]float32
8226
8227                                 //mt:if %s.Field == HUDName
8228                                 Name string
8229
8230                                 //mt:if %s.Field == HUDScale
8231                                 Scale [2]float32
8232
8233                                 //mt:if %s.Field == HUDText
8234                                 Text string
8235
8236                                 //mt:if %s.Field == HUDNumber
8237                                 Number uint32
8238
8239                                 //mt:if %s.Field == HUDItem
8240                                 Item uint32
8241
8242                                 //mt:if %s.Field == HUDDir
8243                                 Dir uint32
8244
8245                                 //mt:if %s.Field == HUDAlign
8246                                 Align [2]float32
8247
8248                                 //mt:if %s.Field == HUDOffset
8249                                 Offset [2]float32
8250
8251                                 //mt:if %s.Field == HUDWorldPos
8252                                 WorldPos Pos
8253
8254                                 //mt:if %s.Field == HUDSize
8255                                 Size [2]int32
8256
8257                                 //mt:if %s.Field == HUDZIndex
8258                                 ZIndex int32
8259
8260                                 //mt:if %s.Field == HUDText2
8261                                 Text2 string
8262                         }))(obj)).Number
8263                         write32(w, uint32(x))
8264                 }
8265         }
8266         if (*(*(struct {
8267                 ID HUDID
8268
8269                 Field HUDField
8270
8271                 //mt:if %s.Field == HUDPos
8272                 Pos [2]float32
8273
8274                 //mt:if %s.Field == HUDName
8275                 Name string
8276
8277                 //mt:if %s.Field == HUDScale
8278                 Scale [2]float32
8279
8280                 //mt:if %s.Field == HUDText
8281                 Text string
8282
8283                 //mt:if %s.Field == HUDNumber
8284                 Number uint32
8285
8286                 //mt:if %s.Field == HUDItem
8287                 Item uint32
8288
8289                 //mt:if %s.Field == HUDDir
8290                 Dir uint32
8291
8292                 //mt:if %s.Field == HUDAlign
8293                 Align [2]float32
8294
8295                 //mt:if %s.Field == HUDOffset
8296                 Offset [2]float32
8297
8298                 //mt:if %s.Field == HUDWorldPos
8299                 WorldPos Pos
8300
8301                 //mt:if %s.Field == HUDSize
8302                 Size [2]int32
8303
8304                 //mt:if %s.Field == HUDZIndex
8305                 ZIndex int32
8306
8307                 //mt:if %s.Field == HUDText2
8308                 Text2 string
8309         }))(obj)).Field == HUDItem {
8310                 {
8311                         x := (*(*(struct {
8312                                 ID HUDID
8313
8314                                 Field HUDField
8315
8316                                 //mt:if %s.Field == HUDPos
8317                                 Pos [2]float32
8318
8319                                 //mt:if %s.Field == HUDName
8320                                 Name string
8321
8322                                 //mt:if %s.Field == HUDScale
8323                                 Scale [2]float32
8324
8325                                 //mt:if %s.Field == HUDText
8326                                 Text string
8327
8328                                 //mt:if %s.Field == HUDNumber
8329                                 Number uint32
8330
8331                                 //mt:if %s.Field == HUDItem
8332                                 Item uint32
8333
8334                                 //mt:if %s.Field == HUDDir
8335                                 Dir uint32
8336
8337                                 //mt:if %s.Field == HUDAlign
8338                                 Align [2]float32
8339
8340                                 //mt:if %s.Field == HUDOffset
8341                                 Offset [2]float32
8342
8343                                 //mt:if %s.Field == HUDWorldPos
8344                                 WorldPos Pos
8345
8346                                 //mt:if %s.Field == HUDSize
8347                                 Size [2]int32
8348
8349                                 //mt:if %s.Field == HUDZIndex
8350                                 ZIndex int32
8351
8352                                 //mt:if %s.Field == HUDText2
8353                                 Text2 string
8354                         }))(obj)).Item
8355                         write32(w, uint32(x))
8356                 }
8357         }
8358         if (*(*(struct {
8359                 ID HUDID
8360
8361                 Field HUDField
8362
8363                 //mt:if %s.Field == HUDPos
8364                 Pos [2]float32
8365
8366                 //mt:if %s.Field == HUDName
8367                 Name string
8368
8369                 //mt:if %s.Field == HUDScale
8370                 Scale [2]float32
8371
8372                 //mt:if %s.Field == HUDText
8373                 Text string
8374
8375                 //mt:if %s.Field == HUDNumber
8376                 Number uint32
8377
8378                 //mt:if %s.Field == HUDItem
8379                 Item uint32
8380
8381                 //mt:if %s.Field == HUDDir
8382                 Dir uint32
8383
8384                 //mt:if %s.Field == HUDAlign
8385                 Align [2]float32
8386
8387                 //mt:if %s.Field == HUDOffset
8388                 Offset [2]float32
8389
8390                 //mt:if %s.Field == HUDWorldPos
8391                 WorldPos Pos
8392
8393                 //mt:if %s.Field == HUDSize
8394                 Size [2]int32
8395
8396                 //mt:if %s.Field == HUDZIndex
8397                 ZIndex int32
8398
8399                 //mt:if %s.Field == HUDText2
8400                 Text2 string
8401         }))(obj)).Field == HUDDir {
8402                 {
8403                         x := (*(*(struct {
8404                                 ID HUDID
8405
8406                                 Field HUDField
8407
8408                                 //mt:if %s.Field == HUDPos
8409                                 Pos [2]float32
8410
8411                                 //mt:if %s.Field == HUDName
8412                                 Name string
8413
8414                                 //mt:if %s.Field == HUDScale
8415                                 Scale [2]float32
8416
8417                                 //mt:if %s.Field == HUDText
8418                                 Text string
8419
8420                                 //mt:if %s.Field == HUDNumber
8421                                 Number uint32
8422
8423                                 //mt:if %s.Field == HUDItem
8424                                 Item uint32
8425
8426                                 //mt:if %s.Field == HUDDir
8427                                 Dir uint32
8428
8429                                 //mt:if %s.Field == HUDAlign
8430                                 Align [2]float32
8431
8432                                 //mt:if %s.Field == HUDOffset
8433                                 Offset [2]float32
8434
8435                                 //mt:if %s.Field == HUDWorldPos
8436                                 WorldPos Pos
8437
8438                                 //mt:if %s.Field == HUDSize
8439                                 Size [2]int32
8440
8441                                 //mt:if %s.Field == HUDZIndex
8442                                 ZIndex int32
8443
8444                                 //mt:if %s.Field == HUDText2
8445                                 Text2 string
8446                         }))(obj)).Dir
8447                         write32(w, uint32(x))
8448                 }
8449         }
8450         if (*(*(struct {
8451                 ID HUDID
8452
8453                 Field HUDField
8454
8455                 //mt:if %s.Field == HUDPos
8456                 Pos [2]float32
8457
8458                 //mt:if %s.Field == HUDName
8459                 Name string
8460
8461                 //mt:if %s.Field == HUDScale
8462                 Scale [2]float32
8463
8464                 //mt:if %s.Field == HUDText
8465                 Text string
8466
8467                 //mt:if %s.Field == HUDNumber
8468                 Number uint32
8469
8470                 //mt:if %s.Field == HUDItem
8471                 Item uint32
8472
8473                 //mt:if %s.Field == HUDDir
8474                 Dir uint32
8475
8476                 //mt:if %s.Field == HUDAlign
8477                 Align [2]float32
8478
8479                 //mt:if %s.Field == HUDOffset
8480                 Offset [2]float32
8481
8482                 //mt:if %s.Field == HUDWorldPos
8483                 WorldPos Pos
8484
8485                 //mt:if %s.Field == HUDSize
8486                 Size [2]int32
8487
8488                 //mt:if %s.Field == HUDZIndex
8489                 ZIndex int32
8490
8491                 //mt:if %s.Field == HUDText2
8492                 Text2 string
8493         }))(obj)).Field == HUDAlign {
8494                 for local176 := range (*(*(struct {
8495                         ID HUDID
8496
8497                         Field HUDField
8498
8499                         //mt:if %s.Field == HUDPos
8500                         Pos [2]float32
8501
8502                         //mt:if %s.Field == HUDName
8503                         Name string
8504
8505                         //mt:if %s.Field == HUDScale
8506                         Scale [2]float32
8507
8508                         //mt:if %s.Field == HUDText
8509                         Text string
8510
8511                         //mt:if %s.Field == HUDNumber
8512                         Number uint32
8513
8514                         //mt:if %s.Field == HUDItem
8515                         Item uint32
8516
8517                         //mt:if %s.Field == HUDDir
8518                         Dir uint32
8519
8520                         //mt:if %s.Field == HUDAlign
8521                         Align [2]float32
8522
8523                         //mt:if %s.Field == HUDOffset
8524                         Offset [2]float32
8525
8526                         //mt:if %s.Field == HUDWorldPos
8527                         WorldPos Pos
8528
8529                         //mt:if %s.Field == HUDSize
8530                         Size [2]int32
8531
8532                         //mt:if %s.Field == HUDZIndex
8533                         ZIndex int32
8534
8535                         //mt:if %s.Field == HUDText2
8536                         Text2 string
8537                 }))(obj)).Align {
8538                         {
8539                                 x := ((*(*(struct {
8540                                         ID HUDID
8541
8542                                         Field HUDField
8543
8544                                         //mt:if %s.Field == HUDPos
8545                                         Pos [2]float32
8546
8547                                         //mt:if %s.Field == HUDName
8548                                         Name string
8549
8550                                         //mt:if %s.Field == HUDScale
8551                                         Scale [2]float32
8552
8553                                         //mt:if %s.Field == HUDText
8554                                         Text string
8555
8556                                         //mt:if %s.Field == HUDNumber
8557                                         Number uint32
8558
8559                                         //mt:if %s.Field == HUDItem
8560                                         Item uint32
8561
8562                                         //mt:if %s.Field == HUDDir
8563                                         Dir uint32
8564
8565                                         //mt:if %s.Field == HUDAlign
8566                                         Align [2]float32
8567
8568                                         //mt:if %s.Field == HUDOffset
8569                                         Offset [2]float32
8570
8571                                         //mt:if %s.Field == HUDWorldPos
8572                                         WorldPos Pos
8573
8574                                         //mt:if %s.Field == HUDSize
8575                                         Size [2]int32
8576
8577                                         //mt:if %s.Field == HUDZIndex
8578                                         ZIndex int32
8579
8580                                         //mt:if %s.Field == HUDText2
8581                                         Text2 string
8582                                 }))(obj)).Align)[local176]
8583                                 write32(w, math.Float32bits(x))
8584                         }
8585                 }
8586         }
8587         if (*(*(struct {
8588                 ID HUDID
8589
8590                 Field HUDField
8591
8592                 //mt:if %s.Field == HUDPos
8593                 Pos [2]float32
8594
8595                 //mt:if %s.Field == HUDName
8596                 Name string
8597
8598                 //mt:if %s.Field == HUDScale
8599                 Scale [2]float32
8600
8601                 //mt:if %s.Field == HUDText
8602                 Text string
8603
8604                 //mt:if %s.Field == HUDNumber
8605                 Number uint32
8606
8607                 //mt:if %s.Field == HUDItem
8608                 Item uint32
8609
8610                 //mt:if %s.Field == HUDDir
8611                 Dir uint32
8612
8613                 //mt:if %s.Field == HUDAlign
8614                 Align [2]float32
8615
8616                 //mt:if %s.Field == HUDOffset
8617                 Offset [2]float32
8618
8619                 //mt:if %s.Field == HUDWorldPos
8620                 WorldPos Pos
8621
8622                 //mt:if %s.Field == HUDSize
8623                 Size [2]int32
8624
8625                 //mt:if %s.Field == HUDZIndex
8626                 ZIndex int32
8627
8628                 //mt:if %s.Field == HUDText2
8629                 Text2 string
8630         }))(obj)).Field == HUDOffset {
8631                 for local177 := range (*(*(struct {
8632                         ID HUDID
8633
8634                         Field HUDField
8635
8636                         //mt:if %s.Field == HUDPos
8637                         Pos [2]float32
8638
8639                         //mt:if %s.Field == HUDName
8640                         Name string
8641
8642                         //mt:if %s.Field == HUDScale
8643                         Scale [2]float32
8644
8645                         //mt:if %s.Field == HUDText
8646                         Text string
8647
8648                         //mt:if %s.Field == HUDNumber
8649                         Number uint32
8650
8651                         //mt:if %s.Field == HUDItem
8652                         Item uint32
8653
8654                         //mt:if %s.Field == HUDDir
8655                         Dir uint32
8656
8657                         //mt:if %s.Field == HUDAlign
8658                         Align [2]float32
8659
8660                         //mt:if %s.Field == HUDOffset
8661                         Offset [2]float32
8662
8663                         //mt:if %s.Field == HUDWorldPos
8664                         WorldPos Pos
8665
8666                         //mt:if %s.Field == HUDSize
8667                         Size [2]int32
8668
8669                         //mt:if %s.Field == HUDZIndex
8670                         ZIndex int32
8671
8672                         //mt:if %s.Field == HUDText2
8673                         Text2 string
8674                 }))(obj)).Offset {
8675                         {
8676                                 x := ((*(*(struct {
8677                                         ID HUDID
8678
8679                                         Field HUDField
8680
8681                                         //mt:if %s.Field == HUDPos
8682                                         Pos [2]float32
8683
8684                                         //mt:if %s.Field == HUDName
8685                                         Name string
8686
8687                                         //mt:if %s.Field == HUDScale
8688                                         Scale [2]float32
8689
8690                                         //mt:if %s.Field == HUDText
8691                                         Text string
8692
8693                                         //mt:if %s.Field == HUDNumber
8694                                         Number uint32
8695
8696                                         //mt:if %s.Field == HUDItem
8697                                         Item uint32
8698
8699                                         //mt:if %s.Field == HUDDir
8700                                         Dir uint32
8701
8702                                         //mt:if %s.Field == HUDAlign
8703                                         Align [2]float32
8704
8705                                         //mt:if %s.Field == HUDOffset
8706                                         Offset [2]float32
8707
8708                                         //mt:if %s.Field == HUDWorldPos
8709                                         WorldPos Pos
8710
8711                                         //mt:if %s.Field == HUDSize
8712                                         Size [2]int32
8713
8714                                         //mt:if %s.Field == HUDZIndex
8715                                         ZIndex int32
8716
8717                                         //mt:if %s.Field == HUDText2
8718                                         Text2 string
8719                                 }))(obj)).Offset)[local177]
8720                                 write32(w, math.Float32bits(x))
8721                         }
8722                 }
8723         }
8724         if (*(*(struct {
8725                 ID HUDID
8726
8727                 Field HUDField
8728
8729                 //mt:if %s.Field == HUDPos
8730                 Pos [2]float32
8731
8732                 //mt:if %s.Field == HUDName
8733                 Name string
8734
8735                 //mt:if %s.Field == HUDScale
8736                 Scale [2]float32
8737
8738                 //mt:if %s.Field == HUDText
8739                 Text string
8740
8741                 //mt:if %s.Field == HUDNumber
8742                 Number uint32
8743
8744                 //mt:if %s.Field == HUDItem
8745                 Item uint32
8746
8747                 //mt:if %s.Field == HUDDir
8748                 Dir uint32
8749
8750                 //mt:if %s.Field == HUDAlign
8751                 Align [2]float32
8752
8753                 //mt:if %s.Field == HUDOffset
8754                 Offset [2]float32
8755
8756                 //mt:if %s.Field == HUDWorldPos
8757                 WorldPos Pos
8758
8759                 //mt:if %s.Field == HUDSize
8760                 Size [2]int32
8761
8762                 //mt:if %s.Field == HUDZIndex
8763                 ZIndex int32
8764
8765                 //mt:if %s.Field == HUDText2
8766                 Text2 string
8767         }))(obj)).Field == HUDWorldPos {
8768                 if err := pcall(func() {
8769                         ((*(*(struct {
8770                                 ID HUDID
8771
8772                                 Field HUDField
8773
8774                                 //mt:if %s.Field == HUDPos
8775                                 Pos [2]float32
8776
8777                                 //mt:if %s.Field == HUDName
8778                                 Name string
8779
8780                                 //mt:if %s.Field == HUDScale
8781                                 Scale [2]float32
8782
8783                                 //mt:if %s.Field == HUDText
8784                                 Text string
8785
8786                                 //mt:if %s.Field == HUDNumber
8787                                 Number uint32
8788
8789                                 //mt:if %s.Field == HUDItem
8790                                 Item uint32
8791
8792                                 //mt:if %s.Field == HUDDir
8793                                 Dir uint32
8794
8795                                 //mt:if %s.Field == HUDAlign
8796                                 Align [2]float32
8797
8798                                 //mt:if %s.Field == HUDOffset
8799                                 Offset [2]float32
8800
8801                                 //mt:if %s.Field == HUDWorldPos
8802                                 WorldPos Pos
8803
8804                                 //mt:if %s.Field == HUDSize
8805                                 Size [2]int32
8806
8807                                 //mt:if %s.Field == HUDZIndex
8808                                 ZIndex int32
8809
8810                                 //mt:if %s.Field == HUDText2
8811                                 Text2 string
8812                         }))(obj)).WorldPos).serialize(w)
8813                 }); err != nil {
8814                         if err == io.EOF {
8815                                 chk(io.EOF)
8816                         }
8817                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
8818                 }
8819         }
8820         if (*(*(struct {
8821                 ID HUDID
8822
8823                 Field HUDField
8824
8825                 //mt:if %s.Field == HUDPos
8826                 Pos [2]float32
8827
8828                 //mt:if %s.Field == HUDName
8829                 Name string
8830
8831                 //mt:if %s.Field == HUDScale
8832                 Scale [2]float32
8833
8834                 //mt:if %s.Field == HUDText
8835                 Text string
8836
8837                 //mt:if %s.Field == HUDNumber
8838                 Number uint32
8839
8840                 //mt:if %s.Field == HUDItem
8841                 Item uint32
8842
8843                 //mt:if %s.Field == HUDDir
8844                 Dir uint32
8845
8846                 //mt:if %s.Field == HUDAlign
8847                 Align [2]float32
8848
8849                 //mt:if %s.Field == HUDOffset
8850                 Offset [2]float32
8851
8852                 //mt:if %s.Field == HUDWorldPos
8853                 WorldPos Pos
8854
8855                 //mt:if %s.Field == HUDSize
8856                 Size [2]int32
8857
8858                 //mt:if %s.Field == HUDZIndex
8859                 ZIndex int32
8860
8861                 //mt:if %s.Field == HUDText2
8862                 Text2 string
8863         }))(obj)).Field == HUDSize {
8864                 for local178 := range (*(*(struct {
8865                         ID HUDID
8866
8867                         Field HUDField
8868
8869                         //mt:if %s.Field == HUDPos
8870                         Pos [2]float32
8871
8872                         //mt:if %s.Field == HUDName
8873                         Name string
8874
8875                         //mt:if %s.Field == HUDScale
8876                         Scale [2]float32
8877
8878                         //mt:if %s.Field == HUDText
8879                         Text string
8880
8881                         //mt:if %s.Field == HUDNumber
8882                         Number uint32
8883
8884                         //mt:if %s.Field == HUDItem
8885                         Item uint32
8886
8887                         //mt:if %s.Field == HUDDir
8888                         Dir uint32
8889
8890                         //mt:if %s.Field == HUDAlign
8891                         Align [2]float32
8892
8893                         //mt:if %s.Field == HUDOffset
8894                         Offset [2]float32
8895
8896                         //mt:if %s.Field == HUDWorldPos
8897                         WorldPos Pos
8898
8899                         //mt:if %s.Field == HUDSize
8900                         Size [2]int32
8901
8902                         //mt:if %s.Field == HUDZIndex
8903                         ZIndex int32
8904
8905                         //mt:if %s.Field == HUDText2
8906                         Text2 string
8907                 }))(obj)).Size {
8908                         {
8909                                 x := ((*(*(struct {
8910                                         ID HUDID
8911
8912                                         Field HUDField
8913
8914                                         //mt:if %s.Field == HUDPos
8915                                         Pos [2]float32
8916
8917                                         //mt:if %s.Field == HUDName
8918                                         Name string
8919
8920                                         //mt:if %s.Field == HUDScale
8921                                         Scale [2]float32
8922
8923                                         //mt:if %s.Field == HUDText
8924                                         Text string
8925
8926                                         //mt:if %s.Field == HUDNumber
8927                                         Number uint32
8928
8929                                         //mt:if %s.Field == HUDItem
8930                                         Item uint32
8931
8932                                         //mt:if %s.Field == HUDDir
8933                                         Dir uint32
8934
8935                                         //mt:if %s.Field == HUDAlign
8936                                         Align [2]float32
8937
8938                                         //mt:if %s.Field == HUDOffset
8939                                         Offset [2]float32
8940
8941                                         //mt:if %s.Field == HUDWorldPos
8942                                         WorldPos Pos
8943
8944                                         //mt:if %s.Field == HUDSize
8945                                         Size [2]int32
8946
8947                                         //mt:if %s.Field == HUDZIndex
8948                                         ZIndex int32
8949
8950                                         //mt:if %s.Field == HUDText2
8951                                         Text2 string
8952                                 }))(obj)).Size)[local178]
8953                                 write32(w, uint32(x))
8954                         }
8955                 }
8956         }
8957         if (*(*(struct {
8958                 ID HUDID
8959
8960                 Field HUDField
8961
8962                 //mt:if %s.Field == HUDPos
8963                 Pos [2]float32
8964
8965                 //mt:if %s.Field == HUDName
8966                 Name string
8967
8968                 //mt:if %s.Field == HUDScale
8969                 Scale [2]float32
8970
8971                 //mt:if %s.Field == HUDText
8972                 Text string
8973
8974                 //mt:if %s.Field == HUDNumber
8975                 Number uint32
8976
8977                 //mt:if %s.Field == HUDItem
8978                 Item uint32
8979
8980                 //mt:if %s.Field == HUDDir
8981                 Dir uint32
8982
8983                 //mt:if %s.Field == HUDAlign
8984                 Align [2]float32
8985
8986                 //mt:if %s.Field == HUDOffset
8987                 Offset [2]float32
8988
8989                 //mt:if %s.Field == HUDWorldPos
8990                 WorldPos Pos
8991
8992                 //mt:if %s.Field == HUDSize
8993                 Size [2]int32
8994
8995                 //mt:if %s.Field == HUDZIndex
8996                 ZIndex int32
8997
8998                 //mt:if %s.Field == HUDText2
8999                 Text2 string
9000         }))(obj)).Field == HUDZIndex {
9001                 {
9002                         x := (*(*(struct {
9003                                 ID HUDID
9004
9005                                 Field HUDField
9006
9007                                 //mt:if %s.Field == HUDPos
9008                                 Pos [2]float32
9009
9010                                 //mt:if %s.Field == HUDName
9011                                 Name string
9012
9013                                 //mt:if %s.Field == HUDScale
9014                                 Scale [2]float32
9015
9016                                 //mt:if %s.Field == HUDText
9017                                 Text string
9018
9019                                 //mt:if %s.Field == HUDNumber
9020                                 Number uint32
9021
9022                                 //mt:if %s.Field == HUDItem
9023                                 Item uint32
9024
9025                                 //mt:if %s.Field == HUDDir
9026                                 Dir uint32
9027
9028                                 //mt:if %s.Field == HUDAlign
9029                                 Align [2]float32
9030
9031                                 //mt:if %s.Field == HUDOffset
9032                                 Offset [2]float32
9033
9034                                 //mt:if %s.Field == HUDWorldPos
9035                                 WorldPos Pos
9036
9037                                 //mt:if %s.Field == HUDSize
9038                                 Size [2]int32
9039
9040                                 //mt:if %s.Field == HUDZIndex
9041                                 ZIndex int32
9042
9043                                 //mt:if %s.Field == HUDText2
9044                                 Text2 string
9045                         }))(obj)).ZIndex
9046                         write32(w, uint32(x))
9047                 }
9048         }
9049         if (*(*(struct {
9050                 ID HUDID
9051
9052                 Field HUDField
9053
9054                 //mt:if %s.Field == HUDPos
9055                 Pos [2]float32
9056
9057                 //mt:if %s.Field == HUDName
9058                 Name string
9059
9060                 //mt:if %s.Field == HUDScale
9061                 Scale [2]float32
9062
9063                 //mt:if %s.Field == HUDText
9064                 Text string
9065
9066                 //mt:if %s.Field == HUDNumber
9067                 Number uint32
9068
9069                 //mt:if %s.Field == HUDItem
9070                 Item uint32
9071
9072                 //mt:if %s.Field == HUDDir
9073                 Dir uint32
9074
9075                 //mt:if %s.Field == HUDAlign
9076                 Align [2]float32
9077
9078                 //mt:if %s.Field == HUDOffset
9079                 Offset [2]float32
9080
9081                 //mt:if %s.Field == HUDWorldPos
9082                 WorldPos Pos
9083
9084                 //mt:if %s.Field == HUDSize
9085                 Size [2]int32
9086
9087                 //mt:if %s.Field == HUDZIndex
9088                 ZIndex int32
9089
9090                 //mt:if %s.Field == HUDText2
9091                 Text2 string
9092         }))(obj)).Field == HUDText2 {
9093                 if len(([]byte((*(*(struct {
9094                         ID HUDID
9095
9096                         Field HUDField
9097
9098                         //mt:if %s.Field == HUDPos
9099                         Pos [2]float32
9100
9101                         //mt:if %s.Field == HUDName
9102                         Name string
9103
9104                         //mt:if %s.Field == HUDScale
9105                         Scale [2]float32
9106
9107                         //mt:if %s.Field == HUDText
9108                         Text string
9109
9110                         //mt:if %s.Field == HUDNumber
9111                         Number uint32
9112
9113                         //mt:if %s.Field == HUDItem
9114                         Item uint32
9115
9116                         //mt:if %s.Field == HUDDir
9117                         Dir uint32
9118
9119                         //mt:if %s.Field == HUDAlign
9120                         Align [2]float32
9121
9122                         //mt:if %s.Field == HUDOffset
9123                         Offset [2]float32
9124
9125                         //mt:if %s.Field == HUDWorldPos
9126                         WorldPos Pos
9127
9128                         //mt:if %s.Field == HUDSize
9129                         Size [2]int32
9130
9131                         //mt:if %s.Field == HUDZIndex
9132                         ZIndex int32
9133
9134                         //mt:if %s.Field == HUDText2
9135                         Text2 string
9136                 }))(obj)).Text2))) > math.MaxUint16 {
9137                         chk(ErrTooLong)
9138                 }
9139                 {
9140                         x := uint16(len(([]byte((*(*(struct {
9141                                 ID HUDID
9142
9143                                 Field HUDField
9144
9145                                 //mt:if %s.Field == HUDPos
9146                                 Pos [2]float32
9147
9148                                 //mt:if %s.Field == HUDName
9149                                 Name string
9150
9151                                 //mt:if %s.Field == HUDScale
9152                                 Scale [2]float32
9153
9154                                 //mt:if %s.Field == HUDText
9155                                 Text string
9156
9157                                 //mt:if %s.Field == HUDNumber
9158                                 Number uint32
9159
9160                                 //mt:if %s.Field == HUDItem
9161                                 Item uint32
9162
9163                                 //mt:if %s.Field == HUDDir
9164                                 Dir uint32
9165
9166                                 //mt:if %s.Field == HUDAlign
9167                                 Align [2]float32
9168
9169                                 //mt:if %s.Field == HUDOffset
9170                                 Offset [2]float32
9171
9172                                 //mt:if %s.Field == HUDWorldPos
9173                                 WorldPos Pos
9174
9175                                 //mt:if %s.Field == HUDSize
9176                                 Size [2]int32
9177
9178                                 //mt:if %s.Field == HUDZIndex
9179                                 ZIndex int32
9180
9181                                 //mt:if %s.Field == HUDText2
9182                                 Text2 string
9183                         }))(obj)).Text2))))
9184                         write16(w, uint16(x))
9185                 }
9186                 {
9187                         _, err := w.Write(([]byte((*(*(struct {
9188                                 ID HUDID
9189
9190                                 Field HUDField
9191
9192                                 //mt:if %s.Field == HUDPos
9193                                 Pos [2]float32
9194
9195                                 //mt:if %s.Field == HUDName
9196                                 Name string
9197
9198                                 //mt:if %s.Field == HUDScale
9199                                 Scale [2]float32
9200
9201                                 //mt:if %s.Field == HUDText
9202                                 Text string
9203
9204                                 //mt:if %s.Field == HUDNumber
9205                                 Number uint32
9206
9207                                 //mt:if %s.Field == HUDItem
9208                                 Item uint32
9209
9210                                 //mt:if %s.Field == HUDDir
9211                                 Dir uint32
9212
9213                                 //mt:if %s.Field == HUDAlign
9214                                 Align [2]float32
9215
9216                                 //mt:if %s.Field == HUDOffset
9217                                 Offset [2]float32
9218
9219                                 //mt:if %s.Field == HUDWorldPos
9220                                 WorldPos Pos
9221
9222                                 //mt:if %s.Field == HUDSize
9223                                 Size [2]int32
9224
9225                                 //mt:if %s.Field == HUDZIndex
9226                                 ZIndex int32
9227
9228                                 //mt:if %s.Field == HUDText2
9229                                 Text2 string
9230                         }))(obj)).Text2))[:])
9231                         chk(err)
9232                 }
9233         }
9234 }
9235
9236 func (obj *ToCltChangeHUD) deserialize(r io.Reader) {
9237         if err := pcall(func() {
9238                 ((*(*(struct {
9239                         ID HUDID
9240
9241                         Field HUDField
9242
9243                         //mt:if %s.Field == HUDPos
9244                         Pos [2]float32
9245
9246                         //mt:if %s.Field == HUDName
9247                         Name string
9248
9249                         //mt:if %s.Field == HUDScale
9250                         Scale [2]float32
9251
9252                         //mt:if %s.Field == HUDText
9253                         Text string
9254
9255                         //mt:if %s.Field == HUDNumber
9256                         Number uint32
9257
9258                         //mt:if %s.Field == HUDItem
9259                         Item uint32
9260
9261                         //mt:if %s.Field == HUDDir
9262                         Dir uint32
9263
9264                         //mt:if %s.Field == HUDAlign
9265                         Align [2]float32
9266
9267                         //mt:if %s.Field == HUDOffset
9268                         Offset [2]float32
9269
9270                         //mt:if %s.Field == HUDWorldPos
9271                         WorldPos Pos
9272
9273                         //mt:if %s.Field == HUDSize
9274                         Size [2]int32
9275
9276                         //mt:if %s.Field == HUDZIndex
9277                         ZIndex int32
9278
9279                         //mt:if %s.Field == HUDText2
9280                         Text2 string
9281                 }))(obj)).ID).deserialize(r)
9282         }); err != nil {
9283                 if err == io.EOF {
9284                         chk(io.EOF)
9285                 }
9286                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDID", err))
9287         }
9288         if err := pcall(func() {
9289                 ((*(*(struct {
9290                         ID HUDID
9291
9292                         Field HUDField
9293
9294                         //mt:if %s.Field == HUDPos
9295                         Pos [2]float32
9296
9297                         //mt:if %s.Field == HUDName
9298                         Name string
9299
9300                         //mt:if %s.Field == HUDScale
9301                         Scale [2]float32
9302
9303                         //mt:if %s.Field == HUDText
9304                         Text string
9305
9306                         //mt:if %s.Field == HUDNumber
9307                         Number uint32
9308
9309                         //mt:if %s.Field == HUDItem
9310                         Item uint32
9311
9312                         //mt:if %s.Field == HUDDir
9313                         Dir uint32
9314
9315                         //mt:if %s.Field == HUDAlign
9316                         Align [2]float32
9317
9318                         //mt:if %s.Field == HUDOffset
9319                         Offset [2]float32
9320
9321                         //mt:if %s.Field == HUDWorldPos
9322                         WorldPos Pos
9323
9324                         //mt:if %s.Field == HUDSize
9325                         Size [2]int32
9326
9327                         //mt:if %s.Field == HUDZIndex
9328                         ZIndex int32
9329
9330                         //mt:if %s.Field == HUDText2
9331                         Text2 string
9332                 }))(obj)).Field).deserialize(r)
9333         }); err != nil {
9334                 if err == io.EOF {
9335                         chk(io.EOF)
9336                 }
9337                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDField", err))
9338         }
9339         if !((*(*(struct {
9340                 ID HUDID
9341
9342                 Field HUDField
9343
9344                 //mt:if %s.Field == HUDPos
9345                 Pos [2]float32
9346
9347                 //mt:if %s.Field == HUDName
9348                 Name string
9349
9350                 //mt:if %s.Field == HUDScale
9351                 Scale [2]float32
9352
9353                 //mt:if %s.Field == HUDText
9354                 Text string
9355
9356                 //mt:if %s.Field == HUDNumber
9357                 Number uint32
9358
9359                 //mt:if %s.Field == HUDItem
9360                 Item uint32
9361
9362                 //mt:if %s.Field == HUDDir
9363                 Dir uint32
9364
9365                 //mt:if %s.Field == HUDAlign
9366                 Align [2]float32
9367
9368                 //mt:if %s.Field == HUDOffset
9369                 Offset [2]float32
9370
9371                 //mt:if %s.Field == HUDWorldPos
9372                 WorldPos Pos
9373
9374                 //mt:if %s.Field == HUDSize
9375                 Size [2]int32
9376
9377                 //mt:if %s.Field == HUDZIndex
9378                 ZIndex int32
9379
9380                 //mt:if %s.Field == HUDText2
9381                 Text2 string
9382         }))(obj)).Field < hudMax) {
9383                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9384         }
9385         if (*(*(struct {
9386                 ID HUDID
9387
9388                 Field HUDField
9389
9390                 //mt:if %s.Field == HUDPos
9391                 Pos [2]float32
9392
9393                 //mt:if %s.Field == HUDName
9394                 Name string
9395
9396                 //mt:if %s.Field == HUDScale
9397                 Scale [2]float32
9398
9399                 //mt:if %s.Field == HUDText
9400                 Text string
9401
9402                 //mt:if %s.Field == HUDNumber
9403                 Number uint32
9404
9405                 //mt:if %s.Field == HUDItem
9406                 Item uint32
9407
9408                 //mt:if %s.Field == HUDDir
9409                 Dir uint32
9410
9411                 //mt:if %s.Field == HUDAlign
9412                 Align [2]float32
9413
9414                 //mt:if %s.Field == HUDOffset
9415                 Offset [2]float32
9416
9417                 //mt:if %s.Field == HUDWorldPos
9418                 WorldPos Pos
9419
9420                 //mt:if %s.Field == HUDSize
9421                 Size [2]int32
9422
9423                 //mt:if %s.Field == HUDZIndex
9424                 ZIndex int32
9425
9426                 //mt:if %s.Field == HUDText2
9427                 Text2 string
9428         }))(obj)).Field == HUDPos {
9429                 for local179 := range (*(*(struct {
9430                         ID HUDID
9431
9432                         Field HUDField
9433
9434                         //mt:if %s.Field == HUDPos
9435                         Pos [2]float32
9436
9437                         //mt:if %s.Field == HUDName
9438                         Name string
9439
9440                         //mt:if %s.Field == HUDScale
9441                         Scale [2]float32
9442
9443                         //mt:if %s.Field == HUDText
9444                         Text string
9445
9446                         //mt:if %s.Field == HUDNumber
9447                         Number uint32
9448
9449                         //mt:if %s.Field == HUDItem
9450                         Item uint32
9451
9452                         //mt:if %s.Field == HUDDir
9453                         Dir uint32
9454
9455                         //mt:if %s.Field == HUDAlign
9456                         Align [2]float32
9457
9458                         //mt:if %s.Field == HUDOffset
9459                         Offset [2]float32
9460
9461                         //mt:if %s.Field == HUDWorldPos
9462                         WorldPos Pos
9463
9464                         //mt:if %s.Field == HUDSize
9465                         Size [2]int32
9466
9467                         //mt:if %s.Field == HUDZIndex
9468                         ZIndex int32
9469
9470                         //mt:if %s.Field == HUDText2
9471                         Text2 string
9472                 }))(obj)).Pos {
9473                         {
9474                                 p := &((*(*(struct {
9475                                         ID HUDID
9476
9477                                         Field HUDField
9478
9479                                         //mt:if %s.Field == HUDPos
9480                                         Pos [2]float32
9481
9482                                         //mt:if %s.Field == HUDName
9483                                         Name string
9484
9485                                         //mt:if %s.Field == HUDScale
9486                                         Scale [2]float32
9487
9488                                         //mt:if %s.Field == HUDText
9489                                         Text string
9490
9491                                         //mt:if %s.Field == HUDNumber
9492                                         Number uint32
9493
9494                                         //mt:if %s.Field == HUDItem
9495                                         Item uint32
9496
9497                                         //mt:if %s.Field == HUDDir
9498                                         Dir uint32
9499
9500                                         //mt:if %s.Field == HUDAlign
9501                                         Align [2]float32
9502
9503                                         //mt:if %s.Field == HUDOffset
9504                                         Offset [2]float32
9505
9506                                         //mt:if %s.Field == HUDWorldPos
9507                                         WorldPos Pos
9508
9509                                         //mt:if %s.Field == HUDSize
9510                                         Size [2]int32
9511
9512                                         //mt:if %s.Field == HUDZIndex
9513                                         ZIndex int32
9514
9515                                         //mt:if %s.Field == HUDText2
9516                                         Text2 string
9517                                 }))(obj)).Pos)[local179]
9518                                 *p = math.Float32frombits(read32(r))
9519                         }
9520                 }
9521         }
9522         if (*(*(struct {
9523                 ID HUDID
9524
9525                 Field HUDField
9526
9527                 //mt:if %s.Field == HUDPos
9528                 Pos [2]float32
9529
9530                 //mt:if %s.Field == HUDName
9531                 Name string
9532
9533                 //mt:if %s.Field == HUDScale
9534                 Scale [2]float32
9535
9536                 //mt:if %s.Field == HUDText
9537                 Text string
9538
9539                 //mt:if %s.Field == HUDNumber
9540                 Number uint32
9541
9542                 //mt:if %s.Field == HUDItem
9543                 Item uint32
9544
9545                 //mt:if %s.Field == HUDDir
9546                 Dir uint32
9547
9548                 //mt:if %s.Field == HUDAlign
9549                 Align [2]float32
9550
9551                 //mt:if %s.Field == HUDOffset
9552                 Offset [2]float32
9553
9554                 //mt:if %s.Field == HUDWorldPos
9555                 WorldPos Pos
9556
9557                 //mt:if %s.Field == HUDSize
9558                 Size [2]int32
9559
9560                 //mt:if %s.Field == HUDZIndex
9561                 ZIndex int32
9562
9563                 //mt:if %s.Field == HUDText2
9564                 Text2 string
9565         }))(obj)).Field == HUDName {
9566                 var local180 []uint8
9567                 var local181 uint16
9568                 {
9569                         p := &local181
9570                         *p = read16(r)
9571                 }
9572                 (local180) = make([]uint8, local181)
9573                 {
9574                         _, err := io.ReadFull(r, (local180)[:])
9575                         chk(err)
9576                 }
9577                 ((*(*(struct {
9578                         ID HUDID
9579
9580                         Field HUDField
9581
9582                         //mt:if %s.Field == HUDPos
9583                         Pos [2]float32
9584
9585                         //mt:if %s.Field == HUDName
9586                         Name string
9587
9588                         //mt:if %s.Field == HUDScale
9589                         Scale [2]float32
9590
9591                         //mt:if %s.Field == HUDText
9592                         Text string
9593
9594                         //mt:if %s.Field == HUDNumber
9595                         Number uint32
9596
9597                         //mt:if %s.Field == HUDItem
9598                         Item uint32
9599
9600                         //mt:if %s.Field == HUDDir
9601                         Dir uint32
9602
9603                         //mt:if %s.Field == HUDAlign
9604                         Align [2]float32
9605
9606                         //mt:if %s.Field == HUDOffset
9607                         Offset [2]float32
9608
9609                         //mt:if %s.Field == HUDWorldPos
9610                         WorldPos Pos
9611
9612                         //mt:if %s.Field == HUDSize
9613                         Size [2]int32
9614
9615                         //mt:if %s.Field == HUDZIndex
9616                         ZIndex int32
9617
9618                         //mt:if %s.Field == HUDText2
9619                         Text2 string
9620                 }))(obj)).Name) = string(local180)
9621         }
9622         if (*(*(struct {
9623                 ID HUDID
9624
9625                 Field HUDField
9626
9627                 //mt:if %s.Field == HUDPos
9628                 Pos [2]float32
9629
9630                 //mt:if %s.Field == HUDName
9631                 Name string
9632
9633                 //mt:if %s.Field == HUDScale
9634                 Scale [2]float32
9635
9636                 //mt:if %s.Field == HUDText
9637                 Text string
9638
9639                 //mt:if %s.Field == HUDNumber
9640                 Number uint32
9641
9642                 //mt:if %s.Field == HUDItem
9643                 Item uint32
9644
9645                 //mt:if %s.Field == HUDDir
9646                 Dir uint32
9647
9648                 //mt:if %s.Field == HUDAlign
9649                 Align [2]float32
9650
9651                 //mt:if %s.Field == HUDOffset
9652                 Offset [2]float32
9653
9654                 //mt:if %s.Field == HUDWorldPos
9655                 WorldPos Pos
9656
9657                 //mt:if %s.Field == HUDSize
9658                 Size [2]int32
9659
9660                 //mt:if %s.Field == HUDZIndex
9661                 ZIndex int32
9662
9663                 //mt:if %s.Field == HUDText2
9664                 Text2 string
9665         }))(obj)).Field == HUDScale {
9666                 for local182 := range (*(*(struct {
9667                         ID HUDID
9668
9669                         Field HUDField
9670
9671                         //mt:if %s.Field == HUDPos
9672                         Pos [2]float32
9673
9674                         //mt:if %s.Field == HUDName
9675                         Name string
9676
9677                         //mt:if %s.Field == HUDScale
9678                         Scale [2]float32
9679
9680                         //mt:if %s.Field == HUDText
9681                         Text string
9682
9683                         //mt:if %s.Field == HUDNumber
9684                         Number uint32
9685
9686                         //mt:if %s.Field == HUDItem
9687                         Item uint32
9688
9689                         //mt:if %s.Field == HUDDir
9690                         Dir uint32
9691
9692                         //mt:if %s.Field == HUDAlign
9693                         Align [2]float32
9694
9695                         //mt:if %s.Field == HUDOffset
9696                         Offset [2]float32
9697
9698                         //mt:if %s.Field == HUDWorldPos
9699                         WorldPos Pos
9700
9701                         //mt:if %s.Field == HUDSize
9702                         Size [2]int32
9703
9704                         //mt:if %s.Field == HUDZIndex
9705                         ZIndex int32
9706
9707                         //mt:if %s.Field == HUDText2
9708                         Text2 string
9709                 }))(obj)).Scale {
9710                         {
9711                                 p := &((*(*(struct {
9712                                         ID HUDID
9713
9714                                         Field HUDField
9715
9716                                         //mt:if %s.Field == HUDPos
9717                                         Pos [2]float32
9718
9719                                         //mt:if %s.Field == HUDName
9720                                         Name string
9721
9722                                         //mt:if %s.Field == HUDScale
9723                                         Scale [2]float32
9724
9725                                         //mt:if %s.Field == HUDText
9726                                         Text string
9727
9728                                         //mt:if %s.Field == HUDNumber
9729                                         Number uint32
9730
9731                                         //mt:if %s.Field == HUDItem
9732                                         Item uint32
9733
9734                                         //mt:if %s.Field == HUDDir
9735                                         Dir uint32
9736
9737                                         //mt:if %s.Field == HUDAlign
9738                                         Align [2]float32
9739
9740                                         //mt:if %s.Field == HUDOffset
9741                                         Offset [2]float32
9742
9743                                         //mt:if %s.Field == HUDWorldPos
9744                                         WorldPos Pos
9745
9746                                         //mt:if %s.Field == HUDSize
9747                                         Size [2]int32
9748
9749                                         //mt:if %s.Field == HUDZIndex
9750                                         ZIndex int32
9751
9752                                         //mt:if %s.Field == HUDText2
9753                                         Text2 string
9754                                 }))(obj)).Scale)[local182]
9755                                 *p = math.Float32frombits(read32(r))
9756                         }
9757                 }
9758         }
9759         if (*(*(struct {
9760                 ID HUDID
9761
9762                 Field HUDField
9763
9764                 //mt:if %s.Field == HUDPos
9765                 Pos [2]float32
9766
9767                 //mt:if %s.Field == HUDName
9768                 Name string
9769
9770                 //mt:if %s.Field == HUDScale
9771                 Scale [2]float32
9772
9773                 //mt:if %s.Field == HUDText
9774                 Text string
9775
9776                 //mt:if %s.Field == HUDNumber
9777                 Number uint32
9778
9779                 //mt:if %s.Field == HUDItem
9780                 Item uint32
9781
9782                 //mt:if %s.Field == HUDDir
9783                 Dir uint32
9784
9785                 //mt:if %s.Field == HUDAlign
9786                 Align [2]float32
9787
9788                 //mt:if %s.Field == HUDOffset
9789                 Offset [2]float32
9790
9791                 //mt:if %s.Field == HUDWorldPos
9792                 WorldPos Pos
9793
9794                 //mt:if %s.Field == HUDSize
9795                 Size [2]int32
9796
9797                 //mt:if %s.Field == HUDZIndex
9798                 ZIndex int32
9799
9800                 //mt:if %s.Field == HUDText2
9801                 Text2 string
9802         }))(obj)).Field == HUDText {
9803                 var local183 []uint8
9804                 var local184 uint16
9805                 {
9806                         p := &local184
9807                         *p = read16(r)
9808                 }
9809                 (local183) = make([]uint8, local184)
9810                 {
9811                         _, err := io.ReadFull(r, (local183)[:])
9812                         chk(err)
9813                 }
9814                 ((*(*(struct {
9815                         ID HUDID
9816
9817                         Field HUDField
9818
9819                         //mt:if %s.Field == HUDPos
9820                         Pos [2]float32
9821
9822                         //mt:if %s.Field == HUDName
9823                         Name string
9824
9825                         //mt:if %s.Field == HUDScale
9826                         Scale [2]float32
9827
9828                         //mt:if %s.Field == HUDText
9829                         Text string
9830
9831                         //mt:if %s.Field == HUDNumber
9832                         Number uint32
9833
9834                         //mt:if %s.Field == HUDItem
9835                         Item uint32
9836
9837                         //mt:if %s.Field == HUDDir
9838                         Dir uint32
9839
9840                         //mt:if %s.Field == HUDAlign
9841                         Align [2]float32
9842
9843                         //mt:if %s.Field == HUDOffset
9844                         Offset [2]float32
9845
9846                         //mt:if %s.Field == HUDWorldPos
9847                         WorldPos Pos
9848
9849                         //mt:if %s.Field == HUDSize
9850                         Size [2]int32
9851
9852                         //mt:if %s.Field == HUDZIndex
9853                         ZIndex int32
9854
9855                         //mt:if %s.Field == HUDText2
9856                         Text2 string
9857                 }))(obj)).Text) = string(local183)
9858         }
9859         if (*(*(struct {
9860                 ID HUDID
9861
9862                 Field HUDField
9863
9864                 //mt:if %s.Field == HUDPos
9865                 Pos [2]float32
9866
9867                 //mt:if %s.Field == HUDName
9868                 Name string
9869
9870                 //mt:if %s.Field == HUDScale
9871                 Scale [2]float32
9872
9873                 //mt:if %s.Field == HUDText
9874                 Text string
9875
9876                 //mt:if %s.Field == HUDNumber
9877                 Number uint32
9878
9879                 //mt:if %s.Field == HUDItem
9880                 Item uint32
9881
9882                 //mt:if %s.Field == HUDDir
9883                 Dir uint32
9884
9885                 //mt:if %s.Field == HUDAlign
9886                 Align [2]float32
9887
9888                 //mt:if %s.Field == HUDOffset
9889                 Offset [2]float32
9890
9891                 //mt:if %s.Field == HUDWorldPos
9892                 WorldPos Pos
9893
9894                 //mt:if %s.Field == HUDSize
9895                 Size [2]int32
9896
9897                 //mt:if %s.Field == HUDZIndex
9898                 ZIndex int32
9899
9900                 //mt:if %s.Field == HUDText2
9901                 Text2 string
9902         }))(obj)).Field == HUDNumber {
9903                 {
9904                         p := &(*(*(struct {
9905                                 ID HUDID
9906
9907                                 Field HUDField
9908
9909                                 //mt:if %s.Field == HUDPos
9910                                 Pos [2]float32
9911
9912                                 //mt:if %s.Field == HUDName
9913                                 Name string
9914
9915                                 //mt:if %s.Field == HUDScale
9916                                 Scale [2]float32
9917
9918                                 //mt:if %s.Field == HUDText
9919                                 Text string
9920
9921                                 //mt:if %s.Field == HUDNumber
9922                                 Number uint32
9923
9924                                 //mt:if %s.Field == HUDItem
9925                                 Item uint32
9926
9927                                 //mt:if %s.Field == HUDDir
9928                                 Dir uint32
9929
9930                                 //mt:if %s.Field == HUDAlign
9931                                 Align [2]float32
9932
9933                                 //mt:if %s.Field == HUDOffset
9934                                 Offset [2]float32
9935
9936                                 //mt:if %s.Field == HUDWorldPos
9937                                 WorldPos Pos
9938
9939                                 //mt:if %s.Field == HUDSize
9940                                 Size [2]int32
9941
9942                                 //mt:if %s.Field == HUDZIndex
9943                                 ZIndex int32
9944
9945                                 //mt:if %s.Field == HUDText2
9946                                 Text2 string
9947                         }))(obj)).Number
9948                         *p = read32(r)
9949                 }
9950         }
9951         if (*(*(struct {
9952                 ID HUDID
9953
9954                 Field HUDField
9955
9956                 //mt:if %s.Field == HUDPos
9957                 Pos [2]float32
9958
9959                 //mt:if %s.Field == HUDName
9960                 Name string
9961
9962                 //mt:if %s.Field == HUDScale
9963                 Scale [2]float32
9964
9965                 //mt:if %s.Field == HUDText
9966                 Text string
9967
9968                 //mt:if %s.Field == HUDNumber
9969                 Number uint32
9970
9971                 //mt:if %s.Field == HUDItem
9972                 Item uint32
9973
9974                 //mt:if %s.Field == HUDDir
9975                 Dir uint32
9976
9977                 //mt:if %s.Field == HUDAlign
9978                 Align [2]float32
9979
9980                 //mt:if %s.Field == HUDOffset
9981                 Offset [2]float32
9982
9983                 //mt:if %s.Field == HUDWorldPos
9984                 WorldPos Pos
9985
9986                 //mt:if %s.Field == HUDSize
9987                 Size [2]int32
9988
9989                 //mt:if %s.Field == HUDZIndex
9990                 ZIndex int32
9991
9992                 //mt:if %s.Field == HUDText2
9993                 Text2 string
9994         }))(obj)).Field == HUDItem {
9995                 {
9996                         p := &(*(*(struct {
9997                                 ID HUDID
9998
9999                                 Field HUDField
10000
10001                                 //mt:if %s.Field == HUDPos
10002                                 Pos [2]float32
10003
10004                                 //mt:if %s.Field == HUDName
10005                                 Name string
10006
10007                                 //mt:if %s.Field == HUDScale
10008                                 Scale [2]float32
10009
10010                                 //mt:if %s.Field == HUDText
10011                                 Text string
10012
10013                                 //mt:if %s.Field == HUDNumber
10014                                 Number uint32
10015
10016                                 //mt:if %s.Field == HUDItem
10017                                 Item uint32
10018
10019                                 //mt:if %s.Field == HUDDir
10020                                 Dir uint32
10021
10022                                 //mt:if %s.Field == HUDAlign
10023                                 Align [2]float32
10024
10025                                 //mt:if %s.Field == HUDOffset
10026                                 Offset [2]float32
10027
10028                                 //mt:if %s.Field == HUDWorldPos
10029                                 WorldPos Pos
10030
10031                                 //mt:if %s.Field == HUDSize
10032                                 Size [2]int32
10033
10034                                 //mt:if %s.Field == HUDZIndex
10035                                 ZIndex int32
10036
10037                                 //mt:if %s.Field == HUDText2
10038                                 Text2 string
10039                         }))(obj)).Item
10040                         *p = read32(r)
10041                 }
10042         }
10043         if (*(*(struct {
10044                 ID HUDID
10045
10046                 Field HUDField
10047
10048                 //mt:if %s.Field == HUDPos
10049                 Pos [2]float32
10050
10051                 //mt:if %s.Field == HUDName
10052                 Name string
10053
10054                 //mt:if %s.Field == HUDScale
10055                 Scale [2]float32
10056
10057                 //mt:if %s.Field == HUDText
10058                 Text string
10059
10060                 //mt:if %s.Field == HUDNumber
10061                 Number uint32
10062
10063                 //mt:if %s.Field == HUDItem
10064                 Item uint32
10065
10066                 //mt:if %s.Field == HUDDir
10067                 Dir uint32
10068
10069                 //mt:if %s.Field == HUDAlign
10070                 Align [2]float32
10071
10072                 //mt:if %s.Field == HUDOffset
10073                 Offset [2]float32
10074
10075                 //mt:if %s.Field == HUDWorldPos
10076                 WorldPos Pos
10077
10078                 //mt:if %s.Field == HUDSize
10079                 Size [2]int32
10080
10081                 //mt:if %s.Field == HUDZIndex
10082                 ZIndex int32
10083
10084                 //mt:if %s.Field == HUDText2
10085                 Text2 string
10086         }))(obj)).Field == HUDDir {
10087                 {
10088                         p := &(*(*(struct {
10089                                 ID HUDID
10090
10091                                 Field HUDField
10092
10093                                 //mt:if %s.Field == HUDPos
10094                                 Pos [2]float32
10095
10096                                 //mt:if %s.Field == HUDName
10097                                 Name string
10098
10099                                 //mt:if %s.Field == HUDScale
10100                                 Scale [2]float32
10101
10102                                 //mt:if %s.Field == HUDText
10103                                 Text string
10104
10105                                 //mt:if %s.Field == HUDNumber
10106                                 Number uint32
10107
10108                                 //mt:if %s.Field == HUDItem
10109                                 Item uint32
10110
10111                                 //mt:if %s.Field == HUDDir
10112                                 Dir uint32
10113
10114                                 //mt:if %s.Field == HUDAlign
10115                                 Align [2]float32
10116
10117                                 //mt:if %s.Field == HUDOffset
10118                                 Offset [2]float32
10119
10120                                 //mt:if %s.Field == HUDWorldPos
10121                                 WorldPos Pos
10122
10123                                 //mt:if %s.Field == HUDSize
10124                                 Size [2]int32
10125
10126                                 //mt:if %s.Field == HUDZIndex
10127                                 ZIndex int32
10128
10129                                 //mt:if %s.Field == HUDText2
10130                                 Text2 string
10131                         }))(obj)).Dir
10132                         *p = read32(r)
10133                 }
10134         }
10135         if (*(*(struct {
10136                 ID HUDID
10137
10138                 Field HUDField
10139
10140                 //mt:if %s.Field == HUDPos
10141                 Pos [2]float32
10142
10143                 //mt:if %s.Field == HUDName
10144                 Name string
10145
10146                 //mt:if %s.Field == HUDScale
10147                 Scale [2]float32
10148
10149                 //mt:if %s.Field == HUDText
10150                 Text string
10151
10152                 //mt:if %s.Field == HUDNumber
10153                 Number uint32
10154
10155                 //mt:if %s.Field == HUDItem
10156                 Item uint32
10157
10158                 //mt:if %s.Field == HUDDir
10159                 Dir uint32
10160
10161                 //mt:if %s.Field == HUDAlign
10162                 Align [2]float32
10163
10164                 //mt:if %s.Field == HUDOffset
10165                 Offset [2]float32
10166
10167                 //mt:if %s.Field == HUDWorldPos
10168                 WorldPos Pos
10169
10170                 //mt:if %s.Field == HUDSize
10171                 Size [2]int32
10172
10173                 //mt:if %s.Field == HUDZIndex
10174                 ZIndex int32
10175
10176                 //mt:if %s.Field == HUDText2
10177                 Text2 string
10178         }))(obj)).Field == HUDAlign {
10179                 for local185 := range (*(*(struct {
10180                         ID HUDID
10181
10182                         Field HUDField
10183
10184                         //mt:if %s.Field == HUDPos
10185                         Pos [2]float32
10186
10187                         //mt:if %s.Field == HUDName
10188                         Name string
10189
10190                         //mt:if %s.Field == HUDScale
10191                         Scale [2]float32
10192
10193                         //mt:if %s.Field == HUDText
10194                         Text string
10195
10196                         //mt:if %s.Field == HUDNumber
10197                         Number uint32
10198
10199                         //mt:if %s.Field == HUDItem
10200                         Item uint32
10201
10202                         //mt:if %s.Field == HUDDir
10203                         Dir uint32
10204
10205                         //mt:if %s.Field == HUDAlign
10206                         Align [2]float32
10207
10208                         //mt:if %s.Field == HUDOffset
10209                         Offset [2]float32
10210
10211                         //mt:if %s.Field == HUDWorldPos
10212                         WorldPos Pos
10213
10214                         //mt:if %s.Field == HUDSize
10215                         Size [2]int32
10216
10217                         //mt:if %s.Field == HUDZIndex
10218                         ZIndex int32
10219
10220                         //mt:if %s.Field == HUDText2
10221                         Text2 string
10222                 }))(obj)).Align {
10223                         {
10224                                 p := &((*(*(struct {
10225                                         ID HUDID
10226
10227                                         Field HUDField
10228
10229                                         //mt:if %s.Field == HUDPos
10230                                         Pos [2]float32
10231
10232                                         //mt:if %s.Field == HUDName
10233                                         Name string
10234
10235                                         //mt:if %s.Field == HUDScale
10236                                         Scale [2]float32
10237
10238                                         //mt:if %s.Field == HUDText
10239                                         Text string
10240
10241                                         //mt:if %s.Field == HUDNumber
10242                                         Number uint32
10243
10244                                         //mt:if %s.Field == HUDItem
10245                                         Item uint32
10246
10247                                         //mt:if %s.Field == HUDDir
10248                                         Dir uint32
10249
10250                                         //mt:if %s.Field == HUDAlign
10251                                         Align [2]float32
10252
10253                                         //mt:if %s.Field == HUDOffset
10254                                         Offset [2]float32
10255
10256                                         //mt:if %s.Field == HUDWorldPos
10257                                         WorldPos Pos
10258
10259                                         //mt:if %s.Field == HUDSize
10260                                         Size [2]int32
10261
10262                                         //mt:if %s.Field == HUDZIndex
10263                                         ZIndex int32
10264
10265                                         //mt:if %s.Field == HUDText2
10266                                         Text2 string
10267                                 }))(obj)).Align)[local185]
10268                                 *p = math.Float32frombits(read32(r))
10269                         }
10270                 }
10271         }
10272         if (*(*(struct {
10273                 ID HUDID
10274
10275                 Field HUDField
10276
10277                 //mt:if %s.Field == HUDPos
10278                 Pos [2]float32
10279
10280                 //mt:if %s.Field == HUDName
10281                 Name string
10282
10283                 //mt:if %s.Field == HUDScale
10284                 Scale [2]float32
10285
10286                 //mt:if %s.Field == HUDText
10287                 Text string
10288
10289                 //mt:if %s.Field == HUDNumber
10290                 Number uint32
10291
10292                 //mt:if %s.Field == HUDItem
10293                 Item uint32
10294
10295                 //mt:if %s.Field == HUDDir
10296                 Dir uint32
10297
10298                 //mt:if %s.Field == HUDAlign
10299                 Align [2]float32
10300
10301                 //mt:if %s.Field == HUDOffset
10302                 Offset [2]float32
10303
10304                 //mt:if %s.Field == HUDWorldPos
10305                 WorldPos Pos
10306
10307                 //mt:if %s.Field == HUDSize
10308                 Size [2]int32
10309
10310                 //mt:if %s.Field == HUDZIndex
10311                 ZIndex int32
10312
10313                 //mt:if %s.Field == HUDText2
10314                 Text2 string
10315         }))(obj)).Field == HUDOffset {
10316                 for local186 := range (*(*(struct {
10317                         ID HUDID
10318
10319                         Field HUDField
10320
10321                         //mt:if %s.Field == HUDPos
10322                         Pos [2]float32
10323
10324                         //mt:if %s.Field == HUDName
10325                         Name string
10326
10327                         //mt:if %s.Field == HUDScale
10328                         Scale [2]float32
10329
10330                         //mt:if %s.Field == HUDText
10331                         Text string
10332
10333                         //mt:if %s.Field == HUDNumber
10334                         Number uint32
10335
10336                         //mt:if %s.Field == HUDItem
10337                         Item uint32
10338
10339                         //mt:if %s.Field == HUDDir
10340                         Dir uint32
10341
10342                         //mt:if %s.Field == HUDAlign
10343                         Align [2]float32
10344
10345                         //mt:if %s.Field == HUDOffset
10346                         Offset [2]float32
10347
10348                         //mt:if %s.Field == HUDWorldPos
10349                         WorldPos Pos
10350
10351                         //mt:if %s.Field == HUDSize
10352                         Size [2]int32
10353
10354                         //mt:if %s.Field == HUDZIndex
10355                         ZIndex int32
10356
10357                         //mt:if %s.Field == HUDText2
10358                         Text2 string
10359                 }))(obj)).Offset {
10360                         {
10361                                 p := &((*(*(struct {
10362                                         ID HUDID
10363
10364                                         Field HUDField
10365
10366                                         //mt:if %s.Field == HUDPos
10367                                         Pos [2]float32
10368
10369                                         //mt:if %s.Field == HUDName
10370                                         Name string
10371
10372                                         //mt:if %s.Field == HUDScale
10373                                         Scale [2]float32
10374
10375                                         //mt:if %s.Field == HUDText
10376                                         Text string
10377
10378                                         //mt:if %s.Field == HUDNumber
10379                                         Number uint32
10380
10381                                         //mt:if %s.Field == HUDItem
10382                                         Item uint32
10383
10384                                         //mt:if %s.Field == HUDDir
10385                                         Dir uint32
10386
10387                                         //mt:if %s.Field == HUDAlign
10388                                         Align [2]float32
10389
10390                                         //mt:if %s.Field == HUDOffset
10391                                         Offset [2]float32
10392
10393                                         //mt:if %s.Field == HUDWorldPos
10394                                         WorldPos Pos
10395
10396                                         //mt:if %s.Field == HUDSize
10397                                         Size [2]int32
10398
10399                                         //mt:if %s.Field == HUDZIndex
10400                                         ZIndex int32
10401
10402                                         //mt:if %s.Field == HUDText2
10403                                         Text2 string
10404                                 }))(obj)).Offset)[local186]
10405                                 *p = math.Float32frombits(read32(r))
10406                         }
10407                 }
10408         }
10409         if (*(*(struct {
10410                 ID HUDID
10411
10412                 Field HUDField
10413
10414                 //mt:if %s.Field == HUDPos
10415                 Pos [2]float32
10416
10417                 //mt:if %s.Field == HUDName
10418                 Name string
10419
10420                 //mt:if %s.Field == HUDScale
10421                 Scale [2]float32
10422
10423                 //mt:if %s.Field == HUDText
10424                 Text string
10425
10426                 //mt:if %s.Field == HUDNumber
10427                 Number uint32
10428
10429                 //mt:if %s.Field == HUDItem
10430                 Item uint32
10431
10432                 //mt:if %s.Field == HUDDir
10433                 Dir uint32
10434
10435                 //mt:if %s.Field == HUDAlign
10436                 Align [2]float32
10437
10438                 //mt:if %s.Field == HUDOffset
10439                 Offset [2]float32
10440
10441                 //mt:if %s.Field == HUDWorldPos
10442                 WorldPos Pos
10443
10444                 //mt:if %s.Field == HUDSize
10445                 Size [2]int32
10446
10447                 //mt:if %s.Field == HUDZIndex
10448                 ZIndex int32
10449
10450                 //mt:if %s.Field == HUDText2
10451                 Text2 string
10452         }))(obj)).Field == HUDWorldPos {
10453                 if err := pcall(func() {
10454                         ((*(*(struct {
10455                                 ID HUDID
10456
10457                                 Field HUDField
10458
10459                                 //mt:if %s.Field == HUDPos
10460                                 Pos [2]float32
10461
10462                                 //mt:if %s.Field == HUDName
10463                                 Name string
10464
10465                                 //mt:if %s.Field == HUDScale
10466                                 Scale [2]float32
10467
10468                                 //mt:if %s.Field == HUDText
10469                                 Text string
10470
10471                                 //mt:if %s.Field == HUDNumber
10472                                 Number uint32
10473
10474                                 //mt:if %s.Field == HUDItem
10475                                 Item uint32
10476
10477                                 //mt:if %s.Field == HUDDir
10478                                 Dir uint32
10479
10480                                 //mt:if %s.Field == HUDAlign
10481                                 Align [2]float32
10482
10483                                 //mt:if %s.Field == HUDOffset
10484                                 Offset [2]float32
10485
10486                                 //mt:if %s.Field == HUDWorldPos
10487                                 WorldPos Pos
10488
10489                                 //mt:if %s.Field == HUDSize
10490                                 Size [2]int32
10491
10492                                 //mt:if %s.Field == HUDZIndex
10493                                 ZIndex int32
10494
10495                                 //mt:if %s.Field == HUDText2
10496                                 Text2 string
10497                         }))(obj)).WorldPos).deserialize(r)
10498                 }); err != nil {
10499                         if err == io.EOF {
10500                                 chk(io.EOF)
10501                         }
10502                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
10503                 }
10504         }
10505         if (*(*(struct {
10506                 ID HUDID
10507
10508                 Field HUDField
10509
10510                 //mt:if %s.Field == HUDPos
10511                 Pos [2]float32
10512
10513                 //mt:if %s.Field == HUDName
10514                 Name string
10515
10516                 //mt:if %s.Field == HUDScale
10517                 Scale [2]float32
10518
10519                 //mt:if %s.Field == HUDText
10520                 Text string
10521
10522                 //mt:if %s.Field == HUDNumber
10523                 Number uint32
10524
10525                 //mt:if %s.Field == HUDItem
10526                 Item uint32
10527
10528                 //mt:if %s.Field == HUDDir
10529                 Dir uint32
10530
10531                 //mt:if %s.Field == HUDAlign
10532                 Align [2]float32
10533
10534                 //mt:if %s.Field == HUDOffset
10535                 Offset [2]float32
10536
10537                 //mt:if %s.Field == HUDWorldPos
10538                 WorldPos Pos
10539
10540                 //mt:if %s.Field == HUDSize
10541                 Size [2]int32
10542
10543                 //mt:if %s.Field == HUDZIndex
10544                 ZIndex int32
10545
10546                 //mt:if %s.Field == HUDText2
10547                 Text2 string
10548         }))(obj)).Field == HUDSize {
10549                 for local187 := range (*(*(struct {
10550                         ID HUDID
10551
10552                         Field HUDField
10553
10554                         //mt:if %s.Field == HUDPos
10555                         Pos [2]float32
10556
10557                         //mt:if %s.Field == HUDName
10558                         Name string
10559
10560                         //mt:if %s.Field == HUDScale
10561                         Scale [2]float32
10562
10563                         //mt:if %s.Field == HUDText
10564                         Text string
10565
10566                         //mt:if %s.Field == HUDNumber
10567                         Number uint32
10568
10569                         //mt:if %s.Field == HUDItem
10570                         Item uint32
10571
10572                         //mt:if %s.Field == HUDDir
10573                         Dir uint32
10574
10575                         //mt:if %s.Field == HUDAlign
10576                         Align [2]float32
10577
10578                         //mt:if %s.Field == HUDOffset
10579                         Offset [2]float32
10580
10581                         //mt:if %s.Field == HUDWorldPos
10582                         WorldPos Pos
10583
10584                         //mt:if %s.Field == HUDSize
10585                         Size [2]int32
10586
10587                         //mt:if %s.Field == HUDZIndex
10588                         ZIndex int32
10589
10590                         //mt:if %s.Field == HUDText2
10591                         Text2 string
10592                 }))(obj)).Size {
10593                         {
10594                                 p := &((*(*(struct {
10595                                         ID HUDID
10596
10597                                         Field HUDField
10598
10599                                         //mt:if %s.Field == HUDPos
10600                                         Pos [2]float32
10601
10602                                         //mt:if %s.Field == HUDName
10603                                         Name string
10604
10605                                         //mt:if %s.Field == HUDScale
10606                                         Scale [2]float32
10607
10608                                         //mt:if %s.Field == HUDText
10609                                         Text string
10610
10611                                         //mt:if %s.Field == HUDNumber
10612                                         Number uint32
10613
10614                                         //mt:if %s.Field == HUDItem
10615                                         Item uint32
10616
10617                                         //mt:if %s.Field == HUDDir
10618                                         Dir uint32
10619
10620                                         //mt:if %s.Field == HUDAlign
10621                                         Align [2]float32
10622
10623                                         //mt:if %s.Field == HUDOffset
10624                                         Offset [2]float32
10625
10626                                         //mt:if %s.Field == HUDWorldPos
10627                                         WorldPos Pos
10628
10629                                         //mt:if %s.Field == HUDSize
10630                                         Size [2]int32
10631
10632                                         //mt:if %s.Field == HUDZIndex
10633                                         ZIndex int32
10634
10635                                         //mt:if %s.Field == HUDText2
10636                                         Text2 string
10637                                 }))(obj)).Size)[local187]
10638                                 *p = int32(read32(r))
10639                         }
10640                 }
10641         }
10642         if (*(*(struct {
10643                 ID HUDID
10644
10645                 Field HUDField
10646
10647                 //mt:if %s.Field == HUDPos
10648                 Pos [2]float32
10649
10650                 //mt:if %s.Field == HUDName
10651                 Name string
10652
10653                 //mt:if %s.Field == HUDScale
10654                 Scale [2]float32
10655
10656                 //mt:if %s.Field == HUDText
10657                 Text string
10658
10659                 //mt:if %s.Field == HUDNumber
10660                 Number uint32
10661
10662                 //mt:if %s.Field == HUDItem
10663                 Item uint32
10664
10665                 //mt:if %s.Field == HUDDir
10666                 Dir uint32
10667
10668                 //mt:if %s.Field == HUDAlign
10669                 Align [2]float32
10670
10671                 //mt:if %s.Field == HUDOffset
10672                 Offset [2]float32
10673
10674                 //mt:if %s.Field == HUDWorldPos
10675                 WorldPos Pos
10676
10677                 //mt:if %s.Field == HUDSize
10678                 Size [2]int32
10679
10680                 //mt:if %s.Field == HUDZIndex
10681                 ZIndex int32
10682
10683                 //mt:if %s.Field == HUDText2
10684                 Text2 string
10685         }))(obj)).Field == HUDZIndex {
10686                 {
10687                         p := &(*(*(struct {
10688                                 ID HUDID
10689
10690                                 Field HUDField
10691
10692                                 //mt:if %s.Field == HUDPos
10693                                 Pos [2]float32
10694
10695                                 //mt:if %s.Field == HUDName
10696                                 Name string
10697
10698                                 //mt:if %s.Field == HUDScale
10699                                 Scale [2]float32
10700
10701                                 //mt:if %s.Field == HUDText
10702                                 Text string
10703
10704                                 //mt:if %s.Field == HUDNumber
10705                                 Number uint32
10706
10707                                 //mt:if %s.Field == HUDItem
10708                                 Item uint32
10709
10710                                 //mt:if %s.Field == HUDDir
10711                                 Dir uint32
10712
10713                                 //mt:if %s.Field == HUDAlign
10714                                 Align [2]float32
10715
10716                                 //mt:if %s.Field == HUDOffset
10717                                 Offset [2]float32
10718
10719                                 //mt:if %s.Field == HUDWorldPos
10720                                 WorldPos Pos
10721
10722                                 //mt:if %s.Field == HUDSize
10723                                 Size [2]int32
10724
10725                                 //mt:if %s.Field == HUDZIndex
10726                                 ZIndex int32
10727
10728                                 //mt:if %s.Field == HUDText2
10729                                 Text2 string
10730                         }))(obj)).ZIndex
10731                         *p = int32(read32(r))
10732                 }
10733         }
10734         if (*(*(struct {
10735                 ID HUDID
10736
10737                 Field HUDField
10738
10739                 //mt:if %s.Field == HUDPos
10740                 Pos [2]float32
10741
10742                 //mt:if %s.Field == HUDName
10743                 Name string
10744
10745                 //mt:if %s.Field == HUDScale
10746                 Scale [2]float32
10747
10748                 //mt:if %s.Field == HUDText
10749                 Text string
10750
10751                 //mt:if %s.Field == HUDNumber
10752                 Number uint32
10753
10754                 //mt:if %s.Field == HUDItem
10755                 Item uint32
10756
10757                 //mt:if %s.Field == HUDDir
10758                 Dir uint32
10759
10760                 //mt:if %s.Field == HUDAlign
10761                 Align [2]float32
10762
10763                 //mt:if %s.Field == HUDOffset
10764                 Offset [2]float32
10765
10766                 //mt:if %s.Field == HUDWorldPos
10767                 WorldPos Pos
10768
10769                 //mt:if %s.Field == HUDSize
10770                 Size [2]int32
10771
10772                 //mt:if %s.Field == HUDZIndex
10773                 ZIndex int32
10774
10775                 //mt:if %s.Field == HUDText2
10776                 Text2 string
10777         }))(obj)).Field == HUDText2 {
10778                 var local188 []uint8
10779                 var local189 uint16
10780                 {
10781                         p := &local189
10782                         *p = read16(r)
10783                 }
10784                 (local188) = make([]uint8, local189)
10785                 {
10786                         _, err := io.ReadFull(r, (local188)[:])
10787                         chk(err)
10788                 }
10789                 ((*(*(struct {
10790                         ID HUDID
10791
10792                         Field HUDField
10793
10794                         //mt:if %s.Field == HUDPos
10795                         Pos [2]float32
10796
10797                         //mt:if %s.Field == HUDName
10798                         Name string
10799
10800                         //mt:if %s.Field == HUDScale
10801                         Scale [2]float32
10802
10803                         //mt:if %s.Field == HUDText
10804                         Text string
10805
10806                         //mt:if %s.Field == HUDNumber
10807                         Number uint32
10808
10809                         //mt:if %s.Field == HUDItem
10810                         Item uint32
10811
10812                         //mt:if %s.Field == HUDDir
10813                         Dir uint32
10814
10815                         //mt:if %s.Field == HUDAlign
10816                         Align [2]float32
10817
10818                         //mt:if %s.Field == HUDOffset
10819                         Offset [2]float32
10820
10821                         //mt:if %s.Field == HUDWorldPos
10822                         WorldPos Pos
10823
10824                         //mt:if %s.Field == HUDSize
10825                         Size [2]int32
10826
10827                         //mt:if %s.Field == HUDZIndex
10828                         ZIndex int32
10829
10830                         //mt:if %s.Field == HUDText2
10831                         Text2 string
10832                 }))(obj)).Text2) = string(local188)
10833         }
10834 }
10835
10836 func (obj *ToCltHUDFlags) serialize(w io.Writer) {
10837         if err := pcall(func() {
10838                 ((*(*(struct {
10839                         // &^= Mask
10840                         // |= Flags
10841                         Flags, Mask HUDFlags
10842                 }))(obj)).Flags).serialize(w)
10843         }); err != nil {
10844                 if err == io.EOF {
10845                         chk(io.EOF)
10846                 }
10847                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10848         }
10849         if err := pcall(func() {
10850                 ((*(*(struct {
10851                         // &^= Mask
10852                         // |= Flags
10853                         Flags, Mask HUDFlags
10854                 }))(obj)).Mask).serialize(w)
10855         }); err != nil {
10856                 if err == io.EOF {
10857                         chk(io.EOF)
10858                 }
10859                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10860         }
10861 }
10862
10863 func (obj *ToCltHUDFlags) deserialize(r io.Reader) {
10864         if err := pcall(func() {
10865                 ((*(*(struct {
10866                         // &^= Mask
10867                         // |= Flags
10868                         Flags, Mask HUDFlags
10869                 }))(obj)).Flags).deserialize(r)
10870         }); err != nil {
10871                 if err == io.EOF {
10872                         chk(io.EOF)
10873                 }
10874                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10875         }
10876         if err := pcall(func() {
10877                 ((*(*(struct {
10878                         // &^= Mask
10879                         // |= Flags
10880                         Flags, Mask HUDFlags
10881                 }))(obj)).Mask).deserialize(r)
10882         }); err != nil {
10883                 if err == io.EOF {
10884                         chk(io.EOF)
10885                 }
10886                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDFlags", err))
10887         }
10888 }
10889
10890 func (obj *ToCltSetHotbarParam) serialize(w io.Writer) {
10891         if err := pcall(func() {
10892                 ((*(*(struct {
10893                         Param HotbarParam
10894
10895                         //mt:if %s.Param == HotbarSize
10896                         //mt:const uint16(4) // Size of Size field.
10897                         Size int32
10898
10899                         //mt:if %s.Param != HotbarSize
10900                         Img Texture
10901                 }))(obj)).Param).serialize(w)
10902         }); err != nil {
10903                 if err == io.EOF {
10904                         chk(io.EOF)
10905                 }
10906                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HotbarParam", err))
10907         }
10908         if (*(*(struct {
10909                 Param HotbarParam
10910
10911                 //mt:if %s.Param == HotbarSize
10912                 //mt:const uint16(4) // Size of Size field.
10913                 Size int32
10914
10915                 //mt:if %s.Param != HotbarSize
10916                 Img Texture
10917         }))(obj)).Param == HotbarSize {
10918                 {
10919                         local190 := uint16(4) // Size of Size field.
10920                         {
10921                                 x := local190
10922                                 write16(w, uint16(x))
10923                         }
10924                 }
10925                 {
10926                         x := (*(*(struct {
10927                                 Param HotbarParam
10928
10929                                 //mt:if %s.Param == HotbarSize
10930                                 //mt:const uint16(4) // Size of Size field.
10931                                 Size int32
10932
10933                                 //mt:if %s.Param != HotbarSize
10934                                 Img Texture
10935                         }))(obj)).Size
10936                         write32(w, uint32(x))
10937                 }
10938         }
10939         if (*(*(struct {
10940                 Param HotbarParam
10941
10942                 //mt:if %s.Param == HotbarSize
10943                 //mt:const uint16(4) // Size of Size field.
10944                 Size int32
10945
10946                 //mt:if %s.Param != HotbarSize
10947                 Img Texture
10948         }))(obj)).Param != HotbarSize {
10949                 if err := pcall(func() {
10950                         ((*(*(struct {
10951                                 Param HotbarParam
10952
10953                                 //mt:if %s.Param == HotbarSize
10954                                 //mt:const uint16(4) // Size of Size field.
10955                                 Size int32
10956
10957                                 //mt:if %s.Param != HotbarSize
10958                                 Img Texture
10959                         }))(obj)).Img).serialize(w)
10960                 }); err != nil {
10961                         if err == io.EOF {
10962                                 chk(io.EOF)
10963                         }
10964                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
10965                 }
10966         }
10967 }
10968
10969 func (obj *ToCltSetHotbarParam) deserialize(r io.Reader) {
10970         if err := pcall(func() {
10971                 ((*(*(struct {
10972                         Param HotbarParam
10973
10974                         //mt:if %s.Param == HotbarSize
10975                         //mt:const uint16(4) // Size of Size field.
10976                         Size int32
10977
10978                         //mt:if %s.Param != HotbarSize
10979                         Img Texture
10980                 }))(obj)).Param).deserialize(r)
10981         }); err != nil {
10982                 if err == io.EOF {
10983                         chk(io.EOF)
10984                 }
10985                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HotbarParam", err))
10986         }
10987         if (*(*(struct {
10988                 Param HotbarParam
10989
10990                 //mt:if %s.Param == HotbarSize
10991                 //mt:const uint16(4) // Size of Size field.
10992                 Size int32
10993
10994                 //mt:if %s.Param != HotbarSize
10995                 Img Texture
10996         }))(obj)).Param == HotbarSize {
10997                 {
10998                         var local191 uint16
10999                         local192 := uint16(4) // Size of Size field.
11000                         {
11001                                 p := &local191
11002                                 *p = read16(r)
11003                         }
11004                         if local191 != local192 {
11005                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local191))
11006                         }
11007                 }
11008                 {
11009                         p := &(*(*(struct {
11010                                 Param HotbarParam
11011
11012                                 //mt:if %s.Param == HotbarSize
11013                                 //mt:const uint16(4) // Size of Size field.
11014                                 Size int32
11015
11016                                 //mt:if %s.Param != HotbarSize
11017                                 Img Texture
11018                         }))(obj)).Size
11019                         *p = int32(read32(r))
11020                 }
11021         }
11022         if (*(*(struct {
11023                 Param HotbarParam
11024
11025                 //mt:if %s.Param == HotbarSize
11026                 //mt:const uint16(4) // Size of Size field.
11027                 Size int32
11028
11029                 //mt:if %s.Param != HotbarSize
11030                 Img Texture
11031         }))(obj)).Param != HotbarSize {
11032                 if err := pcall(func() {
11033                         ((*(*(struct {
11034                                 Param HotbarParam
11035
11036                                 //mt:if %s.Param == HotbarSize
11037                                 //mt:const uint16(4) // Size of Size field.
11038                                 Size int32
11039
11040                                 //mt:if %s.Param != HotbarSize
11041                                 Img Texture
11042                         }))(obj)).Img).deserialize(r)
11043                 }); err != nil {
11044                         if err == io.EOF {
11045                                 chk(io.EOF)
11046                         }
11047                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
11048                 }
11049         }
11050 }
11051
11052 func (obj *ToCltBreath) serialize(w io.Writer) {
11053         {
11054                 x := (*(*(struct {
11055                         Breath uint16
11056                 }))(obj)).Breath
11057                 write16(w, uint16(x))
11058         }
11059 }
11060
11061 func (obj *ToCltBreath) deserialize(r io.Reader) {
11062         {
11063                 p := &(*(*(struct {
11064                         Breath uint16
11065                 }))(obj)).Breath
11066                 *p = read16(r)
11067         }
11068 }
11069
11070 func (obj *ToCltSkyParams) serialize(w io.Writer) {
11071         {
11072                 x := (*(*(struct {
11073                         BgColor     color.NRGBA
11074                         Type        string
11075                         Clouds      bool
11076                         SunFogTint  color.NRGBA
11077                         MoonFogTint color.NRGBA
11078                         FogTintType string
11079
11080                         //mt:if %s.Type == "skybox"
11081                         Textures []Texture
11082
11083                         //mt:if %s.Type == "regular"
11084                         DaySky, DayHorizon,
11085                         DawnSky, DawnHorizon,
11086                         NightSky, NightHorizon,
11087                         Indoor color.NRGBA
11088                 }))(obj)).BgColor
11089                 w.Write([]byte{x.A, x.R, x.G, x.B})
11090
11091         }
11092         if len(([]byte((*(*(struct {
11093                 BgColor     color.NRGBA
11094                 Type        string
11095                 Clouds      bool
11096                 SunFogTint  color.NRGBA
11097                 MoonFogTint color.NRGBA
11098                 FogTintType string
11099
11100                 //mt:if %s.Type == "skybox"
11101                 Textures []Texture
11102
11103                 //mt:if %s.Type == "regular"
11104                 DaySky, DayHorizon,
11105                 DawnSky, DawnHorizon,
11106                 NightSky, NightHorizon,
11107                 Indoor color.NRGBA
11108         }))(obj)).Type))) > math.MaxUint16 {
11109                 chk(ErrTooLong)
11110         }
11111         {
11112                 x := uint16(len(([]byte((*(*(struct {
11113                         BgColor     color.NRGBA
11114                         Type        string
11115                         Clouds      bool
11116                         SunFogTint  color.NRGBA
11117                         MoonFogTint color.NRGBA
11118                         FogTintType string
11119
11120                         //mt:if %s.Type == "skybox"
11121                         Textures []Texture
11122
11123                         //mt:if %s.Type == "regular"
11124                         DaySky, DayHorizon,
11125                         DawnSky, DawnHorizon,
11126                         NightSky, NightHorizon,
11127                         Indoor color.NRGBA
11128                 }))(obj)).Type))))
11129                 write16(w, uint16(x))
11130         }
11131         {
11132                 _, err := w.Write(([]byte((*(*(struct {
11133                         BgColor     color.NRGBA
11134                         Type        string
11135                         Clouds      bool
11136                         SunFogTint  color.NRGBA
11137                         MoonFogTint color.NRGBA
11138                         FogTintType string
11139
11140                         //mt:if %s.Type == "skybox"
11141                         Textures []Texture
11142
11143                         //mt:if %s.Type == "regular"
11144                         DaySky, DayHorizon,
11145                         DawnSky, DawnHorizon,
11146                         NightSky, NightHorizon,
11147                         Indoor color.NRGBA
11148                 }))(obj)).Type))[:])
11149                 chk(err)
11150         }
11151         {
11152                 x := (*(*(struct {
11153                         BgColor     color.NRGBA
11154                         Type        string
11155                         Clouds      bool
11156                         SunFogTint  color.NRGBA
11157                         MoonFogTint color.NRGBA
11158                         FogTintType string
11159
11160                         //mt:if %s.Type == "skybox"
11161                         Textures []Texture
11162
11163                         //mt:if %s.Type == "regular"
11164                         DaySky, DayHorizon,
11165                         DawnSky, DawnHorizon,
11166                         NightSky, NightHorizon,
11167                         Indoor color.NRGBA
11168                 }))(obj)).Clouds
11169                 if x {
11170                         write8(w, 1)
11171                 } else {
11172                         write8(w, 0)
11173                 }
11174
11175         }
11176         {
11177                 x := (*(*(struct {
11178                         BgColor     color.NRGBA
11179                         Type        string
11180                         Clouds      bool
11181                         SunFogTint  color.NRGBA
11182                         MoonFogTint color.NRGBA
11183                         FogTintType string
11184
11185                         //mt:if %s.Type == "skybox"
11186                         Textures []Texture
11187
11188                         //mt:if %s.Type == "regular"
11189                         DaySky, DayHorizon,
11190                         DawnSky, DawnHorizon,
11191                         NightSky, NightHorizon,
11192                         Indoor color.NRGBA
11193                 }))(obj)).SunFogTint
11194                 w.Write([]byte{x.A, x.R, x.G, x.B})
11195
11196         }
11197         {
11198                 x := (*(*(struct {
11199                         BgColor     color.NRGBA
11200                         Type        string
11201                         Clouds      bool
11202                         SunFogTint  color.NRGBA
11203                         MoonFogTint color.NRGBA
11204                         FogTintType string
11205
11206                         //mt:if %s.Type == "skybox"
11207                         Textures []Texture
11208
11209                         //mt:if %s.Type == "regular"
11210                         DaySky, DayHorizon,
11211                         DawnSky, DawnHorizon,
11212                         NightSky, NightHorizon,
11213                         Indoor color.NRGBA
11214                 }))(obj)).MoonFogTint
11215                 w.Write([]byte{x.A, x.R, x.G, x.B})
11216
11217         }
11218         if len(([]byte((*(*(struct {
11219                 BgColor     color.NRGBA
11220                 Type        string
11221                 Clouds      bool
11222                 SunFogTint  color.NRGBA
11223                 MoonFogTint color.NRGBA
11224                 FogTintType string
11225
11226                 //mt:if %s.Type == "skybox"
11227                 Textures []Texture
11228
11229                 //mt:if %s.Type == "regular"
11230                 DaySky, DayHorizon,
11231                 DawnSky, DawnHorizon,
11232                 NightSky, NightHorizon,
11233                 Indoor color.NRGBA
11234         }))(obj)).FogTintType))) > math.MaxUint16 {
11235                 chk(ErrTooLong)
11236         }
11237         {
11238                 x := uint16(len(([]byte((*(*(struct {
11239                         BgColor     color.NRGBA
11240                         Type        string
11241                         Clouds      bool
11242                         SunFogTint  color.NRGBA
11243                         MoonFogTint color.NRGBA
11244                         FogTintType string
11245
11246                         //mt:if %s.Type == "skybox"
11247                         Textures []Texture
11248
11249                         //mt:if %s.Type == "regular"
11250                         DaySky, DayHorizon,
11251                         DawnSky, DawnHorizon,
11252                         NightSky, NightHorizon,
11253                         Indoor color.NRGBA
11254                 }))(obj)).FogTintType))))
11255                 write16(w, uint16(x))
11256         }
11257         {
11258                 _, err := w.Write(([]byte((*(*(struct {
11259                         BgColor     color.NRGBA
11260                         Type        string
11261                         Clouds      bool
11262                         SunFogTint  color.NRGBA
11263                         MoonFogTint color.NRGBA
11264                         FogTintType string
11265
11266                         //mt:if %s.Type == "skybox"
11267                         Textures []Texture
11268
11269                         //mt:if %s.Type == "regular"
11270                         DaySky, DayHorizon,
11271                         DawnSky, DawnHorizon,
11272                         NightSky, NightHorizon,
11273                         Indoor color.NRGBA
11274                 }))(obj)).FogTintType))[:])
11275                 chk(err)
11276         }
11277         if (*(*(struct {
11278                 BgColor     color.NRGBA
11279                 Type        string
11280                 Clouds      bool
11281                 SunFogTint  color.NRGBA
11282                 MoonFogTint color.NRGBA
11283                 FogTintType string
11284
11285                 //mt:if %s.Type == "skybox"
11286                 Textures []Texture
11287
11288                 //mt:if %s.Type == "regular"
11289                 DaySky, DayHorizon,
11290                 DawnSky, DawnHorizon,
11291                 NightSky, NightHorizon,
11292                 Indoor color.NRGBA
11293         }))(obj)).Type == "skybox" {
11294                 if len(((*(*(struct {
11295                         BgColor     color.NRGBA
11296                         Type        string
11297                         Clouds      bool
11298                         SunFogTint  color.NRGBA
11299                         MoonFogTint color.NRGBA
11300                         FogTintType string
11301
11302                         //mt:if %s.Type == "skybox"
11303                         Textures []Texture
11304
11305                         //mt:if %s.Type == "regular"
11306                         DaySky, DayHorizon,
11307                         DawnSky, DawnHorizon,
11308                         NightSky, NightHorizon,
11309                         Indoor color.NRGBA
11310                 }))(obj)).Textures)) > math.MaxUint16 {
11311                         chk(ErrTooLong)
11312                 }
11313                 {
11314                         x := uint16(len(((*(*(struct {
11315                                 BgColor     color.NRGBA
11316                                 Type        string
11317                                 Clouds      bool
11318                                 SunFogTint  color.NRGBA
11319                                 MoonFogTint color.NRGBA
11320                                 FogTintType string
11321
11322                                 //mt:if %s.Type == "skybox"
11323                                 Textures []Texture
11324
11325                                 //mt:if %s.Type == "regular"
11326                                 DaySky, DayHorizon,
11327                                 DawnSky, DawnHorizon,
11328                                 NightSky, NightHorizon,
11329                                 Indoor color.NRGBA
11330                         }))(obj)).Textures)))
11331                         write16(w, uint16(x))
11332                 }
11333                 for local193 := range (*(*(struct {
11334                         BgColor     color.NRGBA
11335                         Type        string
11336                         Clouds      bool
11337                         SunFogTint  color.NRGBA
11338                         MoonFogTint color.NRGBA
11339                         FogTintType string
11340
11341                         //mt:if %s.Type == "skybox"
11342                         Textures []Texture
11343
11344                         //mt:if %s.Type == "regular"
11345                         DaySky, DayHorizon,
11346                         DawnSky, DawnHorizon,
11347                         NightSky, NightHorizon,
11348                         Indoor color.NRGBA
11349                 }))(obj)).Textures {
11350                         if err := pcall(func() {
11351                                 (((*(*(struct {
11352                                         BgColor     color.NRGBA
11353                                         Type        string
11354                                         Clouds      bool
11355                                         SunFogTint  color.NRGBA
11356                                         MoonFogTint color.NRGBA
11357                                         FogTintType string
11358
11359                                         //mt:if %s.Type == "skybox"
11360                                         Textures []Texture
11361
11362                                         //mt:if %s.Type == "regular"
11363                                         DaySky, DayHorizon,
11364                                         DawnSky, DawnHorizon,
11365                                         NightSky, NightHorizon,
11366                                         Indoor color.NRGBA
11367                                 }))(obj)).Textures)[local193]).serialize(w)
11368                         }); err != nil {
11369                                 if err == io.EOF {
11370                                         chk(io.EOF)
11371                                 }
11372                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
11373                         }
11374                 }
11375         }
11376         if (*(*(struct {
11377                 BgColor     color.NRGBA
11378                 Type        string
11379                 Clouds      bool
11380                 SunFogTint  color.NRGBA
11381                 MoonFogTint color.NRGBA
11382                 FogTintType string
11383
11384                 //mt:if %s.Type == "skybox"
11385                 Textures []Texture
11386
11387                 //mt:if %s.Type == "regular"
11388                 DaySky, DayHorizon,
11389                 DawnSky, DawnHorizon,
11390                 NightSky, NightHorizon,
11391                 Indoor color.NRGBA
11392         }))(obj)).Type == "regular" {
11393                 {
11394                         x := (*(*(struct {
11395                                 BgColor     color.NRGBA
11396                                 Type        string
11397                                 Clouds      bool
11398                                 SunFogTint  color.NRGBA
11399                                 MoonFogTint color.NRGBA
11400                                 FogTintType string
11401
11402                                 //mt:if %s.Type == "skybox"
11403                                 Textures []Texture
11404
11405                                 //mt:if %s.Type == "regular"
11406                                 DaySky, DayHorizon,
11407                                 DawnSky, DawnHorizon,
11408                                 NightSky, NightHorizon,
11409                                 Indoor color.NRGBA
11410                         }))(obj)).DaySky
11411                         w.Write([]byte{x.A, x.R, x.G, x.B})
11412
11413                 }
11414                 {
11415                         x := (*(*(struct {
11416                                 BgColor     color.NRGBA
11417                                 Type        string
11418                                 Clouds      bool
11419                                 SunFogTint  color.NRGBA
11420                                 MoonFogTint color.NRGBA
11421                                 FogTintType string
11422
11423                                 //mt:if %s.Type == "skybox"
11424                                 Textures []Texture
11425
11426                                 //mt:if %s.Type == "regular"
11427                                 DaySky, DayHorizon,
11428                                 DawnSky, DawnHorizon,
11429                                 NightSky, NightHorizon,
11430                                 Indoor color.NRGBA
11431                         }))(obj)).DayHorizon
11432                         w.Write([]byte{x.A, x.R, x.G, x.B})
11433
11434                 }
11435                 {
11436                         x := (*(*(struct {
11437                                 BgColor     color.NRGBA
11438                                 Type        string
11439                                 Clouds      bool
11440                                 SunFogTint  color.NRGBA
11441                                 MoonFogTint color.NRGBA
11442                                 FogTintType string
11443
11444                                 //mt:if %s.Type == "skybox"
11445                                 Textures []Texture
11446
11447                                 //mt:if %s.Type == "regular"
11448                                 DaySky, DayHorizon,
11449                                 DawnSky, DawnHorizon,
11450                                 NightSky, NightHorizon,
11451                                 Indoor color.NRGBA
11452                         }))(obj)).DawnSky
11453                         w.Write([]byte{x.A, x.R, x.G, x.B})
11454
11455                 }
11456                 {
11457                         x := (*(*(struct {
11458                                 BgColor     color.NRGBA
11459                                 Type        string
11460                                 Clouds      bool
11461                                 SunFogTint  color.NRGBA
11462                                 MoonFogTint color.NRGBA
11463                                 FogTintType string
11464
11465                                 //mt:if %s.Type == "skybox"
11466                                 Textures []Texture
11467
11468                                 //mt:if %s.Type == "regular"
11469                                 DaySky, DayHorizon,
11470                                 DawnSky, DawnHorizon,
11471                                 NightSky, NightHorizon,
11472                                 Indoor color.NRGBA
11473                         }))(obj)).DawnHorizon
11474                         w.Write([]byte{x.A, x.R, x.G, x.B})
11475
11476                 }
11477                 {
11478                         x := (*(*(struct {
11479                                 BgColor     color.NRGBA
11480                                 Type        string
11481                                 Clouds      bool
11482                                 SunFogTint  color.NRGBA
11483                                 MoonFogTint color.NRGBA
11484                                 FogTintType string
11485
11486                                 //mt:if %s.Type == "skybox"
11487                                 Textures []Texture
11488
11489                                 //mt:if %s.Type == "regular"
11490                                 DaySky, DayHorizon,
11491                                 DawnSky, DawnHorizon,
11492                                 NightSky, NightHorizon,
11493                                 Indoor color.NRGBA
11494                         }))(obj)).NightSky
11495                         w.Write([]byte{x.A, x.R, x.G, x.B})
11496
11497                 }
11498                 {
11499                         x := (*(*(struct {
11500                                 BgColor     color.NRGBA
11501                                 Type        string
11502                                 Clouds      bool
11503                                 SunFogTint  color.NRGBA
11504                                 MoonFogTint color.NRGBA
11505                                 FogTintType string
11506
11507                                 //mt:if %s.Type == "skybox"
11508                                 Textures []Texture
11509
11510                                 //mt:if %s.Type == "regular"
11511                                 DaySky, DayHorizon,
11512                                 DawnSky, DawnHorizon,
11513                                 NightSky, NightHorizon,
11514                                 Indoor color.NRGBA
11515                         }))(obj)).NightHorizon
11516                         w.Write([]byte{x.A, x.R, x.G, x.B})
11517
11518                 }
11519                 {
11520                         x := (*(*(struct {
11521                                 BgColor     color.NRGBA
11522                                 Type        string
11523                                 Clouds      bool
11524                                 SunFogTint  color.NRGBA
11525                                 MoonFogTint color.NRGBA
11526                                 FogTintType string
11527
11528                                 //mt:if %s.Type == "skybox"
11529                                 Textures []Texture
11530
11531                                 //mt:if %s.Type == "regular"
11532                                 DaySky, DayHorizon,
11533                                 DawnSky, DawnHorizon,
11534                                 NightSky, NightHorizon,
11535                                 Indoor color.NRGBA
11536                         }))(obj)).Indoor
11537                         w.Write([]byte{x.A, x.R, x.G, x.B})
11538
11539                 }
11540         }
11541 }
11542
11543 func (obj *ToCltSkyParams) deserialize(r io.Reader) {
11544         {
11545                 p := &(*(*(struct {
11546                         BgColor     color.NRGBA
11547                         Type        string
11548                         Clouds      bool
11549                         SunFogTint  color.NRGBA
11550                         MoonFogTint color.NRGBA
11551                         FogTintType string
11552
11553                         //mt:if %s.Type == "skybox"
11554                         Textures []Texture
11555
11556                         //mt:if %s.Type == "regular"
11557                         DaySky, DayHorizon,
11558                         DawnSky, DawnHorizon,
11559                         NightSky, NightHorizon,
11560                         Indoor color.NRGBA
11561                 }))(obj)).BgColor
11562                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11563
11564         }
11565         var local194 []uint8
11566         var local195 uint16
11567         {
11568                 p := &local195
11569                 *p = read16(r)
11570         }
11571         (local194) = make([]uint8, local195)
11572         {
11573                 _, err := io.ReadFull(r, (local194)[:])
11574                 chk(err)
11575         }
11576         ((*(*(struct {
11577                 BgColor     color.NRGBA
11578                 Type        string
11579                 Clouds      bool
11580                 SunFogTint  color.NRGBA
11581                 MoonFogTint color.NRGBA
11582                 FogTintType string
11583
11584                 //mt:if %s.Type == "skybox"
11585                 Textures []Texture
11586
11587                 //mt:if %s.Type == "regular"
11588                 DaySky, DayHorizon,
11589                 DawnSky, DawnHorizon,
11590                 NightSky, NightHorizon,
11591                 Indoor color.NRGBA
11592         }))(obj)).Type) = string(local194)
11593         {
11594                 p := &(*(*(struct {
11595                         BgColor     color.NRGBA
11596                         Type        string
11597                         Clouds      bool
11598                         SunFogTint  color.NRGBA
11599                         MoonFogTint color.NRGBA
11600                         FogTintType string
11601
11602                         //mt:if %s.Type == "skybox"
11603                         Textures []Texture
11604
11605                         //mt:if %s.Type == "regular"
11606                         DaySky, DayHorizon,
11607                         DawnSky, DawnHorizon,
11608                         NightSky, NightHorizon,
11609                         Indoor color.NRGBA
11610                 }))(obj)).Clouds
11611                 switch n := read8(r); n {
11612                 case 0:
11613                         *p = false
11614                 case 1:
11615                         *p = true
11616                 default:
11617                         chk(fmt.Errorf("invalid bool: %d", n))
11618                 }
11619
11620         }
11621         {
11622                 p := &(*(*(struct {
11623                         BgColor     color.NRGBA
11624                         Type        string
11625                         Clouds      bool
11626                         SunFogTint  color.NRGBA
11627                         MoonFogTint color.NRGBA
11628                         FogTintType string
11629
11630                         //mt:if %s.Type == "skybox"
11631                         Textures []Texture
11632
11633                         //mt:if %s.Type == "regular"
11634                         DaySky, DayHorizon,
11635                         DawnSky, DawnHorizon,
11636                         NightSky, NightHorizon,
11637                         Indoor color.NRGBA
11638                 }))(obj)).SunFogTint
11639                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11640
11641         }
11642         {
11643                 p := &(*(*(struct {
11644                         BgColor     color.NRGBA
11645                         Type        string
11646                         Clouds      bool
11647                         SunFogTint  color.NRGBA
11648                         MoonFogTint color.NRGBA
11649                         FogTintType string
11650
11651                         //mt:if %s.Type == "skybox"
11652                         Textures []Texture
11653
11654                         //mt:if %s.Type == "regular"
11655                         DaySky, DayHorizon,
11656                         DawnSky, DawnHorizon,
11657                         NightSky, NightHorizon,
11658                         Indoor color.NRGBA
11659                 }))(obj)).MoonFogTint
11660                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11661
11662         }
11663         var local196 []uint8
11664         var local197 uint16
11665         {
11666                 p := &local197
11667                 *p = read16(r)
11668         }
11669         (local196) = make([]uint8, local197)
11670         {
11671                 _, err := io.ReadFull(r, (local196)[:])
11672                 chk(err)
11673         }
11674         ((*(*(struct {
11675                 BgColor     color.NRGBA
11676                 Type        string
11677                 Clouds      bool
11678                 SunFogTint  color.NRGBA
11679                 MoonFogTint color.NRGBA
11680                 FogTintType string
11681
11682                 //mt:if %s.Type == "skybox"
11683                 Textures []Texture
11684
11685                 //mt:if %s.Type == "regular"
11686                 DaySky, DayHorizon,
11687                 DawnSky, DawnHorizon,
11688                 NightSky, NightHorizon,
11689                 Indoor color.NRGBA
11690         }))(obj)).FogTintType) = string(local196)
11691         if (*(*(struct {
11692                 BgColor     color.NRGBA
11693                 Type        string
11694                 Clouds      bool
11695                 SunFogTint  color.NRGBA
11696                 MoonFogTint color.NRGBA
11697                 FogTintType string
11698
11699                 //mt:if %s.Type == "skybox"
11700                 Textures []Texture
11701
11702                 //mt:if %s.Type == "regular"
11703                 DaySky, DayHorizon,
11704                 DawnSky, DawnHorizon,
11705                 NightSky, NightHorizon,
11706                 Indoor color.NRGBA
11707         }))(obj)).Type == "skybox" {
11708                 var local198 uint16
11709                 {
11710                         p := &local198
11711                         *p = read16(r)
11712                 }
11713                 ((*(*(struct {
11714                         BgColor     color.NRGBA
11715                         Type        string
11716                         Clouds      bool
11717                         SunFogTint  color.NRGBA
11718                         MoonFogTint color.NRGBA
11719                         FogTintType string
11720
11721                         //mt:if %s.Type == "skybox"
11722                         Textures []Texture
11723
11724                         //mt:if %s.Type == "regular"
11725                         DaySky, DayHorizon,
11726                         DawnSky, DawnHorizon,
11727                         NightSky, NightHorizon,
11728                         Indoor color.NRGBA
11729                 }))(obj)).Textures) = make([]Texture, local198)
11730                 for local199 := range (*(*(struct {
11731                         BgColor     color.NRGBA
11732                         Type        string
11733                         Clouds      bool
11734                         SunFogTint  color.NRGBA
11735                         MoonFogTint color.NRGBA
11736                         FogTintType string
11737
11738                         //mt:if %s.Type == "skybox"
11739                         Textures []Texture
11740
11741                         //mt:if %s.Type == "regular"
11742                         DaySky, DayHorizon,
11743                         DawnSky, DawnHorizon,
11744                         NightSky, NightHorizon,
11745                         Indoor color.NRGBA
11746                 }))(obj)).Textures {
11747                         if err := pcall(func() {
11748                                 (((*(*(struct {
11749                                         BgColor     color.NRGBA
11750                                         Type        string
11751                                         Clouds      bool
11752                                         SunFogTint  color.NRGBA
11753                                         MoonFogTint color.NRGBA
11754                                         FogTintType string
11755
11756                                         //mt:if %s.Type == "skybox"
11757                                         Textures []Texture
11758
11759                                         //mt:if %s.Type == "regular"
11760                                         DaySky, DayHorizon,
11761                                         DawnSky, DawnHorizon,
11762                                         NightSky, NightHorizon,
11763                                         Indoor color.NRGBA
11764                                 }))(obj)).Textures)[local199]).deserialize(r)
11765                         }); err != nil {
11766                                 if err == io.EOF {
11767                                         chk(io.EOF)
11768                                 }
11769                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
11770                         }
11771                 }
11772         }
11773         if (*(*(struct {
11774                 BgColor     color.NRGBA
11775                 Type        string
11776                 Clouds      bool
11777                 SunFogTint  color.NRGBA
11778                 MoonFogTint color.NRGBA
11779                 FogTintType string
11780
11781                 //mt:if %s.Type == "skybox"
11782                 Textures []Texture
11783
11784                 //mt:if %s.Type == "regular"
11785                 DaySky, DayHorizon,
11786                 DawnSky, DawnHorizon,
11787                 NightSky, NightHorizon,
11788                 Indoor color.NRGBA
11789         }))(obj)).Type == "regular" {
11790                 {
11791                         p := &(*(*(struct {
11792                                 BgColor     color.NRGBA
11793                                 Type        string
11794                                 Clouds      bool
11795                                 SunFogTint  color.NRGBA
11796                                 MoonFogTint color.NRGBA
11797                                 FogTintType string
11798
11799                                 //mt:if %s.Type == "skybox"
11800                                 Textures []Texture
11801
11802                                 //mt:if %s.Type == "regular"
11803                                 DaySky, DayHorizon,
11804                                 DawnSky, DawnHorizon,
11805                                 NightSky, NightHorizon,
11806                                 Indoor color.NRGBA
11807                         }))(obj)).DaySky
11808                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11809
11810                 }
11811                 {
11812                         p := &(*(*(struct {
11813                                 BgColor     color.NRGBA
11814                                 Type        string
11815                                 Clouds      bool
11816                                 SunFogTint  color.NRGBA
11817                                 MoonFogTint color.NRGBA
11818                                 FogTintType string
11819
11820                                 //mt:if %s.Type == "skybox"
11821                                 Textures []Texture
11822
11823                                 //mt:if %s.Type == "regular"
11824                                 DaySky, DayHorizon,
11825                                 DawnSky, DawnHorizon,
11826                                 NightSky, NightHorizon,
11827                                 Indoor color.NRGBA
11828                         }))(obj)).DayHorizon
11829                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11830
11831                 }
11832                 {
11833                         p := &(*(*(struct {
11834                                 BgColor     color.NRGBA
11835                                 Type        string
11836                                 Clouds      bool
11837                                 SunFogTint  color.NRGBA
11838                                 MoonFogTint color.NRGBA
11839                                 FogTintType string
11840
11841                                 //mt:if %s.Type == "skybox"
11842                                 Textures []Texture
11843
11844                                 //mt:if %s.Type == "regular"
11845                                 DaySky, DayHorizon,
11846                                 DawnSky, DawnHorizon,
11847                                 NightSky, NightHorizon,
11848                                 Indoor color.NRGBA
11849                         }))(obj)).DawnSky
11850                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11851
11852                 }
11853                 {
11854                         p := &(*(*(struct {
11855                                 BgColor     color.NRGBA
11856                                 Type        string
11857                                 Clouds      bool
11858                                 SunFogTint  color.NRGBA
11859                                 MoonFogTint color.NRGBA
11860                                 FogTintType string
11861
11862                                 //mt:if %s.Type == "skybox"
11863                                 Textures []Texture
11864
11865                                 //mt:if %s.Type == "regular"
11866                                 DaySky, DayHorizon,
11867                                 DawnSky, DawnHorizon,
11868                                 NightSky, NightHorizon,
11869                                 Indoor color.NRGBA
11870                         }))(obj)).DawnHorizon
11871                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11872
11873                 }
11874                 {
11875                         p := &(*(*(struct {
11876                                 BgColor     color.NRGBA
11877                                 Type        string
11878                                 Clouds      bool
11879                                 SunFogTint  color.NRGBA
11880                                 MoonFogTint color.NRGBA
11881                                 FogTintType string
11882
11883                                 //mt:if %s.Type == "skybox"
11884                                 Textures []Texture
11885
11886                                 //mt:if %s.Type == "regular"
11887                                 DaySky, DayHorizon,
11888                                 DawnSky, DawnHorizon,
11889                                 NightSky, NightHorizon,
11890                                 Indoor color.NRGBA
11891                         }))(obj)).NightSky
11892                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11893
11894                 }
11895                 {
11896                         p := &(*(*(struct {
11897                                 BgColor     color.NRGBA
11898                                 Type        string
11899                                 Clouds      bool
11900                                 SunFogTint  color.NRGBA
11901                                 MoonFogTint color.NRGBA
11902                                 FogTintType string
11903
11904                                 //mt:if %s.Type == "skybox"
11905                                 Textures []Texture
11906
11907                                 //mt:if %s.Type == "regular"
11908                                 DaySky, DayHorizon,
11909                                 DawnSky, DawnHorizon,
11910                                 NightSky, NightHorizon,
11911                                 Indoor color.NRGBA
11912                         }))(obj)).NightHorizon
11913                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11914
11915                 }
11916                 {
11917                         p := &(*(*(struct {
11918                                 BgColor     color.NRGBA
11919                                 Type        string
11920                                 Clouds      bool
11921                                 SunFogTint  color.NRGBA
11922                                 MoonFogTint color.NRGBA
11923                                 FogTintType string
11924
11925                                 //mt:if %s.Type == "skybox"
11926                                 Textures []Texture
11927
11928                                 //mt:if %s.Type == "regular"
11929                                 DaySky, DayHorizon,
11930                                 DawnSky, DawnHorizon,
11931                                 NightSky, NightHorizon,
11932                                 Indoor color.NRGBA
11933                         }))(obj)).Indoor
11934                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11935
11936                 }
11937         }
11938 }
11939
11940 func (obj *ToCltOverrideDayNightRatio) serialize(w io.Writer) {
11941         {
11942                 x := (*(*(struct {
11943                         Override bool
11944                         Ratio    uint16
11945                 }))(obj)).Override
11946                 if x {
11947                         write8(w, 1)
11948                 } else {
11949                         write8(w, 0)
11950                 }
11951
11952         }
11953         {
11954                 x := (*(*(struct {
11955                         Override bool
11956                         Ratio    uint16
11957                 }))(obj)).Ratio
11958                 write16(w, uint16(x))
11959         }
11960 }
11961
11962 func (obj *ToCltOverrideDayNightRatio) deserialize(r io.Reader) {
11963         {
11964                 p := &(*(*(struct {
11965                         Override bool
11966                         Ratio    uint16
11967                 }))(obj)).Override
11968                 switch n := read8(r); n {
11969                 case 0:
11970                         *p = false
11971                 case 1:
11972                         *p = true
11973                 default:
11974                         chk(fmt.Errorf("invalid bool: %d", n))
11975                 }
11976
11977         }
11978         {
11979                 p := &(*(*(struct {
11980                         Override bool
11981                         Ratio    uint16
11982                 }))(obj)).Ratio
11983                 *p = read16(r)
11984         }
11985 }
11986
11987 func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
11988         for local200 := range (*(*(struct {
11989                 Idle, Walk, Dig, WalkDig [2]int32
11990                 Speed                    float32
11991         }))(obj)).Idle {
11992                 {
11993                         x := ((*(*(struct {
11994                                 Idle, Walk, Dig, WalkDig [2]int32
11995                                 Speed                    float32
11996                         }))(obj)).Idle)[local200]
11997                         write32(w, uint32(x))
11998                 }
11999         }
12000         for local201 := range (*(*(struct {
12001                 Idle, Walk, Dig, WalkDig [2]int32
12002                 Speed                    float32
12003         }))(obj)).Walk {
12004                 {
12005                         x := ((*(*(struct {
12006                                 Idle, Walk, Dig, WalkDig [2]int32
12007                                 Speed                    float32
12008                         }))(obj)).Walk)[local201]
12009                         write32(w, uint32(x))
12010                 }
12011         }
12012         for local202 := range (*(*(struct {
12013                 Idle, Walk, Dig, WalkDig [2]int32
12014                 Speed                    float32
12015         }))(obj)).Dig {
12016                 {
12017                         x := ((*(*(struct {
12018                                 Idle, Walk, Dig, WalkDig [2]int32
12019                                 Speed                    float32
12020                         }))(obj)).Dig)[local202]
12021                         write32(w, uint32(x))
12022                 }
12023         }
12024         for local203 := range (*(*(struct {
12025                 Idle, Walk, Dig, WalkDig [2]int32
12026                 Speed                    float32
12027         }))(obj)).WalkDig {
12028                 {
12029                         x := ((*(*(struct {
12030                                 Idle, Walk, Dig, WalkDig [2]int32
12031                                 Speed                    float32
12032                         }))(obj)).WalkDig)[local203]
12033                         write32(w, uint32(x))
12034                 }
12035         }
12036         {
12037                 x := (*(*(struct {
12038                         Idle, Walk, Dig, WalkDig [2]int32
12039                         Speed                    float32
12040                 }))(obj)).Speed
12041                 write32(w, math.Float32bits(x))
12042         }
12043 }
12044
12045 func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
12046         for local204 := range (*(*(struct {
12047                 Idle, Walk, Dig, WalkDig [2]int32
12048                 Speed                    float32
12049         }))(obj)).Idle {
12050                 {
12051                         p := &((*(*(struct {
12052                                 Idle, Walk, Dig, WalkDig [2]int32
12053                                 Speed                    float32
12054                         }))(obj)).Idle)[local204]
12055                         *p = int32(read32(r))
12056                 }
12057         }
12058         for local205 := range (*(*(struct {
12059                 Idle, Walk, Dig, WalkDig [2]int32
12060                 Speed                    float32
12061         }))(obj)).Walk {
12062                 {
12063                         p := &((*(*(struct {
12064                                 Idle, Walk, Dig, WalkDig [2]int32
12065                                 Speed                    float32
12066                         }))(obj)).Walk)[local205]
12067                         *p = int32(read32(r))
12068                 }
12069         }
12070         for local206 := range (*(*(struct {
12071                 Idle, Walk, Dig, WalkDig [2]int32
12072                 Speed                    float32
12073         }))(obj)).Dig {
12074                 {
12075                         p := &((*(*(struct {
12076                                 Idle, Walk, Dig, WalkDig [2]int32
12077                                 Speed                    float32
12078                         }))(obj)).Dig)[local206]
12079                         *p = int32(read32(r))
12080                 }
12081         }
12082         for local207 := range (*(*(struct {
12083                 Idle, Walk, Dig, WalkDig [2]int32
12084                 Speed                    float32
12085         }))(obj)).WalkDig {
12086                 {
12087                         p := &((*(*(struct {
12088                                 Idle, Walk, Dig, WalkDig [2]int32
12089                                 Speed                    float32
12090                         }))(obj)).WalkDig)[local207]
12091                         *p = int32(read32(r))
12092                 }
12093         }
12094         {
12095                 p := &(*(*(struct {
12096                         Idle, Walk, Dig, WalkDig [2]int32
12097                         Speed                    float32
12098                 }))(obj)).Speed
12099                 *p = math.Float32frombits(read32(r))
12100         }
12101 }
12102
12103 func (obj *ToCltEyeOffset) serialize(w io.Writer) {
12104         if err := pcall(func() {
12105                 ((*(*(struct {
12106                         First, Third Vec
12107                 }))(obj)).First).serialize(w)
12108         }); err != nil {
12109                 if err == io.EOF {
12110                         chk(io.EOF)
12111                 }
12112                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12113         }
12114         if err := pcall(func() {
12115                 ((*(*(struct {
12116                         First, Third Vec
12117                 }))(obj)).Third).serialize(w)
12118         }); err != nil {
12119                 if err == io.EOF {
12120                         chk(io.EOF)
12121                 }
12122                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12123         }
12124 }
12125
12126 func (obj *ToCltEyeOffset) deserialize(r io.Reader) {
12127         if err := pcall(func() {
12128                 ((*(*(struct {
12129                         First, Third Vec
12130                 }))(obj)).First).deserialize(r)
12131         }); err != nil {
12132                 if err == io.EOF {
12133                         chk(io.EOF)
12134                 }
12135                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12136         }
12137         if err := pcall(func() {
12138                 ((*(*(struct {
12139                         First, Third Vec
12140                 }))(obj)).Third).deserialize(r)
12141         }); err != nil {
12142                 if err == io.EOF {
12143                         chk(io.EOF)
12144                 }
12145                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
12146         }
12147 }
12148
12149 func (obj *ToCltDelParticleSpawner) serialize(w io.Writer) {
12150         if err := pcall(func() {
12151                 ((*(*(struct {
12152                         ID ParticleSpawnerID
12153                 }))(obj)).ID).serialize(w)
12154         }); err != nil {
12155                 if err == io.EOF {
12156                         chk(io.EOF)
12157                 }
12158                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
12159         }
12160 }
12161
12162 func (obj *ToCltDelParticleSpawner) deserialize(r io.Reader) {
12163         if err := pcall(func() {
12164                 ((*(*(struct {
12165                         ID ParticleSpawnerID
12166                 }))(obj)).ID).deserialize(r)
12167         }); err != nil {
12168                 if err == io.EOF {
12169                         chk(io.EOF)
12170                 }
12171                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ParticleSpawnerID", err))
12172         }
12173 }
12174
12175 func (obj *ToCltCloudParams) serialize(w io.Writer) {
12176         {
12177                 x := (*(*(struct {
12178                         Density      float32
12179                         DiffuseColor color.NRGBA
12180                         AmbientColor color.NRGBA
12181                         Height       float32
12182                         Thickness    float32
12183                         Speed        [2]float32
12184                 }))(obj)).Density
12185                 write32(w, math.Float32bits(x))
12186         }
12187         {
12188                 x := (*(*(struct {
12189                         Density      float32
12190                         DiffuseColor color.NRGBA
12191                         AmbientColor color.NRGBA
12192                         Height       float32
12193                         Thickness    float32
12194                         Speed        [2]float32
12195                 }))(obj)).DiffuseColor
12196                 w.Write([]byte{x.A, x.R, x.G, x.B})
12197
12198         }
12199         {
12200                 x := (*(*(struct {
12201                         Density      float32
12202                         DiffuseColor color.NRGBA
12203                         AmbientColor color.NRGBA
12204                         Height       float32
12205                         Thickness    float32
12206                         Speed        [2]float32
12207                 }))(obj)).AmbientColor
12208                 w.Write([]byte{x.A, x.R, x.G, x.B})
12209
12210         }
12211         {
12212                 x := (*(*(struct {
12213                         Density      float32
12214                         DiffuseColor color.NRGBA
12215                         AmbientColor color.NRGBA
12216                         Height       float32
12217                         Thickness    float32
12218                         Speed        [2]float32
12219                 }))(obj)).Height
12220                 write32(w, math.Float32bits(x))
12221         }
12222         {
12223                 x := (*(*(struct {
12224                         Density      float32
12225                         DiffuseColor color.NRGBA
12226                         AmbientColor color.NRGBA
12227                         Height       float32
12228                         Thickness    float32
12229                         Speed        [2]float32
12230                 }))(obj)).Thickness
12231                 write32(w, math.Float32bits(x))
12232         }
12233         for local208 := range (*(*(struct {
12234                 Density      float32
12235                 DiffuseColor color.NRGBA
12236                 AmbientColor color.NRGBA
12237                 Height       float32
12238                 Thickness    float32
12239                 Speed        [2]float32
12240         }))(obj)).Speed {
12241                 {
12242                         x := ((*(*(struct {
12243                                 Density      float32
12244                                 DiffuseColor color.NRGBA
12245                                 AmbientColor color.NRGBA
12246                                 Height       float32
12247                                 Thickness    float32
12248                                 Speed        [2]float32
12249                         }))(obj)).Speed)[local208]
12250                         write32(w, math.Float32bits(x))
12251                 }
12252         }
12253 }
12254
12255 func (obj *ToCltCloudParams) deserialize(r io.Reader) {
12256         {
12257                 p := &(*(*(struct {
12258                         Density      float32
12259                         DiffuseColor color.NRGBA
12260                         AmbientColor color.NRGBA
12261                         Height       float32
12262                         Thickness    float32
12263                         Speed        [2]float32
12264                 }))(obj)).Density
12265                 *p = math.Float32frombits(read32(r))
12266         }
12267         {
12268                 p := &(*(*(struct {
12269                         Density      float32
12270                         DiffuseColor color.NRGBA
12271                         AmbientColor color.NRGBA
12272                         Height       float32
12273                         Thickness    float32
12274                         Speed        [2]float32
12275                 }))(obj)).DiffuseColor
12276                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12277
12278         }
12279         {
12280                 p := &(*(*(struct {
12281                         Density      float32
12282                         DiffuseColor color.NRGBA
12283                         AmbientColor color.NRGBA
12284                         Height       float32
12285                         Thickness    float32
12286                         Speed        [2]float32
12287                 }))(obj)).AmbientColor
12288                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12289
12290         }
12291         {
12292                 p := &(*(*(struct {
12293                         Density      float32
12294                         DiffuseColor color.NRGBA
12295                         AmbientColor color.NRGBA
12296                         Height       float32
12297                         Thickness    float32
12298                         Speed        [2]float32
12299                 }))(obj)).Height
12300                 *p = math.Float32frombits(read32(r))
12301         }
12302         {
12303                 p := &(*(*(struct {
12304                         Density      float32
12305                         DiffuseColor color.NRGBA
12306                         AmbientColor color.NRGBA
12307                         Height       float32
12308                         Thickness    float32
12309                         Speed        [2]float32
12310                 }))(obj)).Thickness
12311                 *p = math.Float32frombits(read32(r))
12312         }
12313         for local209 := range (*(*(struct {
12314                 Density      float32
12315                 DiffuseColor color.NRGBA
12316                 AmbientColor color.NRGBA
12317                 Height       float32
12318                 Thickness    float32
12319                 Speed        [2]float32
12320         }))(obj)).Speed {
12321                 {
12322                         p := &((*(*(struct {
12323                                 Density      float32
12324                                 DiffuseColor color.NRGBA
12325                                 AmbientColor color.NRGBA
12326                                 Height       float32
12327                                 Thickness    float32
12328                                 Speed        [2]float32
12329                         }))(obj)).Speed)[local209]
12330                         *p = math.Float32frombits(read32(r))
12331                 }
12332         }
12333 }
12334
12335 func (obj *ToCltFadeSound) serialize(w io.Writer) {
12336         if err := pcall(func() {
12337                 ((*(*(struct {
12338                         ID   SoundID
12339                         Step float32
12340                         Gain float32
12341                 }))(obj)).ID).serialize(w)
12342         }); err != nil {
12343                 if err == io.EOF {
12344                         chk(io.EOF)
12345                 }
12346                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
12347         }
12348         {
12349                 x := (*(*(struct {
12350                         ID   SoundID
12351                         Step float32
12352                         Gain float32
12353                 }))(obj)).Step
12354                 write32(w, math.Float32bits(x))
12355         }
12356         {
12357                 x := (*(*(struct {
12358                         ID   SoundID
12359                         Step float32
12360                         Gain float32
12361                 }))(obj)).Gain
12362                 write32(w, math.Float32bits(x))
12363         }
12364 }
12365
12366 func (obj *ToCltFadeSound) deserialize(r io.Reader) {
12367         if err := pcall(func() {
12368                 ((*(*(struct {
12369                         ID   SoundID
12370                         Step float32
12371                         Gain float32
12372                 }))(obj)).ID).deserialize(r)
12373         }); err != nil {
12374                 if err == io.EOF {
12375                         chk(io.EOF)
12376                 }
12377                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
12378         }
12379         {
12380                 p := &(*(*(struct {
12381                         ID   SoundID
12382                         Step float32
12383                         Gain float32
12384                 }))(obj)).Step
12385                 *p = math.Float32frombits(read32(r))
12386         }
12387         {
12388                 p := &(*(*(struct {
12389                         ID   SoundID
12390                         Step float32
12391                         Gain float32
12392                 }))(obj)).Gain
12393                 *p = math.Float32frombits(read32(r))
12394         }
12395 }
12396
12397 func (obj *ToCltUpdatePlayerList) serialize(w io.Writer) {
12398         if err := pcall(func() {
12399                 ((*(*(struct {
12400                         Type    PlayerListUpdateType
12401                         Players []string
12402                 }))(obj)).Type).serialize(w)
12403         }); err != nil {
12404                 if err == io.EOF {
12405                         chk(io.EOF)
12406                 }
12407                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
12408         }
12409         if len(((*(*(struct {
12410                 Type    PlayerListUpdateType
12411                 Players []string
12412         }))(obj)).Players)) > math.MaxUint16 {
12413                 chk(ErrTooLong)
12414         }
12415         {
12416                 x := uint16(len(((*(*(struct {
12417                         Type    PlayerListUpdateType
12418                         Players []string
12419                 }))(obj)).Players)))
12420                 write16(w, uint16(x))
12421         }
12422         for local210 := range (*(*(struct {
12423                 Type    PlayerListUpdateType
12424                 Players []string
12425         }))(obj)).Players {
12426                 if len(([]byte(((*(*(struct {
12427                         Type    PlayerListUpdateType
12428                         Players []string
12429                 }))(obj)).Players)[local210]))) > math.MaxUint16 {
12430                         chk(ErrTooLong)
12431                 }
12432                 {
12433                         x := uint16(len(([]byte(((*(*(struct {
12434                                 Type    PlayerListUpdateType
12435                                 Players []string
12436                         }))(obj)).Players)[local210]))))
12437                         write16(w, uint16(x))
12438                 }
12439                 {
12440                         _, err := w.Write(([]byte(((*(*(struct {
12441                                 Type    PlayerListUpdateType
12442                                 Players []string
12443                         }))(obj)).Players)[local210]))[:])
12444                         chk(err)
12445                 }
12446         }
12447 }
12448
12449 func (obj *ToCltUpdatePlayerList) deserialize(r io.Reader) {
12450         if err := pcall(func() {
12451                 ((*(*(struct {
12452                         Type    PlayerListUpdateType
12453                         Players []string
12454                 }))(obj)).Type).deserialize(r)
12455         }); err != nil {
12456                 if err == io.EOF {
12457                         chk(io.EOF)
12458                 }
12459                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
12460         }
12461         var local211 uint16
12462         {
12463                 p := &local211
12464                 *p = read16(r)
12465         }
12466         ((*(*(struct {
12467                 Type    PlayerListUpdateType
12468                 Players []string
12469         }))(obj)).Players) = make([]string, local211)
12470         for local212 := range (*(*(struct {
12471                 Type    PlayerListUpdateType
12472                 Players []string
12473         }))(obj)).Players {
12474                 var local213 []uint8
12475                 var local214 uint16
12476                 {
12477                         p := &local214
12478                         *p = read16(r)
12479                 }
12480                 (local213) = make([]uint8, local214)
12481                 {
12482                         _, err := io.ReadFull(r, (local213)[:])
12483                         chk(err)
12484                 }
12485                 (((*(*(struct {
12486                         Type    PlayerListUpdateType
12487                         Players []string
12488                 }))(obj)).Players)[local212]) = string(local213)
12489         }
12490 }
12491
12492 func (obj *ToCltModChanMsg) serialize(w io.Writer) {
12493         if len(([]byte((*(*(struct {
12494                 Channel string
12495                 Sender  string
12496                 Msg     string
12497         }))(obj)).Channel))) > math.MaxUint16 {
12498                 chk(ErrTooLong)
12499         }
12500         {
12501                 x := uint16(len(([]byte((*(*(struct {
12502                         Channel string
12503                         Sender  string
12504                         Msg     string
12505                 }))(obj)).Channel))))
12506                 write16(w, uint16(x))
12507         }
12508         {
12509                 _, err := w.Write(([]byte((*(*(struct {
12510                         Channel string
12511                         Sender  string
12512                         Msg     string
12513                 }))(obj)).Channel))[:])
12514                 chk(err)
12515         }
12516         if len(([]byte((*(*(struct {
12517                 Channel string
12518                 Sender  string
12519                 Msg     string
12520         }))(obj)).Sender))) > math.MaxUint16 {
12521                 chk(ErrTooLong)
12522         }
12523         {
12524                 x := uint16(len(([]byte((*(*(struct {
12525                         Channel string
12526                         Sender  string
12527                         Msg     string
12528                 }))(obj)).Sender))))
12529                 write16(w, uint16(x))
12530         }
12531         {
12532                 _, err := w.Write(([]byte((*(*(struct {
12533                         Channel string
12534                         Sender  string
12535                         Msg     string
12536                 }))(obj)).Sender))[:])
12537                 chk(err)
12538         }
12539         if len(([]byte((*(*(struct {
12540                 Channel string
12541                 Sender  string
12542                 Msg     string
12543         }))(obj)).Msg))) > math.MaxUint16 {
12544                 chk(ErrTooLong)
12545         }
12546         {
12547                 x := uint16(len(([]byte((*(*(struct {
12548                         Channel string
12549                         Sender  string
12550                         Msg     string
12551                 }))(obj)).Msg))))
12552                 write16(w, uint16(x))
12553         }
12554         {
12555                 _, err := w.Write(([]byte((*(*(struct {
12556                         Channel string
12557                         Sender  string
12558                         Msg     string
12559                 }))(obj)).Msg))[:])
12560                 chk(err)
12561         }
12562 }
12563
12564 func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
12565         var local215 []uint8
12566         var local216 uint16
12567         {
12568                 p := &local216
12569                 *p = read16(r)
12570         }
12571         (local215) = make([]uint8, local216)
12572         {
12573                 _, err := io.ReadFull(r, (local215)[:])
12574                 chk(err)
12575         }
12576         ((*(*(struct {
12577                 Channel string
12578                 Sender  string
12579                 Msg     string
12580         }))(obj)).Channel) = string(local215)
12581         var local217 []uint8
12582         var local218 uint16
12583         {
12584                 p := &local218
12585                 *p = read16(r)
12586         }
12587         (local217) = make([]uint8, local218)
12588         {
12589                 _, err := io.ReadFull(r, (local217)[:])
12590                 chk(err)
12591         }
12592         ((*(*(struct {
12593                 Channel string
12594                 Sender  string
12595                 Msg     string
12596         }))(obj)).Sender) = string(local217)
12597         var local219 []uint8
12598         var local220 uint16
12599         {
12600                 p := &local220
12601                 *p = read16(r)
12602         }
12603         (local219) = make([]uint8, local220)
12604         {
12605                 _, err := io.ReadFull(r, (local219)[:])
12606                 chk(err)
12607         }
12608         ((*(*(struct {
12609                 Channel string
12610                 Sender  string
12611                 Msg     string
12612         }))(obj)).Msg) = string(local219)
12613 }
12614
12615 func (obj *ToCltModChanSig) serialize(w io.Writer) {
12616         if err := pcall(func() {
12617                 ((*(*(struct {
12618                         Signal  ModChanSig
12619                         Channel string
12620                 }))(obj)).Signal).serialize(w)
12621         }); err != nil {
12622                 if err == io.EOF {
12623                         chk(io.EOF)
12624                 }
12625                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
12626         }
12627         if len(([]byte((*(*(struct {
12628                 Signal  ModChanSig
12629                 Channel string
12630         }))(obj)).Channel))) > math.MaxUint16 {
12631                 chk(ErrTooLong)
12632         }
12633         {
12634                 x := uint16(len(([]byte((*(*(struct {
12635                         Signal  ModChanSig
12636                         Channel string
12637                 }))(obj)).Channel))))
12638                 write16(w, uint16(x))
12639         }
12640         {
12641                 _, err := w.Write(([]byte((*(*(struct {
12642                         Signal  ModChanSig
12643                         Channel string
12644                 }))(obj)).Channel))[:])
12645                 chk(err)
12646         }
12647 }
12648
12649 func (obj *ToCltModChanSig) deserialize(r io.Reader) {
12650         if err := pcall(func() {
12651                 ((*(*(struct {
12652                         Signal  ModChanSig
12653                         Channel string
12654                 }))(obj)).Signal).deserialize(r)
12655         }); err != nil {
12656                 if err == io.EOF {
12657                         chk(io.EOF)
12658                 }
12659                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
12660         }
12661         var local221 []uint8
12662         var local222 uint16
12663         {
12664                 p := &local222
12665                 *p = read16(r)
12666         }
12667         (local221) = make([]uint8, local222)
12668         {
12669                 _, err := io.ReadFull(r, (local221)[:])
12670                 chk(err)
12671         }
12672         ((*(*(struct {
12673                 Signal  ModChanSig
12674                 Channel string
12675         }))(obj)).Channel) = string(local221)
12676 }
12677
12678 func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
12679         {
12680                 ow := w
12681                 w := new(bytes.Buffer)
12682                 {
12683                         x := (*(*(struct {
12684                                 //mt:lenhdr 32
12685                                 Changed map[[3]int16]*NodeMeta
12686                         }))(obj)).Changed
12687                         {
12688                                 w := zlib.NewWriter(w)
12689
12690                                 if x == nil {
12691                                         write8(w, 0)
12692                                 } else {
12693                                         write8(w, 2)
12694                                         if len(x) > math.MaxUint16 {
12695                                                 chk(ErrTooLong)
12696                                         }
12697                                         write16(w, uint16(len(x)))
12698                                         keys := make([][3]int16, 0, len(x))
12699                                         for key := range x {
12700                                                 keys = append(keys, key)
12701                                         }
12702                                         sort.Slice(keys, func(i, j int) bool {
12703                                                 p, q := keys[i], keys[j]
12704
12705                                                 for i := range p {
12706                                                         switch {
12707                                                         case p[i] < q[i]:
12708                                                                 return true
12709                                                         case p[i] > q[i]:
12710                                                                 return false
12711                                                         }
12712                                                 }
12713
12714                                                 return false
12715                                         })
12716                                         for _, key := range keys {
12717                                                 for _, n := range key {
12718                                                         write16(w, uint16(n))
12719                                                 }
12720                                                 chk(serialize(w, x[key]))
12721                                         }
12722                                 }
12723
12724                                 chk(w.Close())
12725                         }
12726
12727                 }
12728                 {
12729                         buf := w
12730                         w := ow
12731                         if len((buf.Bytes())) > math.MaxUint32 {
12732                                 chk(ErrTooLong)
12733                         }
12734                         {
12735                                 x := uint32(len((buf.Bytes())))
12736                                 write32(w, uint32(x))
12737                         }
12738                         {
12739                                 _, err := w.Write((buf.Bytes())[:])
12740                                 chk(err)
12741                         }
12742                 }
12743         }
12744 }
12745
12746 func (obj *ToCltNodeMetasChanged) deserialize(r io.Reader) {
12747         {
12748                 var n uint32
12749                 {
12750                         p := &n
12751                         *p = read32(r)
12752                 }
12753                 r := &io.LimitedReader{R: r, N: int64(n)}
12754                 {
12755                         p := &(*(*(struct {
12756                                 //mt:lenhdr 32
12757                                 Changed map[[3]int16]*NodeMeta
12758                         }))(obj)).Changed
12759                         {
12760                                 r, err := zlib.NewReader(byteReader{r})
12761                                 chk(err)
12762
12763                                 switch ver := read8(r); ver {
12764                                 case 0:
12765                                         *p = nil
12766                                 case 2:
12767                                         n := read16(r)
12768                                         *p = make(map[[3]int16]*NodeMeta, n)
12769                                         for ; n > 0; n-- {
12770                                                 var pos [3]int16
12771                                                 for i := range pos {
12772                                                         pos[i] = int16(read16(r))
12773                                                 }
12774                                                 nm := new(NodeMeta)
12775                                                 chk(deserialize(r, nm))
12776                                                 (*p)[pos] = nm
12777                                         }
12778                                 default:
12779                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
12780                                 }
12781
12782                                 chk(r.Close())
12783                         }
12784
12785                 }
12786                 if r.N > 0 {
12787                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
12788                 }
12789         }
12790 }
12791
12792 func (obj *ToCltSunParams) serialize(w io.Writer) {
12793         {
12794                 x := (*(*(struct {
12795                         Visible bool
12796                         Texture
12797                         ToneMap Texture
12798                         Rise    Texture
12799                         Rising  bool
12800                         Size    float32
12801                 }))(obj)).Visible
12802                 if x {
12803                         write8(w, 1)
12804                 } else {
12805                         write8(w, 0)
12806                 }
12807
12808         }
12809         if err := pcall(func() {
12810                 ((*(*(struct {
12811                         Visible bool
12812                         Texture
12813                         ToneMap Texture
12814                         Rise    Texture
12815                         Rising  bool
12816                         Size    float32
12817                 }))(obj)).Texture).serialize(w)
12818         }); err != nil {
12819                 if err == io.EOF {
12820                         chk(io.EOF)
12821                 }
12822                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12823         }
12824         if err := pcall(func() {
12825                 ((*(*(struct {
12826                         Visible bool
12827                         Texture
12828                         ToneMap Texture
12829                         Rise    Texture
12830                         Rising  bool
12831                         Size    float32
12832                 }))(obj)).ToneMap).serialize(w)
12833         }); err != nil {
12834                 if err == io.EOF {
12835                         chk(io.EOF)
12836                 }
12837                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12838         }
12839         if err := pcall(func() {
12840                 ((*(*(struct {
12841                         Visible bool
12842                         Texture
12843                         ToneMap Texture
12844                         Rise    Texture
12845                         Rising  bool
12846                         Size    float32
12847                 }))(obj)).Rise).serialize(w)
12848         }); err != nil {
12849                 if err == io.EOF {
12850                         chk(io.EOF)
12851                 }
12852                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12853         }
12854         {
12855                 x := (*(*(struct {
12856                         Visible bool
12857                         Texture
12858                         ToneMap Texture
12859                         Rise    Texture
12860                         Rising  bool
12861                         Size    float32
12862                 }))(obj)).Rising
12863                 if x {
12864                         write8(w, 1)
12865                 } else {
12866                         write8(w, 0)
12867                 }
12868
12869         }
12870         {
12871                 x := (*(*(struct {
12872                         Visible bool
12873                         Texture
12874                         ToneMap Texture
12875                         Rise    Texture
12876                         Rising  bool
12877                         Size    float32
12878                 }))(obj)).Size
12879                 write32(w, math.Float32bits(x))
12880         }
12881 }
12882
12883 func (obj *ToCltSunParams) deserialize(r io.Reader) {
12884         {
12885                 p := &(*(*(struct {
12886                         Visible bool
12887                         Texture
12888                         ToneMap Texture
12889                         Rise    Texture
12890                         Rising  bool
12891                         Size    float32
12892                 }))(obj)).Visible
12893                 switch n := read8(r); n {
12894                 case 0:
12895                         *p = false
12896                 case 1:
12897                         *p = true
12898                 default:
12899                         chk(fmt.Errorf("invalid bool: %d", n))
12900                 }
12901
12902         }
12903         if err := pcall(func() {
12904                 ((*(*(struct {
12905                         Visible bool
12906                         Texture
12907                         ToneMap Texture
12908                         Rise    Texture
12909                         Rising  bool
12910                         Size    float32
12911                 }))(obj)).Texture).deserialize(r)
12912         }); err != nil {
12913                 if err == io.EOF {
12914                         chk(io.EOF)
12915                 }
12916                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12917         }
12918         if err := pcall(func() {
12919                 ((*(*(struct {
12920                         Visible bool
12921                         Texture
12922                         ToneMap Texture
12923                         Rise    Texture
12924                         Rising  bool
12925                         Size    float32
12926                 }))(obj)).ToneMap).deserialize(r)
12927         }); err != nil {
12928                 if err == io.EOF {
12929                         chk(io.EOF)
12930                 }
12931                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12932         }
12933         if err := pcall(func() {
12934                 ((*(*(struct {
12935                         Visible bool
12936                         Texture
12937                         ToneMap Texture
12938                         Rise    Texture
12939                         Rising  bool
12940                         Size    float32
12941                 }))(obj)).Rise).deserialize(r)
12942         }); err != nil {
12943                 if err == io.EOF {
12944                         chk(io.EOF)
12945                 }
12946                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
12947         }
12948         {
12949                 p := &(*(*(struct {
12950                         Visible bool
12951                         Texture
12952                         ToneMap Texture
12953                         Rise    Texture
12954                         Rising  bool
12955                         Size    float32
12956                 }))(obj)).Rising
12957                 switch n := read8(r); n {
12958                 case 0:
12959                         *p = false
12960                 case 1:
12961                         *p = true
12962                 default:
12963                         chk(fmt.Errorf("invalid bool: %d", n))
12964                 }
12965
12966         }
12967         {
12968                 p := &(*(*(struct {
12969                         Visible bool
12970                         Texture
12971                         ToneMap Texture
12972                         Rise    Texture
12973                         Rising  bool
12974                         Size    float32
12975                 }))(obj)).Size
12976                 *p = math.Float32frombits(read32(r))
12977         }
12978 }
12979
12980 func (obj *ToCltMoonParams) serialize(w io.Writer) {
12981         {
12982                 x := (*(*(struct {
12983                         Visible bool
12984                         Texture
12985                         ToneMap Texture
12986                         Size    float32
12987                 }))(obj)).Visible
12988                 if x {
12989                         write8(w, 1)
12990                 } else {
12991                         write8(w, 0)
12992                 }
12993
12994         }
12995         if err := pcall(func() {
12996                 ((*(*(struct {
12997                         Visible bool
12998                         Texture
12999                         ToneMap Texture
13000                         Size    float32
13001                 }))(obj)).Texture).serialize(w)
13002         }); err != nil {
13003                 if err == io.EOF {
13004                         chk(io.EOF)
13005                 }
13006                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13007         }
13008         if err := pcall(func() {
13009                 ((*(*(struct {
13010                         Visible bool
13011                         Texture
13012                         ToneMap Texture
13013                         Size    float32
13014                 }))(obj)).ToneMap).serialize(w)
13015         }); err != nil {
13016                 if err == io.EOF {
13017                         chk(io.EOF)
13018                 }
13019                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13020         }
13021         {
13022                 x := (*(*(struct {
13023                         Visible bool
13024                         Texture
13025                         ToneMap Texture
13026                         Size    float32
13027                 }))(obj)).Size
13028                 write32(w, math.Float32bits(x))
13029         }
13030 }
13031
13032 func (obj *ToCltMoonParams) deserialize(r io.Reader) {
13033         {
13034                 p := &(*(*(struct {
13035                         Visible bool
13036                         Texture
13037                         ToneMap Texture
13038                         Size    float32
13039                 }))(obj)).Visible
13040                 switch n := read8(r); n {
13041                 case 0:
13042                         *p = false
13043                 case 1:
13044                         *p = true
13045                 default:
13046                         chk(fmt.Errorf("invalid bool: %d", n))
13047                 }
13048
13049         }
13050         if err := pcall(func() {
13051                 ((*(*(struct {
13052                         Visible bool
13053                         Texture
13054                         ToneMap Texture
13055                         Size    float32
13056                 }))(obj)).Texture).deserialize(r)
13057         }); err != nil {
13058                 if err == io.EOF {
13059                         chk(io.EOF)
13060                 }
13061                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13062         }
13063         if err := pcall(func() {
13064                 ((*(*(struct {
13065                         Visible bool
13066                         Texture
13067                         ToneMap Texture
13068                         Size    float32
13069                 }))(obj)).ToneMap).deserialize(r)
13070         }); err != nil {
13071                 if err == io.EOF {
13072                         chk(io.EOF)
13073                 }
13074                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13075         }
13076         {
13077                 p := &(*(*(struct {
13078                         Visible bool
13079                         Texture
13080                         ToneMap Texture
13081                         Size    float32
13082                 }))(obj)).Size
13083                 *p = math.Float32frombits(read32(r))
13084         }
13085 }
13086
13087 func (obj *ToCltStarParams) serialize(w io.Writer) {
13088         {
13089                 x := (*(*(struct {
13090                         Visible bool
13091                         Count   uint32
13092                         Color   color.NRGBA
13093                         Size    float32
13094                 }))(obj)).Visible
13095                 if x {
13096                         write8(w, 1)
13097                 } else {
13098                         write8(w, 0)
13099                 }
13100
13101         }
13102         {
13103                 x := (*(*(struct {
13104                         Visible bool
13105                         Count   uint32
13106                         Color   color.NRGBA
13107                         Size    float32
13108                 }))(obj)).Count
13109                 write32(w, uint32(x))
13110         }
13111         {
13112                 x := (*(*(struct {
13113                         Visible bool
13114                         Count   uint32
13115                         Color   color.NRGBA
13116                         Size    float32
13117                 }))(obj)).Color
13118                 w.Write([]byte{x.A, x.R, x.G, x.B})
13119
13120         }
13121         {
13122                 x := (*(*(struct {
13123                         Visible bool
13124                         Count   uint32
13125                         Color   color.NRGBA
13126                         Size    float32
13127                 }))(obj)).Size
13128                 write32(w, math.Float32bits(x))
13129         }
13130 }
13131
13132 func (obj *ToCltStarParams) deserialize(r io.Reader) {
13133         {
13134                 p := &(*(*(struct {
13135                         Visible bool
13136                         Count   uint32
13137                         Color   color.NRGBA
13138                         Size    float32
13139                 }))(obj)).Visible
13140                 switch n := read8(r); n {
13141                 case 0:
13142                         *p = false
13143                 case 1:
13144                         *p = true
13145                 default:
13146                         chk(fmt.Errorf("invalid bool: %d", n))
13147                 }
13148
13149         }
13150         {
13151                 p := &(*(*(struct {
13152                         Visible bool
13153                         Count   uint32
13154                         Color   color.NRGBA
13155                         Size    float32
13156                 }))(obj)).Count
13157                 *p = read32(r)
13158         }
13159         {
13160                 p := &(*(*(struct {
13161                         Visible bool
13162                         Count   uint32
13163                         Color   color.NRGBA
13164                         Size    float32
13165                 }))(obj)).Color
13166                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13167
13168         }
13169         {
13170                 p := &(*(*(struct {
13171                         Visible bool
13172                         Count   uint32
13173                         Color   color.NRGBA
13174                         Size    float32
13175                 }))(obj)).Size
13176                 *p = math.Float32frombits(read32(r))
13177         }
13178 }
13179
13180 func (obj *ToCltSRPBytesSaltB) serialize(w io.Writer) {
13181         if len(((*(*(struct {
13182                 Salt, B []byte
13183         }))(obj)).Salt)) > math.MaxUint16 {
13184                 chk(ErrTooLong)
13185         }
13186         {
13187                 x := uint16(len(((*(*(struct {
13188                         Salt, B []byte
13189                 }))(obj)).Salt)))
13190                 write16(w, uint16(x))
13191         }
13192         {
13193                 _, err := w.Write(((*(*(struct {
13194                         Salt, B []byte
13195                 }))(obj)).Salt)[:])
13196                 chk(err)
13197         }
13198         if len(((*(*(struct {
13199                 Salt, B []byte
13200         }))(obj)).B)) > math.MaxUint16 {
13201                 chk(ErrTooLong)
13202         }
13203         {
13204                 x := uint16(len(((*(*(struct {
13205                         Salt, B []byte
13206                 }))(obj)).B)))
13207                 write16(w, uint16(x))
13208         }
13209         {
13210                 _, err := w.Write(((*(*(struct {
13211                         Salt, B []byte
13212                 }))(obj)).B)[:])
13213                 chk(err)
13214         }
13215 }
13216
13217 func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
13218         var local223 uint16
13219         {
13220                 p := &local223
13221                 *p = read16(r)
13222         }
13223         ((*(*(struct {
13224                 Salt, B []byte
13225         }))(obj)).Salt) = make([]byte, local223)
13226         {
13227                 _, err := io.ReadFull(r, ((*(*(struct {
13228                         Salt, B []byte
13229                 }))(obj)).Salt)[:])
13230                 chk(err)
13231         }
13232         var local224 uint16
13233         {
13234                 p := &local224
13235                 *p = read16(r)
13236         }
13237         ((*(*(struct {
13238                 Salt, B []byte
13239         }))(obj)).B) = make([]byte, local224)
13240         {
13241                 _, err := io.ReadFull(r, ((*(*(struct {
13242                         Salt, B []byte
13243                 }))(obj)).B)[:])
13244                 chk(err)
13245         }
13246 }
13247
13248 func (obj *ToCltFormspecPrepend) serialize(w io.Writer) {
13249         if len(([]byte((*(*(struct {
13250                 Prepend string
13251         }))(obj)).Prepend))) > math.MaxUint16 {
13252                 chk(ErrTooLong)
13253         }
13254         {
13255                 x := uint16(len(([]byte((*(*(struct {
13256                         Prepend string
13257                 }))(obj)).Prepend))))
13258                 write16(w, uint16(x))
13259         }
13260         {
13261                 _, err := w.Write(([]byte((*(*(struct {
13262                         Prepend string
13263                 }))(obj)).Prepend))[:])
13264                 chk(err)
13265         }
13266 }
13267
13268 func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
13269         var local225 []uint8
13270         var local226 uint16
13271         {
13272                 p := &local226
13273                 *p = read16(r)
13274         }
13275         (local225) = make([]uint8, local226)
13276         {
13277                 _, err := io.ReadFull(r, (local225)[:])
13278                 chk(err)
13279         }
13280         ((*(*(struct {
13281                 Prepend string
13282         }))(obj)).Prepend) = string(local225)
13283 }
13284
13285 func (obj *AOCmdProps) serialize(w io.Writer) {
13286         if err := pcall(func() {
13287                 ((*(*(struct {
13288                         Props AOProps
13289                 }))(obj)).Props).serialize(w)
13290         }); err != nil {
13291                 if err == io.EOF {
13292                         chk(io.EOF)
13293                 }
13294                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOProps", err))
13295         }
13296 }
13297
13298 func (obj *AOCmdProps) deserialize(r io.Reader) {
13299         if err := pcall(func() {
13300                 ((*(*(struct {
13301                         Props AOProps
13302                 }))(obj)).Props).deserialize(r)
13303         }); err != nil {
13304                 if err == io.EOF {
13305                         chk(io.EOF)
13306                 }
13307                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOProps", err))
13308         }
13309 }
13310
13311 func (obj *AOCmdPos) serialize(w io.Writer) {
13312         if err := pcall(func() {
13313                 ((*(*(struct {
13314                         Pos AOPos
13315                 }))(obj)).Pos).serialize(w)
13316         }); err != nil {
13317                 if err == io.EOF {
13318                         chk(io.EOF)
13319                 }
13320                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPos", err))
13321         }
13322 }
13323
13324 func (obj *AOCmdPos) deserialize(r io.Reader) {
13325         if err := pcall(func() {
13326                 ((*(*(struct {
13327                         Pos AOPos
13328                 }))(obj)).Pos).deserialize(r)
13329         }); err != nil {
13330                 if err == io.EOF {
13331                         chk(io.EOF)
13332                 }
13333                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPos", err))
13334         }
13335 }
13336
13337 func (obj *AOCmdTextureMod) serialize(w io.Writer) {
13338         if err := pcall(func() {
13339                 ((*(*(struct {
13340                         Mod Texture // suffix
13341                 }))(obj)).Mod).serialize(w)
13342         }); err != nil {
13343                 if err == io.EOF {
13344                         chk(io.EOF)
13345                 }
13346                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13347         }
13348 }
13349
13350 func (obj *AOCmdTextureMod) deserialize(r io.Reader) {
13351         if err := pcall(func() {
13352                 ((*(*(struct {
13353                         Mod Texture // suffix
13354                 }))(obj)).Mod).deserialize(r)
13355         }); err != nil {
13356                 if err == io.EOF {
13357                         chk(io.EOF)
13358                 }
13359                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13360         }
13361 }
13362
13363 func (obj *AOCmdSprite) serialize(w io.Writer) {
13364         if err := pcall(func() {
13365                 ((*(*(struct {
13366                         Sprite AOSprite
13367                 }))(obj)).Sprite).serialize(w)
13368         }); err != nil {
13369                 if err == io.EOF {
13370                         chk(io.EOF)
13371                 }
13372                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOSprite", err))
13373         }
13374 }
13375
13376 func (obj *AOCmdSprite) deserialize(r io.Reader) {
13377         if err := pcall(func() {
13378                 ((*(*(struct {
13379                         Sprite AOSprite
13380                 }))(obj)).Sprite).deserialize(r)
13381         }); err != nil {
13382                 if err == io.EOF {
13383                         chk(io.EOF)
13384                 }
13385                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOSprite", err))
13386         }
13387 }
13388
13389 func (obj *AOCmdHP) serialize(w io.Writer) {
13390         {
13391                 x := (*(*(struct {
13392                         HP uint16
13393                 }))(obj)).HP
13394                 write16(w, uint16(x))
13395         }
13396 }
13397
13398 func (obj *AOCmdHP) deserialize(r io.Reader) {
13399         {
13400                 p := &(*(*(struct {
13401                         HP uint16
13402                 }))(obj)).HP
13403                 *p = read16(r)
13404         }
13405 }
13406
13407 func (obj *AOCmdArmorGroups) serialize(w io.Writer) {
13408         if len(((*(*(struct {
13409                 Armor []Group
13410         }))(obj)).Armor)) > math.MaxUint16 {
13411                 chk(ErrTooLong)
13412         }
13413         {
13414                 x := uint16(len(((*(*(struct {
13415                         Armor []Group
13416                 }))(obj)).Armor)))
13417                 write16(w, uint16(x))
13418         }
13419         for local227 := range (*(*(struct {
13420                 Armor []Group
13421         }))(obj)).Armor {
13422                 if err := pcall(func() {
13423                         (((*(*(struct {
13424                                 Armor []Group
13425                         }))(obj)).Armor)[local227]).serialize(w)
13426                 }); err != nil {
13427                         if err == io.EOF {
13428                                 chk(io.EOF)
13429                         }
13430                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
13431                 }
13432         }
13433 }
13434
13435 func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
13436         var local228 uint16
13437         {
13438                 p := &local228
13439                 *p = read16(r)
13440         }
13441         ((*(*(struct {
13442                 Armor []Group
13443         }))(obj)).Armor) = make([]Group, local228)
13444         for local229 := range (*(*(struct {
13445                 Armor []Group
13446         }))(obj)).Armor {
13447                 if err := pcall(func() {
13448                         (((*(*(struct {
13449                                 Armor []Group
13450                         }))(obj)).Armor)[local229]).deserialize(r)
13451                 }); err != nil {
13452                         if err == io.EOF {
13453                                 chk(io.EOF)
13454                         }
13455                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
13456                 }
13457         }
13458 }
13459
13460 func (obj *AOCmdAnim) serialize(w io.Writer) {
13461         if err := pcall(func() {
13462                 ((*(*(struct {
13463                         Anim AOAnim
13464                 }))(obj)).Anim).serialize(w)
13465         }); err != nil {
13466                 if err == io.EOF {
13467                         chk(io.EOF)
13468                 }
13469                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAnim", err))
13470         }
13471 }
13472
13473 func (obj *AOCmdAnim) deserialize(r io.Reader) {
13474         if err := pcall(func() {
13475                 ((*(*(struct {
13476                         Anim AOAnim
13477                 }))(obj)).Anim).deserialize(r)
13478         }); err != nil {
13479                 if err == io.EOF {
13480                         chk(io.EOF)
13481                 }
13482                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAnim", err))
13483         }
13484 }
13485
13486 func (obj *AOCmdBonePos) serialize(w io.Writer) {
13487         if len(([]byte((*(*(struct {
13488                 Bone string
13489                 Pos  AOBonePos
13490         }))(obj)).Bone))) > math.MaxUint16 {
13491                 chk(ErrTooLong)
13492         }
13493         {
13494                 x := uint16(len(([]byte((*(*(struct {
13495                         Bone string
13496                         Pos  AOBonePos
13497                 }))(obj)).Bone))))
13498                 write16(w, uint16(x))
13499         }
13500         {
13501                 _, err := w.Write(([]byte((*(*(struct {
13502                         Bone string
13503                         Pos  AOBonePos
13504                 }))(obj)).Bone))[:])
13505                 chk(err)
13506         }
13507         if err := pcall(func() {
13508                 ((*(*(struct {
13509                         Bone string
13510                         Pos  AOBonePos
13511                 }))(obj)).Pos).serialize(w)
13512         }); err != nil {
13513                 if err == io.EOF {
13514                         chk(io.EOF)
13515                 }
13516                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOBonePos", err))
13517         }
13518 }
13519
13520 func (obj *AOCmdBonePos) deserialize(r io.Reader) {
13521         var local230 []uint8
13522         var local231 uint16
13523         {
13524                 p := &local231
13525                 *p = read16(r)
13526         }
13527         (local230) = make([]uint8, local231)
13528         {
13529                 _, err := io.ReadFull(r, (local230)[:])
13530                 chk(err)
13531         }
13532         ((*(*(struct {
13533                 Bone string
13534                 Pos  AOBonePos
13535         }))(obj)).Bone) = string(local230)
13536         if err := pcall(func() {
13537                 ((*(*(struct {
13538                         Bone string
13539                         Pos  AOBonePos
13540                 }))(obj)).Pos).deserialize(r)
13541         }); err != nil {
13542                 if err == io.EOF {
13543                         chk(io.EOF)
13544                 }
13545                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOBonePos", err))
13546         }
13547 }
13548
13549 func (obj *AOCmdAttach) serialize(w io.Writer) {
13550         if err := pcall(func() {
13551                 ((*(*(struct {
13552                         Attach AOAttach
13553                 }))(obj)).Attach).serialize(w)
13554         }); err != nil {
13555                 if err == io.EOF {
13556                         chk(io.EOF)
13557                 }
13558                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAttach", err))
13559         }
13560 }
13561
13562 func (obj *AOCmdAttach) deserialize(r io.Reader) {
13563         if err := pcall(func() {
13564                 ((*(*(struct {
13565                         Attach AOAttach
13566                 }))(obj)).Attach).deserialize(r)
13567         }); err != nil {
13568                 if err == io.EOF {
13569                         chk(io.EOF)
13570                 }
13571                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOAttach", err))
13572         }
13573 }
13574
13575 func (obj *AOCmdPhysOverride) serialize(w io.Writer) {
13576         if err := pcall(func() {
13577                 ((*(*(struct {
13578                         Phys AOPhysOverride
13579                 }))(obj)).Phys).serialize(w)
13580         }); err != nil {
13581                 if err == io.EOF {
13582                         chk(io.EOF)
13583                 }
13584                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPhysOverride", err))
13585         }
13586 }
13587
13588 func (obj *AOCmdPhysOverride) deserialize(r io.Reader) {
13589         if err := pcall(func() {
13590                 ((*(*(struct {
13591                         Phys AOPhysOverride
13592                 }))(obj)).Phys).deserialize(r)
13593         }); err != nil {
13594                 if err == io.EOF {
13595                         chk(io.EOF)
13596                 }
13597                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOPhysOverride", err))
13598         }
13599 }
13600
13601 func (obj *AOCmdSpawnInfant) serialize(w io.Writer) {
13602         if err := pcall(func() {
13603                 ((*(*(struct {
13604                         ID AOID
13605                 }))(obj)).ID).serialize(w)
13606         }); err != nil {
13607                 if err == io.EOF {
13608                         chk(io.EOF)
13609                 }
13610                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
13611         }
13612         {
13613                 local232 := genericCAO
13614                 if err := pcall(func() {
13615                         (local232).serialize(w)
13616                 }); err != nil {
13617                         if err == io.EOF {
13618                                 chk(io.EOF)
13619                         }
13620                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
13621                 }
13622         }
13623 }
13624
13625 func (obj *AOCmdSpawnInfant) deserialize(r io.Reader) {
13626         if err := pcall(func() {
13627                 ((*(*(struct {
13628                         ID AOID
13629                 }))(obj)).ID).deserialize(r)
13630         }); err != nil {
13631                 if err == io.EOF {
13632                         chk(io.EOF)
13633                 }
13634                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
13635         }
13636         {
13637                 var local233 aoType
13638                 local234 := genericCAO
13639                 if err := pcall(func() {
13640                         (local233).deserialize(r)
13641                 }); err != nil {
13642                         if err == io.EOF {
13643                                 chk(io.EOF)
13644                         }
13645                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
13646                 }
13647                 if local233 != local234 {
13648                         chk(fmt.Errorf("const %v: %v", "genericCAO", local233))
13649                 }
13650         }
13651 }
13652
13653 func (obj *AOCmdAnimSpeed) serialize(w io.Writer) {
13654         {
13655                 x := (*(*(struct {
13656                         Speed float32
13657                 }))(obj)).Speed
13658                 write32(w, math.Float32bits(x))
13659         }
13660 }
13661
13662 func (obj *AOCmdAnimSpeed) deserialize(r io.Reader) {
13663         {
13664                 p := &(*(*(struct {
13665                         Speed float32
13666                 }))(obj)).Speed
13667                 *p = math.Float32frombits(read32(r))
13668         }
13669 }
13670
13671 func (obj *NodeMeta) serialize(w io.Writer) {
13672         if len(((*(*(struct {
13673                 //mt:len32
13674                 Fields []NodeMetaField
13675
13676                 Inv Inv
13677         }))(obj)).Fields)) > math.MaxUint32 {
13678                 chk(ErrTooLong)
13679         }
13680         {
13681                 x := uint32(len(((*(*(struct {
13682                         //mt:len32
13683                         Fields []NodeMetaField
13684
13685                         Inv Inv
13686                 }))(obj)).Fields)))
13687                 write32(w, uint32(x))
13688         }
13689         for local235 := range (*(*(struct {
13690                 //mt:len32
13691                 Fields []NodeMetaField
13692
13693                 Inv Inv
13694         }))(obj)).Fields {
13695                 if err := pcall(func() {
13696                         (((*(*(struct {
13697                                 //mt:len32
13698                                 Fields []NodeMetaField
13699
13700                                 Inv Inv
13701                         }))(obj)).Fields)[local235]).serialize(w)
13702                 }); err != nil {
13703                         if err == io.EOF {
13704                                 chk(io.EOF)
13705                         }
13706                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeMetaField", err))
13707                 }
13708         }
13709         chk(((*(*(struct {
13710                 //mt:len32
13711                 Fields []NodeMetaField
13712
13713                 Inv Inv
13714         }))(obj)).Inv).Serialize(w))
13715 }
13716
13717 func (obj *NodeMeta) deserialize(r io.Reader) {
13718         var local236 uint32
13719         {
13720                 p := &local236
13721                 *p = read32(r)
13722         }
13723         ((*(*(struct {
13724                 //mt:len32
13725                 Fields []NodeMetaField
13726
13727                 Inv Inv
13728         }))(obj)).Fields) = make([]NodeMetaField, local236)
13729         for local237 := range (*(*(struct {
13730                 //mt:len32
13731                 Fields []NodeMetaField
13732
13733                 Inv Inv
13734         }))(obj)).Fields {
13735                 if err := pcall(func() {
13736                         (((*(*(struct {
13737                                 //mt:len32
13738                                 Fields []NodeMetaField
13739
13740                                 Inv Inv
13741                         }))(obj)).Fields)[local237]).deserialize(r)
13742                 }); err != nil {
13743                         if err == io.EOF {
13744                                 chk(io.EOF)
13745                         }
13746                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeMetaField", err))
13747                 }
13748         }
13749         chk(((*(*(struct {
13750                 //mt:len32
13751                 Fields []NodeMetaField
13752
13753                 Inv Inv
13754         }))(obj)).Inv).Deserialize(r))
13755 }
13756
13757 func (obj *MinimapMode) serialize(w io.Writer) {
13758         if err := pcall(func() {
13759                 ((*(*(struct {
13760                         Type  MinimapType
13761                         Label string
13762                         Size  uint16
13763                         Texture
13764                         Scale uint16
13765                 }))(obj)).Type).serialize(w)
13766         }); err != nil {
13767                 if err == io.EOF {
13768                         chk(io.EOF)
13769                 }
13770                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
13771         }
13772         if len(([]byte((*(*(struct {
13773                 Type  MinimapType
13774                 Label string
13775                 Size  uint16
13776                 Texture
13777                 Scale uint16
13778         }))(obj)).Label))) > math.MaxUint16 {
13779                 chk(ErrTooLong)
13780         }
13781         {
13782                 x := uint16(len(([]byte((*(*(struct {
13783                         Type  MinimapType
13784                         Label string
13785                         Size  uint16
13786                         Texture
13787                         Scale uint16
13788                 }))(obj)).Label))))
13789                 write16(w, uint16(x))
13790         }
13791         {
13792                 _, err := w.Write(([]byte((*(*(struct {
13793                         Type  MinimapType
13794                         Label string
13795                         Size  uint16
13796                         Texture
13797                         Scale uint16
13798                 }))(obj)).Label))[:])
13799                 chk(err)
13800         }
13801         {
13802                 x := (*(*(struct {
13803                         Type  MinimapType
13804                         Label string
13805                         Size  uint16
13806                         Texture
13807                         Scale uint16
13808                 }))(obj)).Size
13809                 write16(w, uint16(x))
13810         }
13811         if err := pcall(func() {
13812                 ((*(*(struct {
13813                         Type  MinimapType
13814                         Label string
13815                         Size  uint16
13816                         Texture
13817                         Scale uint16
13818                 }))(obj)).Texture).serialize(w)
13819         }); err != nil {
13820                 if err == io.EOF {
13821                         chk(io.EOF)
13822                 }
13823                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13824         }
13825         {
13826                 x := (*(*(struct {
13827                         Type  MinimapType
13828                         Label string
13829                         Size  uint16
13830                         Texture
13831                         Scale uint16
13832                 }))(obj)).Scale
13833                 write16(w, uint16(x))
13834         }
13835 }
13836
13837 func (obj *MinimapMode) deserialize(r io.Reader) {
13838         if err := pcall(func() {
13839                 ((*(*(struct {
13840                         Type  MinimapType
13841                         Label string
13842                         Size  uint16
13843                         Texture
13844                         Scale uint16
13845                 }))(obj)).Type).deserialize(r)
13846         }); err != nil {
13847                 if err == io.EOF {
13848                         chk(io.EOF)
13849                 }
13850                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
13851         }
13852         var local238 []uint8
13853         var local239 uint16
13854         {
13855                 p := &local239
13856                 *p = read16(r)
13857         }
13858         (local238) = make([]uint8, local239)
13859         {
13860                 _, err := io.ReadFull(r, (local238)[:])
13861                 chk(err)
13862         }
13863         ((*(*(struct {
13864                 Type  MinimapType
13865                 Label string
13866                 Size  uint16
13867                 Texture
13868                 Scale uint16
13869         }))(obj)).Label) = string(local238)
13870         {
13871                 p := &(*(*(struct {
13872                         Type  MinimapType
13873                         Label string
13874                         Size  uint16
13875                         Texture
13876                         Scale uint16
13877                 }))(obj)).Size
13878                 *p = read16(r)
13879         }
13880         if err := pcall(func() {
13881                 ((*(*(struct {
13882                         Type  MinimapType
13883                         Label string
13884                         Size  uint16
13885                         Texture
13886                         Scale uint16
13887                 }))(obj)).Texture).deserialize(r)
13888         }); err != nil {
13889                 if err == io.EOF {
13890                         chk(io.EOF)
13891                 }
13892                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
13893         }
13894         {
13895                 p := &(*(*(struct {
13896                         Type  MinimapType
13897                         Label string
13898                         Size  uint16
13899                         Texture
13900                         Scale uint16
13901                 }))(obj)).Scale
13902                 *p = read16(r)
13903         }
13904 }
13905
13906 func (obj *NodeDef) serialize(w io.Writer) {
13907         if err := pcall(func() {
13908                 ((*(*(struct {
13909                         Param0 Content
13910
13911                         Name   string
13912                         Groups []Group
13913
13914                         P1Type   Param1Type
13915                         P2Type   Param2Type
13916                         DrawType DrawType
13917
13918                         Mesh  string
13919                         Scale float32
13920                         //mt:const uint8(6)
13921                         Tiles        [6]TileDef
13922                         OverlayTiles [6]TileDef
13923                         //mt:const uint8(6)
13924                         SpecialTiles [6]TileDef
13925
13926                         Color   color.NRGBA
13927                         Palette Texture
13928
13929                         Waving       WaveType
13930                         ConnectSides uint8
13931                         ConnectTo    []Content
13932                         InsideTint   color.NRGBA
13933                         Level        uint8 // Must be < 128.
13934
13935                         Translucent bool // Sunlight is scattered and becomes normal light.
13936                         Transparent bool // Sunlight isn't scattered.
13937                         LightSrc    uint8
13938
13939                         GndContent   bool
13940                         Collides     bool
13941                         Pointable    bool
13942                         Diggable     bool
13943                         Climbable    bool
13944                         Replaceable  bool
13945                         OnRightClick bool
13946
13947                         DmgPerSec int32
13948
13949                         LiquidType   LiquidType
13950                         FlowingAlt   string
13951                         SrcAlt       string
13952                         Viscosity    uint8 // 0-7
13953                         LiqRenewable bool
13954                         FlowRange    uint8
13955                         DrownDmg     uint8
13956                         Floodable    bool
13957
13958                         DrawBox, ColBox, SelBox NodeBox
13959
13960                         FootstepSnd, DiggingSnd, DugSnd SoundDef
13961
13962                         LegacyFaceDir bool
13963                         LegacyMounted bool
13964
13965                         DigPredict string
13966
13967                         MaxLvl uint8
13968
13969                         AlphaUse
13970                 }))(obj)).Param0).serialize(w)
13971         }); err != nil {
13972                 if err == io.EOF {
13973                         chk(io.EOF)
13974                 }
13975                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
13976         }
13977         {
13978                 ow := w
13979                 w := new(bytes.Buffer)
13980                 {
13981                         local240 := uint8(13)
13982                         {
13983                                 x := local240
13984                                 write8(w, uint8(x))
13985                         }
13986                 }
13987                 if len(([]byte((*(*(struct {
13988                         Param0 Content
13989
13990                         Name   string
13991                         Groups []Group
13992
13993                         P1Type   Param1Type
13994                         P2Type   Param2Type
13995                         DrawType DrawType
13996
13997                         Mesh  string
13998                         Scale float32
13999                         //mt:const uint8(6)
14000                         Tiles        [6]TileDef
14001                         OverlayTiles [6]TileDef
14002                         //mt:const uint8(6)
14003                         SpecialTiles [6]TileDef
14004
14005                         Color   color.NRGBA
14006                         Palette Texture
14007
14008                         Waving       WaveType
14009                         ConnectSides uint8
14010                         ConnectTo    []Content
14011                         InsideTint   color.NRGBA
14012                         Level        uint8 // Must be < 128.
14013
14014                         Translucent bool // Sunlight is scattered and becomes normal light.
14015                         Transparent bool // Sunlight isn't scattered.
14016                         LightSrc    uint8
14017
14018                         GndContent   bool
14019                         Collides     bool
14020                         Pointable    bool
14021                         Diggable     bool
14022                         Climbable    bool
14023                         Replaceable  bool
14024                         OnRightClick bool
14025
14026                         DmgPerSec int32
14027
14028                         LiquidType   LiquidType
14029                         FlowingAlt   string
14030                         SrcAlt       string
14031                         Viscosity    uint8 // 0-7
14032                         LiqRenewable bool
14033                         FlowRange    uint8
14034                         DrownDmg     uint8
14035                         Floodable    bool
14036
14037                         DrawBox, ColBox, SelBox NodeBox
14038
14039                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14040
14041                         LegacyFaceDir bool
14042                         LegacyMounted bool
14043
14044                         DigPredict string
14045
14046                         MaxLvl uint8
14047
14048                         AlphaUse
14049                 }))(obj)).Name))) > math.MaxUint16 {
14050                         chk(ErrTooLong)
14051                 }
14052                 {
14053                         x := uint16(len(([]byte((*(*(struct {
14054                                 Param0 Content
14055
14056                                 Name   string
14057                                 Groups []Group
14058
14059                                 P1Type   Param1Type
14060                                 P2Type   Param2Type
14061                                 DrawType DrawType
14062
14063                                 Mesh  string
14064                                 Scale float32
14065                                 //mt:const uint8(6)
14066                                 Tiles        [6]TileDef
14067                                 OverlayTiles [6]TileDef
14068                                 //mt:const uint8(6)
14069                                 SpecialTiles [6]TileDef
14070
14071                                 Color   color.NRGBA
14072                                 Palette Texture
14073
14074                                 Waving       WaveType
14075                                 ConnectSides uint8
14076                                 ConnectTo    []Content
14077                                 InsideTint   color.NRGBA
14078                                 Level        uint8 // Must be < 128.
14079
14080                                 Translucent bool // Sunlight is scattered and becomes normal light.
14081                                 Transparent bool // Sunlight isn't scattered.
14082                                 LightSrc    uint8
14083
14084                                 GndContent   bool
14085                                 Collides     bool
14086                                 Pointable    bool
14087                                 Diggable     bool
14088                                 Climbable    bool
14089                                 Replaceable  bool
14090                                 OnRightClick bool
14091
14092                                 DmgPerSec int32
14093
14094                                 LiquidType   LiquidType
14095                                 FlowingAlt   string
14096                                 SrcAlt       string
14097                                 Viscosity    uint8 // 0-7
14098                                 LiqRenewable bool
14099                                 FlowRange    uint8
14100                                 DrownDmg     uint8
14101                                 Floodable    bool
14102
14103                                 DrawBox, ColBox, SelBox NodeBox
14104
14105                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14106
14107                                 LegacyFaceDir bool
14108                                 LegacyMounted bool
14109
14110                                 DigPredict string
14111
14112                                 MaxLvl uint8
14113
14114                                 AlphaUse
14115                         }))(obj)).Name))))
14116                         write16(w, uint16(x))
14117                 }
14118                 {
14119                         _, err := w.Write(([]byte((*(*(struct {
14120                                 Param0 Content
14121
14122                                 Name   string
14123                                 Groups []Group
14124
14125                                 P1Type   Param1Type
14126                                 P2Type   Param2Type
14127                                 DrawType DrawType
14128
14129                                 Mesh  string
14130                                 Scale float32
14131                                 //mt:const uint8(6)
14132                                 Tiles        [6]TileDef
14133                                 OverlayTiles [6]TileDef
14134                                 //mt:const uint8(6)
14135                                 SpecialTiles [6]TileDef
14136
14137                                 Color   color.NRGBA
14138                                 Palette Texture
14139
14140                                 Waving       WaveType
14141                                 ConnectSides uint8
14142                                 ConnectTo    []Content
14143                                 InsideTint   color.NRGBA
14144                                 Level        uint8 // Must be < 128.
14145
14146                                 Translucent bool // Sunlight is scattered and becomes normal light.
14147                                 Transparent bool // Sunlight isn't scattered.
14148                                 LightSrc    uint8
14149
14150                                 GndContent   bool
14151                                 Collides     bool
14152                                 Pointable    bool
14153                                 Diggable     bool
14154                                 Climbable    bool
14155                                 Replaceable  bool
14156                                 OnRightClick bool
14157
14158                                 DmgPerSec int32
14159
14160                                 LiquidType   LiquidType
14161                                 FlowingAlt   string
14162                                 SrcAlt       string
14163                                 Viscosity    uint8 // 0-7
14164                                 LiqRenewable bool
14165                                 FlowRange    uint8
14166                                 DrownDmg     uint8
14167                                 Floodable    bool
14168
14169                                 DrawBox, ColBox, SelBox NodeBox
14170
14171                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14172
14173                                 LegacyFaceDir bool
14174                                 LegacyMounted bool
14175
14176                                 DigPredict string
14177
14178                                 MaxLvl uint8
14179
14180                                 AlphaUse
14181                         }))(obj)).Name))[:])
14182                         chk(err)
14183                 }
14184                 if len(((*(*(struct {
14185                         Param0 Content
14186
14187                         Name   string
14188                         Groups []Group
14189
14190                         P1Type   Param1Type
14191                         P2Type   Param2Type
14192                         DrawType DrawType
14193
14194                         Mesh  string
14195                         Scale float32
14196                         //mt:const uint8(6)
14197                         Tiles        [6]TileDef
14198                         OverlayTiles [6]TileDef
14199                         //mt:const uint8(6)
14200                         SpecialTiles [6]TileDef
14201
14202                         Color   color.NRGBA
14203                         Palette Texture
14204
14205                         Waving       WaveType
14206                         ConnectSides uint8
14207                         ConnectTo    []Content
14208                         InsideTint   color.NRGBA
14209                         Level        uint8 // Must be < 128.
14210
14211                         Translucent bool // Sunlight is scattered and becomes normal light.
14212                         Transparent bool // Sunlight isn't scattered.
14213                         LightSrc    uint8
14214
14215                         GndContent   bool
14216                         Collides     bool
14217                         Pointable    bool
14218                         Diggable     bool
14219                         Climbable    bool
14220                         Replaceable  bool
14221                         OnRightClick bool
14222
14223                         DmgPerSec int32
14224
14225                         LiquidType   LiquidType
14226                         FlowingAlt   string
14227                         SrcAlt       string
14228                         Viscosity    uint8 // 0-7
14229                         LiqRenewable bool
14230                         FlowRange    uint8
14231                         DrownDmg     uint8
14232                         Floodable    bool
14233
14234                         DrawBox, ColBox, SelBox NodeBox
14235
14236                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14237
14238                         LegacyFaceDir bool
14239                         LegacyMounted bool
14240
14241                         DigPredict string
14242
14243                         MaxLvl uint8
14244
14245                         AlphaUse
14246                 }))(obj)).Groups)) > math.MaxUint16 {
14247                         chk(ErrTooLong)
14248                 }
14249                 {
14250                         x := uint16(len(((*(*(struct {
14251                                 Param0 Content
14252
14253                                 Name   string
14254                                 Groups []Group
14255
14256                                 P1Type   Param1Type
14257                                 P2Type   Param2Type
14258                                 DrawType DrawType
14259
14260                                 Mesh  string
14261                                 Scale float32
14262                                 //mt:const uint8(6)
14263                                 Tiles        [6]TileDef
14264                                 OverlayTiles [6]TileDef
14265                                 //mt:const uint8(6)
14266                                 SpecialTiles [6]TileDef
14267
14268                                 Color   color.NRGBA
14269                                 Palette Texture
14270
14271                                 Waving       WaveType
14272                                 ConnectSides uint8
14273                                 ConnectTo    []Content
14274                                 InsideTint   color.NRGBA
14275                                 Level        uint8 // Must be < 128.
14276
14277                                 Translucent bool // Sunlight is scattered and becomes normal light.
14278                                 Transparent bool // Sunlight isn't scattered.
14279                                 LightSrc    uint8
14280
14281                                 GndContent   bool
14282                                 Collides     bool
14283                                 Pointable    bool
14284                                 Diggable     bool
14285                                 Climbable    bool
14286                                 Replaceable  bool
14287                                 OnRightClick bool
14288
14289                                 DmgPerSec int32
14290
14291                                 LiquidType   LiquidType
14292                                 FlowingAlt   string
14293                                 SrcAlt       string
14294                                 Viscosity    uint8 // 0-7
14295                                 LiqRenewable bool
14296                                 FlowRange    uint8
14297                                 DrownDmg     uint8
14298                                 Floodable    bool
14299
14300                                 DrawBox, ColBox, SelBox NodeBox
14301
14302                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14303
14304                                 LegacyFaceDir bool
14305                                 LegacyMounted bool
14306
14307                                 DigPredict string
14308
14309                                 MaxLvl uint8
14310
14311                                 AlphaUse
14312                         }))(obj)).Groups)))
14313                         write16(w, uint16(x))
14314                 }
14315                 for local241 := range (*(*(struct {
14316                         Param0 Content
14317
14318                         Name   string
14319                         Groups []Group
14320
14321                         P1Type   Param1Type
14322                         P2Type   Param2Type
14323                         DrawType DrawType
14324
14325                         Mesh  string
14326                         Scale float32
14327                         //mt:const uint8(6)
14328                         Tiles        [6]TileDef
14329                         OverlayTiles [6]TileDef
14330                         //mt:const uint8(6)
14331                         SpecialTiles [6]TileDef
14332
14333                         Color   color.NRGBA
14334                         Palette Texture
14335
14336                         Waving       WaveType
14337                         ConnectSides uint8
14338                         ConnectTo    []Content
14339                         InsideTint   color.NRGBA
14340                         Level        uint8 // Must be < 128.
14341
14342                         Translucent bool // Sunlight is scattered and becomes normal light.
14343                         Transparent bool // Sunlight isn't scattered.
14344                         LightSrc    uint8
14345
14346                         GndContent   bool
14347                         Collides     bool
14348                         Pointable    bool
14349                         Diggable     bool
14350                         Climbable    bool
14351                         Replaceable  bool
14352                         OnRightClick bool
14353
14354                         DmgPerSec int32
14355
14356                         LiquidType   LiquidType
14357                         FlowingAlt   string
14358                         SrcAlt       string
14359                         Viscosity    uint8 // 0-7
14360                         LiqRenewable bool
14361                         FlowRange    uint8
14362                         DrownDmg     uint8
14363                         Floodable    bool
14364
14365                         DrawBox, ColBox, SelBox NodeBox
14366
14367                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14368
14369                         LegacyFaceDir bool
14370                         LegacyMounted bool
14371
14372                         DigPredict string
14373
14374                         MaxLvl uint8
14375
14376                         AlphaUse
14377                 }))(obj)).Groups {
14378                         if err := pcall(func() {
14379                                 (((*(*(struct {
14380                                         Param0 Content
14381
14382                                         Name   string
14383                                         Groups []Group
14384
14385                                         P1Type   Param1Type
14386                                         P2Type   Param2Type
14387                                         DrawType DrawType
14388
14389                                         Mesh  string
14390                                         Scale float32
14391                                         //mt:const uint8(6)
14392                                         Tiles        [6]TileDef
14393                                         OverlayTiles [6]TileDef
14394                                         //mt:const uint8(6)
14395                                         SpecialTiles [6]TileDef
14396
14397                                         Color   color.NRGBA
14398                                         Palette Texture
14399
14400                                         Waving       WaveType
14401                                         ConnectSides uint8
14402                                         ConnectTo    []Content
14403                                         InsideTint   color.NRGBA
14404                                         Level        uint8 // Must be < 128.
14405
14406                                         Translucent bool // Sunlight is scattered and becomes normal light.
14407                                         Transparent bool // Sunlight isn't scattered.
14408                                         LightSrc    uint8
14409
14410                                         GndContent   bool
14411                                         Collides     bool
14412                                         Pointable    bool
14413                                         Diggable     bool
14414                                         Climbable    bool
14415                                         Replaceable  bool
14416                                         OnRightClick bool
14417
14418                                         DmgPerSec int32
14419
14420                                         LiquidType   LiquidType
14421                                         FlowingAlt   string
14422                                         SrcAlt       string
14423                                         Viscosity    uint8 // 0-7
14424                                         LiqRenewable bool
14425                                         FlowRange    uint8
14426                                         DrownDmg     uint8
14427                                         Floodable    bool
14428
14429                                         DrawBox, ColBox, SelBox NodeBox
14430
14431                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14432
14433                                         LegacyFaceDir bool
14434                                         LegacyMounted bool
14435
14436                                         DigPredict string
14437
14438                                         MaxLvl uint8
14439
14440                                         AlphaUse
14441                                 }))(obj)).Groups)[local241]).serialize(w)
14442                         }); err != nil {
14443                                 if err == io.EOF {
14444                                         chk(io.EOF)
14445                                 }
14446                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
14447                         }
14448                 }
14449                 if err := pcall(func() {
14450                         ((*(*(struct {
14451                                 Param0 Content
14452
14453                                 Name   string
14454                                 Groups []Group
14455
14456                                 P1Type   Param1Type
14457                                 P2Type   Param2Type
14458                                 DrawType DrawType
14459
14460                                 Mesh  string
14461                                 Scale float32
14462                                 //mt:const uint8(6)
14463                                 Tiles        [6]TileDef
14464                                 OverlayTiles [6]TileDef
14465                                 //mt:const uint8(6)
14466                                 SpecialTiles [6]TileDef
14467
14468                                 Color   color.NRGBA
14469                                 Palette Texture
14470
14471                                 Waving       WaveType
14472                                 ConnectSides uint8
14473                                 ConnectTo    []Content
14474                                 InsideTint   color.NRGBA
14475                                 Level        uint8 // Must be < 128.
14476
14477                                 Translucent bool // Sunlight is scattered and becomes normal light.
14478                                 Transparent bool // Sunlight isn't scattered.
14479                                 LightSrc    uint8
14480
14481                                 GndContent   bool
14482                                 Collides     bool
14483                                 Pointable    bool
14484                                 Diggable     bool
14485                                 Climbable    bool
14486                                 Replaceable  bool
14487                                 OnRightClick bool
14488
14489                                 DmgPerSec int32
14490
14491                                 LiquidType   LiquidType
14492                                 FlowingAlt   string
14493                                 SrcAlt       string
14494                                 Viscosity    uint8 // 0-7
14495                                 LiqRenewable bool
14496                                 FlowRange    uint8
14497                                 DrownDmg     uint8
14498                                 Floodable    bool
14499
14500                                 DrawBox, ColBox, SelBox NodeBox
14501
14502                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14503
14504                                 LegacyFaceDir bool
14505                                 LegacyMounted bool
14506
14507                                 DigPredict string
14508
14509                                 MaxLvl uint8
14510
14511                                 AlphaUse
14512                         }))(obj)).P1Type).serialize(w)
14513                 }); err != nil {
14514                         if err == io.EOF {
14515                                 chk(io.EOF)
14516                         }
14517                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param1Type", err))
14518                 }
14519                 if err := pcall(func() {
14520                         ((*(*(struct {
14521                                 Param0 Content
14522
14523                                 Name   string
14524                                 Groups []Group
14525
14526                                 P1Type   Param1Type
14527                                 P2Type   Param2Type
14528                                 DrawType DrawType
14529
14530                                 Mesh  string
14531                                 Scale float32
14532                                 //mt:const uint8(6)
14533                                 Tiles        [6]TileDef
14534                                 OverlayTiles [6]TileDef
14535                                 //mt:const uint8(6)
14536                                 SpecialTiles [6]TileDef
14537
14538                                 Color   color.NRGBA
14539                                 Palette Texture
14540
14541                                 Waving       WaveType
14542                                 ConnectSides uint8
14543                                 ConnectTo    []Content
14544                                 InsideTint   color.NRGBA
14545                                 Level        uint8 // Must be < 128.
14546
14547                                 Translucent bool // Sunlight is scattered and becomes normal light.
14548                                 Transparent bool // Sunlight isn't scattered.
14549                                 LightSrc    uint8
14550
14551                                 GndContent   bool
14552                                 Collides     bool
14553                                 Pointable    bool
14554                                 Diggable     bool
14555                                 Climbable    bool
14556                                 Replaceable  bool
14557                                 OnRightClick bool
14558
14559                                 DmgPerSec int32
14560
14561                                 LiquidType   LiquidType
14562                                 FlowingAlt   string
14563                                 SrcAlt       string
14564                                 Viscosity    uint8 // 0-7
14565                                 LiqRenewable bool
14566                                 FlowRange    uint8
14567                                 DrownDmg     uint8
14568                                 Floodable    bool
14569
14570                                 DrawBox, ColBox, SelBox NodeBox
14571
14572                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14573
14574                                 LegacyFaceDir bool
14575                                 LegacyMounted bool
14576
14577                                 DigPredict string
14578
14579                                 MaxLvl uint8
14580
14581                                 AlphaUse
14582                         }))(obj)).P2Type).serialize(w)
14583                 }); err != nil {
14584                         if err == io.EOF {
14585                                 chk(io.EOF)
14586                         }
14587                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param2Type", err))
14588                 }
14589                 if err := pcall(func() {
14590                         ((*(*(struct {
14591                                 Param0 Content
14592
14593                                 Name   string
14594                                 Groups []Group
14595
14596                                 P1Type   Param1Type
14597                                 P2Type   Param2Type
14598                                 DrawType DrawType
14599
14600                                 Mesh  string
14601                                 Scale float32
14602                                 //mt:const uint8(6)
14603                                 Tiles        [6]TileDef
14604                                 OverlayTiles [6]TileDef
14605                                 //mt:const uint8(6)
14606                                 SpecialTiles [6]TileDef
14607
14608                                 Color   color.NRGBA
14609                                 Palette Texture
14610
14611                                 Waving       WaveType
14612                                 ConnectSides uint8
14613                                 ConnectTo    []Content
14614                                 InsideTint   color.NRGBA
14615                                 Level        uint8 // Must be < 128.
14616
14617                                 Translucent bool // Sunlight is scattered and becomes normal light.
14618                                 Transparent bool // Sunlight isn't scattered.
14619                                 LightSrc    uint8
14620
14621                                 GndContent   bool
14622                                 Collides     bool
14623                                 Pointable    bool
14624                                 Diggable     bool
14625                                 Climbable    bool
14626                                 Replaceable  bool
14627                                 OnRightClick bool
14628
14629                                 DmgPerSec int32
14630
14631                                 LiquidType   LiquidType
14632                                 FlowingAlt   string
14633                                 SrcAlt       string
14634                                 Viscosity    uint8 // 0-7
14635                                 LiqRenewable bool
14636                                 FlowRange    uint8
14637                                 DrownDmg     uint8
14638                                 Floodable    bool
14639
14640                                 DrawBox, ColBox, SelBox NodeBox
14641
14642                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14643
14644                                 LegacyFaceDir bool
14645                                 LegacyMounted bool
14646
14647                                 DigPredict string
14648
14649                                 MaxLvl uint8
14650
14651                                 AlphaUse
14652                         }))(obj)).DrawType).serialize(w)
14653                 }); err != nil {
14654                         if err == io.EOF {
14655                                 chk(io.EOF)
14656                         }
14657                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
14658                 }
14659                 if len(([]byte((*(*(struct {
14660                         Param0 Content
14661
14662                         Name   string
14663                         Groups []Group
14664
14665                         P1Type   Param1Type
14666                         P2Type   Param2Type
14667                         DrawType DrawType
14668
14669                         Mesh  string
14670                         Scale float32
14671                         //mt:const uint8(6)
14672                         Tiles        [6]TileDef
14673                         OverlayTiles [6]TileDef
14674                         //mt:const uint8(6)
14675                         SpecialTiles [6]TileDef
14676
14677                         Color   color.NRGBA
14678                         Palette Texture
14679
14680                         Waving       WaveType
14681                         ConnectSides uint8
14682                         ConnectTo    []Content
14683                         InsideTint   color.NRGBA
14684                         Level        uint8 // Must be < 128.
14685
14686                         Translucent bool // Sunlight is scattered and becomes normal light.
14687                         Transparent bool // Sunlight isn't scattered.
14688                         LightSrc    uint8
14689
14690                         GndContent   bool
14691                         Collides     bool
14692                         Pointable    bool
14693                         Diggable     bool
14694                         Climbable    bool
14695                         Replaceable  bool
14696                         OnRightClick bool
14697
14698                         DmgPerSec int32
14699
14700                         LiquidType   LiquidType
14701                         FlowingAlt   string
14702                         SrcAlt       string
14703                         Viscosity    uint8 // 0-7
14704                         LiqRenewable bool
14705                         FlowRange    uint8
14706                         DrownDmg     uint8
14707                         Floodable    bool
14708
14709                         DrawBox, ColBox, SelBox NodeBox
14710
14711                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14712
14713                         LegacyFaceDir bool
14714                         LegacyMounted bool
14715
14716                         DigPredict string
14717
14718                         MaxLvl uint8
14719
14720                         AlphaUse
14721                 }))(obj)).Mesh))) > math.MaxUint16 {
14722                         chk(ErrTooLong)
14723                 }
14724                 {
14725                         x := uint16(len(([]byte((*(*(struct {
14726                                 Param0 Content
14727
14728                                 Name   string
14729                                 Groups []Group
14730
14731                                 P1Type   Param1Type
14732                                 P2Type   Param2Type
14733                                 DrawType DrawType
14734
14735                                 Mesh  string
14736                                 Scale float32
14737                                 //mt:const uint8(6)
14738                                 Tiles        [6]TileDef
14739                                 OverlayTiles [6]TileDef
14740                                 //mt:const uint8(6)
14741                                 SpecialTiles [6]TileDef
14742
14743                                 Color   color.NRGBA
14744                                 Palette Texture
14745
14746                                 Waving       WaveType
14747                                 ConnectSides uint8
14748                                 ConnectTo    []Content
14749                                 InsideTint   color.NRGBA
14750                                 Level        uint8 // Must be < 128.
14751
14752                                 Translucent bool // Sunlight is scattered and becomes normal light.
14753                                 Transparent bool // Sunlight isn't scattered.
14754                                 LightSrc    uint8
14755
14756                                 GndContent   bool
14757                                 Collides     bool
14758                                 Pointable    bool
14759                                 Diggable     bool
14760                                 Climbable    bool
14761                                 Replaceable  bool
14762                                 OnRightClick bool
14763
14764                                 DmgPerSec int32
14765
14766                                 LiquidType   LiquidType
14767                                 FlowingAlt   string
14768                                 SrcAlt       string
14769                                 Viscosity    uint8 // 0-7
14770                                 LiqRenewable bool
14771                                 FlowRange    uint8
14772                                 DrownDmg     uint8
14773                                 Floodable    bool
14774
14775                                 DrawBox, ColBox, SelBox NodeBox
14776
14777                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14778
14779                                 LegacyFaceDir bool
14780                                 LegacyMounted bool
14781
14782                                 DigPredict string
14783
14784                                 MaxLvl uint8
14785
14786                                 AlphaUse
14787                         }))(obj)).Mesh))))
14788                         write16(w, uint16(x))
14789                 }
14790                 {
14791                         _, err := w.Write(([]byte((*(*(struct {
14792                                 Param0 Content
14793
14794                                 Name   string
14795                                 Groups []Group
14796
14797                                 P1Type   Param1Type
14798                                 P2Type   Param2Type
14799                                 DrawType DrawType
14800
14801                                 Mesh  string
14802                                 Scale float32
14803                                 //mt:const uint8(6)
14804                                 Tiles        [6]TileDef
14805                                 OverlayTiles [6]TileDef
14806                                 //mt:const uint8(6)
14807                                 SpecialTiles [6]TileDef
14808
14809                                 Color   color.NRGBA
14810                                 Palette Texture
14811
14812                                 Waving       WaveType
14813                                 ConnectSides uint8
14814                                 ConnectTo    []Content
14815                                 InsideTint   color.NRGBA
14816                                 Level        uint8 // Must be < 128.
14817
14818                                 Translucent bool // Sunlight is scattered and becomes normal light.
14819                                 Transparent bool // Sunlight isn't scattered.
14820                                 LightSrc    uint8
14821
14822                                 GndContent   bool
14823                                 Collides     bool
14824                                 Pointable    bool
14825                                 Diggable     bool
14826                                 Climbable    bool
14827                                 Replaceable  bool
14828                                 OnRightClick bool
14829
14830                                 DmgPerSec int32
14831
14832                                 LiquidType   LiquidType
14833                                 FlowingAlt   string
14834                                 SrcAlt       string
14835                                 Viscosity    uint8 // 0-7
14836                                 LiqRenewable bool
14837                                 FlowRange    uint8
14838                                 DrownDmg     uint8
14839                                 Floodable    bool
14840
14841                                 DrawBox, ColBox, SelBox NodeBox
14842
14843                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14844
14845                                 LegacyFaceDir bool
14846                                 LegacyMounted bool
14847
14848                                 DigPredict string
14849
14850                                 MaxLvl uint8
14851
14852                                 AlphaUse
14853                         }))(obj)).Mesh))[:])
14854                         chk(err)
14855                 }
14856                 {
14857                         x := (*(*(struct {
14858                                 Param0 Content
14859
14860                                 Name   string
14861                                 Groups []Group
14862
14863                                 P1Type   Param1Type
14864                                 P2Type   Param2Type
14865                                 DrawType DrawType
14866
14867                                 Mesh  string
14868                                 Scale float32
14869                                 //mt:const uint8(6)
14870                                 Tiles        [6]TileDef
14871                                 OverlayTiles [6]TileDef
14872                                 //mt:const uint8(6)
14873                                 SpecialTiles [6]TileDef
14874
14875                                 Color   color.NRGBA
14876                                 Palette Texture
14877
14878                                 Waving       WaveType
14879                                 ConnectSides uint8
14880                                 ConnectTo    []Content
14881                                 InsideTint   color.NRGBA
14882                                 Level        uint8 // Must be < 128.
14883
14884                                 Translucent bool // Sunlight is scattered and becomes normal light.
14885                                 Transparent bool // Sunlight isn't scattered.
14886                                 LightSrc    uint8
14887
14888                                 GndContent   bool
14889                                 Collides     bool
14890                                 Pointable    bool
14891                                 Diggable     bool
14892                                 Climbable    bool
14893                                 Replaceable  bool
14894                                 OnRightClick bool
14895
14896                                 DmgPerSec int32
14897
14898                                 LiquidType   LiquidType
14899                                 FlowingAlt   string
14900                                 SrcAlt       string
14901                                 Viscosity    uint8 // 0-7
14902                                 LiqRenewable bool
14903                                 FlowRange    uint8
14904                                 DrownDmg     uint8
14905                                 Floodable    bool
14906
14907                                 DrawBox, ColBox, SelBox NodeBox
14908
14909                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14910
14911                                 LegacyFaceDir bool
14912                                 LegacyMounted bool
14913
14914                                 DigPredict string
14915
14916                                 MaxLvl uint8
14917
14918                                 AlphaUse
14919                         }))(obj)).Scale
14920                         write32(w, math.Float32bits(x))
14921                 }
14922                 {
14923                         local242 := uint8(6)
14924                         {
14925                                 x := local242
14926                                 write8(w, uint8(x))
14927                         }
14928                 }
14929                 for local243 := range (*(*(struct {
14930                         Param0 Content
14931
14932                         Name   string
14933                         Groups []Group
14934
14935                         P1Type   Param1Type
14936                         P2Type   Param2Type
14937                         DrawType DrawType
14938
14939                         Mesh  string
14940                         Scale float32
14941                         //mt:const uint8(6)
14942                         Tiles        [6]TileDef
14943                         OverlayTiles [6]TileDef
14944                         //mt:const uint8(6)
14945                         SpecialTiles [6]TileDef
14946
14947                         Color   color.NRGBA
14948                         Palette Texture
14949
14950                         Waving       WaveType
14951                         ConnectSides uint8
14952                         ConnectTo    []Content
14953                         InsideTint   color.NRGBA
14954                         Level        uint8 // Must be < 128.
14955
14956                         Translucent bool // Sunlight is scattered and becomes normal light.
14957                         Transparent bool // Sunlight isn't scattered.
14958                         LightSrc    uint8
14959
14960                         GndContent   bool
14961                         Collides     bool
14962                         Pointable    bool
14963                         Diggable     bool
14964                         Climbable    bool
14965                         Replaceable  bool
14966                         OnRightClick bool
14967
14968                         DmgPerSec int32
14969
14970                         LiquidType   LiquidType
14971                         FlowingAlt   string
14972                         SrcAlt       string
14973                         Viscosity    uint8 // 0-7
14974                         LiqRenewable bool
14975                         FlowRange    uint8
14976                         DrownDmg     uint8
14977                         Floodable    bool
14978
14979                         DrawBox, ColBox, SelBox NodeBox
14980
14981                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14982
14983                         LegacyFaceDir bool
14984                         LegacyMounted bool
14985
14986                         DigPredict string
14987
14988                         MaxLvl uint8
14989
14990                         AlphaUse
14991                 }))(obj)).Tiles {
14992                         if err := pcall(func() {
14993                                 (((*(*(struct {
14994                                         Param0 Content
14995
14996                                         Name   string
14997                                         Groups []Group
14998
14999                                         P1Type   Param1Type
15000                                         P2Type   Param2Type
15001                                         DrawType DrawType
15002
15003                                         Mesh  string
15004                                         Scale float32
15005                                         //mt:const uint8(6)
15006                                         Tiles        [6]TileDef
15007                                         OverlayTiles [6]TileDef
15008                                         //mt:const uint8(6)
15009                                         SpecialTiles [6]TileDef
15010
15011                                         Color   color.NRGBA
15012                                         Palette Texture
15013
15014                                         Waving       WaveType
15015                                         ConnectSides uint8
15016                                         ConnectTo    []Content
15017                                         InsideTint   color.NRGBA
15018                                         Level        uint8 // Must be < 128.
15019
15020                                         Translucent bool // Sunlight is scattered and becomes normal light.
15021                                         Transparent bool // Sunlight isn't scattered.
15022                                         LightSrc    uint8
15023
15024                                         GndContent   bool
15025                                         Collides     bool
15026                                         Pointable    bool
15027                                         Diggable     bool
15028                                         Climbable    bool
15029                                         Replaceable  bool
15030                                         OnRightClick bool
15031
15032                                         DmgPerSec int32
15033
15034                                         LiquidType   LiquidType
15035                                         FlowingAlt   string
15036                                         SrcAlt       string
15037                                         Viscosity    uint8 // 0-7
15038                                         LiqRenewable bool
15039                                         FlowRange    uint8
15040                                         DrownDmg     uint8
15041                                         Floodable    bool
15042
15043                                         DrawBox, ColBox, SelBox NodeBox
15044
15045                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15046
15047                                         LegacyFaceDir bool
15048                                         LegacyMounted bool
15049
15050                                         DigPredict string
15051
15052                                         MaxLvl uint8
15053
15054                                         AlphaUse
15055                                 }))(obj)).Tiles)[local243]).serialize(w)
15056                         }); err != nil {
15057                                 if err == io.EOF {
15058                                         chk(io.EOF)
15059                                 }
15060                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
15061                         }
15062                 }
15063                 for local244 := range (*(*(struct {
15064                         Param0 Content
15065
15066                         Name   string
15067                         Groups []Group
15068
15069                         P1Type   Param1Type
15070                         P2Type   Param2Type
15071                         DrawType DrawType
15072
15073                         Mesh  string
15074                         Scale float32
15075                         //mt:const uint8(6)
15076                         Tiles        [6]TileDef
15077                         OverlayTiles [6]TileDef
15078                         //mt:const uint8(6)
15079                         SpecialTiles [6]TileDef
15080
15081                         Color   color.NRGBA
15082                         Palette Texture
15083
15084                         Waving       WaveType
15085                         ConnectSides uint8
15086                         ConnectTo    []Content
15087                         InsideTint   color.NRGBA
15088                         Level        uint8 // Must be < 128.
15089
15090                         Translucent bool // Sunlight is scattered and becomes normal light.
15091                         Transparent bool // Sunlight isn't scattered.
15092                         LightSrc    uint8
15093
15094                         GndContent   bool
15095                         Collides     bool
15096                         Pointable    bool
15097                         Diggable     bool
15098                         Climbable    bool
15099                         Replaceable  bool
15100                         OnRightClick bool
15101
15102                         DmgPerSec int32
15103
15104                         LiquidType   LiquidType
15105                         FlowingAlt   string
15106                         SrcAlt       string
15107                         Viscosity    uint8 // 0-7
15108                         LiqRenewable bool
15109                         FlowRange    uint8
15110                         DrownDmg     uint8
15111                         Floodable    bool
15112
15113                         DrawBox, ColBox, SelBox NodeBox
15114
15115                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15116
15117                         LegacyFaceDir bool
15118                         LegacyMounted bool
15119
15120                         DigPredict string
15121
15122                         MaxLvl uint8
15123
15124                         AlphaUse
15125                 }))(obj)).OverlayTiles {
15126                         if err := pcall(func() {
15127                                 (((*(*(struct {
15128                                         Param0 Content
15129
15130                                         Name   string
15131                                         Groups []Group
15132
15133                                         P1Type   Param1Type
15134                                         P2Type   Param2Type
15135                                         DrawType DrawType
15136
15137                                         Mesh  string
15138                                         Scale float32
15139                                         //mt:const uint8(6)
15140                                         Tiles        [6]TileDef
15141                                         OverlayTiles [6]TileDef
15142                                         //mt:const uint8(6)
15143                                         SpecialTiles [6]TileDef
15144
15145                                         Color   color.NRGBA
15146                                         Palette Texture
15147
15148                                         Waving       WaveType
15149                                         ConnectSides uint8
15150                                         ConnectTo    []Content
15151                                         InsideTint   color.NRGBA
15152                                         Level        uint8 // Must be < 128.
15153
15154                                         Translucent bool // Sunlight is scattered and becomes normal light.
15155                                         Transparent bool // Sunlight isn't scattered.
15156                                         LightSrc    uint8
15157
15158                                         GndContent   bool
15159                                         Collides     bool
15160                                         Pointable    bool
15161                                         Diggable     bool
15162                                         Climbable    bool
15163                                         Replaceable  bool
15164                                         OnRightClick bool
15165
15166                                         DmgPerSec int32
15167
15168                                         LiquidType   LiquidType
15169                                         FlowingAlt   string
15170                                         SrcAlt       string
15171                                         Viscosity    uint8 // 0-7
15172                                         LiqRenewable bool
15173                                         FlowRange    uint8
15174                                         DrownDmg     uint8
15175                                         Floodable    bool
15176
15177                                         DrawBox, ColBox, SelBox NodeBox
15178
15179                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15180
15181                                         LegacyFaceDir bool
15182                                         LegacyMounted bool
15183
15184                                         DigPredict string
15185
15186                                         MaxLvl uint8
15187
15188                                         AlphaUse
15189                                 }))(obj)).OverlayTiles)[local244]).serialize(w)
15190                         }); err != nil {
15191                                 if err == io.EOF {
15192                                         chk(io.EOF)
15193                                 }
15194                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
15195                         }
15196                 }
15197                 {
15198                         local245 := uint8(6)
15199                         {
15200                                 x := local245
15201                                 write8(w, uint8(x))
15202                         }
15203                 }
15204                 for local246 := range (*(*(struct {
15205                         Param0 Content
15206
15207                         Name   string
15208                         Groups []Group
15209
15210                         P1Type   Param1Type
15211                         P2Type   Param2Type
15212                         DrawType DrawType
15213
15214                         Mesh  string
15215                         Scale float32
15216                         //mt:const uint8(6)
15217                         Tiles        [6]TileDef
15218                         OverlayTiles [6]TileDef
15219                         //mt:const uint8(6)
15220                         SpecialTiles [6]TileDef
15221
15222                         Color   color.NRGBA
15223                         Palette Texture
15224
15225                         Waving       WaveType
15226                         ConnectSides uint8
15227                         ConnectTo    []Content
15228                         InsideTint   color.NRGBA
15229                         Level        uint8 // Must be < 128.
15230
15231                         Translucent bool // Sunlight is scattered and becomes normal light.
15232                         Transparent bool // Sunlight isn't scattered.
15233                         LightSrc    uint8
15234
15235                         GndContent   bool
15236                         Collides     bool
15237                         Pointable    bool
15238                         Diggable     bool
15239                         Climbable    bool
15240                         Replaceable  bool
15241                         OnRightClick bool
15242
15243                         DmgPerSec int32
15244
15245                         LiquidType   LiquidType
15246                         FlowingAlt   string
15247                         SrcAlt       string
15248                         Viscosity    uint8 // 0-7
15249                         LiqRenewable bool
15250                         FlowRange    uint8
15251                         DrownDmg     uint8
15252                         Floodable    bool
15253
15254                         DrawBox, ColBox, SelBox NodeBox
15255
15256                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15257
15258                         LegacyFaceDir bool
15259                         LegacyMounted bool
15260
15261                         DigPredict string
15262
15263                         MaxLvl uint8
15264
15265                         AlphaUse
15266                 }))(obj)).SpecialTiles {
15267                         if err := pcall(func() {
15268                                 (((*(*(struct {
15269                                         Param0 Content
15270
15271                                         Name   string
15272                                         Groups []Group
15273
15274                                         P1Type   Param1Type
15275                                         P2Type   Param2Type
15276                                         DrawType DrawType
15277
15278                                         Mesh  string
15279                                         Scale float32
15280                                         //mt:const uint8(6)
15281                                         Tiles        [6]TileDef
15282                                         OverlayTiles [6]TileDef
15283                                         //mt:const uint8(6)
15284                                         SpecialTiles [6]TileDef
15285
15286                                         Color   color.NRGBA
15287                                         Palette Texture
15288
15289                                         Waving       WaveType
15290                                         ConnectSides uint8
15291                                         ConnectTo    []Content
15292                                         InsideTint   color.NRGBA
15293                                         Level        uint8 // Must be < 128.
15294
15295                                         Translucent bool // Sunlight is scattered and becomes normal light.
15296                                         Transparent bool // Sunlight isn't scattered.
15297                                         LightSrc    uint8
15298
15299                                         GndContent   bool
15300                                         Collides     bool
15301                                         Pointable    bool
15302                                         Diggable     bool
15303                                         Climbable    bool
15304                                         Replaceable  bool
15305                                         OnRightClick bool
15306
15307                                         DmgPerSec int32
15308
15309                                         LiquidType   LiquidType
15310                                         FlowingAlt   string
15311                                         SrcAlt       string
15312                                         Viscosity    uint8 // 0-7
15313                                         LiqRenewable bool
15314                                         FlowRange    uint8
15315                                         DrownDmg     uint8
15316                                         Floodable    bool
15317
15318                                         DrawBox, ColBox, SelBox NodeBox
15319
15320                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15321
15322                                         LegacyFaceDir bool
15323                                         LegacyMounted bool
15324
15325                                         DigPredict string
15326
15327                                         MaxLvl uint8
15328
15329                                         AlphaUse
15330                                 }))(obj)).SpecialTiles)[local246]).serialize(w)
15331                         }); err != nil {
15332                                 if err == io.EOF {
15333                                         chk(io.EOF)
15334                                 }
15335                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
15336                         }
15337                 }
15338                 {
15339                         x := (*(*(struct {
15340                                 Param0 Content
15341
15342                                 Name   string
15343                                 Groups []Group
15344
15345                                 P1Type   Param1Type
15346                                 P2Type   Param2Type
15347                                 DrawType DrawType
15348
15349                                 Mesh  string
15350                                 Scale float32
15351                                 //mt:const uint8(6)
15352                                 Tiles        [6]TileDef
15353                                 OverlayTiles [6]TileDef
15354                                 //mt:const uint8(6)
15355                                 SpecialTiles [6]TileDef
15356
15357                                 Color   color.NRGBA
15358                                 Palette Texture
15359
15360                                 Waving       WaveType
15361                                 ConnectSides uint8
15362                                 ConnectTo    []Content
15363                                 InsideTint   color.NRGBA
15364                                 Level        uint8 // Must be < 128.
15365
15366                                 Translucent bool // Sunlight is scattered and becomes normal light.
15367                                 Transparent bool // Sunlight isn't scattered.
15368                                 LightSrc    uint8
15369
15370                                 GndContent   bool
15371                                 Collides     bool
15372                                 Pointable    bool
15373                                 Diggable     bool
15374                                 Climbable    bool
15375                                 Replaceable  bool
15376                                 OnRightClick bool
15377
15378                                 DmgPerSec int32
15379
15380                                 LiquidType   LiquidType
15381                                 FlowingAlt   string
15382                                 SrcAlt       string
15383                                 Viscosity    uint8 // 0-7
15384                                 LiqRenewable bool
15385                                 FlowRange    uint8
15386                                 DrownDmg     uint8
15387                                 Floodable    bool
15388
15389                                 DrawBox, ColBox, SelBox NodeBox
15390
15391                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15392
15393                                 LegacyFaceDir bool
15394                                 LegacyMounted bool
15395
15396                                 DigPredict string
15397
15398                                 MaxLvl uint8
15399
15400                                 AlphaUse
15401                         }))(obj)).Color
15402                         w.Write([]byte{x.A, x.R, x.G, x.B})
15403
15404                 }
15405                 if err := pcall(func() {
15406                         ((*(*(struct {
15407                                 Param0 Content
15408
15409                                 Name   string
15410                                 Groups []Group
15411
15412                                 P1Type   Param1Type
15413                                 P2Type   Param2Type
15414                                 DrawType DrawType
15415
15416                                 Mesh  string
15417                                 Scale float32
15418                                 //mt:const uint8(6)
15419                                 Tiles        [6]TileDef
15420                                 OverlayTiles [6]TileDef
15421                                 //mt:const uint8(6)
15422                                 SpecialTiles [6]TileDef
15423
15424                                 Color   color.NRGBA
15425                                 Palette Texture
15426
15427                                 Waving       WaveType
15428                                 ConnectSides uint8
15429                                 ConnectTo    []Content
15430                                 InsideTint   color.NRGBA
15431                                 Level        uint8 // Must be < 128.
15432
15433                                 Translucent bool // Sunlight is scattered and becomes normal light.
15434                                 Transparent bool // Sunlight isn't scattered.
15435                                 LightSrc    uint8
15436
15437                                 GndContent   bool
15438                                 Collides     bool
15439                                 Pointable    bool
15440                                 Diggable     bool
15441                                 Climbable    bool
15442                                 Replaceable  bool
15443                                 OnRightClick bool
15444
15445                                 DmgPerSec int32
15446
15447                                 LiquidType   LiquidType
15448                                 FlowingAlt   string
15449                                 SrcAlt       string
15450                                 Viscosity    uint8 // 0-7
15451                                 LiqRenewable bool
15452                                 FlowRange    uint8
15453                                 DrownDmg     uint8
15454                                 Floodable    bool
15455
15456                                 DrawBox, ColBox, SelBox NodeBox
15457
15458                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15459
15460                                 LegacyFaceDir bool
15461                                 LegacyMounted bool
15462
15463                                 DigPredict string
15464
15465                                 MaxLvl uint8
15466
15467                                 AlphaUse
15468                         }))(obj)).Palette).serialize(w)
15469                 }); err != nil {
15470                         if err == io.EOF {
15471                                 chk(io.EOF)
15472                         }
15473                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
15474                 }
15475                 if err := pcall(func() {
15476                         ((*(*(struct {
15477                                 Param0 Content
15478
15479                                 Name   string
15480                                 Groups []Group
15481
15482                                 P1Type   Param1Type
15483                                 P2Type   Param2Type
15484                                 DrawType DrawType
15485
15486                                 Mesh  string
15487                                 Scale float32
15488                                 //mt:const uint8(6)
15489                                 Tiles        [6]TileDef
15490                                 OverlayTiles [6]TileDef
15491                                 //mt:const uint8(6)
15492                                 SpecialTiles [6]TileDef
15493
15494                                 Color   color.NRGBA
15495                                 Palette Texture
15496
15497                                 Waving       WaveType
15498                                 ConnectSides uint8
15499                                 ConnectTo    []Content
15500                                 InsideTint   color.NRGBA
15501                                 Level        uint8 // Must be < 128.
15502
15503                                 Translucent bool // Sunlight is scattered and becomes normal light.
15504                                 Transparent bool // Sunlight isn't scattered.
15505                                 LightSrc    uint8
15506
15507                                 GndContent   bool
15508                                 Collides     bool
15509                                 Pointable    bool
15510                                 Diggable     bool
15511                                 Climbable    bool
15512                                 Replaceable  bool
15513                                 OnRightClick bool
15514
15515                                 DmgPerSec int32
15516
15517                                 LiquidType   LiquidType
15518                                 FlowingAlt   string
15519                                 SrcAlt       string
15520                                 Viscosity    uint8 // 0-7
15521                                 LiqRenewable bool
15522                                 FlowRange    uint8
15523                                 DrownDmg     uint8
15524                                 Floodable    bool
15525
15526                                 DrawBox, ColBox, SelBox NodeBox
15527
15528                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15529
15530                                 LegacyFaceDir bool
15531                                 LegacyMounted bool
15532
15533                                 DigPredict string
15534
15535                                 MaxLvl uint8
15536
15537                                 AlphaUse
15538                         }))(obj)).Waving).serialize(w)
15539                 }); err != nil {
15540                         if err == io.EOF {
15541                                 chk(io.EOF)
15542                         }
15543                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.WaveType", err))
15544                 }
15545                 {
15546                         x := (*(*(struct {
15547                                 Param0 Content
15548
15549                                 Name   string
15550                                 Groups []Group
15551
15552                                 P1Type   Param1Type
15553                                 P2Type   Param2Type
15554                                 DrawType DrawType
15555
15556                                 Mesh  string
15557                                 Scale float32
15558                                 //mt:const uint8(6)
15559                                 Tiles        [6]TileDef
15560                                 OverlayTiles [6]TileDef
15561                                 //mt:const uint8(6)
15562                                 SpecialTiles [6]TileDef
15563
15564                                 Color   color.NRGBA
15565                                 Palette Texture
15566
15567                                 Waving       WaveType
15568                                 ConnectSides uint8
15569                                 ConnectTo    []Content
15570                                 InsideTint   color.NRGBA
15571                                 Level        uint8 // Must be < 128.
15572
15573                                 Translucent bool // Sunlight is scattered and becomes normal light.
15574                                 Transparent bool // Sunlight isn't scattered.
15575                                 LightSrc    uint8
15576
15577                                 GndContent   bool
15578                                 Collides     bool
15579                                 Pointable    bool
15580                                 Diggable     bool
15581                                 Climbable    bool
15582                                 Replaceable  bool
15583                                 OnRightClick bool
15584
15585                                 DmgPerSec int32
15586
15587                                 LiquidType   LiquidType
15588                                 FlowingAlt   string
15589                                 SrcAlt       string
15590                                 Viscosity    uint8 // 0-7
15591                                 LiqRenewable bool
15592                                 FlowRange    uint8
15593                                 DrownDmg     uint8
15594                                 Floodable    bool
15595
15596                                 DrawBox, ColBox, SelBox NodeBox
15597
15598                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15599
15600                                 LegacyFaceDir bool
15601                                 LegacyMounted bool
15602
15603                                 DigPredict string
15604
15605                                 MaxLvl uint8
15606
15607                                 AlphaUse
15608                         }))(obj)).ConnectSides
15609                         write8(w, uint8(x))
15610                 }
15611                 if len(((*(*(struct {
15612                         Param0 Content
15613
15614                         Name   string
15615                         Groups []Group
15616
15617                         P1Type   Param1Type
15618                         P2Type   Param2Type
15619                         DrawType DrawType
15620
15621                         Mesh  string
15622                         Scale float32
15623                         //mt:const uint8(6)
15624                         Tiles        [6]TileDef
15625                         OverlayTiles [6]TileDef
15626                         //mt:const uint8(6)
15627                         SpecialTiles [6]TileDef
15628
15629                         Color   color.NRGBA
15630                         Palette Texture
15631
15632                         Waving       WaveType
15633                         ConnectSides uint8
15634                         ConnectTo    []Content
15635                         InsideTint   color.NRGBA
15636                         Level        uint8 // Must be < 128.
15637
15638                         Translucent bool // Sunlight is scattered and becomes normal light.
15639                         Transparent bool // Sunlight isn't scattered.
15640                         LightSrc    uint8
15641
15642                         GndContent   bool
15643                         Collides     bool
15644                         Pointable    bool
15645                         Diggable     bool
15646                         Climbable    bool
15647                         Replaceable  bool
15648                         OnRightClick bool
15649
15650                         DmgPerSec int32
15651
15652                         LiquidType   LiquidType
15653                         FlowingAlt   string
15654                         SrcAlt       string
15655                         Viscosity    uint8 // 0-7
15656                         LiqRenewable bool
15657                         FlowRange    uint8
15658                         DrownDmg     uint8
15659                         Floodable    bool
15660
15661                         DrawBox, ColBox, SelBox NodeBox
15662
15663                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15664
15665                         LegacyFaceDir bool
15666                         LegacyMounted bool
15667
15668                         DigPredict string
15669
15670                         MaxLvl uint8
15671
15672                         AlphaUse
15673                 }))(obj)).ConnectTo)) > math.MaxUint16 {
15674                         chk(ErrTooLong)
15675                 }
15676                 {
15677                         x := uint16(len(((*(*(struct {
15678                                 Param0 Content
15679
15680                                 Name   string
15681                                 Groups []Group
15682
15683                                 P1Type   Param1Type
15684                                 P2Type   Param2Type
15685                                 DrawType DrawType
15686
15687                                 Mesh  string
15688                                 Scale float32
15689                                 //mt:const uint8(6)
15690                                 Tiles        [6]TileDef
15691                                 OverlayTiles [6]TileDef
15692                                 //mt:const uint8(6)
15693                                 SpecialTiles [6]TileDef
15694
15695                                 Color   color.NRGBA
15696                                 Palette Texture
15697
15698                                 Waving       WaveType
15699                                 ConnectSides uint8
15700                                 ConnectTo    []Content
15701                                 InsideTint   color.NRGBA
15702                                 Level        uint8 // Must be < 128.
15703
15704                                 Translucent bool // Sunlight is scattered and becomes normal light.
15705                                 Transparent bool // Sunlight isn't scattered.
15706                                 LightSrc    uint8
15707
15708                                 GndContent   bool
15709                                 Collides     bool
15710                                 Pointable    bool
15711                                 Diggable     bool
15712                                 Climbable    bool
15713                                 Replaceable  bool
15714                                 OnRightClick bool
15715
15716                                 DmgPerSec int32
15717
15718                                 LiquidType   LiquidType
15719                                 FlowingAlt   string
15720                                 SrcAlt       string
15721                                 Viscosity    uint8 // 0-7
15722                                 LiqRenewable bool
15723                                 FlowRange    uint8
15724                                 DrownDmg     uint8
15725                                 Floodable    bool
15726
15727                                 DrawBox, ColBox, SelBox NodeBox
15728
15729                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15730
15731                                 LegacyFaceDir bool
15732                                 LegacyMounted bool
15733
15734                                 DigPredict string
15735
15736                                 MaxLvl uint8
15737
15738                                 AlphaUse
15739                         }))(obj)).ConnectTo)))
15740                         write16(w, uint16(x))
15741                 }
15742                 for local247 := range (*(*(struct {
15743                         Param0 Content
15744
15745                         Name   string
15746                         Groups []Group
15747
15748                         P1Type   Param1Type
15749                         P2Type   Param2Type
15750                         DrawType DrawType
15751
15752                         Mesh  string
15753                         Scale float32
15754                         //mt:const uint8(6)
15755                         Tiles        [6]TileDef
15756                         OverlayTiles [6]TileDef
15757                         //mt:const uint8(6)
15758                         SpecialTiles [6]TileDef
15759
15760                         Color   color.NRGBA
15761                         Palette Texture
15762
15763                         Waving       WaveType
15764                         ConnectSides uint8
15765                         ConnectTo    []Content
15766                         InsideTint   color.NRGBA
15767                         Level        uint8 // Must be < 128.
15768
15769                         Translucent bool // Sunlight is scattered and becomes normal light.
15770                         Transparent bool // Sunlight isn't scattered.
15771                         LightSrc    uint8
15772
15773                         GndContent   bool
15774                         Collides     bool
15775                         Pointable    bool
15776                         Diggable     bool
15777                         Climbable    bool
15778                         Replaceable  bool
15779                         OnRightClick bool
15780
15781                         DmgPerSec int32
15782
15783                         LiquidType   LiquidType
15784                         FlowingAlt   string
15785                         SrcAlt       string
15786                         Viscosity    uint8 // 0-7
15787                         LiqRenewable bool
15788                         FlowRange    uint8
15789                         DrownDmg     uint8
15790                         Floodable    bool
15791
15792                         DrawBox, ColBox, SelBox NodeBox
15793
15794                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15795
15796                         LegacyFaceDir bool
15797                         LegacyMounted bool
15798
15799                         DigPredict string
15800
15801                         MaxLvl uint8
15802
15803                         AlphaUse
15804                 }))(obj)).ConnectTo {
15805                         if err := pcall(func() {
15806                                 (((*(*(struct {
15807                                         Param0 Content
15808
15809                                         Name   string
15810                                         Groups []Group
15811
15812                                         P1Type   Param1Type
15813                                         P2Type   Param2Type
15814                                         DrawType DrawType
15815
15816                                         Mesh  string
15817                                         Scale float32
15818                                         //mt:const uint8(6)
15819                                         Tiles        [6]TileDef
15820                                         OverlayTiles [6]TileDef
15821                                         //mt:const uint8(6)
15822                                         SpecialTiles [6]TileDef
15823
15824                                         Color   color.NRGBA
15825                                         Palette Texture
15826
15827                                         Waving       WaveType
15828                                         ConnectSides uint8
15829                                         ConnectTo    []Content
15830                                         InsideTint   color.NRGBA
15831                                         Level        uint8 // Must be < 128.
15832
15833                                         Translucent bool // Sunlight is scattered and becomes normal light.
15834                                         Transparent bool // Sunlight isn't scattered.
15835                                         LightSrc    uint8
15836
15837                                         GndContent   bool
15838                                         Collides     bool
15839                                         Pointable    bool
15840                                         Diggable     bool
15841                                         Climbable    bool
15842                                         Replaceable  bool
15843                                         OnRightClick bool
15844
15845                                         DmgPerSec int32
15846
15847                                         LiquidType   LiquidType
15848                                         FlowingAlt   string
15849                                         SrcAlt       string
15850                                         Viscosity    uint8 // 0-7
15851                                         LiqRenewable bool
15852                                         FlowRange    uint8
15853                                         DrownDmg     uint8
15854                                         Floodable    bool
15855
15856                                         DrawBox, ColBox, SelBox NodeBox
15857
15858                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15859
15860                                         LegacyFaceDir bool
15861                                         LegacyMounted bool
15862
15863                                         DigPredict string
15864
15865                                         MaxLvl uint8
15866
15867                                         AlphaUse
15868                                 }))(obj)).ConnectTo)[local247]).serialize(w)
15869                         }); err != nil {
15870                                 if err == io.EOF {
15871                                         chk(io.EOF)
15872                                 }
15873                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
15874                         }
15875                 }
15876                 {
15877                         x := (*(*(struct {
15878                                 Param0 Content
15879
15880                                 Name   string
15881                                 Groups []Group
15882
15883                                 P1Type   Param1Type
15884                                 P2Type   Param2Type
15885                                 DrawType DrawType
15886
15887                                 Mesh  string
15888                                 Scale float32
15889                                 //mt:const uint8(6)
15890                                 Tiles        [6]TileDef
15891                                 OverlayTiles [6]TileDef
15892                                 //mt:const uint8(6)
15893                                 SpecialTiles [6]TileDef
15894
15895                                 Color   color.NRGBA
15896                                 Palette Texture
15897
15898                                 Waving       WaveType
15899                                 ConnectSides uint8
15900                                 ConnectTo    []Content
15901                                 InsideTint   color.NRGBA
15902                                 Level        uint8 // Must be < 128.
15903
15904                                 Translucent bool // Sunlight is scattered and becomes normal light.
15905                                 Transparent bool // Sunlight isn't scattered.
15906                                 LightSrc    uint8
15907
15908                                 GndContent   bool
15909                                 Collides     bool
15910                                 Pointable    bool
15911                                 Diggable     bool
15912                                 Climbable    bool
15913                                 Replaceable  bool
15914                                 OnRightClick bool
15915
15916                                 DmgPerSec int32
15917
15918                                 LiquidType   LiquidType
15919                                 FlowingAlt   string
15920                                 SrcAlt       string
15921                                 Viscosity    uint8 // 0-7
15922                                 LiqRenewable bool
15923                                 FlowRange    uint8
15924                                 DrownDmg     uint8
15925                                 Floodable    bool
15926
15927                                 DrawBox, ColBox, SelBox NodeBox
15928
15929                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15930
15931                                 LegacyFaceDir bool
15932                                 LegacyMounted bool
15933
15934                                 DigPredict string
15935
15936                                 MaxLvl uint8
15937
15938                                 AlphaUse
15939                         }))(obj)).InsideTint
15940                         w.Write([]byte{x.A, x.R, x.G, x.B})
15941
15942                 }
15943                 {
15944                         x := (*(*(struct {
15945                                 Param0 Content
15946
15947                                 Name   string
15948                                 Groups []Group
15949
15950                                 P1Type   Param1Type
15951                                 P2Type   Param2Type
15952                                 DrawType DrawType
15953
15954                                 Mesh  string
15955                                 Scale float32
15956                                 //mt:const uint8(6)
15957                                 Tiles        [6]TileDef
15958                                 OverlayTiles [6]TileDef
15959                                 //mt:const uint8(6)
15960                                 SpecialTiles [6]TileDef
15961
15962                                 Color   color.NRGBA
15963                                 Palette Texture
15964
15965                                 Waving       WaveType
15966                                 ConnectSides uint8
15967                                 ConnectTo    []Content
15968                                 InsideTint   color.NRGBA
15969                                 Level        uint8 // Must be < 128.
15970
15971                                 Translucent bool // Sunlight is scattered and becomes normal light.
15972                                 Transparent bool // Sunlight isn't scattered.
15973                                 LightSrc    uint8
15974
15975                                 GndContent   bool
15976                                 Collides     bool
15977                                 Pointable    bool
15978                                 Diggable     bool
15979                                 Climbable    bool
15980                                 Replaceable  bool
15981                                 OnRightClick bool
15982
15983                                 DmgPerSec int32
15984
15985                                 LiquidType   LiquidType
15986                                 FlowingAlt   string
15987                                 SrcAlt       string
15988                                 Viscosity    uint8 // 0-7
15989                                 LiqRenewable bool
15990                                 FlowRange    uint8
15991                                 DrownDmg     uint8
15992                                 Floodable    bool
15993
15994                                 DrawBox, ColBox, SelBox NodeBox
15995
15996                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15997
15998                                 LegacyFaceDir bool
15999                                 LegacyMounted bool
16000
16001                                 DigPredict string
16002
16003                                 MaxLvl uint8
16004
16005                                 AlphaUse
16006                         }))(obj)).Level
16007                         write8(w, uint8(x))
16008                 }
16009                 {
16010                         x := (*(*(struct {
16011                                 Param0 Content
16012
16013                                 Name   string
16014                                 Groups []Group
16015
16016                                 P1Type   Param1Type
16017                                 P2Type   Param2Type
16018                                 DrawType DrawType
16019
16020                                 Mesh  string
16021                                 Scale float32
16022                                 //mt:const uint8(6)
16023                                 Tiles        [6]TileDef
16024                                 OverlayTiles [6]TileDef
16025                                 //mt:const uint8(6)
16026                                 SpecialTiles [6]TileDef
16027
16028                                 Color   color.NRGBA
16029                                 Palette Texture
16030
16031                                 Waving       WaveType
16032                                 ConnectSides uint8
16033                                 ConnectTo    []Content
16034                                 InsideTint   color.NRGBA
16035                                 Level        uint8 // Must be < 128.
16036
16037                                 Translucent bool // Sunlight is scattered and becomes normal light.
16038                                 Transparent bool // Sunlight isn't scattered.
16039                                 LightSrc    uint8
16040
16041                                 GndContent   bool
16042                                 Collides     bool
16043                                 Pointable    bool
16044                                 Diggable     bool
16045                                 Climbable    bool
16046                                 Replaceable  bool
16047                                 OnRightClick bool
16048
16049                                 DmgPerSec int32
16050
16051                                 LiquidType   LiquidType
16052                                 FlowingAlt   string
16053                                 SrcAlt       string
16054                                 Viscosity    uint8 // 0-7
16055                                 LiqRenewable bool
16056                                 FlowRange    uint8
16057                                 DrownDmg     uint8
16058                                 Floodable    bool
16059
16060                                 DrawBox, ColBox, SelBox NodeBox
16061
16062                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16063
16064                                 LegacyFaceDir bool
16065                                 LegacyMounted bool
16066
16067                                 DigPredict string
16068
16069                                 MaxLvl uint8
16070
16071                                 AlphaUse
16072                         }))(obj)).Translucent
16073                         if x {
16074                                 write8(w, 1)
16075                         } else {
16076                                 write8(w, 0)
16077                         }
16078
16079                 }
16080                 {
16081                         x := (*(*(struct {
16082                                 Param0 Content
16083
16084                                 Name   string
16085                                 Groups []Group
16086
16087                                 P1Type   Param1Type
16088                                 P2Type   Param2Type
16089                                 DrawType DrawType
16090
16091                                 Mesh  string
16092                                 Scale float32
16093                                 //mt:const uint8(6)
16094                                 Tiles        [6]TileDef
16095                                 OverlayTiles [6]TileDef
16096                                 //mt:const uint8(6)
16097                                 SpecialTiles [6]TileDef
16098
16099                                 Color   color.NRGBA
16100                                 Palette Texture
16101
16102                                 Waving       WaveType
16103                                 ConnectSides uint8
16104                                 ConnectTo    []Content
16105                                 InsideTint   color.NRGBA
16106                                 Level        uint8 // Must be < 128.
16107
16108                                 Translucent bool // Sunlight is scattered and becomes normal light.
16109                                 Transparent bool // Sunlight isn't scattered.
16110                                 LightSrc    uint8
16111
16112                                 GndContent   bool
16113                                 Collides     bool
16114                                 Pointable    bool
16115                                 Diggable     bool
16116                                 Climbable    bool
16117                                 Replaceable  bool
16118                                 OnRightClick bool
16119
16120                                 DmgPerSec int32
16121
16122                                 LiquidType   LiquidType
16123                                 FlowingAlt   string
16124                                 SrcAlt       string
16125                                 Viscosity    uint8 // 0-7
16126                                 LiqRenewable bool
16127                                 FlowRange    uint8
16128                                 DrownDmg     uint8
16129                                 Floodable    bool
16130
16131                                 DrawBox, ColBox, SelBox NodeBox
16132
16133                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16134
16135                                 LegacyFaceDir bool
16136                                 LegacyMounted bool
16137
16138                                 DigPredict string
16139
16140                                 MaxLvl uint8
16141
16142                                 AlphaUse
16143                         }))(obj)).Transparent
16144                         if x {
16145                                 write8(w, 1)
16146                         } else {
16147                                 write8(w, 0)
16148                         }
16149
16150                 }
16151                 {
16152                         x := (*(*(struct {
16153                                 Param0 Content
16154
16155                                 Name   string
16156                                 Groups []Group
16157
16158                                 P1Type   Param1Type
16159                                 P2Type   Param2Type
16160                                 DrawType DrawType
16161
16162                                 Mesh  string
16163                                 Scale float32
16164                                 //mt:const uint8(6)
16165                                 Tiles        [6]TileDef
16166                                 OverlayTiles [6]TileDef
16167                                 //mt:const uint8(6)
16168                                 SpecialTiles [6]TileDef
16169
16170                                 Color   color.NRGBA
16171                                 Palette Texture
16172
16173                                 Waving       WaveType
16174                                 ConnectSides uint8
16175                                 ConnectTo    []Content
16176                                 InsideTint   color.NRGBA
16177                                 Level        uint8 // Must be < 128.
16178
16179                                 Translucent bool // Sunlight is scattered and becomes normal light.
16180                                 Transparent bool // Sunlight isn't scattered.
16181                                 LightSrc    uint8
16182
16183                                 GndContent   bool
16184                                 Collides     bool
16185                                 Pointable    bool
16186                                 Diggable     bool
16187                                 Climbable    bool
16188                                 Replaceable  bool
16189                                 OnRightClick bool
16190
16191                                 DmgPerSec int32
16192
16193                                 LiquidType   LiquidType
16194                                 FlowingAlt   string
16195                                 SrcAlt       string
16196                                 Viscosity    uint8 // 0-7
16197                                 LiqRenewable bool
16198                                 FlowRange    uint8
16199                                 DrownDmg     uint8
16200                                 Floodable    bool
16201
16202                                 DrawBox, ColBox, SelBox NodeBox
16203
16204                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16205
16206                                 LegacyFaceDir bool
16207                                 LegacyMounted bool
16208
16209                                 DigPredict string
16210
16211                                 MaxLvl uint8
16212
16213                                 AlphaUse
16214                         }))(obj)).LightSrc
16215                         write8(w, uint8(x))
16216                 }
16217                 {
16218                         x := (*(*(struct {
16219                                 Param0 Content
16220
16221                                 Name   string
16222                                 Groups []Group
16223
16224                                 P1Type   Param1Type
16225                                 P2Type   Param2Type
16226                                 DrawType DrawType
16227
16228                                 Mesh  string
16229                                 Scale float32
16230                                 //mt:const uint8(6)
16231                                 Tiles        [6]TileDef
16232                                 OverlayTiles [6]TileDef
16233                                 //mt:const uint8(6)
16234                                 SpecialTiles [6]TileDef
16235
16236                                 Color   color.NRGBA
16237                                 Palette Texture
16238
16239                                 Waving       WaveType
16240                                 ConnectSides uint8
16241                                 ConnectTo    []Content
16242                                 InsideTint   color.NRGBA
16243                                 Level        uint8 // Must be < 128.
16244
16245                                 Translucent bool // Sunlight is scattered and becomes normal light.
16246                                 Transparent bool // Sunlight isn't scattered.
16247                                 LightSrc    uint8
16248
16249                                 GndContent   bool
16250                                 Collides     bool
16251                                 Pointable    bool
16252                                 Diggable     bool
16253                                 Climbable    bool
16254                                 Replaceable  bool
16255                                 OnRightClick bool
16256
16257                                 DmgPerSec int32
16258
16259                                 LiquidType   LiquidType
16260                                 FlowingAlt   string
16261                                 SrcAlt       string
16262                                 Viscosity    uint8 // 0-7
16263                                 LiqRenewable bool
16264                                 FlowRange    uint8
16265                                 DrownDmg     uint8
16266                                 Floodable    bool
16267
16268                                 DrawBox, ColBox, SelBox NodeBox
16269
16270                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16271
16272                                 LegacyFaceDir bool
16273                                 LegacyMounted bool
16274
16275                                 DigPredict string
16276
16277                                 MaxLvl uint8
16278
16279                                 AlphaUse
16280                         }))(obj)).GndContent
16281                         if x {
16282                                 write8(w, 1)
16283                         } else {
16284                                 write8(w, 0)
16285                         }
16286
16287                 }
16288                 {
16289                         x := (*(*(struct {
16290                                 Param0 Content
16291
16292                                 Name   string
16293                                 Groups []Group
16294
16295                                 P1Type   Param1Type
16296                                 P2Type   Param2Type
16297                                 DrawType DrawType
16298
16299                                 Mesh  string
16300                                 Scale float32
16301                                 //mt:const uint8(6)
16302                                 Tiles        [6]TileDef
16303                                 OverlayTiles [6]TileDef
16304                                 //mt:const uint8(6)
16305                                 SpecialTiles [6]TileDef
16306
16307                                 Color   color.NRGBA
16308                                 Palette Texture
16309
16310                                 Waving       WaveType
16311                                 ConnectSides uint8
16312                                 ConnectTo    []Content
16313                                 InsideTint   color.NRGBA
16314                                 Level        uint8 // Must be < 128.
16315
16316                                 Translucent bool // Sunlight is scattered and becomes normal light.
16317                                 Transparent bool // Sunlight isn't scattered.
16318                                 LightSrc    uint8
16319
16320                                 GndContent   bool
16321                                 Collides     bool
16322                                 Pointable    bool
16323                                 Diggable     bool
16324                                 Climbable    bool
16325                                 Replaceable  bool
16326                                 OnRightClick bool
16327
16328                                 DmgPerSec int32
16329
16330                                 LiquidType   LiquidType
16331                                 FlowingAlt   string
16332                                 SrcAlt       string
16333                                 Viscosity    uint8 // 0-7
16334                                 LiqRenewable bool
16335                                 FlowRange    uint8
16336                                 DrownDmg     uint8
16337                                 Floodable    bool
16338
16339                                 DrawBox, ColBox, SelBox NodeBox
16340
16341                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16342
16343                                 LegacyFaceDir bool
16344                                 LegacyMounted bool
16345
16346                                 DigPredict string
16347
16348                                 MaxLvl uint8
16349
16350                                 AlphaUse
16351                         }))(obj)).Collides
16352                         if x {
16353                                 write8(w, 1)
16354                         } else {
16355                                 write8(w, 0)
16356                         }
16357
16358                 }
16359                 {
16360                         x := (*(*(struct {
16361                                 Param0 Content
16362
16363                                 Name   string
16364                                 Groups []Group
16365
16366                                 P1Type   Param1Type
16367                                 P2Type   Param2Type
16368                                 DrawType DrawType
16369
16370                                 Mesh  string
16371                                 Scale float32
16372                                 //mt:const uint8(6)
16373                                 Tiles        [6]TileDef
16374                                 OverlayTiles [6]TileDef
16375                                 //mt:const uint8(6)
16376                                 SpecialTiles [6]TileDef
16377
16378                                 Color   color.NRGBA
16379                                 Palette Texture
16380
16381                                 Waving       WaveType
16382                                 ConnectSides uint8
16383                                 ConnectTo    []Content
16384                                 InsideTint   color.NRGBA
16385                                 Level        uint8 // Must be < 128.
16386
16387                                 Translucent bool // Sunlight is scattered and becomes normal light.
16388                                 Transparent bool // Sunlight isn't scattered.
16389                                 LightSrc    uint8
16390
16391                                 GndContent   bool
16392                                 Collides     bool
16393                                 Pointable    bool
16394                                 Diggable     bool
16395                                 Climbable    bool
16396                                 Replaceable  bool
16397                                 OnRightClick bool
16398
16399                                 DmgPerSec int32
16400
16401                                 LiquidType   LiquidType
16402                                 FlowingAlt   string
16403                                 SrcAlt       string
16404                                 Viscosity    uint8 // 0-7
16405                                 LiqRenewable bool
16406                                 FlowRange    uint8
16407                                 DrownDmg     uint8
16408                                 Floodable    bool
16409
16410                                 DrawBox, ColBox, SelBox NodeBox
16411
16412                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16413
16414                                 LegacyFaceDir bool
16415                                 LegacyMounted bool
16416
16417                                 DigPredict string
16418
16419                                 MaxLvl uint8
16420
16421                                 AlphaUse
16422                         }))(obj)).Pointable
16423                         if x {
16424                                 write8(w, 1)
16425                         } else {
16426                                 write8(w, 0)
16427                         }
16428
16429                 }
16430                 {
16431                         x := (*(*(struct {
16432                                 Param0 Content
16433
16434                                 Name   string
16435                                 Groups []Group
16436
16437                                 P1Type   Param1Type
16438                                 P2Type   Param2Type
16439                                 DrawType DrawType
16440
16441                                 Mesh  string
16442                                 Scale float32
16443                                 //mt:const uint8(6)
16444                                 Tiles        [6]TileDef
16445                                 OverlayTiles [6]TileDef
16446                                 //mt:const uint8(6)
16447                                 SpecialTiles [6]TileDef
16448
16449                                 Color   color.NRGBA
16450                                 Palette Texture
16451
16452                                 Waving       WaveType
16453                                 ConnectSides uint8
16454                                 ConnectTo    []Content
16455                                 InsideTint   color.NRGBA
16456                                 Level        uint8 // Must be < 128.
16457
16458                                 Translucent bool // Sunlight is scattered and becomes normal light.
16459                                 Transparent bool // Sunlight isn't scattered.
16460                                 LightSrc    uint8
16461
16462                                 GndContent   bool
16463                                 Collides     bool
16464                                 Pointable    bool
16465                                 Diggable     bool
16466                                 Climbable    bool
16467                                 Replaceable  bool
16468                                 OnRightClick bool
16469
16470                                 DmgPerSec int32
16471
16472                                 LiquidType   LiquidType
16473                                 FlowingAlt   string
16474                                 SrcAlt       string
16475                                 Viscosity    uint8 // 0-7
16476                                 LiqRenewable bool
16477                                 FlowRange    uint8
16478                                 DrownDmg     uint8
16479                                 Floodable    bool
16480
16481                                 DrawBox, ColBox, SelBox NodeBox
16482
16483                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16484
16485                                 LegacyFaceDir bool
16486                                 LegacyMounted bool
16487
16488                                 DigPredict string
16489
16490                                 MaxLvl uint8
16491
16492                                 AlphaUse
16493                         }))(obj)).Diggable
16494                         if x {
16495                                 write8(w, 1)
16496                         } else {
16497                                 write8(w, 0)
16498                         }
16499
16500                 }
16501                 {
16502                         x := (*(*(struct {
16503                                 Param0 Content
16504
16505                                 Name   string
16506                                 Groups []Group
16507
16508                                 P1Type   Param1Type
16509                                 P2Type   Param2Type
16510                                 DrawType DrawType
16511
16512                                 Mesh  string
16513                                 Scale float32
16514                                 //mt:const uint8(6)
16515                                 Tiles        [6]TileDef
16516                                 OverlayTiles [6]TileDef
16517                                 //mt:const uint8(6)
16518                                 SpecialTiles [6]TileDef
16519
16520                                 Color   color.NRGBA
16521                                 Palette Texture
16522
16523                                 Waving       WaveType
16524                                 ConnectSides uint8
16525                                 ConnectTo    []Content
16526                                 InsideTint   color.NRGBA
16527                                 Level        uint8 // Must be < 128.
16528
16529                                 Translucent bool // Sunlight is scattered and becomes normal light.
16530                                 Transparent bool // Sunlight isn't scattered.
16531                                 LightSrc    uint8
16532
16533                                 GndContent   bool
16534                                 Collides     bool
16535                                 Pointable    bool
16536                                 Diggable     bool
16537                                 Climbable    bool
16538                                 Replaceable  bool
16539                                 OnRightClick bool
16540
16541                                 DmgPerSec int32
16542
16543                                 LiquidType   LiquidType
16544                                 FlowingAlt   string
16545                                 SrcAlt       string
16546                                 Viscosity    uint8 // 0-7
16547                                 LiqRenewable bool
16548                                 FlowRange    uint8
16549                                 DrownDmg     uint8
16550                                 Floodable    bool
16551
16552                                 DrawBox, ColBox, SelBox NodeBox
16553
16554                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16555
16556                                 LegacyFaceDir bool
16557                                 LegacyMounted bool
16558
16559                                 DigPredict string
16560
16561                                 MaxLvl uint8
16562
16563                                 AlphaUse
16564                         }))(obj)).Climbable
16565                         if x {
16566                                 write8(w, 1)
16567                         } else {
16568                                 write8(w, 0)
16569                         }
16570
16571                 }
16572                 {
16573                         x := (*(*(struct {
16574                                 Param0 Content
16575
16576                                 Name   string
16577                                 Groups []Group
16578
16579                                 P1Type   Param1Type
16580                                 P2Type   Param2Type
16581                                 DrawType DrawType
16582
16583                                 Mesh  string
16584                                 Scale float32
16585                                 //mt:const uint8(6)
16586                                 Tiles        [6]TileDef
16587                                 OverlayTiles [6]TileDef
16588                                 //mt:const uint8(6)
16589                                 SpecialTiles [6]TileDef
16590
16591                                 Color   color.NRGBA
16592                                 Palette Texture
16593
16594                                 Waving       WaveType
16595                                 ConnectSides uint8
16596                                 ConnectTo    []Content
16597                                 InsideTint   color.NRGBA
16598                                 Level        uint8 // Must be < 128.
16599
16600                                 Translucent bool // Sunlight is scattered and becomes normal light.
16601                                 Transparent bool // Sunlight isn't scattered.
16602                                 LightSrc    uint8
16603
16604                                 GndContent   bool
16605                                 Collides     bool
16606                                 Pointable    bool
16607                                 Diggable     bool
16608                                 Climbable    bool
16609                                 Replaceable  bool
16610                                 OnRightClick bool
16611
16612                                 DmgPerSec int32
16613
16614                                 LiquidType   LiquidType
16615                                 FlowingAlt   string
16616                                 SrcAlt       string
16617                                 Viscosity    uint8 // 0-7
16618                                 LiqRenewable bool
16619                                 FlowRange    uint8
16620                                 DrownDmg     uint8
16621                                 Floodable    bool
16622
16623                                 DrawBox, ColBox, SelBox NodeBox
16624
16625                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16626
16627                                 LegacyFaceDir bool
16628                                 LegacyMounted bool
16629
16630                                 DigPredict string
16631
16632                                 MaxLvl uint8
16633
16634                                 AlphaUse
16635                         }))(obj)).Replaceable
16636                         if x {
16637                                 write8(w, 1)
16638                         } else {
16639                                 write8(w, 0)
16640                         }
16641
16642                 }
16643                 {
16644                         x := (*(*(struct {
16645                                 Param0 Content
16646
16647                                 Name   string
16648                                 Groups []Group
16649
16650                                 P1Type   Param1Type
16651                                 P2Type   Param2Type
16652                                 DrawType DrawType
16653
16654                                 Mesh  string
16655                                 Scale float32
16656                                 //mt:const uint8(6)
16657                                 Tiles        [6]TileDef
16658                                 OverlayTiles [6]TileDef
16659                                 //mt:const uint8(6)
16660                                 SpecialTiles [6]TileDef
16661
16662                                 Color   color.NRGBA
16663                                 Palette Texture
16664
16665                                 Waving       WaveType
16666                                 ConnectSides uint8
16667                                 ConnectTo    []Content
16668                                 InsideTint   color.NRGBA
16669                                 Level        uint8 // Must be < 128.
16670
16671                                 Translucent bool // Sunlight is scattered and becomes normal light.
16672                                 Transparent bool // Sunlight isn't scattered.
16673                                 LightSrc    uint8
16674
16675                                 GndContent   bool
16676                                 Collides     bool
16677                                 Pointable    bool
16678                                 Diggable     bool
16679                                 Climbable    bool
16680                                 Replaceable  bool
16681                                 OnRightClick bool
16682
16683                                 DmgPerSec int32
16684
16685                                 LiquidType   LiquidType
16686                                 FlowingAlt   string
16687                                 SrcAlt       string
16688                                 Viscosity    uint8 // 0-7
16689                                 LiqRenewable bool
16690                                 FlowRange    uint8
16691                                 DrownDmg     uint8
16692                                 Floodable    bool
16693
16694                                 DrawBox, ColBox, SelBox NodeBox
16695
16696                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16697
16698                                 LegacyFaceDir bool
16699                                 LegacyMounted bool
16700
16701                                 DigPredict string
16702
16703                                 MaxLvl uint8
16704
16705                                 AlphaUse
16706                         }))(obj)).OnRightClick
16707                         if x {
16708                                 write8(w, 1)
16709                         } else {
16710                                 write8(w, 0)
16711                         }
16712
16713                 }
16714                 {
16715                         x := (*(*(struct {
16716                                 Param0 Content
16717
16718                                 Name   string
16719                                 Groups []Group
16720
16721                                 P1Type   Param1Type
16722                                 P2Type   Param2Type
16723                                 DrawType DrawType
16724
16725                                 Mesh  string
16726                                 Scale float32
16727                                 //mt:const uint8(6)
16728                                 Tiles        [6]TileDef
16729                                 OverlayTiles [6]TileDef
16730                                 //mt:const uint8(6)
16731                                 SpecialTiles [6]TileDef
16732
16733                                 Color   color.NRGBA
16734                                 Palette Texture
16735
16736                                 Waving       WaveType
16737                                 ConnectSides uint8
16738                                 ConnectTo    []Content
16739                                 InsideTint   color.NRGBA
16740                                 Level        uint8 // Must be < 128.
16741
16742                                 Translucent bool // Sunlight is scattered and becomes normal light.
16743                                 Transparent bool // Sunlight isn't scattered.
16744                                 LightSrc    uint8
16745
16746                                 GndContent   bool
16747                                 Collides     bool
16748                                 Pointable    bool
16749                                 Diggable     bool
16750                                 Climbable    bool
16751                                 Replaceable  bool
16752                                 OnRightClick bool
16753
16754                                 DmgPerSec int32
16755
16756                                 LiquidType   LiquidType
16757                                 FlowingAlt   string
16758                                 SrcAlt       string
16759                                 Viscosity    uint8 // 0-7
16760                                 LiqRenewable bool
16761                                 FlowRange    uint8
16762                                 DrownDmg     uint8
16763                                 Floodable    bool
16764
16765                                 DrawBox, ColBox, SelBox NodeBox
16766
16767                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16768
16769                                 LegacyFaceDir bool
16770                                 LegacyMounted bool
16771
16772                                 DigPredict string
16773
16774                                 MaxLvl uint8
16775
16776                                 AlphaUse
16777                         }))(obj)).DmgPerSec
16778                         write32(w, uint32(x))
16779                 }
16780                 if err := pcall(func() {
16781                         ((*(*(struct {
16782                                 Param0 Content
16783
16784                                 Name   string
16785                                 Groups []Group
16786
16787                                 P1Type   Param1Type
16788                                 P2Type   Param2Type
16789                                 DrawType DrawType
16790
16791                                 Mesh  string
16792                                 Scale float32
16793                                 //mt:const uint8(6)
16794                                 Tiles        [6]TileDef
16795                                 OverlayTiles [6]TileDef
16796                                 //mt:const uint8(6)
16797                                 SpecialTiles [6]TileDef
16798
16799                                 Color   color.NRGBA
16800                                 Palette Texture
16801
16802                                 Waving       WaveType
16803                                 ConnectSides uint8
16804                                 ConnectTo    []Content
16805                                 InsideTint   color.NRGBA
16806                                 Level        uint8 // Must be < 128.
16807
16808                                 Translucent bool // Sunlight is scattered and becomes normal light.
16809                                 Transparent bool // Sunlight isn't scattered.
16810                                 LightSrc    uint8
16811
16812                                 GndContent   bool
16813                                 Collides     bool
16814                                 Pointable    bool
16815                                 Diggable     bool
16816                                 Climbable    bool
16817                                 Replaceable  bool
16818                                 OnRightClick bool
16819
16820                                 DmgPerSec int32
16821
16822                                 LiquidType   LiquidType
16823                                 FlowingAlt   string
16824                                 SrcAlt       string
16825                                 Viscosity    uint8 // 0-7
16826                                 LiqRenewable bool
16827                                 FlowRange    uint8
16828                                 DrownDmg     uint8
16829                                 Floodable    bool
16830
16831                                 DrawBox, ColBox, SelBox NodeBox
16832
16833                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16834
16835                                 LegacyFaceDir bool
16836                                 LegacyMounted bool
16837
16838                                 DigPredict string
16839
16840                                 MaxLvl uint8
16841
16842                                 AlphaUse
16843                         }))(obj)).LiquidType).serialize(w)
16844                 }); err != nil {
16845                         if err == io.EOF {
16846                                 chk(io.EOF)
16847                         }
16848                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
16849                 }
16850                 if len(([]byte((*(*(struct {
16851                         Param0 Content
16852
16853                         Name   string
16854                         Groups []Group
16855
16856                         P1Type   Param1Type
16857                         P2Type   Param2Type
16858                         DrawType DrawType
16859
16860                         Mesh  string
16861                         Scale float32
16862                         //mt:const uint8(6)
16863                         Tiles        [6]TileDef
16864                         OverlayTiles [6]TileDef
16865                         //mt:const uint8(6)
16866                         SpecialTiles [6]TileDef
16867
16868                         Color   color.NRGBA
16869                         Palette Texture
16870
16871                         Waving       WaveType
16872                         ConnectSides uint8
16873                         ConnectTo    []Content
16874                         InsideTint   color.NRGBA
16875                         Level        uint8 // Must be < 128.
16876
16877                         Translucent bool // Sunlight is scattered and becomes normal light.
16878                         Transparent bool // Sunlight isn't scattered.
16879                         LightSrc    uint8
16880
16881                         GndContent   bool
16882                         Collides     bool
16883                         Pointable    bool
16884                         Diggable     bool
16885                         Climbable    bool
16886                         Replaceable  bool
16887                         OnRightClick bool
16888
16889                         DmgPerSec int32
16890
16891                         LiquidType   LiquidType
16892                         FlowingAlt   string
16893                         SrcAlt       string
16894                         Viscosity    uint8 // 0-7
16895                         LiqRenewable bool
16896                         FlowRange    uint8
16897                         DrownDmg     uint8
16898                         Floodable    bool
16899
16900                         DrawBox, ColBox, SelBox NodeBox
16901
16902                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16903
16904                         LegacyFaceDir bool
16905                         LegacyMounted bool
16906
16907                         DigPredict string
16908
16909                         MaxLvl uint8
16910
16911                         AlphaUse
16912                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
16913                         chk(ErrTooLong)
16914                 }
16915                 {
16916                         x := uint16(len(([]byte((*(*(struct {
16917                                 Param0 Content
16918
16919                                 Name   string
16920                                 Groups []Group
16921
16922                                 P1Type   Param1Type
16923                                 P2Type   Param2Type
16924                                 DrawType DrawType
16925
16926                                 Mesh  string
16927                                 Scale float32
16928                                 //mt:const uint8(6)
16929                                 Tiles        [6]TileDef
16930                                 OverlayTiles [6]TileDef
16931                                 //mt:const uint8(6)
16932                                 SpecialTiles [6]TileDef
16933
16934                                 Color   color.NRGBA
16935                                 Palette Texture
16936
16937                                 Waving       WaveType
16938                                 ConnectSides uint8
16939                                 ConnectTo    []Content
16940                                 InsideTint   color.NRGBA
16941                                 Level        uint8 // Must be < 128.
16942
16943                                 Translucent bool // Sunlight is scattered and becomes normal light.
16944                                 Transparent bool // Sunlight isn't scattered.
16945                                 LightSrc    uint8
16946
16947                                 GndContent   bool
16948                                 Collides     bool
16949                                 Pointable    bool
16950                                 Diggable     bool
16951                                 Climbable    bool
16952                                 Replaceable  bool
16953                                 OnRightClick bool
16954
16955                                 DmgPerSec int32
16956
16957                                 LiquidType   LiquidType
16958                                 FlowingAlt   string
16959                                 SrcAlt       string
16960                                 Viscosity    uint8 // 0-7
16961                                 LiqRenewable bool
16962                                 FlowRange    uint8
16963                                 DrownDmg     uint8
16964                                 Floodable    bool
16965
16966                                 DrawBox, ColBox, SelBox NodeBox
16967
16968                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16969
16970                                 LegacyFaceDir bool
16971                                 LegacyMounted bool
16972
16973                                 DigPredict string
16974
16975                                 MaxLvl uint8
16976
16977                                 AlphaUse
16978                         }))(obj)).FlowingAlt))))
16979                         write16(w, uint16(x))
16980                 }
16981                 {
16982                         _, err := w.Write(([]byte((*(*(struct {
16983                                 Param0 Content
16984
16985                                 Name   string
16986                                 Groups []Group
16987
16988                                 P1Type   Param1Type
16989                                 P2Type   Param2Type
16990                                 DrawType DrawType
16991
16992                                 Mesh  string
16993                                 Scale float32
16994                                 //mt:const uint8(6)
16995                                 Tiles        [6]TileDef
16996                                 OverlayTiles [6]TileDef
16997                                 //mt:const uint8(6)
16998                                 SpecialTiles [6]TileDef
16999
17000                                 Color   color.NRGBA
17001                                 Palette Texture
17002
17003                                 Waving       WaveType
17004                                 ConnectSides uint8
17005                                 ConnectTo    []Content
17006                                 InsideTint   color.NRGBA
17007                                 Level        uint8 // Must be < 128.
17008
17009                                 Translucent bool // Sunlight is scattered and becomes normal light.
17010                                 Transparent bool // Sunlight isn't scattered.
17011                                 LightSrc    uint8
17012
17013                                 GndContent   bool
17014                                 Collides     bool
17015                                 Pointable    bool
17016                                 Diggable     bool
17017                                 Climbable    bool
17018                                 Replaceable  bool
17019                                 OnRightClick bool
17020
17021                                 DmgPerSec int32
17022
17023                                 LiquidType   LiquidType
17024                                 FlowingAlt   string
17025                                 SrcAlt       string
17026                                 Viscosity    uint8 // 0-7
17027                                 LiqRenewable bool
17028                                 FlowRange    uint8
17029                                 DrownDmg     uint8
17030                                 Floodable    bool
17031
17032                                 DrawBox, ColBox, SelBox NodeBox
17033
17034                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17035
17036                                 LegacyFaceDir bool
17037                                 LegacyMounted bool
17038
17039                                 DigPredict string
17040
17041                                 MaxLvl uint8
17042
17043                                 AlphaUse
17044                         }))(obj)).FlowingAlt))[:])
17045                         chk(err)
17046                 }
17047                 if len(([]byte((*(*(struct {
17048                         Param0 Content
17049
17050                         Name   string
17051                         Groups []Group
17052
17053                         P1Type   Param1Type
17054                         P2Type   Param2Type
17055                         DrawType DrawType
17056
17057                         Mesh  string
17058                         Scale float32
17059                         //mt:const uint8(6)
17060                         Tiles        [6]TileDef
17061                         OverlayTiles [6]TileDef
17062                         //mt:const uint8(6)
17063                         SpecialTiles [6]TileDef
17064
17065                         Color   color.NRGBA
17066                         Palette Texture
17067
17068                         Waving       WaveType
17069                         ConnectSides uint8
17070                         ConnectTo    []Content
17071                         InsideTint   color.NRGBA
17072                         Level        uint8 // Must be < 128.
17073
17074                         Translucent bool // Sunlight is scattered and becomes normal light.
17075                         Transparent bool // Sunlight isn't scattered.
17076                         LightSrc    uint8
17077
17078                         GndContent   bool
17079                         Collides     bool
17080                         Pointable    bool
17081                         Diggable     bool
17082                         Climbable    bool
17083                         Replaceable  bool
17084                         OnRightClick bool
17085
17086                         DmgPerSec int32
17087
17088                         LiquidType   LiquidType
17089                         FlowingAlt   string
17090                         SrcAlt       string
17091                         Viscosity    uint8 // 0-7
17092                         LiqRenewable bool
17093                         FlowRange    uint8
17094                         DrownDmg     uint8
17095                         Floodable    bool
17096
17097                         DrawBox, ColBox, SelBox NodeBox
17098
17099                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17100
17101                         LegacyFaceDir bool
17102                         LegacyMounted bool
17103
17104                         DigPredict string
17105
17106                         MaxLvl uint8
17107
17108                         AlphaUse
17109                 }))(obj)).SrcAlt))) > math.MaxUint16 {
17110                         chk(ErrTooLong)
17111                 }
17112                 {
17113                         x := uint16(len(([]byte((*(*(struct {
17114                                 Param0 Content
17115
17116                                 Name   string
17117                                 Groups []Group
17118
17119                                 P1Type   Param1Type
17120                                 P2Type   Param2Type
17121                                 DrawType DrawType
17122
17123                                 Mesh  string
17124                                 Scale float32
17125                                 //mt:const uint8(6)
17126                                 Tiles        [6]TileDef
17127                                 OverlayTiles [6]TileDef
17128                                 //mt:const uint8(6)
17129                                 SpecialTiles [6]TileDef
17130
17131                                 Color   color.NRGBA
17132                                 Palette Texture
17133
17134                                 Waving       WaveType
17135                                 ConnectSides uint8
17136                                 ConnectTo    []Content
17137                                 InsideTint   color.NRGBA
17138                                 Level        uint8 // Must be < 128.
17139
17140                                 Translucent bool // Sunlight is scattered and becomes normal light.
17141                                 Transparent bool // Sunlight isn't scattered.
17142                                 LightSrc    uint8
17143
17144                                 GndContent   bool
17145                                 Collides     bool
17146                                 Pointable    bool
17147                                 Diggable     bool
17148                                 Climbable    bool
17149                                 Replaceable  bool
17150                                 OnRightClick bool
17151
17152                                 DmgPerSec int32
17153
17154                                 LiquidType   LiquidType
17155                                 FlowingAlt   string
17156                                 SrcAlt       string
17157                                 Viscosity    uint8 // 0-7
17158                                 LiqRenewable bool
17159                                 FlowRange    uint8
17160                                 DrownDmg     uint8
17161                                 Floodable    bool
17162
17163                                 DrawBox, ColBox, SelBox NodeBox
17164
17165                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17166
17167                                 LegacyFaceDir bool
17168                                 LegacyMounted bool
17169
17170                                 DigPredict string
17171
17172                                 MaxLvl uint8
17173
17174                                 AlphaUse
17175                         }))(obj)).SrcAlt))))
17176                         write16(w, uint16(x))
17177                 }
17178                 {
17179                         _, err := w.Write(([]byte((*(*(struct {
17180                                 Param0 Content
17181
17182                                 Name   string
17183                                 Groups []Group
17184
17185                                 P1Type   Param1Type
17186                                 P2Type   Param2Type
17187                                 DrawType DrawType
17188
17189                                 Mesh  string
17190                                 Scale float32
17191                                 //mt:const uint8(6)
17192                                 Tiles        [6]TileDef
17193                                 OverlayTiles [6]TileDef
17194                                 //mt:const uint8(6)
17195                                 SpecialTiles [6]TileDef
17196
17197                                 Color   color.NRGBA
17198                                 Palette Texture
17199
17200                                 Waving       WaveType
17201                                 ConnectSides uint8
17202                                 ConnectTo    []Content
17203                                 InsideTint   color.NRGBA
17204                                 Level        uint8 // Must be < 128.
17205
17206                                 Translucent bool // Sunlight is scattered and becomes normal light.
17207                                 Transparent bool // Sunlight isn't scattered.
17208                                 LightSrc    uint8
17209
17210                                 GndContent   bool
17211                                 Collides     bool
17212                                 Pointable    bool
17213                                 Diggable     bool
17214                                 Climbable    bool
17215                                 Replaceable  bool
17216                                 OnRightClick bool
17217
17218                                 DmgPerSec int32
17219
17220                                 LiquidType   LiquidType
17221                                 FlowingAlt   string
17222                                 SrcAlt       string
17223                                 Viscosity    uint8 // 0-7
17224                                 LiqRenewable bool
17225                                 FlowRange    uint8
17226                                 DrownDmg     uint8
17227                                 Floodable    bool
17228
17229                                 DrawBox, ColBox, SelBox NodeBox
17230
17231                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17232
17233                                 LegacyFaceDir bool
17234                                 LegacyMounted bool
17235
17236                                 DigPredict string
17237
17238                                 MaxLvl uint8
17239
17240                                 AlphaUse
17241                         }))(obj)).SrcAlt))[:])
17242                         chk(err)
17243                 }
17244                 {
17245                         x := (*(*(struct {
17246                                 Param0 Content
17247
17248                                 Name   string
17249                                 Groups []Group
17250
17251                                 P1Type   Param1Type
17252                                 P2Type   Param2Type
17253                                 DrawType DrawType
17254
17255                                 Mesh  string
17256                                 Scale float32
17257                                 //mt:const uint8(6)
17258                                 Tiles        [6]TileDef
17259                                 OverlayTiles [6]TileDef
17260                                 //mt:const uint8(6)
17261                                 SpecialTiles [6]TileDef
17262
17263                                 Color   color.NRGBA
17264                                 Palette Texture
17265
17266                                 Waving       WaveType
17267                                 ConnectSides uint8
17268                                 ConnectTo    []Content
17269                                 InsideTint   color.NRGBA
17270                                 Level        uint8 // Must be < 128.
17271
17272                                 Translucent bool // Sunlight is scattered and becomes normal light.
17273                                 Transparent bool // Sunlight isn't scattered.
17274                                 LightSrc    uint8
17275
17276                                 GndContent   bool
17277                                 Collides     bool
17278                                 Pointable    bool
17279                                 Diggable     bool
17280                                 Climbable    bool
17281                                 Replaceable  bool
17282                                 OnRightClick bool
17283
17284                                 DmgPerSec int32
17285
17286                                 LiquidType   LiquidType
17287                                 FlowingAlt   string
17288                                 SrcAlt       string
17289                                 Viscosity    uint8 // 0-7
17290                                 LiqRenewable bool
17291                                 FlowRange    uint8
17292                                 DrownDmg     uint8
17293                                 Floodable    bool
17294
17295                                 DrawBox, ColBox, SelBox NodeBox
17296
17297                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17298
17299                                 LegacyFaceDir bool
17300                                 LegacyMounted bool
17301
17302                                 DigPredict string
17303
17304                                 MaxLvl uint8
17305
17306                                 AlphaUse
17307                         }))(obj)).Viscosity
17308                         write8(w, uint8(x))
17309                 }
17310                 {
17311                         x := (*(*(struct {
17312                                 Param0 Content
17313
17314                                 Name   string
17315                                 Groups []Group
17316
17317                                 P1Type   Param1Type
17318                                 P2Type   Param2Type
17319                                 DrawType DrawType
17320
17321                                 Mesh  string
17322                                 Scale float32
17323                                 //mt:const uint8(6)
17324                                 Tiles        [6]TileDef
17325                                 OverlayTiles [6]TileDef
17326                                 //mt:const uint8(6)
17327                                 SpecialTiles [6]TileDef
17328
17329                                 Color   color.NRGBA
17330                                 Palette Texture
17331
17332                                 Waving       WaveType
17333                                 ConnectSides uint8
17334                                 ConnectTo    []Content
17335                                 InsideTint   color.NRGBA
17336                                 Level        uint8 // Must be < 128.
17337
17338                                 Translucent bool // Sunlight is scattered and becomes normal light.
17339                                 Transparent bool // Sunlight isn't scattered.
17340                                 LightSrc    uint8
17341
17342                                 GndContent   bool
17343                                 Collides     bool
17344                                 Pointable    bool
17345                                 Diggable     bool
17346                                 Climbable    bool
17347                                 Replaceable  bool
17348                                 OnRightClick bool
17349
17350                                 DmgPerSec int32
17351
17352                                 LiquidType   LiquidType
17353                                 FlowingAlt   string
17354                                 SrcAlt       string
17355                                 Viscosity    uint8 // 0-7
17356                                 LiqRenewable bool
17357                                 FlowRange    uint8
17358                                 DrownDmg     uint8
17359                                 Floodable    bool
17360
17361                                 DrawBox, ColBox, SelBox NodeBox
17362
17363                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17364
17365                                 LegacyFaceDir bool
17366                                 LegacyMounted bool
17367
17368                                 DigPredict string
17369
17370                                 MaxLvl uint8
17371
17372                                 AlphaUse
17373                         }))(obj)).LiqRenewable
17374                         if x {
17375                                 write8(w, 1)
17376                         } else {
17377                                 write8(w, 0)
17378                         }
17379
17380                 }
17381                 {
17382                         x := (*(*(struct {
17383                                 Param0 Content
17384
17385                                 Name   string
17386                                 Groups []Group
17387
17388                                 P1Type   Param1Type
17389                                 P2Type   Param2Type
17390                                 DrawType DrawType
17391
17392                                 Mesh  string
17393                                 Scale float32
17394                                 //mt:const uint8(6)
17395                                 Tiles        [6]TileDef
17396                                 OverlayTiles [6]TileDef
17397                                 //mt:const uint8(6)
17398                                 SpecialTiles [6]TileDef
17399
17400                                 Color   color.NRGBA
17401                                 Palette Texture
17402
17403                                 Waving       WaveType
17404                                 ConnectSides uint8
17405                                 ConnectTo    []Content
17406                                 InsideTint   color.NRGBA
17407                                 Level        uint8 // Must be < 128.
17408
17409                                 Translucent bool // Sunlight is scattered and becomes normal light.
17410                                 Transparent bool // Sunlight isn't scattered.
17411                                 LightSrc    uint8
17412
17413                                 GndContent   bool
17414                                 Collides     bool
17415                                 Pointable    bool
17416                                 Diggable     bool
17417                                 Climbable    bool
17418                                 Replaceable  bool
17419                                 OnRightClick bool
17420
17421                                 DmgPerSec int32
17422
17423                                 LiquidType   LiquidType
17424                                 FlowingAlt   string
17425                                 SrcAlt       string
17426                                 Viscosity    uint8 // 0-7
17427                                 LiqRenewable bool
17428                                 FlowRange    uint8
17429                                 DrownDmg     uint8
17430                                 Floodable    bool
17431
17432                                 DrawBox, ColBox, SelBox NodeBox
17433
17434                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17435
17436                                 LegacyFaceDir bool
17437                                 LegacyMounted bool
17438
17439                                 DigPredict string
17440
17441                                 MaxLvl uint8
17442
17443                                 AlphaUse
17444                         }))(obj)).FlowRange
17445                         write8(w, uint8(x))
17446                 }
17447                 {
17448                         x := (*(*(struct {
17449                                 Param0 Content
17450
17451                                 Name   string
17452                                 Groups []Group
17453
17454                                 P1Type   Param1Type
17455                                 P2Type   Param2Type
17456                                 DrawType DrawType
17457
17458                                 Mesh  string
17459                                 Scale float32
17460                                 //mt:const uint8(6)
17461                                 Tiles        [6]TileDef
17462                                 OverlayTiles [6]TileDef
17463                                 //mt:const uint8(6)
17464                                 SpecialTiles [6]TileDef
17465
17466                                 Color   color.NRGBA
17467                                 Palette Texture
17468
17469                                 Waving       WaveType
17470                                 ConnectSides uint8
17471                                 ConnectTo    []Content
17472                                 InsideTint   color.NRGBA
17473                                 Level        uint8 // Must be < 128.
17474
17475                                 Translucent bool // Sunlight is scattered and becomes normal light.
17476                                 Transparent bool // Sunlight isn't scattered.
17477                                 LightSrc    uint8
17478
17479                                 GndContent   bool
17480                                 Collides     bool
17481                                 Pointable    bool
17482                                 Diggable     bool
17483                                 Climbable    bool
17484                                 Replaceable  bool
17485                                 OnRightClick bool
17486
17487                                 DmgPerSec int32
17488
17489                                 LiquidType   LiquidType
17490                                 FlowingAlt   string
17491                                 SrcAlt       string
17492                                 Viscosity    uint8 // 0-7
17493                                 LiqRenewable bool
17494                                 FlowRange    uint8
17495                                 DrownDmg     uint8
17496                                 Floodable    bool
17497
17498                                 DrawBox, ColBox, SelBox NodeBox
17499
17500                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17501
17502                                 LegacyFaceDir bool
17503                                 LegacyMounted bool
17504
17505                                 DigPredict string
17506
17507                                 MaxLvl uint8
17508
17509                                 AlphaUse
17510                         }))(obj)).DrownDmg
17511                         write8(w, uint8(x))
17512                 }
17513                 {
17514                         x := (*(*(struct {
17515                                 Param0 Content
17516
17517                                 Name   string
17518                                 Groups []Group
17519
17520                                 P1Type   Param1Type
17521                                 P2Type   Param2Type
17522                                 DrawType DrawType
17523
17524                                 Mesh  string
17525                                 Scale float32
17526                                 //mt:const uint8(6)
17527                                 Tiles        [6]TileDef
17528                                 OverlayTiles [6]TileDef
17529                                 //mt:const uint8(6)
17530                                 SpecialTiles [6]TileDef
17531
17532                                 Color   color.NRGBA
17533                                 Palette Texture
17534
17535                                 Waving       WaveType
17536                                 ConnectSides uint8
17537                                 ConnectTo    []Content
17538                                 InsideTint   color.NRGBA
17539                                 Level        uint8 // Must be < 128.
17540
17541                                 Translucent bool // Sunlight is scattered and becomes normal light.
17542                                 Transparent bool // Sunlight isn't scattered.
17543                                 LightSrc    uint8
17544
17545                                 GndContent   bool
17546                                 Collides     bool
17547                                 Pointable    bool
17548                                 Diggable     bool
17549                                 Climbable    bool
17550                                 Replaceable  bool
17551                                 OnRightClick bool
17552
17553                                 DmgPerSec int32
17554
17555                                 LiquidType   LiquidType
17556                                 FlowingAlt   string
17557                                 SrcAlt       string
17558                                 Viscosity    uint8 // 0-7
17559                                 LiqRenewable bool
17560                                 FlowRange    uint8
17561                                 DrownDmg     uint8
17562                                 Floodable    bool
17563
17564                                 DrawBox, ColBox, SelBox NodeBox
17565
17566                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17567
17568                                 LegacyFaceDir bool
17569                                 LegacyMounted bool
17570
17571                                 DigPredict string
17572
17573                                 MaxLvl uint8
17574
17575                                 AlphaUse
17576                         }))(obj)).Floodable
17577                         if x {
17578                                 write8(w, 1)
17579                         } else {
17580                                 write8(w, 0)
17581                         }
17582
17583                 }
17584                 if err := pcall(func() {
17585                         ((*(*(struct {
17586                                 Param0 Content
17587
17588                                 Name   string
17589                                 Groups []Group
17590
17591                                 P1Type   Param1Type
17592                                 P2Type   Param2Type
17593                                 DrawType DrawType
17594
17595                                 Mesh  string
17596                                 Scale float32
17597                                 //mt:const uint8(6)
17598                                 Tiles        [6]TileDef
17599                                 OverlayTiles [6]TileDef
17600                                 //mt:const uint8(6)
17601                                 SpecialTiles [6]TileDef
17602
17603                                 Color   color.NRGBA
17604                                 Palette Texture
17605
17606                                 Waving       WaveType
17607                                 ConnectSides uint8
17608                                 ConnectTo    []Content
17609                                 InsideTint   color.NRGBA
17610                                 Level        uint8 // Must be < 128.
17611
17612                                 Translucent bool // Sunlight is scattered and becomes normal light.
17613                                 Transparent bool // Sunlight isn't scattered.
17614                                 LightSrc    uint8
17615
17616                                 GndContent   bool
17617                                 Collides     bool
17618                                 Pointable    bool
17619                                 Diggable     bool
17620                                 Climbable    bool
17621                                 Replaceable  bool
17622                                 OnRightClick bool
17623
17624                                 DmgPerSec int32
17625
17626                                 LiquidType   LiquidType
17627                                 FlowingAlt   string
17628                                 SrcAlt       string
17629                                 Viscosity    uint8 // 0-7
17630                                 LiqRenewable bool
17631                                 FlowRange    uint8
17632                                 DrownDmg     uint8
17633                                 Floodable    bool
17634
17635                                 DrawBox, ColBox, SelBox NodeBox
17636
17637                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17638
17639                                 LegacyFaceDir bool
17640                                 LegacyMounted bool
17641
17642                                 DigPredict string
17643
17644                                 MaxLvl uint8
17645
17646                                 AlphaUse
17647                         }))(obj)).DrawBox).serialize(w)
17648                 }); err != nil {
17649                         if err == io.EOF {
17650                                 chk(io.EOF)
17651                         }
17652                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17653                 }
17654                 if err := pcall(func() {
17655                         ((*(*(struct {
17656                                 Param0 Content
17657
17658                                 Name   string
17659                                 Groups []Group
17660
17661                                 P1Type   Param1Type
17662                                 P2Type   Param2Type
17663                                 DrawType DrawType
17664
17665                                 Mesh  string
17666                                 Scale float32
17667                                 //mt:const uint8(6)
17668                                 Tiles        [6]TileDef
17669                                 OverlayTiles [6]TileDef
17670                                 //mt:const uint8(6)
17671                                 SpecialTiles [6]TileDef
17672
17673                                 Color   color.NRGBA
17674                                 Palette Texture
17675
17676                                 Waving       WaveType
17677                                 ConnectSides uint8
17678                                 ConnectTo    []Content
17679                                 InsideTint   color.NRGBA
17680                                 Level        uint8 // Must be < 128.
17681
17682                                 Translucent bool // Sunlight is scattered and becomes normal light.
17683                                 Transparent bool // Sunlight isn't scattered.
17684                                 LightSrc    uint8
17685
17686                                 GndContent   bool
17687                                 Collides     bool
17688                                 Pointable    bool
17689                                 Diggable     bool
17690                                 Climbable    bool
17691                                 Replaceable  bool
17692                                 OnRightClick bool
17693
17694                                 DmgPerSec int32
17695
17696                                 LiquidType   LiquidType
17697                                 FlowingAlt   string
17698                                 SrcAlt       string
17699                                 Viscosity    uint8 // 0-7
17700                                 LiqRenewable bool
17701                                 FlowRange    uint8
17702                                 DrownDmg     uint8
17703                                 Floodable    bool
17704
17705                                 DrawBox, ColBox, SelBox NodeBox
17706
17707                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17708
17709                                 LegacyFaceDir bool
17710                                 LegacyMounted bool
17711
17712                                 DigPredict string
17713
17714                                 MaxLvl uint8
17715
17716                                 AlphaUse
17717                         }))(obj)).ColBox).serialize(w)
17718                 }); err != nil {
17719                         if err == io.EOF {
17720                                 chk(io.EOF)
17721                         }
17722                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17723                 }
17724                 if err := pcall(func() {
17725                         ((*(*(struct {
17726                                 Param0 Content
17727
17728                                 Name   string
17729                                 Groups []Group
17730
17731                                 P1Type   Param1Type
17732                                 P2Type   Param2Type
17733                                 DrawType DrawType
17734
17735                                 Mesh  string
17736                                 Scale float32
17737                                 //mt:const uint8(6)
17738                                 Tiles        [6]TileDef
17739                                 OverlayTiles [6]TileDef
17740                                 //mt:const uint8(6)
17741                                 SpecialTiles [6]TileDef
17742
17743                                 Color   color.NRGBA
17744                                 Palette Texture
17745
17746                                 Waving       WaveType
17747                                 ConnectSides uint8
17748                                 ConnectTo    []Content
17749                                 InsideTint   color.NRGBA
17750                                 Level        uint8 // Must be < 128.
17751
17752                                 Translucent bool // Sunlight is scattered and becomes normal light.
17753                                 Transparent bool // Sunlight isn't scattered.
17754                                 LightSrc    uint8
17755
17756                                 GndContent   bool
17757                                 Collides     bool
17758                                 Pointable    bool
17759                                 Diggable     bool
17760                                 Climbable    bool
17761                                 Replaceable  bool
17762                                 OnRightClick bool
17763
17764                                 DmgPerSec int32
17765
17766                                 LiquidType   LiquidType
17767                                 FlowingAlt   string
17768                                 SrcAlt       string
17769                                 Viscosity    uint8 // 0-7
17770                                 LiqRenewable bool
17771                                 FlowRange    uint8
17772                                 DrownDmg     uint8
17773                                 Floodable    bool
17774
17775                                 DrawBox, ColBox, SelBox NodeBox
17776
17777                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17778
17779                                 LegacyFaceDir bool
17780                                 LegacyMounted bool
17781
17782                                 DigPredict string
17783
17784                                 MaxLvl uint8
17785
17786                                 AlphaUse
17787                         }))(obj)).SelBox).serialize(w)
17788                 }); err != nil {
17789                         if err == io.EOF {
17790                                 chk(io.EOF)
17791                         }
17792                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
17793                 }
17794                 if err := pcall(func() {
17795                         ((*(*(struct {
17796                                 Param0 Content
17797
17798                                 Name   string
17799                                 Groups []Group
17800
17801                                 P1Type   Param1Type
17802                                 P2Type   Param2Type
17803                                 DrawType DrawType
17804
17805                                 Mesh  string
17806                                 Scale float32
17807                                 //mt:const uint8(6)
17808                                 Tiles        [6]TileDef
17809                                 OverlayTiles [6]TileDef
17810                                 //mt:const uint8(6)
17811                                 SpecialTiles [6]TileDef
17812
17813                                 Color   color.NRGBA
17814                                 Palette Texture
17815
17816                                 Waving       WaveType
17817                                 ConnectSides uint8
17818                                 ConnectTo    []Content
17819                                 InsideTint   color.NRGBA
17820                                 Level        uint8 // Must be < 128.
17821
17822                                 Translucent bool // Sunlight is scattered and becomes normal light.
17823                                 Transparent bool // Sunlight isn't scattered.
17824                                 LightSrc    uint8
17825
17826                                 GndContent   bool
17827                                 Collides     bool
17828                                 Pointable    bool
17829                                 Diggable     bool
17830                                 Climbable    bool
17831                                 Replaceable  bool
17832                                 OnRightClick bool
17833
17834                                 DmgPerSec int32
17835
17836                                 LiquidType   LiquidType
17837                                 FlowingAlt   string
17838                                 SrcAlt       string
17839                                 Viscosity    uint8 // 0-7
17840                                 LiqRenewable bool
17841                                 FlowRange    uint8
17842                                 DrownDmg     uint8
17843                                 Floodable    bool
17844
17845                                 DrawBox, ColBox, SelBox NodeBox
17846
17847                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17848
17849                                 LegacyFaceDir bool
17850                                 LegacyMounted bool
17851
17852                                 DigPredict string
17853
17854                                 MaxLvl uint8
17855
17856                                 AlphaUse
17857                         }))(obj)).FootstepSnd).serialize(w)
17858                 }); err != nil {
17859                         if err == io.EOF {
17860                                 chk(io.EOF)
17861                         }
17862                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
17863                 }
17864                 if err := pcall(func() {
17865                         ((*(*(struct {
17866                                 Param0 Content
17867
17868                                 Name   string
17869                                 Groups []Group
17870
17871                                 P1Type   Param1Type
17872                                 P2Type   Param2Type
17873                                 DrawType DrawType
17874
17875                                 Mesh  string
17876                                 Scale float32
17877                                 //mt:const uint8(6)
17878                                 Tiles        [6]TileDef
17879                                 OverlayTiles [6]TileDef
17880                                 //mt:const uint8(6)
17881                                 SpecialTiles [6]TileDef
17882
17883                                 Color   color.NRGBA
17884                                 Palette Texture
17885
17886                                 Waving       WaveType
17887                                 ConnectSides uint8
17888                                 ConnectTo    []Content
17889                                 InsideTint   color.NRGBA
17890                                 Level        uint8 // Must be < 128.
17891
17892                                 Translucent bool // Sunlight is scattered and becomes normal light.
17893                                 Transparent bool // Sunlight isn't scattered.
17894                                 LightSrc    uint8
17895
17896                                 GndContent   bool
17897                                 Collides     bool
17898                                 Pointable    bool
17899                                 Diggable     bool
17900                                 Climbable    bool
17901                                 Replaceable  bool
17902                                 OnRightClick bool
17903
17904                                 DmgPerSec int32
17905
17906                                 LiquidType   LiquidType
17907                                 FlowingAlt   string
17908                                 SrcAlt       string
17909                                 Viscosity    uint8 // 0-7
17910                                 LiqRenewable bool
17911                                 FlowRange    uint8
17912                                 DrownDmg     uint8
17913                                 Floodable    bool
17914
17915                                 DrawBox, ColBox, SelBox NodeBox
17916
17917                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17918
17919                                 LegacyFaceDir bool
17920                                 LegacyMounted bool
17921
17922                                 DigPredict string
17923
17924                                 MaxLvl uint8
17925
17926                                 AlphaUse
17927                         }))(obj)).DiggingSnd).serialize(w)
17928                 }); err != nil {
17929                         if err == io.EOF {
17930                                 chk(io.EOF)
17931                         }
17932                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
17933                 }
17934                 if err := pcall(func() {
17935                         ((*(*(struct {
17936                                 Param0 Content
17937
17938                                 Name   string
17939                                 Groups []Group
17940
17941                                 P1Type   Param1Type
17942                                 P2Type   Param2Type
17943                                 DrawType DrawType
17944
17945                                 Mesh  string
17946                                 Scale float32
17947                                 //mt:const uint8(6)
17948                                 Tiles        [6]TileDef
17949                                 OverlayTiles [6]TileDef
17950                                 //mt:const uint8(6)
17951                                 SpecialTiles [6]TileDef
17952
17953                                 Color   color.NRGBA
17954                                 Palette Texture
17955
17956                                 Waving       WaveType
17957                                 ConnectSides uint8
17958                                 ConnectTo    []Content
17959                                 InsideTint   color.NRGBA
17960                                 Level        uint8 // Must be < 128.
17961
17962                                 Translucent bool // Sunlight is scattered and becomes normal light.
17963                                 Transparent bool // Sunlight isn't scattered.
17964                                 LightSrc    uint8
17965
17966                                 GndContent   bool
17967                                 Collides     bool
17968                                 Pointable    bool
17969                                 Diggable     bool
17970                                 Climbable    bool
17971                                 Replaceable  bool
17972                                 OnRightClick bool
17973
17974                                 DmgPerSec int32
17975
17976                                 LiquidType   LiquidType
17977                                 FlowingAlt   string
17978                                 SrcAlt       string
17979                                 Viscosity    uint8 // 0-7
17980                                 LiqRenewable bool
17981                                 FlowRange    uint8
17982                                 DrownDmg     uint8
17983                                 Floodable    bool
17984
17985                                 DrawBox, ColBox, SelBox NodeBox
17986
17987                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17988
17989                                 LegacyFaceDir bool
17990                                 LegacyMounted bool
17991
17992                                 DigPredict string
17993
17994                                 MaxLvl uint8
17995
17996                                 AlphaUse
17997                         }))(obj)).DugSnd).serialize(w)
17998                 }); err != nil {
17999                         if err == io.EOF {
18000                                 chk(io.EOF)
18001                         }
18002                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
18003                 }
18004                 {
18005                         x := (*(*(struct {
18006                                 Param0 Content
18007
18008                                 Name   string
18009                                 Groups []Group
18010
18011                                 P1Type   Param1Type
18012                                 P2Type   Param2Type
18013                                 DrawType DrawType
18014
18015                                 Mesh  string
18016                                 Scale float32
18017                                 //mt:const uint8(6)
18018                                 Tiles        [6]TileDef
18019                                 OverlayTiles [6]TileDef
18020                                 //mt:const uint8(6)
18021                                 SpecialTiles [6]TileDef
18022
18023                                 Color   color.NRGBA
18024                                 Palette Texture
18025
18026                                 Waving       WaveType
18027                                 ConnectSides uint8
18028                                 ConnectTo    []Content
18029                                 InsideTint   color.NRGBA
18030                                 Level        uint8 // Must be < 128.
18031
18032                                 Translucent bool // Sunlight is scattered and becomes normal light.
18033                                 Transparent bool // Sunlight isn't scattered.
18034                                 LightSrc    uint8
18035
18036                                 GndContent   bool
18037                                 Collides     bool
18038                                 Pointable    bool
18039                                 Diggable     bool
18040                                 Climbable    bool
18041                                 Replaceable  bool
18042                                 OnRightClick bool
18043
18044                                 DmgPerSec int32
18045
18046                                 LiquidType   LiquidType
18047                                 FlowingAlt   string
18048                                 SrcAlt       string
18049                                 Viscosity    uint8 // 0-7
18050                                 LiqRenewable bool
18051                                 FlowRange    uint8
18052                                 DrownDmg     uint8
18053                                 Floodable    bool
18054
18055                                 DrawBox, ColBox, SelBox NodeBox
18056
18057                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18058
18059                                 LegacyFaceDir bool
18060                                 LegacyMounted bool
18061
18062                                 DigPredict string
18063
18064                                 MaxLvl uint8
18065
18066                                 AlphaUse
18067                         }))(obj)).LegacyFaceDir
18068                         if x {
18069                                 write8(w, 1)
18070                         } else {
18071                                 write8(w, 0)
18072                         }
18073
18074                 }
18075                 {
18076                         x := (*(*(struct {
18077                                 Param0 Content
18078
18079                                 Name   string
18080                                 Groups []Group
18081
18082                                 P1Type   Param1Type
18083                                 P2Type   Param2Type
18084                                 DrawType DrawType
18085
18086                                 Mesh  string
18087                                 Scale float32
18088                                 //mt:const uint8(6)
18089                                 Tiles        [6]TileDef
18090                                 OverlayTiles [6]TileDef
18091                                 //mt:const uint8(6)
18092                                 SpecialTiles [6]TileDef
18093
18094                                 Color   color.NRGBA
18095                                 Palette Texture
18096
18097                                 Waving       WaveType
18098                                 ConnectSides uint8
18099                                 ConnectTo    []Content
18100                                 InsideTint   color.NRGBA
18101                                 Level        uint8 // Must be < 128.
18102
18103                                 Translucent bool // Sunlight is scattered and becomes normal light.
18104                                 Transparent bool // Sunlight isn't scattered.
18105                                 LightSrc    uint8
18106
18107                                 GndContent   bool
18108                                 Collides     bool
18109                                 Pointable    bool
18110                                 Diggable     bool
18111                                 Climbable    bool
18112                                 Replaceable  bool
18113                                 OnRightClick bool
18114
18115                                 DmgPerSec int32
18116
18117                                 LiquidType   LiquidType
18118                                 FlowingAlt   string
18119                                 SrcAlt       string
18120                                 Viscosity    uint8 // 0-7
18121                                 LiqRenewable bool
18122                                 FlowRange    uint8
18123                                 DrownDmg     uint8
18124                                 Floodable    bool
18125
18126                                 DrawBox, ColBox, SelBox NodeBox
18127
18128                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18129
18130                                 LegacyFaceDir bool
18131                                 LegacyMounted bool
18132
18133                                 DigPredict string
18134
18135                                 MaxLvl uint8
18136
18137                                 AlphaUse
18138                         }))(obj)).LegacyMounted
18139                         if x {
18140                                 write8(w, 1)
18141                         } else {
18142                                 write8(w, 0)
18143                         }
18144
18145                 }
18146                 if len(([]byte((*(*(struct {
18147                         Param0 Content
18148
18149                         Name   string
18150                         Groups []Group
18151
18152                         P1Type   Param1Type
18153                         P2Type   Param2Type
18154                         DrawType DrawType
18155
18156                         Mesh  string
18157                         Scale float32
18158                         //mt:const uint8(6)
18159                         Tiles        [6]TileDef
18160                         OverlayTiles [6]TileDef
18161                         //mt:const uint8(6)
18162                         SpecialTiles [6]TileDef
18163
18164                         Color   color.NRGBA
18165                         Palette Texture
18166
18167                         Waving       WaveType
18168                         ConnectSides uint8
18169                         ConnectTo    []Content
18170                         InsideTint   color.NRGBA
18171                         Level        uint8 // Must be < 128.
18172
18173                         Translucent bool // Sunlight is scattered and becomes normal light.
18174                         Transparent bool // Sunlight isn't scattered.
18175                         LightSrc    uint8
18176
18177                         GndContent   bool
18178                         Collides     bool
18179                         Pointable    bool
18180                         Diggable     bool
18181                         Climbable    bool
18182                         Replaceable  bool
18183                         OnRightClick bool
18184
18185                         DmgPerSec int32
18186
18187                         LiquidType   LiquidType
18188                         FlowingAlt   string
18189                         SrcAlt       string
18190                         Viscosity    uint8 // 0-7
18191                         LiqRenewable bool
18192                         FlowRange    uint8
18193                         DrownDmg     uint8
18194                         Floodable    bool
18195
18196                         DrawBox, ColBox, SelBox NodeBox
18197
18198                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18199
18200                         LegacyFaceDir bool
18201                         LegacyMounted bool
18202
18203                         DigPredict string
18204
18205                         MaxLvl uint8
18206
18207                         AlphaUse
18208                 }))(obj)).DigPredict))) > math.MaxUint16 {
18209                         chk(ErrTooLong)
18210                 }
18211                 {
18212                         x := uint16(len(([]byte((*(*(struct {
18213                                 Param0 Content
18214
18215                                 Name   string
18216                                 Groups []Group
18217
18218                                 P1Type   Param1Type
18219                                 P2Type   Param2Type
18220                                 DrawType DrawType
18221
18222                                 Mesh  string
18223                                 Scale float32
18224                                 //mt:const uint8(6)
18225                                 Tiles        [6]TileDef
18226                                 OverlayTiles [6]TileDef
18227                                 //mt:const uint8(6)
18228                                 SpecialTiles [6]TileDef
18229
18230                                 Color   color.NRGBA
18231                                 Palette Texture
18232
18233                                 Waving       WaveType
18234                                 ConnectSides uint8
18235                                 ConnectTo    []Content
18236                                 InsideTint   color.NRGBA
18237                                 Level        uint8 // Must be < 128.
18238
18239                                 Translucent bool // Sunlight is scattered and becomes normal light.
18240                                 Transparent bool // Sunlight isn't scattered.
18241                                 LightSrc    uint8
18242
18243                                 GndContent   bool
18244                                 Collides     bool
18245                                 Pointable    bool
18246                                 Diggable     bool
18247                                 Climbable    bool
18248                                 Replaceable  bool
18249                                 OnRightClick bool
18250
18251                                 DmgPerSec int32
18252
18253                                 LiquidType   LiquidType
18254                                 FlowingAlt   string
18255                                 SrcAlt       string
18256                                 Viscosity    uint8 // 0-7
18257                                 LiqRenewable bool
18258                                 FlowRange    uint8
18259                                 DrownDmg     uint8
18260                                 Floodable    bool
18261
18262                                 DrawBox, ColBox, SelBox NodeBox
18263
18264                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18265
18266                                 LegacyFaceDir bool
18267                                 LegacyMounted bool
18268
18269                                 DigPredict string
18270
18271                                 MaxLvl uint8
18272
18273                                 AlphaUse
18274                         }))(obj)).DigPredict))))
18275                         write16(w, uint16(x))
18276                 }
18277                 {
18278                         _, err := w.Write(([]byte((*(*(struct {
18279                                 Param0 Content
18280
18281                                 Name   string
18282                                 Groups []Group
18283
18284                                 P1Type   Param1Type
18285                                 P2Type   Param2Type
18286                                 DrawType DrawType
18287
18288                                 Mesh  string
18289                                 Scale float32
18290                                 //mt:const uint8(6)
18291                                 Tiles        [6]TileDef
18292                                 OverlayTiles [6]TileDef
18293                                 //mt:const uint8(6)
18294                                 SpecialTiles [6]TileDef
18295
18296                                 Color   color.NRGBA
18297                                 Palette Texture
18298
18299                                 Waving       WaveType
18300                                 ConnectSides uint8
18301                                 ConnectTo    []Content
18302                                 InsideTint   color.NRGBA
18303                                 Level        uint8 // Must be < 128.
18304
18305                                 Translucent bool // Sunlight is scattered and becomes normal light.
18306                                 Transparent bool // Sunlight isn't scattered.
18307                                 LightSrc    uint8
18308
18309                                 GndContent   bool
18310                                 Collides     bool
18311                                 Pointable    bool
18312                                 Diggable     bool
18313                                 Climbable    bool
18314                                 Replaceable  bool
18315                                 OnRightClick bool
18316
18317                                 DmgPerSec int32
18318
18319                                 LiquidType   LiquidType
18320                                 FlowingAlt   string
18321                                 SrcAlt       string
18322                                 Viscosity    uint8 // 0-7
18323                                 LiqRenewable bool
18324                                 FlowRange    uint8
18325                                 DrownDmg     uint8
18326                                 Floodable    bool
18327
18328                                 DrawBox, ColBox, SelBox NodeBox
18329
18330                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18331
18332                                 LegacyFaceDir bool
18333                                 LegacyMounted bool
18334
18335                                 DigPredict string
18336
18337                                 MaxLvl uint8
18338
18339                                 AlphaUse
18340                         }))(obj)).DigPredict))[:])
18341                         chk(err)
18342                 }
18343                 {
18344                         x := (*(*(struct {
18345                                 Param0 Content
18346
18347                                 Name   string
18348                                 Groups []Group
18349
18350                                 P1Type   Param1Type
18351                                 P2Type   Param2Type
18352                                 DrawType DrawType
18353
18354                                 Mesh  string
18355                                 Scale float32
18356                                 //mt:const uint8(6)
18357                                 Tiles        [6]TileDef
18358                                 OverlayTiles [6]TileDef
18359                                 //mt:const uint8(6)
18360                                 SpecialTiles [6]TileDef
18361
18362                                 Color   color.NRGBA
18363                                 Palette Texture
18364
18365                                 Waving       WaveType
18366                                 ConnectSides uint8
18367                                 ConnectTo    []Content
18368                                 InsideTint   color.NRGBA
18369                                 Level        uint8 // Must be < 128.
18370
18371                                 Translucent bool // Sunlight is scattered and becomes normal light.
18372                                 Transparent bool // Sunlight isn't scattered.
18373                                 LightSrc    uint8
18374
18375                                 GndContent   bool
18376                                 Collides     bool
18377                                 Pointable    bool
18378                                 Diggable     bool
18379                                 Climbable    bool
18380                                 Replaceable  bool
18381                                 OnRightClick bool
18382
18383                                 DmgPerSec int32
18384
18385                                 LiquidType   LiquidType
18386                                 FlowingAlt   string
18387                                 SrcAlt       string
18388                                 Viscosity    uint8 // 0-7
18389                                 LiqRenewable bool
18390                                 FlowRange    uint8
18391                                 DrownDmg     uint8
18392                                 Floodable    bool
18393
18394                                 DrawBox, ColBox, SelBox NodeBox
18395
18396                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18397
18398                                 LegacyFaceDir bool
18399                                 LegacyMounted bool
18400
18401                                 DigPredict string
18402
18403                                 MaxLvl uint8
18404
18405                                 AlphaUse
18406                         }))(obj)).MaxLvl
18407                         write8(w, uint8(x))
18408                 }
18409                 if err := pcall(func() {
18410                         ((*(*(struct {
18411                                 Param0 Content
18412
18413                                 Name   string
18414                                 Groups []Group
18415
18416                                 P1Type   Param1Type
18417                                 P2Type   Param2Type
18418                                 DrawType DrawType
18419
18420                                 Mesh  string
18421                                 Scale float32
18422                                 //mt:const uint8(6)
18423                                 Tiles        [6]TileDef
18424                                 OverlayTiles [6]TileDef
18425                                 //mt:const uint8(6)
18426                                 SpecialTiles [6]TileDef
18427
18428                                 Color   color.NRGBA
18429                                 Palette Texture
18430
18431                                 Waving       WaveType
18432                                 ConnectSides uint8
18433                                 ConnectTo    []Content
18434                                 InsideTint   color.NRGBA
18435                                 Level        uint8 // Must be < 128.
18436
18437                                 Translucent bool // Sunlight is scattered and becomes normal light.
18438                                 Transparent bool // Sunlight isn't scattered.
18439                                 LightSrc    uint8
18440
18441                                 GndContent   bool
18442                                 Collides     bool
18443                                 Pointable    bool
18444                                 Diggable     bool
18445                                 Climbable    bool
18446                                 Replaceable  bool
18447                                 OnRightClick bool
18448
18449                                 DmgPerSec int32
18450
18451                                 LiquidType   LiquidType
18452                                 FlowingAlt   string
18453                                 SrcAlt       string
18454                                 Viscosity    uint8 // 0-7
18455                                 LiqRenewable bool
18456                                 FlowRange    uint8
18457                                 DrownDmg     uint8
18458                                 Floodable    bool
18459
18460                                 DrawBox, ColBox, SelBox NodeBox
18461
18462                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18463
18464                                 LegacyFaceDir bool
18465                                 LegacyMounted bool
18466
18467                                 DigPredict string
18468
18469                                 MaxLvl uint8
18470
18471                                 AlphaUse
18472                         }))(obj)).AlphaUse).serialize(w)
18473                 }); err != nil {
18474                         if err == io.EOF {
18475                                 chk(io.EOF)
18476                         }
18477                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlphaUse", err))
18478                 }
18479                 {
18480                         buf := w
18481                         w := ow
18482                         if len((buf.Bytes())) > math.MaxUint16 {
18483                                 chk(ErrTooLong)
18484                         }
18485                         {
18486                                 x := uint16(len((buf.Bytes())))
18487                                 write16(w, uint16(x))
18488                         }
18489                         {
18490                                 _, err := w.Write((buf.Bytes())[:])
18491                                 chk(err)
18492                         }
18493                 }
18494         }
18495 }
18496
18497 func (obj *NodeDef) deserialize(r io.Reader) {
18498         if err := pcall(func() {
18499                 ((*(*(struct {
18500                         Param0 Content
18501
18502                         Name   string
18503                         Groups []Group
18504
18505                         P1Type   Param1Type
18506                         P2Type   Param2Type
18507                         DrawType DrawType
18508
18509                         Mesh  string
18510                         Scale float32
18511                         //mt:const uint8(6)
18512                         Tiles        [6]TileDef
18513                         OverlayTiles [6]TileDef
18514                         //mt:const uint8(6)
18515                         SpecialTiles [6]TileDef
18516
18517                         Color   color.NRGBA
18518                         Palette Texture
18519
18520                         Waving       WaveType
18521                         ConnectSides uint8
18522                         ConnectTo    []Content
18523                         InsideTint   color.NRGBA
18524                         Level        uint8 // Must be < 128.
18525
18526                         Translucent bool // Sunlight is scattered and becomes normal light.
18527                         Transparent bool // Sunlight isn't scattered.
18528                         LightSrc    uint8
18529
18530                         GndContent   bool
18531                         Collides     bool
18532                         Pointable    bool
18533                         Diggable     bool
18534                         Climbable    bool
18535                         Replaceable  bool
18536                         OnRightClick bool
18537
18538                         DmgPerSec int32
18539
18540                         LiquidType   LiquidType
18541                         FlowingAlt   string
18542                         SrcAlt       string
18543                         Viscosity    uint8 // 0-7
18544                         LiqRenewable bool
18545                         FlowRange    uint8
18546                         DrownDmg     uint8
18547                         Floodable    bool
18548
18549                         DrawBox, ColBox, SelBox NodeBox
18550
18551                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18552
18553                         LegacyFaceDir bool
18554                         LegacyMounted bool
18555
18556                         DigPredict string
18557
18558                         MaxLvl uint8
18559
18560                         AlphaUse
18561                 }))(obj)).Param0).deserialize(r)
18562         }); err != nil {
18563                 if err == io.EOF {
18564                         chk(io.EOF)
18565                 }
18566                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
18567         }
18568         {
18569                 var n uint16
18570                 {
18571                         p := &n
18572                         *p = read16(r)
18573                 }
18574                 r := &io.LimitedReader{R: r, N: int64(n)}
18575                 {
18576                         var local248 uint8
18577                         local249 := uint8(13)
18578                         {
18579                                 p := &local248
18580                                 *p = read8(r)
18581                         }
18582                         if local248 != local249 {
18583                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local248))
18584                         }
18585                 }
18586                 var local250 []uint8
18587                 var local251 uint16
18588                 {
18589                         p := &local251
18590                         *p = read16(r)
18591                 }
18592                 (local250) = make([]uint8, local251)
18593                 {
18594                         _, err := io.ReadFull(r, (local250)[:])
18595                         chk(err)
18596                 }
18597                 ((*(*(struct {
18598                         Param0 Content
18599
18600                         Name   string
18601                         Groups []Group
18602
18603                         P1Type   Param1Type
18604                         P2Type   Param2Type
18605                         DrawType DrawType
18606
18607                         Mesh  string
18608                         Scale float32
18609                         //mt:const uint8(6)
18610                         Tiles        [6]TileDef
18611                         OverlayTiles [6]TileDef
18612                         //mt:const uint8(6)
18613                         SpecialTiles [6]TileDef
18614
18615                         Color   color.NRGBA
18616                         Palette Texture
18617
18618                         Waving       WaveType
18619                         ConnectSides uint8
18620                         ConnectTo    []Content
18621                         InsideTint   color.NRGBA
18622                         Level        uint8 // Must be < 128.
18623
18624                         Translucent bool // Sunlight is scattered and becomes normal light.
18625                         Transparent bool // Sunlight isn't scattered.
18626                         LightSrc    uint8
18627
18628                         GndContent   bool
18629                         Collides     bool
18630                         Pointable    bool
18631                         Diggable     bool
18632                         Climbable    bool
18633                         Replaceable  bool
18634                         OnRightClick bool
18635
18636                         DmgPerSec int32
18637
18638                         LiquidType   LiquidType
18639                         FlowingAlt   string
18640                         SrcAlt       string
18641                         Viscosity    uint8 // 0-7
18642                         LiqRenewable bool
18643                         FlowRange    uint8
18644                         DrownDmg     uint8
18645                         Floodable    bool
18646
18647                         DrawBox, ColBox, SelBox NodeBox
18648
18649                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18650
18651                         LegacyFaceDir bool
18652                         LegacyMounted bool
18653
18654                         DigPredict string
18655
18656                         MaxLvl uint8
18657
18658                         AlphaUse
18659                 }))(obj)).Name) = string(local250)
18660                 var local252 uint16
18661                 {
18662                         p := &local252
18663                         *p = read16(r)
18664                 }
18665                 ((*(*(struct {
18666                         Param0 Content
18667
18668                         Name   string
18669                         Groups []Group
18670
18671                         P1Type   Param1Type
18672                         P2Type   Param2Type
18673                         DrawType DrawType
18674
18675                         Mesh  string
18676                         Scale float32
18677                         //mt:const uint8(6)
18678                         Tiles        [6]TileDef
18679                         OverlayTiles [6]TileDef
18680                         //mt:const uint8(6)
18681                         SpecialTiles [6]TileDef
18682
18683                         Color   color.NRGBA
18684                         Palette Texture
18685
18686                         Waving       WaveType
18687                         ConnectSides uint8
18688                         ConnectTo    []Content
18689                         InsideTint   color.NRGBA
18690                         Level        uint8 // Must be < 128.
18691
18692                         Translucent bool // Sunlight is scattered and becomes normal light.
18693                         Transparent bool // Sunlight isn't scattered.
18694                         LightSrc    uint8
18695
18696                         GndContent   bool
18697                         Collides     bool
18698                         Pointable    bool
18699                         Diggable     bool
18700                         Climbable    bool
18701                         Replaceable  bool
18702                         OnRightClick bool
18703
18704                         DmgPerSec int32
18705
18706                         LiquidType   LiquidType
18707                         FlowingAlt   string
18708                         SrcAlt       string
18709                         Viscosity    uint8 // 0-7
18710                         LiqRenewable bool
18711                         FlowRange    uint8
18712                         DrownDmg     uint8
18713                         Floodable    bool
18714
18715                         DrawBox, ColBox, SelBox NodeBox
18716
18717                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18718
18719                         LegacyFaceDir bool
18720                         LegacyMounted bool
18721
18722                         DigPredict string
18723
18724                         MaxLvl uint8
18725
18726                         AlphaUse
18727                 }))(obj)).Groups) = make([]Group, local252)
18728                 for local253 := range (*(*(struct {
18729                         Param0 Content
18730
18731                         Name   string
18732                         Groups []Group
18733
18734                         P1Type   Param1Type
18735                         P2Type   Param2Type
18736                         DrawType DrawType
18737
18738                         Mesh  string
18739                         Scale float32
18740                         //mt:const uint8(6)
18741                         Tiles        [6]TileDef
18742                         OverlayTiles [6]TileDef
18743                         //mt:const uint8(6)
18744                         SpecialTiles [6]TileDef
18745
18746                         Color   color.NRGBA
18747                         Palette Texture
18748
18749                         Waving       WaveType
18750                         ConnectSides uint8
18751                         ConnectTo    []Content
18752                         InsideTint   color.NRGBA
18753                         Level        uint8 // Must be < 128.
18754
18755                         Translucent bool // Sunlight is scattered and becomes normal light.
18756                         Transparent bool // Sunlight isn't scattered.
18757                         LightSrc    uint8
18758
18759                         GndContent   bool
18760                         Collides     bool
18761                         Pointable    bool
18762                         Diggable     bool
18763                         Climbable    bool
18764                         Replaceable  bool
18765                         OnRightClick bool
18766
18767                         DmgPerSec int32
18768
18769                         LiquidType   LiquidType
18770                         FlowingAlt   string
18771                         SrcAlt       string
18772                         Viscosity    uint8 // 0-7
18773                         LiqRenewable bool
18774                         FlowRange    uint8
18775                         DrownDmg     uint8
18776                         Floodable    bool
18777
18778                         DrawBox, ColBox, SelBox NodeBox
18779
18780                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18781
18782                         LegacyFaceDir bool
18783                         LegacyMounted bool
18784
18785                         DigPredict string
18786
18787                         MaxLvl uint8
18788
18789                         AlphaUse
18790                 }))(obj)).Groups {
18791                         if err := pcall(func() {
18792                                 (((*(*(struct {
18793                                         Param0 Content
18794
18795                                         Name   string
18796                                         Groups []Group
18797
18798                                         P1Type   Param1Type
18799                                         P2Type   Param2Type
18800                                         DrawType DrawType
18801
18802                                         Mesh  string
18803                                         Scale float32
18804                                         //mt:const uint8(6)
18805                                         Tiles        [6]TileDef
18806                                         OverlayTiles [6]TileDef
18807                                         //mt:const uint8(6)
18808                                         SpecialTiles [6]TileDef
18809
18810                                         Color   color.NRGBA
18811                                         Palette Texture
18812
18813                                         Waving       WaveType
18814                                         ConnectSides uint8
18815                                         ConnectTo    []Content
18816                                         InsideTint   color.NRGBA
18817                                         Level        uint8 // Must be < 128.
18818
18819                                         Translucent bool // Sunlight is scattered and becomes normal light.
18820                                         Transparent bool // Sunlight isn't scattered.
18821                                         LightSrc    uint8
18822
18823                                         GndContent   bool
18824                                         Collides     bool
18825                                         Pointable    bool
18826                                         Diggable     bool
18827                                         Climbable    bool
18828                                         Replaceable  bool
18829                                         OnRightClick bool
18830
18831                                         DmgPerSec int32
18832
18833                                         LiquidType   LiquidType
18834                                         FlowingAlt   string
18835                                         SrcAlt       string
18836                                         Viscosity    uint8 // 0-7
18837                                         LiqRenewable bool
18838                                         FlowRange    uint8
18839                                         DrownDmg     uint8
18840                                         Floodable    bool
18841
18842                                         DrawBox, ColBox, SelBox NodeBox
18843
18844                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18845
18846                                         LegacyFaceDir bool
18847                                         LegacyMounted bool
18848
18849                                         DigPredict string
18850
18851                                         MaxLvl uint8
18852
18853                                         AlphaUse
18854                                 }))(obj)).Groups)[local253]).deserialize(r)
18855                         }); err != nil {
18856                                 if err == io.EOF {
18857                                         chk(io.EOF)
18858                                 }
18859                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
18860                         }
18861                 }
18862                 if err := pcall(func() {
18863                         ((*(*(struct {
18864                                 Param0 Content
18865
18866                                 Name   string
18867                                 Groups []Group
18868
18869                                 P1Type   Param1Type
18870                                 P2Type   Param2Type
18871                                 DrawType DrawType
18872
18873                                 Mesh  string
18874                                 Scale float32
18875                                 //mt:const uint8(6)
18876                                 Tiles        [6]TileDef
18877                                 OverlayTiles [6]TileDef
18878                                 //mt:const uint8(6)
18879                                 SpecialTiles [6]TileDef
18880
18881                                 Color   color.NRGBA
18882                                 Palette Texture
18883
18884                                 Waving       WaveType
18885                                 ConnectSides uint8
18886                                 ConnectTo    []Content
18887                                 InsideTint   color.NRGBA
18888                                 Level        uint8 // Must be < 128.
18889
18890                                 Translucent bool // Sunlight is scattered and becomes normal light.
18891                                 Transparent bool // Sunlight isn't scattered.
18892                                 LightSrc    uint8
18893
18894                                 GndContent   bool
18895                                 Collides     bool
18896                                 Pointable    bool
18897                                 Diggable     bool
18898                                 Climbable    bool
18899                                 Replaceable  bool
18900                                 OnRightClick bool
18901
18902                                 DmgPerSec int32
18903
18904                                 LiquidType   LiquidType
18905                                 FlowingAlt   string
18906                                 SrcAlt       string
18907                                 Viscosity    uint8 // 0-7
18908                                 LiqRenewable bool
18909                                 FlowRange    uint8
18910                                 DrownDmg     uint8
18911                                 Floodable    bool
18912
18913                                 DrawBox, ColBox, SelBox NodeBox
18914
18915                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18916
18917                                 LegacyFaceDir bool
18918                                 LegacyMounted bool
18919
18920                                 DigPredict string
18921
18922                                 MaxLvl uint8
18923
18924                                 AlphaUse
18925                         }))(obj)).P1Type).deserialize(r)
18926                 }); err != nil {
18927                         if err == io.EOF {
18928                                 chk(io.EOF)
18929                         }
18930                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param1Type", err))
18931                 }
18932                 if err := pcall(func() {
18933                         ((*(*(struct {
18934                                 Param0 Content
18935
18936                                 Name   string
18937                                 Groups []Group
18938
18939                                 P1Type   Param1Type
18940                                 P2Type   Param2Type
18941                                 DrawType DrawType
18942
18943                                 Mesh  string
18944                                 Scale float32
18945                                 //mt:const uint8(6)
18946                                 Tiles        [6]TileDef
18947                                 OverlayTiles [6]TileDef
18948                                 //mt:const uint8(6)
18949                                 SpecialTiles [6]TileDef
18950
18951                                 Color   color.NRGBA
18952                                 Palette Texture
18953
18954                                 Waving       WaveType
18955                                 ConnectSides uint8
18956                                 ConnectTo    []Content
18957                                 InsideTint   color.NRGBA
18958                                 Level        uint8 // Must be < 128.
18959
18960                                 Translucent bool // Sunlight is scattered and becomes normal light.
18961                                 Transparent bool // Sunlight isn't scattered.
18962                                 LightSrc    uint8
18963
18964                                 GndContent   bool
18965                                 Collides     bool
18966                                 Pointable    bool
18967                                 Diggable     bool
18968                                 Climbable    bool
18969                                 Replaceable  bool
18970                                 OnRightClick bool
18971
18972                                 DmgPerSec int32
18973
18974                                 LiquidType   LiquidType
18975                                 FlowingAlt   string
18976                                 SrcAlt       string
18977                                 Viscosity    uint8 // 0-7
18978                                 LiqRenewable bool
18979                                 FlowRange    uint8
18980                                 DrownDmg     uint8
18981                                 Floodable    bool
18982
18983                                 DrawBox, ColBox, SelBox NodeBox
18984
18985                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18986
18987                                 LegacyFaceDir bool
18988                                 LegacyMounted bool
18989
18990                                 DigPredict string
18991
18992                                 MaxLvl uint8
18993
18994                                 AlphaUse
18995                         }))(obj)).P2Type).deserialize(r)
18996                 }); err != nil {
18997                         if err == io.EOF {
18998                                 chk(io.EOF)
18999                         }
19000                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Param2Type", err))
19001                 }
19002                 if err := pcall(func() {
19003                         ((*(*(struct {
19004                                 Param0 Content
19005
19006                                 Name   string
19007                                 Groups []Group
19008
19009                                 P1Type   Param1Type
19010                                 P2Type   Param2Type
19011                                 DrawType DrawType
19012
19013                                 Mesh  string
19014                                 Scale float32
19015                                 //mt:const uint8(6)
19016                                 Tiles        [6]TileDef
19017                                 OverlayTiles [6]TileDef
19018                                 //mt:const uint8(6)
19019                                 SpecialTiles [6]TileDef
19020
19021                                 Color   color.NRGBA
19022                                 Palette Texture
19023
19024                                 Waving       WaveType
19025                                 ConnectSides uint8
19026                                 ConnectTo    []Content
19027                                 InsideTint   color.NRGBA
19028                                 Level        uint8 // Must be < 128.
19029
19030                                 Translucent bool // Sunlight is scattered and becomes normal light.
19031                                 Transparent bool // Sunlight isn't scattered.
19032                                 LightSrc    uint8
19033
19034                                 GndContent   bool
19035                                 Collides     bool
19036                                 Pointable    bool
19037                                 Diggable     bool
19038                                 Climbable    bool
19039                                 Replaceable  bool
19040                                 OnRightClick bool
19041
19042                                 DmgPerSec int32
19043
19044                                 LiquidType   LiquidType
19045                                 FlowingAlt   string
19046                                 SrcAlt       string
19047                                 Viscosity    uint8 // 0-7
19048                                 LiqRenewable bool
19049                                 FlowRange    uint8
19050                                 DrownDmg     uint8
19051                                 Floodable    bool
19052
19053                                 DrawBox, ColBox, SelBox NodeBox
19054
19055                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19056
19057                                 LegacyFaceDir bool
19058                                 LegacyMounted bool
19059
19060                                 DigPredict string
19061
19062                                 MaxLvl uint8
19063
19064                                 AlphaUse
19065                         }))(obj)).DrawType).deserialize(r)
19066                 }); err != nil {
19067                         if err == io.EOF {
19068                                 chk(io.EOF)
19069                         }
19070                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
19071                 }
19072                 var local254 []uint8
19073                 var local255 uint16
19074                 {
19075                         p := &local255
19076                         *p = read16(r)
19077                 }
19078                 (local254) = make([]uint8, local255)
19079                 {
19080                         _, err := io.ReadFull(r, (local254)[:])
19081                         chk(err)
19082                 }
19083                 ((*(*(struct {
19084                         Param0 Content
19085
19086                         Name   string
19087                         Groups []Group
19088
19089                         P1Type   Param1Type
19090                         P2Type   Param2Type
19091                         DrawType DrawType
19092
19093                         Mesh  string
19094                         Scale float32
19095                         //mt:const uint8(6)
19096                         Tiles        [6]TileDef
19097                         OverlayTiles [6]TileDef
19098                         //mt:const uint8(6)
19099                         SpecialTiles [6]TileDef
19100
19101                         Color   color.NRGBA
19102                         Palette Texture
19103
19104                         Waving       WaveType
19105                         ConnectSides uint8
19106                         ConnectTo    []Content
19107                         InsideTint   color.NRGBA
19108                         Level        uint8 // Must be < 128.
19109
19110                         Translucent bool // Sunlight is scattered and becomes normal light.
19111                         Transparent bool // Sunlight isn't scattered.
19112                         LightSrc    uint8
19113
19114                         GndContent   bool
19115                         Collides     bool
19116                         Pointable    bool
19117                         Diggable     bool
19118                         Climbable    bool
19119                         Replaceable  bool
19120                         OnRightClick bool
19121
19122                         DmgPerSec int32
19123
19124                         LiquidType   LiquidType
19125                         FlowingAlt   string
19126                         SrcAlt       string
19127                         Viscosity    uint8 // 0-7
19128                         LiqRenewable bool
19129                         FlowRange    uint8
19130                         DrownDmg     uint8
19131                         Floodable    bool
19132
19133                         DrawBox, ColBox, SelBox NodeBox
19134
19135                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19136
19137                         LegacyFaceDir bool
19138                         LegacyMounted bool
19139
19140                         DigPredict string
19141
19142                         MaxLvl uint8
19143
19144                         AlphaUse
19145                 }))(obj)).Mesh) = string(local254)
19146                 {
19147                         p := &(*(*(struct {
19148                                 Param0 Content
19149
19150                                 Name   string
19151                                 Groups []Group
19152
19153                                 P1Type   Param1Type
19154                                 P2Type   Param2Type
19155                                 DrawType DrawType
19156
19157                                 Mesh  string
19158                                 Scale float32
19159                                 //mt:const uint8(6)
19160                                 Tiles        [6]TileDef
19161                                 OverlayTiles [6]TileDef
19162                                 //mt:const uint8(6)
19163                                 SpecialTiles [6]TileDef
19164
19165                                 Color   color.NRGBA
19166                                 Palette Texture
19167
19168                                 Waving       WaveType
19169                                 ConnectSides uint8
19170                                 ConnectTo    []Content
19171                                 InsideTint   color.NRGBA
19172                                 Level        uint8 // Must be < 128.
19173
19174                                 Translucent bool // Sunlight is scattered and becomes normal light.
19175                                 Transparent bool // Sunlight isn't scattered.
19176                                 LightSrc    uint8
19177
19178                                 GndContent   bool
19179                                 Collides     bool
19180                                 Pointable    bool
19181                                 Diggable     bool
19182                                 Climbable    bool
19183                                 Replaceable  bool
19184                                 OnRightClick bool
19185
19186                                 DmgPerSec int32
19187
19188                                 LiquidType   LiquidType
19189                                 FlowingAlt   string
19190                                 SrcAlt       string
19191                                 Viscosity    uint8 // 0-7
19192                                 LiqRenewable bool
19193                                 FlowRange    uint8
19194                                 DrownDmg     uint8
19195                                 Floodable    bool
19196
19197                                 DrawBox, ColBox, SelBox NodeBox
19198
19199                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19200
19201                                 LegacyFaceDir bool
19202                                 LegacyMounted bool
19203
19204                                 DigPredict string
19205
19206                                 MaxLvl uint8
19207
19208                                 AlphaUse
19209                         }))(obj)).Scale
19210                         *p = math.Float32frombits(read32(r))
19211                 }
19212                 {
19213                         var local256 uint8
19214                         local257 := uint8(6)
19215                         {
19216                                 p := &local256
19217                                 *p = read8(r)
19218                         }
19219                         if local256 != local257 {
19220                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local256))
19221                         }
19222                 }
19223                 for local258 := range (*(*(struct {
19224                         Param0 Content
19225
19226                         Name   string
19227                         Groups []Group
19228
19229                         P1Type   Param1Type
19230                         P2Type   Param2Type
19231                         DrawType DrawType
19232
19233                         Mesh  string
19234                         Scale float32
19235                         //mt:const uint8(6)
19236                         Tiles        [6]TileDef
19237                         OverlayTiles [6]TileDef
19238                         //mt:const uint8(6)
19239                         SpecialTiles [6]TileDef
19240
19241                         Color   color.NRGBA
19242                         Palette Texture
19243
19244                         Waving       WaveType
19245                         ConnectSides uint8
19246                         ConnectTo    []Content
19247                         InsideTint   color.NRGBA
19248                         Level        uint8 // Must be < 128.
19249
19250                         Translucent bool // Sunlight is scattered and becomes normal light.
19251                         Transparent bool // Sunlight isn't scattered.
19252                         LightSrc    uint8
19253
19254                         GndContent   bool
19255                         Collides     bool
19256                         Pointable    bool
19257                         Diggable     bool
19258                         Climbable    bool
19259                         Replaceable  bool
19260                         OnRightClick bool
19261
19262                         DmgPerSec int32
19263
19264                         LiquidType   LiquidType
19265                         FlowingAlt   string
19266                         SrcAlt       string
19267                         Viscosity    uint8 // 0-7
19268                         LiqRenewable bool
19269                         FlowRange    uint8
19270                         DrownDmg     uint8
19271                         Floodable    bool
19272
19273                         DrawBox, ColBox, SelBox NodeBox
19274
19275                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19276
19277                         LegacyFaceDir bool
19278                         LegacyMounted bool
19279
19280                         DigPredict string
19281
19282                         MaxLvl uint8
19283
19284                         AlphaUse
19285                 }))(obj)).Tiles {
19286                         if err := pcall(func() {
19287                                 (((*(*(struct {
19288                                         Param0 Content
19289
19290                                         Name   string
19291                                         Groups []Group
19292
19293                                         P1Type   Param1Type
19294                                         P2Type   Param2Type
19295                                         DrawType DrawType
19296
19297                                         Mesh  string
19298                                         Scale float32
19299                                         //mt:const uint8(6)
19300                                         Tiles        [6]TileDef
19301                                         OverlayTiles [6]TileDef
19302                                         //mt:const uint8(6)
19303                                         SpecialTiles [6]TileDef
19304
19305                                         Color   color.NRGBA
19306                                         Palette Texture
19307
19308                                         Waving       WaveType
19309                                         ConnectSides uint8
19310                                         ConnectTo    []Content
19311                                         InsideTint   color.NRGBA
19312                                         Level        uint8 // Must be < 128.
19313
19314                                         Translucent bool // Sunlight is scattered and becomes normal light.
19315                                         Transparent bool // Sunlight isn't scattered.
19316                                         LightSrc    uint8
19317
19318                                         GndContent   bool
19319                                         Collides     bool
19320                                         Pointable    bool
19321                                         Diggable     bool
19322                                         Climbable    bool
19323                                         Replaceable  bool
19324                                         OnRightClick bool
19325
19326                                         DmgPerSec int32
19327
19328                                         LiquidType   LiquidType
19329                                         FlowingAlt   string
19330                                         SrcAlt       string
19331                                         Viscosity    uint8 // 0-7
19332                                         LiqRenewable bool
19333                                         FlowRange    uint8
19334                                         DrownDmg     uint8
19335                                         Floodable    bool
19336
19337                                         DrawBox, ColBox, SelBox NodeBox
19338
19339                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19340
19341                                         LegacyFaceDir bool
19342                                         LegacyMounted bool
19343
19344                                         DigPredict string
19345
19346                                         MaxLvl uint8
19347
19348                                         AlphaUse
19349                                 }))(obj)).Tiles)[local258]).deserialize(r)
19350                         }); err != nil {
19351                                 if err == io.EOF {
19352                                         chk(io.EOF)
19353                                 }
19354                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19355                         }
19356                 }
19357                 for local259 := range (*(*(struct {
19358                         Param0 Content
19359
19360                         Name   string
19361                         Groups []Group
19362
19363                         P1Type   Param1Type
19364                         P2Type   Param2Type
19365                         DrawType DrawType
19366
19367                         Mesh  string
19368                         Scale float32
19369                         //mt:const uint8(6)
19370                         Tiles        [6]TileDef
19371                         OverlayTiles [6]TileDef
19372                         //mt:const uint8(6)
19373                         SpecialTiles [6]TileDef
19374
19375                         Color   color.NRGBA
19376                         Palette Texture
19377
19378                         Waving       WaveType
19379                         ConnectSides uint8
19380                         ConnectTo    []Content
19381                         InsideTint   color.NRGBA
19382                         Level        uint8 // Must be < 128.
19383
19384                         Translucent bool // Sunlight is scattered and becomes normal light.
19385                         Transparent bool // Sunlight isn't scattered.
19386                         LightSrc    uint8
19387
19388                         GndContent   bool
19389                         Collides     bool
19390                         Pointable    bool
19391                         Diggable     bool
19392                         Climbable    bool
19393                         Replaceable  bool
19394                         OnRightClick bool
19395
19396                         DmgPerSec int32
19397
19398                         LiquidType   LiquidType
19399                         FlowingAlt   string
19400                         SrcAlt       string
19401                         Viscosity    uint8 // 0-7
19402                         LiqRenewable bool
19403                         FlowRange    uint8
19404                         DrownDmg     uint8
19405                         Floodable    bool
19406
19407                         DrawBox, ColBox, SelBox NodeBox
19408
19409                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19410
19411                         LegacyFaceDir bool
19412                         LegacyMounted bool
19413
19414                         DigPredict string
19415
19416                         MaxLvl uint8
19417
19418                         AlphaUse
19419                 }))(obj)).OverlayTiles {
19420                         if err := pcall(func() {
19421                                 (((*(*(struct {
19422                                         Param0 Content
19423
19424                                         Name   string
19425                                         Groups []Group
19426
19427                                         P1Type   Param1Type
19428                                         P2Type   Param2Type
19429                                         DrawType DrawType
19430
19431                                         Mesh  string
19432                                         Scale float32
19433                                         //mt:const uint8(6)
19434                                         Tiles        [6]TileDef
19435                                         OverlayTiles [6]TileDef
19436                                         //mt:const uint8(6)
19437                                         SpecialTiles [6]TileDef
19438
19439                                         Color   color.NRGBA
19440                                         Palette Texture
19441
19442                                         Waving       WaveType
19443                                         ConnectSides uint8
19444                                         ConnectTo    []Content
19445                                         InsideTint   color.NRGBA
19446                                         Level        uint8 // Must be < 128.
19447
19448                                         Translucent bool // Sunlight is scattered and becomes normal light.
19449                                         Transparent bool // Sunlight isn't scattered.
19450                                         LightSrc    uint8
19451
19452                                         GndContent   bool
19453                                         Collides     bool
19454                                         Pointable    bool
19455                                         Diggable     bool
19456                                         Climbable    bool
19457                                         Replaceable  bool
19458                                         OnRightClick bool
19459
19460                                         DmgPerSec int32
19461
19462                                         LiquidType   LiquidType
19463                                         FlowingAlt   string
19464                                         SrcAlt       string
19465                                         Viscosity    uint8 // 0-7
19466                                         LiqRenewable bool
19467                                         FlowRange    uint8
19468                                         DrownDmg     uint8
19469                                         Floodable    bool
19470
19471                                         DrawBox, ColBox, SelBox NodeBox
19472
19473                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19474
19475                                         LegacyFaceDir bool
19476                                         LegacyMounted bool
19477
19478                                         DigPredict string
19479
19480                                         MaxLvl uint8
19481
19482                                         AlphaUse
19483                                 }))(obj)).OverlayTiles)[local259]).deserialize(r)
19484                         }); err != nil {
19485                                 if err == io.EOF {
19486                                         chk(io.EOF)
19487                                 }
19488                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19489                         }
19490                 }
19491                 {
19492                         var local260 uint8
19493                         local261 := uint8(6)
19494                         {
19495                                 p := &local260
19496                                 *p = read8(r)
19497                         }
19498                         if local260 != local261 {
19499                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local260))
19500                         }
19501                 }
19502                 for local262 := range (*(*(struct {
19503                         Param0 Content
19504
19505                         Name   string
19506                         Groups []Group
19507
19508                         P1Type   Param1Type
19509                         P2Type   Param2Type
19510                         DrawType DrawType
19511
19512                         Mesh  string
19513                         Scale float32
19514                         //mt:const uint8(6)
19515                         Tiles        [6]TileDef
19516                         OverlayTiles [6]TileDef
19517                         //mt:const uint8(6)
19518                         SpecialTiles [6]TileDef
19519
19520                         Color   color.NRGBA
19521                         Palette Texture
19522
19523                         Waving       WaveType
19524                         ConnectSides uint8
19525                         ConnectTo    []Content
19526                         InsideTint   color.NRGBA
19527                         Level        uint8 // Must be < 128.
19528
19529                         Translucent bool // Sunlight is scattered and becomes normal light.
19530                         Transparent bool // Sunlight isn't scattered.
19531                         LightSrc    uint8
19532
19533                         GndContent   bool
19534                         Collides     bool
19535                         Pointable    bool
19536                         Diggable     bool
19537                         Climbable    bool
19538                         Replaceable  bool
19539                         OnRightClick bool
19540
19541                         DmgPerSec int32
19542
19543                         LiquidType   LiquidType
19544                         FlowingAlt   string
19545                         SrcAlt       string
19546                         Viscosity    uint8 // 0-7
19547                         LiqRenewable bool
19548                         FlowRange    uint8
19549                         DrownDmg     uint8
19550                         Floodable    bool
19551
19552                         DrawBox, ColBox, SelBox NodeBox
19553
19554                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19555
19556                         LegacyFaceDir bool
19557                         LegacyMounted bool
19558
19559                         DigPredict string
19560
19561                         MaxLvl uint8
19562
19563                         AlphaUse
19564                 }))(obj)).SpecialTiles {
19565                         if err := pcall(func() {
19566                                 (((*(*(struct {
19567                                         Param0 Content
19568
19569                                         Name   string
19570                                         Groups []Group
19571
19572                                         P1Type   Param1Type
19573                                         P2Type   Param2Type
19574                                         DrawType DrawType
19575
19576                                         Mesh  string
19577                                         Scale float32
19578                                         //mt:const uint8(6)
19579                                         Tiles        [6]TileDef
19580                                         OverlayTiles [6]TileDef
19581                                         //mt:const uint8(6)
19582                                         SpecialTiles [6]TileDef
19583
19584                                         Color   color.NRGBA
19585                                         Palette Texture
19586
19587                                         Waving       WaveType
19588                                         ConnectSides uint8
19589                                         ConnectTo    []Content
19590                                         InsideTint   color.NRGBA
19591                                         Level        uint8 // Must be < 128.
19592
19593                                         Translucent bool // Sunlight is scattered and becomes normal light.
19594                                         Transparent bool // Sunlight isn't scattered.
19595                                         LightSrc    uint8
19596
19597                                         GndContent   bool
19598                                         Collides     bool
19599                                         Pointable    bool
19600                                         Diggable     bool
19601                                         Climbable    bool
19602                                         Replaceable  bool
19603                                         OnRightClick bool
19604
19605                                         DmgPerSec int32
19606
19607                                         LiquidType   LiquidType
19608                                         FlowingAlt   string
19609                                         SrcAlt       string
19610                                         Viscosity    uint8 // 0-7
19611                                         LiqRenewable bool
19612                                         FlowRange    uint8
19613                                         DrownDmg     uint8
19614                                         Floodable    bool
19615
19616                                         DrawBox, ColBox, SelBox NodeBox
19617
19618                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19619
19620                                         LegacyFaceDir bool
19621                                         LegacyMounted bool
19622
19623                                         DigPredict string
19624
19625                                         MaxLvl uint8
19626
19627                                         AlphaUse
19628                                 }))(obj)).SpecialTiles)[local262]).deserialize(r)
19629                         }); err != nil {
19630                                 if err == io.EOF {
19631                                         chk(io.EOF)
19632                                 }
19633                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
19634                         }
19635                 }
19636                 {
19637                         p := &(*(*(struct {
19638                                 Param0 Content
19639
19640                                 Name   string
19641                                 Groups []Group
19642
19643                                 P1Type   Param1Type
19644                                 P2Type   Param2Type
19645                                 DrawType DrawType
19646
19647                                 Mesh  string
19648                                 Scale float32
19649                                 //mt:const uint8(6)
19650                                 Tiles        [6]TileDef
19651                                 OverlayTiles [6]TileDef
19652                                 //mt:const uint8(6)
19653                                 SpecialTiles [6]TileDef
19654
19655                                 Color   color.NRGBA
19656                                 Palette Texture
19657
19658                                 Waving       WaveType
19659                                 ConnectSides uint8
19660                                 ConnectTo    []Content
19661                                 InsideTint   color.NRGBA
19662                                 Level        uint8 // Must be < 128.
19663
19664                                 Translucent bool // Sunlight is scattered and becomes normal light.
19665                                 Transparent bool // Sunlight isn't scattered.
19666                                 LightSrc    uint8
19667
19668                                 GndContent   bool
19669                                 Collides     bool
19670                                 Pointable    bool
19671                                 Diggable     bool
19672                                 Climbable    bool
19673                                 Replaceable  bool
19674                                 OnRightClick bool
19675
19676                                 DmgPerSec int32
19677
19678                                 LiquidType   LiquidType
19679                                 FlowingAlt   string
19680                                 SrcAlt       string
19681                                 Viscosity    uint8 // 0-7
19682                                 LiqRenewable bool
19683                                 FlowRange    uint8
19684                                 DrownDmg     uint8
19685                                 Floodable    bool
19686
19687                                 DrawBox, ColBox, SelBox NodeBox
19688
19689                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19690
19691                                 LegacyFaceDir bool
19692                                 LegacyMounted bool
19693
19694                                 DigPredict string
19695
19696                                 MaxLvl uint8
19697
19698                                 AlphaUse
19699                         }))(obj)).Color
19700                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
19701
19702                 }
19703                 if err := pcall(func() {
19704                         ((*(*(struct {
19705                                 Param0 Content
19706
19707                                 Name   string
19708                                 Groups []Group
19709
19710                                 P1Type   Param1Type
19711                                 P2Type   Param2Type
19712                                 DrawType DrawType
19713
19714                                 Mesh  string
19715                                 Scale float32
19716                                 //mt:const uint8(6)
19717                                 Tiles        [6]TileDef
19718                                 OverlayTiles [6]TileDef
19719                                 //mt:const uint8(6)
19720                                 SpecialTiles [6]TileDef
19721
19722                                 Color   color.NRGBA
19723                                 Palette Texture
19724
19725                                 Waving       WaveType
19726                                 ConnectSides uint8
19727                                 ConnectTo    []Content
19728                                 InsideTint   color.NRGBA
19729                                 Level        uint8 // Must be < 128.
19730
19731                                 Translucent bool // Sunlight is scattered and becomes normal light.
19732                                 Transparent bool // Sunlight isn't scattered.
19733                                 LightSrc    uint8
19734
19735                                 GndContent   bool
19736                                 Collides     bool
19737                                 Pointable    bool
19738                                 Diggable     bool
19739                                 Climbable    bool
19740                                 Replaceable  bool
19741                                 OnRightClick bool
19742
19743                                 DmgPerSec int32
19744
19745                                 LiquidType   LiquidType
19746                                 FlowingAlt   string
19747                                 SrcAlt       string
19748                                 Viscosity    uint8 // 0-7
19749                                 LiqRenewable bool
19750                                 FlowRange    uint8
19751                                 DrownDmg     uint8
19752                                 Floodable    bool
19753
19754                                 DrawBox, ColBox, SelBox NodeBox
19755
19756                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19757
19758                                 LegacyFaceDir bool
19759                                 LegacyMounted bool
19760
19761                                 DigPredict string
19762
19763                                 MaxLvl uint8
19764
19765                                 AlphaUse
19766                         }))(obj)).Palette).deserialize(r)
19767                 }); err != nil {
19768                         if err == io.EOF {
19769                                 chk(io.EOF)
19770                         }
19771                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
19772                 }
19773                 if err := pcall(func() {
19774                         ((*(*(struct {
19775                                 Param0 Content
19776
19777                                 Name   string
19778                                 Groups []Group
19779
19780                                 P1Type   Param1Type
19781                                 P2Type   Param2Type
19782                                 DrawType DrawType
19783
19784                                 Mesh  string
19785                                 Scale float32
19786                                 //mt:const uint8(6)
19787                                 Tiles        [6]TileDef
19788                                 OverlayTiles [6]TileDef
19789                                 //mt:const uint8(6)
19790                                 SpecialTiles [6]TileDef
19791
19792                                 Color   color.NRGBA
19793                                 Palette Texture
19794
19795                                 Waving       WaveType
19796                                 ConnectSides uint8
19797                                 ConnectTo    []Content
19798                                 InsideTint   color.NRGBA
19799                                 Level        uint8 // Must be < 128.
19800
19801                                 Translucent bool // Sunlight is scattered and becomes normal light.
19802                                 Transparent bool // Sunlight isn't scattered.
19803                                 LightSrc    uint8
19804
19805                                 GndContent   bool
19806                                 Collides     bool
19807                                 Pointable    bool
19808                                 Diggable     bool
19809                                 Climbable    bool
19810                                 Replaceable  bool
19811                                 OnRightClick bool
19812
19813                                 DmgPerSec int32
19814
19815                                 LiquidType   LiquidType
19816                                 FlowingAlt   string
19817                                 SrcAlt       string
19818                                 Viscosity    uint8 // 0-7
19819                                 LiqRenewable bool
19820                                 FlowRange    uint8
19821                                 DrownDmg     uint8
19822                                 Floodable    bool
19823
19824                                 DrawBox, ColBox, SelBox NodeBox
19825
19826                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19827
19828                                 LegacyFaceDir bool
19829                                 LegacyMounted bool
19830
19831                                 DigPredict string
19832
19833                                 MaxLvl uint8
19834
19835                                 AlphaUse
19836                         }))(obj)).Waving).deserialize(r)
19837                 }); err != nil {
19838                         if err == io.EOF {
19839                                 chk(io.EOF)
19840                         }
19841                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.WaveType", err))
19842                 }
19843                 {
19844                         p := &(*(*(struct {
19845                                 Param0 Content
19846
19847                                 Name   string
19848                                 Groups []Group
19849
19850                                 P1Type   Param1Type
19851                                 P2Type   Param2Type
19852                                 DrawType DrawType
19853
19854                                 Mesh  string
19855                                 Scale float32
19856                                 //mt:const uint8(6)
19857                                 Tiles        [6]TileDef
19858                                 OverlayTiles [6]TileDef
19859                                 //mt:const uint8(6)
19860                                 SpecialTiles [6]TileDef
19861
19862                                 Color   color.NRGBA
19863                                 Palette Texture
19864
19865                                 Waving       WaveType
19866                                 ConnectSides uint8
19867                                 ConnectTo    []Content
19868                                 InsideTint   color.NRGBA
19869                                 Level        uint8 // Must be < 128.
19870
19871                                 Translucent bool // Sunlight is scattered and becomes normal light.
19872                                 Transparent bool // Sunlight isn't scattered.
19873                                 LightSrc    uint8
19874
19875                                 GndContent   bool
19876                                 Collides     bool
19877                                 Pointable    bool
19878                                 Diggable     bool
19879                                 Climbable    bool
19880                                 Replaceable  bool
19881                                 OnRightClick bool
19882
19883                                 DmgPerSec int32
19884
19885                                 LiquidType   LiquidType
19886                                 FlowingAlt   string
19887                                 SrcAlt       string
19888                                 Viscosity    uint8 // 0-7
19889                                 LiqRenewable bool
19890                                 FlowRange    uint8
19891                                 DrownDmg     uint8
19892                                 Floodable    bool
19893
19894                                 DrawBox, ColBox, SelBox NodeBox
19895
19896                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19897
19898                                 LegacyFaceDir bool
19899                                 LegacyMounted bool
19900
19901                                 DigPredict string
19902
19903                                 MaxLvl uint8
19904
19905                                 AlphaUse
19906                         }))(obj)).ConnectSides
19907                         *p = read8(r)
19908                 }
19909                 var local263 uint16
19910                 {
19911                         p := &local263
19912                         *p = read16(r)
19913                 }
19914                 ((*(*(struct {
19915                         Param0 Content
19916
19917                         Name   string
19918                         Groups []Group
19919
19920                         P1Type   Param1Type
19921                         P2Type   Param2Type
19922                         DrawType DrawType
19923
19924                         Mesh  string
19925                         Scale float32
19926                         //mt:const uint8(6)
19927                         Tiles        [6]TileDef
19928                         OverlayTiles [6]TileDef
19929                         //mt:const uint8(6)
19930                         SpecialTiles [6]TileDef
19931
19932                         Color   color.NRGBA
19933                         Palette Texture
19934
19935                         Waving       WaveType
19936                         ConnectSides uint8
19937                         ConnectTo    []Content
19938                         InsideTint   color.NRGBA
19939                         Level        uint8 // Must be < 128.
19940
19941                         Translucent bool // Sunlight is scattered and becomes normal light.
19942                         Transparent bool // Sunlight isn't scattered.
19943                         LightSrc    uint8
19944
19945                         GndContent   bool
19946                         Collides     bool
19947                         Pointable    bool
19948                         Diggable     bool
19949                         Climbable    bool
19950                         Replaceable  bool
19951                         OnRightClick bool
19952
19953                         DmgPerSec int32
19954
19955                         LiquidType   LiquidType
19956                         FlowingAlt   string
19957                         SrcAlt       string
19958                         Viscosity    uint8 // 0-7
19959                         LiqRenewable bool
19960                         FlowRange    uint8
19961                         DrownDmg     uint8
19962                         Floodable    bool
19963
19964                         DrawBox, ColBox, SelBox NodeBox
19965
19966                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19967
19968                         LegacyFaceDir bool
19969                         LegacyMounted bool
19970
19971                         DigPredict string
19972
19973                         MaxLvl uint8
19974
19975                         AlphaUse
19976                 }))(obj)).ConnectTo) = make([]Content, local263)
19977                 for local264 := range (*(*(struct {
19978                         Param0 Content
19979
19980                         Name   string
19981                         Groups []Group
19982
19983                         P1Type   Param1Type
19984                         P2Type   Param2Type
19985                         DrawType DrawType
19986
19987                         Mesh  string
19988                         Scale float32
19989                         //mt:const uint8(6)
19990                         Tiles        [6]TileDef
19991                         OverlayTiles [6]TileDef
19992                         //mt:const uint8(6)
19993                         SpecialTiles [6]TileDef
19994
19995                         Color   color.NRGBA
19996                         Palette Texture
19997
19998                         Waving       WaveType
19999                         ConnectSides uint8
20000                         ConnectTo    []Content
20001                         InsideTint   color.NRGBA
20002                         Level        uint8 // Must be < 128.
20003
20004                         Translucent bool // Sunlight is scattered and becomes normal light.
20005                         Transparent bool // Sunlight isn't scattered.
20006                         LightSrc    uint8
20007
20008                         GndContent   bool
20009                         Collides     bool
20010                         Pointable    bool
20011                         Diggable     bool
20012                         Climbable    bool
20013                         Replaceable  bool
20014                         OnRightClick bool
20015
20016                         DmgPerSec int32
20017
20018                         LiquidType   LiquidType
20019                         FlowingAlt   string
20020                         SrcAlt       string
20021                         Viscosity    uint8 // 0-7
20022                         LiqRenewable bool
20023                         FlowRange    uint8
20024                         DrownDmg     uint8
20025                         Floodable    bool
20026
20027                         DrawBox, ColBox, SelBox NodeBox
20028
20029                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20030
20031                         LegacyFaceDir bool
20032                         LegacyMounted bool
20033
20034                         DigPredict string
20035
20036                         MaxLvl uint8
20037
20038                         AlphaUse
20039                 }))(obj)).ConnectTo {
20040                         if err := pcall(func() {
20041                                 (((*(*(struct {
20042                                         Param0 Content
20043
20044                                         Name   string
20045                                         Groups []Group
20046
20047                                         P1Type   Param1Type
20048                                         P2Type   Param2Type
20049                                         DrawType DrawType
20050
20051                                         Mesh  string
20052                                         Scale float32
20053                                         //mt:const uint8(6)
20054                                         Tiles        [6]TileDef
20055                                         OverlayTiles [6]TileDef
20056                                         //mt:const uint8(6)
20057                                         SpecialTiles [6]TileDef
20058
20059                                         Color   color.NRGBA
20060                                         Palette Texture
20061
20062                                         Waving       WaveType
20063                                         ConnectSides uint8
20064                                         ConnectTo    []Content
20065                                         InsideTint   color.NRGBA
20066                                         Level        uint8 // Must be < 128.
20067
20068                                         Translucent bool // Sunlight is scattered and becomes normal light.
20069                                         Transparent bool // Sunlight isn't scattered.
20070                                         LightSrc    uint8
20071
20072                                         GndContent   bool
20073                                         Collides     bool
20074                                         Pointable    bool
20075                                         Diggable     bool
20076                                         Climbable    bool
20077                                         Replaceable  bool
20078                                         OnRightClick bool
20079
20080                                         DmgPerSec int32
20081
20082                                         LiquidType   LiquidType
20083                                         FlowingAlt   string
20084                                         SrcAlt       string
20085                                         Viscosity    uint8 // 0-7
20086                                         LiqRenewable bool
20087                                         FlowRange    uint8
20088                                         DrownDmg     uint8
20089                                         Floodable    bool
20090
20091                                         DrawBox, ColBox, SelBox NodeBox
20092
20093                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20094
20095                                         LegacyFaceDir bool
20096                                         LegacyMounted bool
20097
20098                                         DigPredict string
20099
20100                                         MaxLvl uint8
20101
20102                                         AlphaUse
20103                                 }))(obj)).ConnectTo)[local264]).deserialize(r)
20104                         }); err != nil {
20105                                 if err == io.EOF {
20106                                         chk(io.EOF)
20107                                 }
20108                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
20109                         }
20110                 }
20111                 {
20112                         p := &(*(*(struct {
20113                                 Param0 Content
20114
20115                                 Name   string
20116                                 Groups []Group
20117
20118                                 P1Type   Param1Type
20119                                 P2Type   Param2Type
20120                                 DrawType DrawType
20121
20122                                 Mesh  string
20123                                 Scale float32
20124                                 //mt:const uint8(6)
20125                                 Tiles        [6]TileDef
20126                                 OverlayTiles [6]TileDef
20127                                 //mt:const uint8(6)
20128                                 SpecialTiles [6]TileDef
20129
20130                                 Color   color.NRGBA
20131                                 Palette Texture
20132
20133                                 Waving       WaveType
20134                                 ConnectSides uint8
20135                                 ConnectTo    []Content
20136                                 InsideTint   color.NRGBA
20137                                 Level        uint8 // Must be < 128.
20138
20139                                 Translucent bool // Sunlight is scattered and becomes normal light.
20140                                 Transparent bool // Sunlight isn't scattered.
20141                                 LightSrc    uint8
20142
20143                                 GndContent   bool
20144                                 Collides     bool
20145                                 Pointable    bool
20146                                 Diggable     bool
20147                                 Climbable    bool
20148                                 Replaceable  bool
20149                                 OnRightClick bool
20150
20151                                 DmgPerSec int32
20152
20153                                 LiquidType   LiquidType
20154                                 FlowingAlt   string
20155                                 SrcAlt       string
20156                                 Viscosity    uint8 // 0-7
20157                                 LiqRenewable bool
20158                                 FlowRange    uint8
20159                                 DrownDmg     uint8
20160                                 Floodable    bool
20161
20162                                 DrawBox, ColBox, SelBox NodeBox
20163
20164                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20165
20166                                 LegacyFaceDir bool
20167                                 LegacyMounted bool
20168
20169                                 DigPredict string
20170
20171                                 MaxLvl uint8
20172
20173                                 AlphaUse
20174                         }))(obj)).InsideTint
20175                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20176
20177                 }
20178                 {
20179                         p := &(*(*(struct {
20180                                 Param0 Content
20181
20182                                 Name   string
20183                                 Groups []Group
20184
20185                                 P1Type   Param1Type
20186                                 P2Type   Param2Type
20187                                 DrawType DrawType
20188
20189                                 Mesh  string
20190                                 Scale float32
20191                                 //mt:const uint8(6)
20192                                 Tiles        [6]TileDef
20193                                 OverlayTiles [6]TileDef
20194                                 //mt:const uint8(6)
20195                                 SpecialTiles [6]TileDef
20196
20197                                 Color   color.NRGBA
20198                                 Palette Texture
20199
20200                                 Waving       WaveType
20201                                 ConnectSides uint8
20202                                 ConnectTo    []Content
20203                                 InsideTint   color.NRGBA
20204                                 Level        uint8 // Must be < 128.
20205
20206                                 Translucent bool // Sunlight is scattered and becomes normal light.
20207                                 Transparent bool // Sunlight isn't scattered.
20208                                 LightSrc    uint8
20209
20210                                 GndContent   bool
20211                                 Collides     bool
20212                                 Pointable    bool
20213                                 Diggable     bool
20214                                 Climbable    bool
20215                                 Replaceable  bool
20216                                 OnRightClick bool
20217
20218                                 DmgPerSec int32
20219
20220                                 LiquidType   LiquidType
20221                                 FlowingAlt   string
20222                                 SrcAlt       string
20223                                 Viscosity    uint8 // 0-7
20224                                 LiqRenewable bool
20225                                 FlowRange    uint8
20226                                 DrownDmg     uint8
20227                                 Floodable    bool
20228
20229                                 DrawBox, ColBox, SelBox NodeBox
20230
20231                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20232
20233                                 LegacyFaceDir bool
20234                                 LegacyMounted bool
20235
20236                                 DigPredict string
20237
20238                                 MaxLvl uint8
20239
20240                                 AlphaUse
20241                         }))(obj)).Level
20242                         *p = read8(r)
20243                 }
20244                 {
20245                         p := &(*(*(struct {
20246                                 Param0 Content
20247
20248                                 Name   string
20249                                 Groups []Group
20250
20251                                 P1Type   Param1Type
20252                                 P2Type   Param2Type
20253                                 DrawType DrawType
20254
20255                                 Mesh  string
20256                                 Scale float32
20257                                 //mt:const uint8(6)
20258                                 Tiles        [6]TileDef
20259                                 OverlayTiles [6]TileDef
20260                                 //mt:const uint8(6)
20261                                 SpecialTiles [6]TileDef
20262
20263                                 Color   color.NRGBA
20264                                 Palette Texture
20265
20266                                 Waving       WaveType
20267                                 ConnectSides uint8
20268                                 ConnectTo    []Content
20269                                 InsideTint   color.NRGBA
20270                                 Level        uint8 // Must be < 128.
20271
20272                                 Translucent bool // Sunlight is scattered and becomes normal light.
20273                                 Transparent bool // Sunlight isn't scattered.
20274                                 LightSrc    uint8
20275
20276                                 GndContent   bool
20277                                 Collides     bool
20278                                 Pointable    bool
20279                                 Diggable     bool
20280                                 Climbable    bool
20281                                 Replaceable  bool
20282                                 OnRightClick bool
20283
20284                                 DmgPerSec int32
20285
20286                                 LiquidType   LiquidType
20287                                 FlowingAlt   string
20288                                 SrcAlt       string
20289                                 Viscosity    uint8 // 0-7
20290                                 LiqRenewable bool
20291                                 FlowRange    uint8
20292                                 DrownDmg     uint8
20293                                 Floodable    bool
20294
20295                                 DrawBox, ColBox, SelBox NodeBox
20296
20297                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20298
20299                                 LegacyFaceDir bool
20300                                 LegacyMounted bool
20301
20302                                 DigPredict string
20303
20304                                 MaxLvl uint8
20305
20306                                 AlphaUse
20307                         }))(obj)).Translucent
20308                         switch n := read8(r); n {
20309                         case 0:
20310                                 *p = false
20311                         case 1:
20312                                 *p = true
20313                         default:
20314                                 chk(fmt.Errorf("invalid bool: %d", n))
20315                         }
20316
20317                 }
20318                 {
20319                         p := &(*(*(struct {
20320                                 Param0 Content
20321
20322                                 Name   string
20323                                 Groups []Group
20324
20325                                 P1Type   Param1Type
20326                                 P2Type   Param2Type
20327                                 DrawType DrawType
20328
20329                                 Mesh  string
20330                                 Scale float32
20331                                 //mt:const uint8(6)
20332                                 Tiles        [6]TileDef
20333                                 OverlayTiles [6]TileDef
20334                                 //mt:const uint8(6)
20335                                 SpecialTiles [6]TileDef
20336
20337                                 Color   color.NRGBA
20338                                 Palette Texture
20339
20340                                 Waving       WaveType
20341                                 ConnectSides uint8
20342                                 ConnectTo    []Content
20343                                 InsideTint   color.NRGBA
20344                                 Level        uint8 // Must be < 128.
20345
20346                                 Translucent bool // Sunlight is scattered and becomes normal light.
20347                                 Transparent bool // Sunlight isn't scattered.
20348                                 LightSrc    uint8
20349
20350                                 GndContent   bool
20351                                 Collides     bool
20352                                 Pointable    bool
20353                                 Diggable     bool
20354                                 Climbable    bool
20355                                 Replaceable  bool
20356                                 OnRightClick bool
20357
20358                                 DmgPerSec int32
20359
20360                                 LiquidType   LiquidType
20361                                 FlowingAlt   string
20362                                 SrcAlt       string
20363                                 Viscosity    uint8 // 0-7
20364                                 LiqRenewable bool
20365                                 FlowRange    uint8
20366                                 DrownDmg     uint8
20367                                 Floodable    bool
20368
20369                                 DrawBox, ColBox, SelBox NodeBox
20370
20371                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20372
20373                                 LegacyFaceDir bool
20374                                 LegacyMounted bool
20375
20376                                 DigPredict string
20377
20378                                 MaxLvl uint8
20379
20380                                 AlphaUse
20381                         }))(obj)).Transparent
20382                         switch n := read8(r); n {
20383                         case 0:
20384                                 *p = false
20385                         case 1:
20386                                 *p = true
20387                         default:
20388                                 chk(fmt.Errorf("invalid bool: %d", n))
20389                         }
20390
20391                 }
20392                 {
20393                         p := &(*(*(struct {
20394                                 Param0 Content
20395
20396                                 Name   string
20397                                 Groups []Group
20398
20399                                 P1Type   Param1Type
20400                                 P2Type   Param2Type
20401                                 DrawType DrawType
20402
20403                                 Mesh  string
20404                                 Scale float32
20405                                 //mt:const uint8(6)
20406                                 Tiles        [6]TileDef
20407                                 OverlayTiles [6]TileDef
20408                                 //mt:const uint8(6)
20409                                 SpecialTiles [6]TileDef
20410
20411                                 Color   color.NRGBA
20412                                 Palette Texture
20413
20414                                 Waving       WaveType
20415                                 ConnectSides uint8
20416                                 ConnectTo    []Content
20417                                 InsideTint   color.NRGBA
20418                                 Level        uint8 // Must be < 128.
20419
20420                                 Translucent bool // Sunlight is scattered and becomes normal light.
20421                                 Transparent bool // Sunlight isn't scattered.
20422                                 LightSrc    uint8
20423
20424                                 GndContent   bool
20425                                 Collides     bool
20426                                 Pointable    bool
20427                                 Diggable     bool
20428                                 Climbable    bool
20429                                 Replaceable  bool
20430                                 OnRightClick bool
20431
20432                                 DmgPerSec int32
20433
20434                                 LiquidType   LiquidType
20435                                 FlowingAlt   string
20436                                 SrcAlt       string
20437                                 Viscosity    uint8 // 0-7
20438                                 LiqRenewable bool
20439                                 FlowRange    uint8
20440                                 DrownDmg     uint8
20441                                 Floodable    bool
20442
20443                                 DrawBox, ColBox, SelBox NodeBox
20444
20445                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20446
20447                                 LegacyFaceDir bool
20448                                 LegacyMounted bool
20449
20450                                 DigPredict string
20451
20452                                 MaxLvl uint8
20453
20454                                 AlphaUse
20455                         }))(obj)).LightSrc
20456                         *p = read8(r)
20457                 }
20458                 {
20459                         p := &(*(*(struct {
20460                                 Param0 Content
20461
20462                                 Name   string
20463                                 Groups []Group
20464
20465                                 P1Type   Param1Type
20466                                 P2Type   Param2Type
20467                                 DrawType DrawType
20468
20469                                 Mesh  string
20470                                 Scale float32
20471                                 //mt:const uint8(6)
20472                                 Tiles        [6]TileDef
20473                                 OverlayTiles [6]TileDef
20474                                 //mt:const uint8(6)
20475                                 SpecialTiles [6]TileDef
20476
20477                                 Color   color.NRGBA
20478                                 Palette Texture
20479
20480                                 Waving       WaveType
20481                                 ConnectSides uint8
20482                                 ConnectTo    []Content
20483                                 InsideTint   color.NRGBA
20484                                 Level        uint8 // Must be < 128.
20485
20486                                 Translucent bool // Sunlight is scattered and becomes normal light.
20487                                 Transparent bool // Sunlight isn't scattered.
20488                                 LightSrc    uint8
20489
20490                                 GndContent   bool
20491                                 Collides     bool
20492                                 Pointable    bool
20493                                 Diggable     bool
20494                                 Climbable    bool
20495                                 Replaceable  bool
20496                                 OnRightClick bool
20497
20498                                 DmgPerSec int32
20499
20500                                 LiquidType   LiquidType
20501                                 FlowingAlt   string
20502                                 SrcAlt       string
20503                                 Viscosity    uint8 // 0-7
20504                                 LiqRenewable bool
20505                                 FlowRange    uint8
20506                                 DrownDmg     uint8
20507                                 Floodable    bool
20508
20509                                 DrawBox, ColBox, SelBox NodeBox
20510
20511                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20512
20513                                 LegacyFaceDir bool
20514                                 LegacyMounted bool
20515
20516                                 DigPredict string
20517
20518                                 MaxLvl uint8
20519
20520                                 AlphaUse
20521                         }))(obj)).GndContent
20522                         switch n := read8(r); n {
20523                         case 0:
20524                                 *p = false
20525                         case 1:
20526                                 *p = true
20527                         default:
20528                                 chk(fmt.Errorf("invalid bool: %d", n))
20529                         }
20530
20531                 }
20532                 {
20533                         p := &(*(*(struct {
20534                                 Param0 Content
20535
20536                                 Name   string
20537                                 Groups []Group
20538
20539                                 P1Type   Param1Type
20540                                 P2Type   Param2Type
20541                                 DrawType DrawType
20542
20543                                 Mesh  string
20544                                 Scale float32
20545                                 //mt:const uint8(6)
20546                                 Tiles        [6]TileDef
20547                                 OverlayTiles [6]TileDef
20548                                 //mt:const uint8(6)
20549                                 SpecialTiles [6]TileDef
20550
20551                                 Color   color.NRGBA
20552                                 Palette Texture
20553
20554                                 Waving       WaveType
20555                                 ConnectSides uint8
20556                                 ConnectTo    []Content
20557                                 InsideTint   color.NRGBA
20558                                 Level        uint8 // Must be < 128.
20559
20560                                 Translucent bool // Sunlight is scattered and becomes normal light.
20561                                 Transparent bool // Sunlight isn't scattered.
20562                                 LightSrc    uint8
20563
20564                                 GndContent   bool
20565                                 Collides     bool
20566                                 Pointable    bool
20567                                 Diggable     bool
20568                                 Climbable    bool
20569                                 Replaceable  bool
20570                                 OnRightClick bool
20571
20572                                 DmgPerSec int32
20573
20574                                 LiquidType   LiquidType
20575                                 FlowingAlt   string
20576                                 SrcAlt       string
20577                                 Viscosity    uint8 // 0-7
20578                                 LiqRenewable bool
20579                                 FlowRange    uint8
20580                                 DrownDmg     uint8
20581                                 Floodable    bool
20582
20583                                 DrawBox, ColBox, SelBox NodeBox
20584
20585                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20586
20587                                 LegacyFaceDir bool
20588                                 LegacyMounted bool
20589
20590                                 DigPredict string
20591
20592                                 MaxLvl uint8
20593
20594                                 AlphaUse
20595                         }))(obj)).Collides
20596                         switch n := read8(r); n {
20597                         case 0:
20598                                 *p = false
20599                         case 1:
20600                                 *p = true
20601                         default:
20602                                 chk(fmt.Errorf("invalid bool: %d", n))
20603                         }
20604
20605                 }
20606                 {
20607                         p := &(*(*(struct {
20608                                 Param0 Content
20609
20610                                 Name   string
20611                                 Groups []Group
20612
20613                                 P1Type   Param1Type
20614                                 P2Type   Param2Type
20615                                 DrawType DrawType
20616
20617                                 Mesh  string
20618                                 Scale float32
20619                                 //mt:const uint8(6)
20620                                 Tiles        [6]TileDef
20621                                 OverlayTiles [6]TileDef
20622                                 //mt:const uint8(6)
20623                                 SpecialTiles [6]TileDef
20624
20625                                 Color   color.NRGBA
20626                                 Palette Texture
20627
20628                                 Waving       WaveType
20629                                 ConnectSides uint8
20630                                 ConnectTo    []Content
20631                                 InsideTint   color.NRGBA
20632                                 Level        uint8 // Must be < 128.
20633
20634                                 Translucent bool // Sunlight is scattered and becomes normal light.
20635                                 Transparent bool // Sunlight isn't scattered.
20636                                 LightSrc    uint8
20637
20638                                 GndContent   bool
20639                                 Collides     bool
20640                                 Pointable    bool
20641                                 Diggable     bool
20642                                 Climbable    bool
20643                                 Replaceable  bool
20644                                 OnRightClick bool
20645
20646                                 DmgPerSec int32
20647
20648                                 LiquidType   LiquidType
20649                                 FlowingAlt   string
20650                                 SrcAlt       string
20651                                 Viscosity    uint8 // 0-7
20652                                 LiqRenewable bool
20653                                 FlowRange    uint8
20654                                 DrownDmg     uint8
20655                                 Floodable    bool
20656
20657                                 DrawBox, ColBox, SelBox NodeBox
20658
20659                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20660
20661                                 LegacyFaceDir bool
20662                                 LegacyMounted bool
20663
20664                                 DigPredict string
20665
20666                                 MaxLvl uint8
20667
20668                                 AlphaUse
20669                         }))(obj)).Pointable
20670                         switch n := read8(r); n {
20671                         case 0:
20672                                 *p = false
20673                         case 1:
20674                                 *p = true
20675                         default:
20676                                 chk(fmt.Errorf("invalid bool: %d", n))
20677                         }
20678
20679                 }
20680                 {
20681                         p := &(*(*(struct {
20682                                 Param0 Content
20683
20684                                 Name   string
20685                                 Groups []Group
20686
20687                                 P1Type   Param1Type
20688                                 P2Type   Param2Type
20689                                 DrawType DrawType
20690
20691                                 Mesh  string
20692                                 Scale float32
20693                                 //mt:const uint8(6)
20694                                 Tiles        [6]TileDef
20695                                 OverlayTiles [6]TileDef
20696                                 //mt:const uint8(6)
20697                                 SpecialTiles [6]TileDef
20698
20699                                 Color   color.NRGBA
20700                                 Palette Texture
20701
20702                                 Waving       WaveType
20703                                 ConnectSides uint8
20704                                 ConnectTo    []Content
20705                                 InsideTint   color.NRGBA
20706                                 Level        uint8 // Must be < 128.
20707
20708                                 Translucent bool // Sunlight is scattered and becomes normal light.
20709                                 Transparent bool // Sunlight isn't scattered.
20710                                 LightSrc    uint8
20711
20712                                 GndContent   bool
20713                                 Collides     bool
20714                                 Pointable    bool
20715                                 Diggable     bool
20716                                 Climbable    bool
20717                                 Replaceable  bool
20718                                 OnRightClick bool
20719
20720                                 DmgPerSec int32
20721
20722                                 LiquidType   LiquidType
20723                                 FlowingAlt   string
20724                                 SrcAlt       string
20725                                 Viscosity    uint8 // 0-7
20726                                 LiqRenewable bool
20727                                 FlowRange    uint8
20728                                 DrownDmg     uint8
20729                                 Floodable    bool
20730
20731                                 DrawBox, ColBox, SelBox NodeBox
20732
20733                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20734
20735                                 LegacyFaceDir bool
20736                                 LegacyMounted bool
20737
20738                                 DigPredict string
20739
20740                                 MaxLvl uint8
20741
20742                                 AlphaUse
20743                         }))(obj)).Diggable
20744                         switch n := read8(r); n {
20745                         case 0:
20746                                 *p = false
20747                         case 1:
20748                                 *p = true
20749                         default:
20750                                 chk(fmt.Errorf("invalid bool: %d", n))
20751                         }
20752
20753                 }
20754                 {
20755                         p := &(*(*(struct {
20756                                 Param0 Content
20757
20758                                 Name   string
20759                                 Groups []Group
20760
20761                                 P1Type   Param1Type
20762                                 P2Type   Param2Type
20763                                 DrawType DrawType
20764
20765                                 Mesh  string
20766                                 Scale float32
20767                                 //mt:const uint8(6)
20768                                 Tiles        [6]TileDef
20769                                 OverlayTiles [6]TileDef
20770                                 //mt:const uint8(6)
20771                                 SpecialTiles [6]TileDef
20772
20773                                 Color   color.NRGBA
20774                                 Palette Texture
20775
20776                                 Waving       WaveType
20777                                 ConnectSides uint8
20778                                 ConnectTo    []Content
20779                                 InsideTint   color.NRGBA
20780                                 Level        uint8 // Must be < 128.
20781
20782                                 Translucent bool // Sunlight is scattered and becomes normal light.
20783                                 Transparent bool // Sunlight isn't scattered.
20784                                 LightSrc    uint8
20785
20786                                 GndContent   bool
20787                                 Collides     bool
20788                                 Pointable    bool
20789                                 Diggable     bool
20790                                 Climbable    bool
20791                                 Replaceable  bool
20792                                 OnRightClick bool
20793
20794                                 DmgPerSec int32
20795
20796                                 LiquidType   LiquidType
20797                                 FlowingAlt   string
20798                                 SrcAlt       string
20799                                 Viscosity    uint8 // 0-7
20800                                 LiqRenewable bool
20801                                 FlowRange    uint8
20802                                 DrownDmg     uint8
20803                                 Floodable    bool
20804
20805                                 DrawBox, ColBox, SelBox NodeBox
20806
20807                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20808
20809                                 LegacyFaceDir bool
20810                                 LegacyMounted bool
20811
20812                                 DigPredict string
20813
20814                                 MaxLvl uint8
20815
20816                                 AlphaUse
20817                         }))(obj)).Climbable
20818                         switch n := read8(r); n {
20819                         case 0:
20820                                 *p = false
20821                         case 1:
20822                                 *p = true
20823                         default:
20824                                 chk(fmt.Errorf("invalid bool: %d", n))
20825                         }
20826
20827                 }
20828                 {
20829                         p := &(*(*(struct {
20830                                 Param0 Content
20831
20832                                 Name   string
20833                                 Groups []Group
20834
20835                                 P1Type   Param1Type
20836                                 P2Type   Param2Type
20837                                 DrawType DrawType
20838
20839                                 Mesh  string
20840                                 Scale float32
20841                                 //mt:const uint8(6)
20842                                 Tiles        [6]TileDef
20843                                 OverlayTiles [6]TileDef
20844                                 //mt:const uint8(6)
20845                                 SpecialTiles [6]TileDef
20846
20847                                 Color   color.NRGBA
20848                                 Palette Texture
20849
20850                                 Waving       WaveType
20851                                 ConnectSides uint8
20852                                 ConnectTo    []Content
20853                                 InsideTint   color.NRGBA
20854                                 Level        uint8 // Must be < 128.
20855
20856                                 Translucent bool // Sunlight is scattered and becomes normal light.
20857                                 Transparent bool // Sunlight isn't scattered.
20858                                 LightSrc    uint8
20859
20860                                 GndContent   bool
20861                                 Collides     bool
20862                                 Pointable    bool
20863                                 Diggable     bool
20864                                 Climbable    bool
20865                                 Replaceable  bool
20866                                 OnRightClick bool
20867
20868                                 DmgPerSec int32
20869
20870                                 LiquidType   LiquidType
20871                                 FlowingAlt   string
20872                                 SrcAlt       string
20873                                 Viscosity    uint8 // 0-7
20874                                 LiqRenewable bool
20875                                 FlowRange    uint8
20876                                 DrownDmg     uint8
20877                                 Floodable    bool
20878
20879                                 DrawBox, ColBox, SelBox NodeBox
20880
20881                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20882
20883                                 LegacyFaceDir bool
20884                                 LegacyMounted bool
20885
20886                                 DigPredict string
20887
20888                                 MaxLvl uint8
20889
20890                                 AlphaUse
20891                         }))(obj)).Replaceable
20892                         switch n := read8(r); n {
20893                         case 0:
20894                                 *p = false
20895                         case 1:
20896                                 *p = true
20897                         default:
20898                                 chk(fmt.Errorf("invalid bool: %d", n))
20899                         }
20900
20901                 }
20902                 {
20903                         p := &(*(*(struct {
20904                                 Param0 Content
20905
20906                                 Name   string
20907                                 Groups []Group
20908
20909                                 P1Type   Param1Type
20910                                 P2Type   Param2Type
20911                                 DrawType DrawType
20912
20913                                 Mesh  string
20914                                 Scale float32
20915                                 //mt:const uint8(6)
20916                                 Tiles        [6]TileDef
20917                                 OverlayTiles [6]TileDef
20918                                 //mt:const uint8(6)
20919                                 SpecialTiles [6]TileDef
20920
20921                                 Color   color.NRGBA
20922                                 Palette Texture
20923
20924                                 Waving       WaveType
20925                                 ConnectSides uint8
20926                                 ConnectTo    []Content
20927                                 InsideTint   color.NRGBA
20928                                 Level        uint8 // Must be < 128.
20929
20930                                 Translucent bool // Sunlight is scattered and becomes normal light.
20931                                 Transparent bool // Sunlight isn't scattered.
20932                                 LightSrc    uint8
20933
20934                                 GndContent   bool
20935                                 Collides     bool
20936                                 Pointable    bool
20937                                 Diggable     bool
20938                                 Climbable    bool
20939                                 Replaceable  bool
20940                                 OnRightClick bool
20941
20942                                 DmgPerSec int32
20943
20944                                 LiquidType   LiquidType
20945                                 FlowingAlt   string
20946                                 SrcAlt       string
20947                                 Viscosity    uint8 // 0-7
20948                                 LiqRenewable bool
20949                                 FlowRange    uint8
20950                                 DrownDmg     uint8
20951                                 Floodable    bool
20952
20953                                 DrawBox, ColBox, SelBox NodeBox
20954
20955                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20956
20957                                 LegacyFaceDir bool
20958                                 LegacyMounted bool
20959
20960                                 DigPredict string
20961
20962                                 MaxLvl uint8
20963
20964                                 AlphaUse
20965                         }))(obj)).OnRightClick
20966                         switch n := read8(r); n {
20967                         case 0:
20968                                 *p = false
20969                         case 1:
20970                                 *p = true
20971                         default:
20972                                 chk(fmt.Errorf("invalid bool: %d", n))
20973                         }
20974
20975                 }
20976                 {
20977                         p := &(*(*(struct {
20978                                 Param0 Content
20979
20980                                 Name   string
20981                                 Groups []Group
20982
20983                                 P1Type   Param1Type
20984                                 P2Type   Param2Type
20985                                 DrawType DrawType
20986
20987                                 Mesh  string
20988                                 Scale float32
20989                                 //mt:const uint8(6)
20990                                 Tiles        [6]TileDef
20991                                 OverlayTiles [6]TileDef
20992                                 //mt:const uint8(6)
20993                                 SpecialTiles [6]TileDef
20994
20995                                 Color   color.NRGBA
20996                                 Palette Texture
20997
20998                                 Waving       WaveType
20999                                 ConnectSides uint8
21000                                 ConnectTo    []Content
21001                                 InsideTint   color.NRGBA
21002                                 Level        uint8 // Must be < 128.
21003
21004                                 Translucent bool // Sunlight is scattered and becomes normal light.
21005                                 Transparent bool // Sunlight isn't scattered.
21006                                 LightSrc    uint8
21007
21008                                 GndContent   bool
21009                                 Collides     bool
21010                                 Pointable    bool
21011                                 Diggable     bool
21012                                 Climbable    bool
21013                                 Replaceable  bool
21014                                 OnRightClick bool
21015
21016                                 DmgPerSec int32
21017
21018                                 LiquidType   LiquidType
21019                                 FlowingAlt   string
21020                                 SrcAlt       string
21021                                 Viscosity    uint8 // 0-7
21022                                 LiqRenewable bool
21023                                 FlowRange    uint8
21024                                 DrownDmg     uint8
21025                                 Floodable    bool
21026
21027                                 DrawBox, ColBox, SelBox NodeBox
21028
21029                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21030
21031                                 LegacyFaceDir bool
21032                                 LegacyMounted bool
21033
21034                                 DigPredict string
21035
21036                                 MaxLvl uint8
21037
21038                                 AlphaUse
21039                         }))(obj)).DmgPerSec
21040                         *p = int32(read32(r))
21041                 }
21042                 if err := pcall(func() {
21043                         ((*(*(struct {
21044                                 Param0 Content
21045
21046                                 Name   string
21047                                 Groups []Group
21048
21049                                 P1Type   Param1Type
21050                                 P2Type   Param2Type
21051                                 DrawType DrawType
21052
21053                                 Mesh  string
21054                                 Scale float32
21055                                 //mt:const uint8(6)
21056                                 Tiles        [6]TileDef
21057                                 OverlayTiles [6]TileDef
21058                                 //mt:const uint8(6)
21059                                 SpecialTiles [6]TileDef
21060
21061                                 Color   color.NRGBA
21062                                 Palette Texture
21063
21064                                 Waving       WaveType
21065                                 ConnectSides uint8
21066                                 ConnectTo    []Content
21067                                 InsideTint   color.NRGBA
21068                                 Level        uint8 // Must be < 128.
21069
21070                                 Translucent bool // Sunlight is scattered and becomes normal light.
21071                                 Transparent bool // Sunlight isn't scattered.
21072                                 LightSrc    uint8
21073
21074                                 GndContent   bool
21075                                 Collides     bool
21076                                 Pointable    bool
21077                                 Diggable     bool
21078                                 Climbable    bool
21079                                 Replaceable  bool
21080                                 OnRightClick bool
21081
21082                                 DmgPerSec int32
21083
21084                                 LiquidType   LiquidType
21085                                 FlowingAlt   string
21086                                 SrcAlt       string
21087                                 Viscosity    uint8 // 0-7
21088                                 LiqRenewable bool
21089                                 FlowRange    uint8
21090                                 DrownDmg     uint8
21091                                 Floodable    bool
21092
21093                                 DrawBox, ColBox, SelBox NodeBox
21094
21095                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21096
21097                                 LegacyFaceDir bool
21098                                 LegacyMounted bool
21099
21100                                 DigPredict string
21101
21102                                 MaxLvl uint8
21103
21104                                 AlphaUse
21105                         }))(obj)).LiquidType).deserialize(r)
21106                 }); err != nil {
21107                         if err == io.EOF {
21108                                 chk(io.EOF)
21109                         }
21110                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
21111                 }
21112                 var local265 []uint8
21113                 var local266 uint16
21114                 {
21115                         p := &local266
21116                         *p = read16(r)
21117                 }
21118                 (local265) = make([]uint8, local266)
21119                 {
21120                         _, err := io.ReadFull(r, (local265)[:])
21121                         chk(err)
21122                 }
21123                 ((*(*(struct {
21124                         Param0 Content
21125
21126                         Name   string
21127                         Groups []Group
21128
21129                         P1Type   Param1Type
21130                         P2Type   Param2Type
21131                         DrawType DrawType
21132
21133                         Mesh  string
21134                         Scale float32
21135                         //mt:const uint8(6)
21136                         Tiles        [6]TileDef
21137                         OverlayTiles [6]TileDef
21138                         //mt:const uint8(6)
21139                         SpecialTiles [6]TileDef
21140
21141                         Color   color.NRGBA
21142                         Palette Texture
21143
21144                         Waving       WaveType
21145                         ConnectSides uint8
21146                         ConnectTo    []Content
21147                         InsideTint   color.NRGBA
21148                         Level        uint8 // Must be < 128.
21149
21150                         Translucent bool // Sunlight is scattered and becomes normal light.
21151                         Transparent bool // Sunlight isn't scattered.
21152                         LightSrc    uint8
21153
21154                         GndContent   bool
21155                         Collides     bool
21156                         Pointable    bool
21157                         Diggable     bool
21158                         Climbable    bool
21159                         Replaceable  bool
21160                         OnRightClick bool
21161
21162                         DmgPerSec int32
21163
21164                         LiquidType   LiquidType
21165                         FlowingAlt   string
21166                         SrcAlt       string
21167                         Viscosity    uint8 // 0-7
21168                         LiqRenewable bool
21169                         FlowRange    uint8
21170                         DrownDmg     uint8
21171                         Floodable    bool
21172
21173                         DrawBox, ColBox, SelBox NodeBox
21174
21175                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21176
21177                         LegacyFaceDir bool
21178                         LegacyMounted bool
21179
21180                         DigPredict string
21181
21182                         MaxLvl uint8
21183
21184                         AlphaUse
21185                 }))(obj)).FlowingAlt) = string(local265)
21186                 var local267 []uint8
21187                 var local268 uint16
21188                 {
21189                         p := &local268
21190                         *p = read16(r)
21191                 }
21192                 (local267) = make([]uint8, local268)
21193                 {
21194                         _, err := io.ReadFull(r, (local267)[:])
21195                         chk(err)
21196                 }
21197                 ((*(*(struct {
21198                         Param0 Content
21199
21200                         Name   string
21201                         Groups []Group
21202
21203                         P1Type   Param1Type
21204                         P2Type   Param2Type
21205                         DrawType DrawType
21206
21207                         Mesh  string
21208                         Scale float32
21209                         //mt:const uint8(6)
21210                         Tiles        [6]TileDef
21211                         OverlayTiles [6]TileDef
21212                         //mt:const uint8(6)
21213                         SpecialTiles [6]TileDef
21214
21215                         Color   color.NRGBA
21216                         Palette Texture
21217
21218                         Waving       WaveType
21219                         ConnectSides uint8
21220                         ConnectTo    []Content
21221                         InsideTint   color.NRGBA
21222                         Level        uint8 // Must be < 128.
21223
21224                         Translucent bool // Sunlight is scattered and becomes normal light.
21225                         Transparent bool // Sunlight isn't scattered.
21226                         LightSrc    uint8
21227
21228                         GndContent   bool
21229                         Collides     bool
21230                         Pointable    bool
21231                         Diggable     bool
21232                         Climbable    bool
21233                         Replaceable  bool
21234                         OnRightClick bool
21235
21236                         DmgPerSec int32
21237
21238                         LiquidType   LiquidType
21239                         FlowingAlt   string
21240                         SrcAlt       string
21241                         Viscosity    uint8 // 0-7
21242                         LiqRenewable bool
21243                         FlowRange    uint8
21244                         DrownDmg     uint8
21245                         Floodable    bool
21246
21247                         DrawBox, ColBox, SelBox NodeBox
21248
21249                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21250
21251                         LegacyFaceDir bool
21252                         LegacyMounted bool
21253
21254                         DigPredict string
21255
21256                         MaxLvl uint8
21257
21258                         AlphaUse
21259                 }))(obj)).SrcAlt) = string(local267)
21260                 {
21261                         p := &(*(*(struct {
21262                                 Param0 Content
21263
21264                                 Name   string
21265                                 Groups []Group
21266
21267                                 P1Type   Param1Type
21268                                 P2Type   Param2Type
21269                                 DrawType DrawType
21270
21271                                 Mesh  string
21272                                 Scale float32
21273                                 //mt:const uint8(6)
21274                                 Tiles        [6]TileDef
21275                                 OverlayTiles [6]TileDef
21276                                 //mt:const uint8(6)
21277                                 SpecialTiles [6]TileDef
21278
21279                                 Color   color.NRGBA
21280                                 Palette Texture
21281
21282                                 Waving       WaveType
21283                                 ConnectSides uint8
21284                                 ConnectTo    []Content
21285                                 InsideTint   color.NRGBA
21286                                 Level        uint8 // Must be < 128.
21287
21288                                 Translucent bool // Sunlight is scattered and becomes normal light.
21289                                 Transparent bool // Sunlight isn't scattered.
21290                                 LightSrc    uint8
21291
21292                                 GndContent   bool
21293                                 Collides     bool
21294                                 Pointable    bool
21295                                 Diggable     bool
21296                                 Climbable    bool
21297                                 Replaceable  bool
21298                                 OnRightClick bool
21299
21300                                 DmgPerSec int32
21301
21302                                 LiquidType   LiquidType
21303                                 FlowingAlt   string
21304                                 SrcAlt       string
21305                                 Viscosity    uint8 // 0-7
21306                                 LiqRenewable bool
21307                                 FlowRange    uint8
21308                                 DrownDmg     uint8
21309                                 Floodable    bool
21310
21311                                 DrawBox, ColBox, SelBox NodeBox
21312
21313                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21314
21315                                 LegacyFaceDir bool
21316                                 LegacyMounted bool
21317
21318                                 DigPredict string
21319
21320                                 MaxLvl uint8
21321
21322                                 AlphaUse
21323                         }))(obj)).Viscosity
21324                         *p = read8(r)
21325                 }
21326                 {
21327                         p := &(*(*(struct {
21328                                 Param0 Content
21329
21330                                 Name   string
21331                                 Groups []Group
21332
21333                                 P1Type   Param1Type
21334                                 P2Type   Param2Type
21335                                 DrawType DrawType
21336
21337                                 Mesh  string
21338                                 Scale float32
21339                                 //mt:const uint8(6)
21340                                 Tiles        [6]TileDef
21341                                 OverlayTiles [6]TileDef
21342                                 //mt:const uint8(6)
21343                                 SpecialTiles [6]TileDef
21344
21345                                 Color   color.NRGBA
21346                                 Palette Texture
21347
21348                                 Waving       WaveType
21349                                 ConnectSides uint8
21350                                 ConnectTo    []Content
21351                                 InsideTint   color.NRGBA
21352                                 Level        uint8 // Must be < 128.
21353
21354                                 Translucent bool // Sunlight is scattered and becomes normal light.
21355                                 Transparent bool // Sunlight isn't scattered.
21356                                 LightSrc    uint8
21357
21358                                 GndContent   bool
21359                                 Collides     bool
21360                                 Pointable    bool
21361                                 Diggable     bool
21362                                 Climbable    bool
21363                                 Replaceable  bool
21364                                 OnRightClick bool
21365
21366                                 DmgPerSec int32
21367
21368                                 LiquidType   LiquidType
21369                                 FlowingAlt   string
21370                                 SrcAlt       string
21371                                 Viscosity    uint8 // 0-7
21372                                 LiqRenewable bool
21373                                 FlowRange    uint8
21374                                 DrownDmg     uint8
21375                                 Floodable    bool
21376
21377                                 DrawBox, ColBox, SelBox NodeBox
21378
21379                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21380
21381                                 LegacyFaceDir bool
21382                                 LegacyMounted bool
21383
21384                                 DigPredict string
21385
21386                                 MaxLvl uint8
21387
21388                                 AlphaUse
21389                         }))(obj)).LiqRenewable
21390                         switch n := read8(r); n {
21391                         case 0:
21392                                 *p = false
21393                         case 1:
21394                                 *p = true
21395                         default:
21396                                 chk(fmt.Errorf("invalid bool: %d", n))
21397                         }
21398
21399                 }
21400                 {
21401                         p := &(*(*(struct {
21402                                 Param0 Content
21403
21404                                 Name   string
21405                                 Groups []Group
21406
21407                                 P1Type   Param1Type
21408                                 P2Type   Param2Type
21409                                 DrawType DrawType
21410
21411                                 Mesh  string
21412                                 Scale float32
21413                                 //mt:const uint8(6)
21414                                 Tiles        [6]TileDef
21415                                 OverlayTiles [6]TileDef
21416                                 //mt:const uint8(6)
21417                                 SpecialTiles [6]TileDef
21418
21419                                 Color   color.NRGBA
21420                                 Palette Texture
21421
21422                                 Waving       WaveType
21423                                 ConnectSides uint8
21424                                 ConnectTo    []Content
21425                                 InsideTint   color.NRGBA
21426                                 Level        uint8 // Must be < 128.
21427
21428                                 Translucent bool // Sunlight is scattered and becomes normal light.
21429                                 Transparent bool // Sunlight isn't scattered.
21430                                 LightSrc    uint8
21431
21432                                 GndContent   bool
21433                                 Collides     bool
21434                                 Pointable    bool
21435                                 Diggable     bool
21436                                 Climbable    bool
21437                                 Replaceable  bool
21438                                 OnRightClick bool
21439
21440                                 DmgPerSec int32
21441
21442                                 LiquidType   LiquidType
21443                                 FlowingAlt   string
21444                                 SrcAlt       string
21445                                 Viscosity    uint8 // 0-7
21446                                 LiqRenewable bool
21447                                 FlowRange    uint8
21448                                 DrownDmg     uint8
21449                                 Floodable    bool
21450
21451                                 DrawBox, ColBox, SelBox NodeBox
21452
21453                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21454
21455                                 LegacyFaceDir bool
21456                                 LegacyMounted bool
21457
21458                                 DigPredict string
21459
21460                                 MaxLvl uint8
21461
21462                                 AlphaUse
21463                         }))(obj)).FlowRange
21464                         *p = read8(r)
21465                 }
21466                 {
21467                         p := &(*(*(struct {
21468                                 Param0 Content
21469
21470                                 Name   string
21471                                 Groups []Group
21472
21473                                 P1Type   Param1Type
21474                                 P2Type   Param2Type
21475                                 DrawType DrawType
21476
21477                                 Mesh  string
21478                                 Scale float32
21479                                 //mt:const uint8(6)
21480                                 Tiles        [6]TileDef
21481                                 OverlayTiles [6]TileDef
21482                                 //mt:const uint8(6)
21483                                 SpecialTiles [6]TileDef
21484
21485                                 Color   color.NRGBA
21486                                 Palette Texture
21487
21488                                 Waving       WaveType
21489                                 ConnectSides uint8
21490                                 ConnectTo    []Content
21491                                 InsideTint   color.NRGBA
21492                                 Level        uint8 // Must be < 128.
21493
21494                                 Translucent bool // Sunlight is scattered and becomes normal light.
21495                                 Transparent bool // Sunlight isn't scattered.
21496                                 LightSrc    uint8
21497
21498                                 GndContent   bool
21499                                 Collides     bool
21500                                 Pointable    bool
21501                                 Diggable     bool
21502                                 Climbable    bool
21503                                 Replaceable  bool
21504                                 OnRightClick bool
21505
21506                                 DmgPerSec int32
21507
21508                                 LiquidType   LiquidType
21509                                 FlowingAlt   string
21510                                 SrcAlt       string
21511                                 Viscosity    uint8 // 0-7
21512                                 LiqRenewable bool
21513                                 FlowRange    uint8
21514                                 DrownDmg     uint8
21515                                 Floodable    bool
21516
21517                                 DrawBox, ColBox, SelBox NodeBox
21518
21519                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21520
21521                                 LegacyFaceDir bool
21522                                 LegacyMounted bool
21523
21524                                 DigPredict string
21525
21526                                 MaxLvl uint8
21527
21528                                 AlphaUse
21529                         }))(obj)).DrownDmg
21530                         *p = read8(r)
21531                 }
21532                 {
21533                         p := &(*(*(struct {
21534                                 Param0 Content
21535
21536                                 Name   string
21537                                 Groups []Group
21538
21539                                 P1Type   Param1Type
21540                                 P2Type   Param2Type
21541                                 DrawType DrawType
21542
21543                                 Mesh  string
21544                                 Scale float32
21545                                 //mt:const uint8(6)
21546                                 Tiles        [6]TileDef
21547                                 OverlayTiles [6]TileDef
21548                                 //mt:const uint8(6)
21549                                 SpecialTiles [6]TileDef
21550
21551                                 Color   color.NRGBA
21552                                 Palette Texture
21553
21554                                 Waving       WaveType
21555                                 ConnectSides uint8
21556                                 ConnectTo    []Content
21557                                 InsideTint   color.NRGBA
21558                                 Level        uint8 // Must be < 128.
21559
21560                                 Translucent bool // Sunlight is scattered and becomes normal light.
21561                                 Transparent bool // Sunlight isn't scattered.
21562                                 LightSrc    uint8
21563
21564                                 GndContent   bool
21565                                 Collides     bool
21566                                 Pointable    bool
21567                                 Diggable     bool
21568                                 Climbable    bool
21569                                 Replaceable  bool
21570                                 OnRightClick bool
21571
21572                                 DmgPerSec int32
21573
21574                                 LiquidType   LiquidType
21575                                 FlowingAlt   string
21576                                 SrcAlt       string
21577                                 Viscosity    uint8 // 0-7
21578                                 LiqRenewable bool
21579                                 FlowRange    uint8
21580                                 DrownDmg     uint8
21581                                 Floodable    bool
21582
21583                                 DrawBox, ColBox, SelBox NodeBox
21584
21585                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21586
21587                                 LegacyFaceDir bool
21588                                 LegacyMounted bool
21589
21590                                 DigPredict string
21591
21592                                 MaxLvl uint8
21593
21594                                 AlphaUse
21595                         }))(obj)).Floodable
21596                         switch n := read8(r); n {
21597                         case 0:
21598                                 *p = false
21599                         case 1:
21600                                 *p = true
21601                         default:
21602                                 chk(fmt.Errorf("invalid bool: %d", n))
21603                         }
21604
21605                 }
21606                 if err := pcall(func() {
21607                         ((*(*(struct {
21608                                 Param0 Content
21609
21610                                 Name   string
21611                                 Groups []Group
21612
21613                                 P1Type   Param1Type
21614                                 P2Type   Param2Type
21615                                 DrawType DrawType
21616
21617                                 Mesh  string
21618                                 Scale float32
21619                                 //mt:const uint8(6)
21620                                 Tiles        [6]TileDef
21621                                 OverlayTiles [6]TileDef
21622                                 //mt:const uint8(6)
21623                                 SpecialTiles [6]TileDef
21624
21625                                 Color   color.NRGBA
21626                                 Palette Texture
21627
21628                                 Waving       WaveType
21629                                 ConnectSides uint8
21630                                 ConnectTo    []Content
21631                                 InsideTint   color.NRGBA
21632                                 Level        uint8 // Must be < 128.
21633
21634                                 Translucent bool // Sunlight is scattered and becomes normal light.
21635                                 Transparent bool // Sunlight isn't scattered.
21636                                 LightSrc    uint8
21637
21638                                 GndContent   bool
21639                                 Collides     bool
21640                                 Pointable    bool
21641                                 Diggable     bool
21642                                 Climbable    bool
21643                                 Replaceable  bool
21644                                 OnRightClick bool
21645
21646                                 DmgPerSec int32
21647
21648                                 LiquidType   LiquidType
21649                                 FlowingAlt   string
21650                                 SrcAlt       string
21651                                 Viscosity    uint8 // 0-7
21652                                 LiqRenewable bool
21653                                 FlowRange    uint8
21654                                 DrownDmg     uint8
21655                                 Floodable    bool
21656
21657                                 DrawBox, ColBox, SelBox NodeBox
21658
21659                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21660
21661                                 LegacyFaceDir bool
21662                                 LegacyMounted bool
21663
21664                                 DigPredict string
21665
21666                                 MaxLvl uint8
21667
21668                                 AlphaUse
21669                         }))(obj)).DrawBox).deserialize(r)
21670                 }); err != nil {
21671                         if err == io.EOF {
21672                                 chk(io.EOF)
21673                         }
21674                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21675                 }
21676                 if err := pcall(func() {
21677                         ((*(*(struct {
21678                                 Param0 Content
21679
21680                                 Name   string
21681                                 Groups []Group
21682
21683                                 P1Type   Param1Type
21684                                 P2Type   Param2Type
21685                                 DrawType DrawType
21686
21687                                 Mesh  string
21688                                 Scale float32
21689                                 //mt:const uint8(6)
21690                                 Tiles        [6]TileDef
21691                                 OverlayTiles [6]TileDef
21692                                 //mt:const uint8(6)
21693                                 SpecialTiles [6]TileDef
21694
21695                                 Color   color.NRGBA
21696                                 Palette Texture
21697
21698                                 Waving       WaveType
21699                                 ConnectSides uint8
21700                                 ConnectTo    []Content
21701                                 InsideTint   color.NRGBA
21702                                 Level        uint8 // Must be < 128.
21703
21704                                 Translucent bool // Sunlight is scattered and becomes normal light.
21705                                 Transparent bool // Sunlight isn't scattered.
21706                                 LightSrc    uint8
21707
21708                                 GndContent   bool
21709                                 Collides     bool
21710                                 Pointable    bool
21711                                 Diggable     bool
21712                                 Climbable    bool
21713                                 Replaceable  bool
21714                                 OnRightClick bool
21715
21716                                 DmgPerSec int32
21717
21718                                 LiquidType   LiquidType
21719                                 FlowingAlt   string
21720                                 SrcAlt       string
21721                                 Viscosity    uint8 // 0-7
21722                                 LiqRenewable bool
21723                                 FlowRange    uint8
21724                                 DrownDmg     uint8
21725                                 Floodable    bool
21726
21727                                 DrawBox, ColBox, SelBox NodeBox
21728
21729                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21730
21731                                 LegacyFaceDir bool
21732                                 LegacyMounted bool
21733
21734                                 DigPredict string
21735
21736                                 MaxLvl uint8
21737
21738                                 AlphaUse
21739                         }))(obj)).ColBox).deserialize(r)
21740                 }); err != nil {
21741                         if err == io.EOF {
21742                                 chk(io.EOF)
21743                         }
21744                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21745                 }
21746                 if err := pcall(func() {
21747                         ((*(*(struct {
21748                                 Param0 Content
21749
21750                                 Name   string
21751                                 Groups []Group
21752
21753                                 P1Type   Param1Type
21754                                 P2Type   Param2Type
21755                                 DrawType DrawType
21756
21757                                 Mesh  string
21758                                 Scale float32
21759                                 //mt:const uint8(6)
21760                                 Tiles        [6]TileDef
21761                                 OverlayTiles [6]TileDef
21762                                 //mt:const uint8(6)
21763                                 SpecialTiles [6]TileDef
21764
21765                                 Color   color.NRGBA
21766                                 Palette Texture
21767
21768                                 Waving       WaveType
21769                                 ConnectSides uint8
21770                                 ConnectTo    []Content
21771                                 InsideTint   color.NRGBA
21772                                 Level        uint8 // Must be < 128.
21773
21774                                 Translucent bool // Sunlight is scattered and becomes normal light.
21775                                 Transparent bool // Sunlight isn't scattered.
21776                                 LightSrc    uint8
21777
21778                                 GndContent   bool
21779                                 Collides     bool
21780                                 Pointable    bool
21781                                 Diggable     bool
21782                                 Climbable    bool
21783                                 Replaceable  bool
21784                                 OnRightClick bool
21785
21786                                 DmgPerSec int32
21787
21788                                 LiquidType   LiquidType
21789                                 FlowingAlt   string
21790                                 SrcAlt       string
21791                                 Viscosity    uint8 // 0-7
21792                                 LiqRenewable bool
21793                                 FlowRange    uint8
21794                                 DrownDmg     uint8
21795                                 Floodable    bool
21796
21797                                 DrawBox, ColBox, SelBox NodeBox
21798
21799                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21800
21801                                 LegacyFaceDir bool
21802                                 LegacyMounted bool
21803
21804                                 DigPredict string
21805
21806                                 MaxLvl uint8
21807
21808                                 AlphaUse
21809                         }))(obj)).SelBox).deserialize(r)
21810                 }); err != nil {
21811                         if err == io.EOF {
21812                                 chk(io.EOF)
21813                         }
21814                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBox", err))
21815                 }
21816                 if err := pcall(func() {
21817                         ((*(*(struct {
21818                                 Param0 Content
21819
21820                                 Name   string
21821                                 Groups []Group
21822
21823                                 P1Type   Param1Type
21824                                 P2Type   Param2Type
21825                                 DrawType DrawType
21826
21827                                 Mesh  string
21828                                 Scale float32
21829                                 //mt:const uint8(6)
21830                                 Tiles        [6]TileDef
21831                                 OverlayTiles [6]TileDef
21832                                 //mt:const uint8(6)
21833                                 SpecialTiles [6]TileDef
21834
21835                                 Color   color.NRGBA
21836                                 Palette Texture
21837
21838                                 Waving       WaveType
21839                                 ConnectSides uint8
21840                                 ConnectTo    []Content
21841                                 InsideTint   color.NRGBA
21842                                 Level        uint8 // Must be < 128.
21843
21844                                 Translucent bool // Sunlight is scattered and becomes normal light.
21845                                 Transparent bool // Sunlight isn't scattered.
21846                                 LightSrc    uint8
21847
21848                                 GndContent   bool
21849                                 Collides     bool
21850                                 Pointable    bool
21851                                 Diggable     bool
21852                                 Climbable    bool
21853                                 Replaceable  bool
21854                                 OnRightClick bool
21855
21856                                 DmgPerSec int32
21857
21858                                 LiquidType   LiquidType
21859                                 FlowingAlt   string
21860                                 SrcAlt       string
21861                                 Viscosity    uint8 // 0-7
21862                                 LiqRenewable bool
21863                                 FlowRange    uint8
21864                                 DrownDmg     uint8
21865                                 Floodable    bool
21866
21867                                 DrawBox, ColBox, SelBox NodeBox
21868
21869                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21870
21871                                 LegacyFaceDir bool
21872                                 LegacyMounted bool
21873
21874                                 DigPredict string
21875
21876                                 MaxLvl uint8
21877
21878                                 AlphaUse
21879                         }))(obj)).FootstepSnd).deserialize(r)
21880                 }); err != nil {
21881                         if err == io.EOF {
21882                                 chk(io.EOF)
21883                         }
21884                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
21885                 }
21886                 if err := pcall(func() {
21887                         ((*(*(struct {
21888                                 Param0 Content
21889
21890                                 Name   string
21891                                 Groups []Group
21892
21893                                 P1Type   Param1Type
21894                                 P2Type   Param2Type
21895                                 DrawType DrawType
21896
21897                                 Mesh  string
21898                                 Scale float32
21899                                 //mt:const uint8(6)
21900                                 Tiles        [6]TileDef
21901                                 OverlayTiles [6]TileDef
21902                                 //mt:const uint8(6)
21903                                 SpecialTiles [6]TileDef
21904
21905                                 Color   color.NRGBA
21906                                 Palette Texture
21907
21908                                 Waving       WaveType
21909                                 ConnectSides uint8
21910                                 ConnectTo    []Content
21911                                 InsideTint   color.NRGBA
21912                                 Level        uint8 // Must be < 128.
21913
21914                                 Translucent bool // Sunlight is scattered and becomes normal light.
21915                                 Transparent bool // Sunlight isn't scattered.
21916                                 LightSrc    uint8
21917
21918                                 GndContent   bool
21919                                 Collides     bool
21920                                 Pointable    bool
21921                                 Diggable     bool
21922                                 Climbable    bool
21923                                 Replaceable  bool
21924                                 OnRightClick bool
21925
21926                                 DmgPerSec int32
21927
21928                                 LiquidType   LiquidType
21929                                 FlowingAlt   string
21930                                 SrcAlt       string
21931                                 Viscosity    uint8 // 0-7
21932                                 LiqRenewable bool
21933                                 FlowRange    uint8
21934                                 DrownDmg     uint8
21935                                 Floodable    bool
21936
21937                                 DrawBox, ColBox, SelBox NodeBox
21938
21939                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21940
21941                                 LegacyFaceDir bool
21942                                 LegacyMounted bool
21943
21944                                 DigPredict string
21945
21946                                 MaxLvl uint8
21947
21948                                 AlphaUse
21949                         }))(obj)).DiggingSnd).deserialize(r)
21950                 }); err != nil {
21951                         if err == io.EOF {
21952                                 chk(io.EOF)
21953                         }
21954                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
21955                 }
21956                 if err := pcall(func() {
21957                         ((*(*(struct {
21958                                 Param0 Content
21959
21960                                 Name   string
21961                                 Groups []Group
21962
21963                                 P1Type   Param1Type
21964                                 P2Type   Param2Type
21965                                 DrawType DrawType
21966
21967                                 Mesh  string
21968                                 Scale float32
21969                                 //mt:const uint8(6)
21970                                 Tiles        [6]TileDef
21971                                 OverlayTiles [6]TileDef
21972                                 //mt:const uint8(6)
21973                                 SpecialTiles [6]TileDef
21974
21975                                 Color   color.NRGBA
21976                                 Palette Texture
21977
21978                                 Waving       WaveType
21979                                 ConnectSides uint8
21980                                 ConnectTo    []Content
21981                                 InsideTint   color.NRGBA
21982                                 Level        uint8 // Must be < 128.
21983
21984                                 Translucent bool // Sunlight is scattered and becomes normal light.
21985                                 Transparent bool // Sunlight isn't scattered.
21986                                 LightSrc    uint8
21987
21988                                 GndContent   bool
21989                                 Collides     bool
21990                                 Pointable    bool
21991                                 Diggable     bool
21992                                 Climbable    bool
21993                                 Replaceable  bool
21994                                 OnRightClick bool
21995
21996                                 DmgPerSec int32
21997
21998                                 LiquidType   LiquidType
21999                                 FlowingAlt   string
22000                                 SrcAlt       string
22001                                 Viscosity    uint8 // 0-7
22002                                 LiqRenewable bool
22003                                 FlowRange    uint8
22004                                 DrownDmg     uint8
22005                                 Floodable    bool
22006
22007                                 DrawBox, ColBox, SelBox NodeBox
22008
22009                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22010
22011                                 LegacyFaceDir bool
22012                                 LegacyMounted bool
22013
22014                                 DigPredict string
22015
22016                                 MaxLvl uint8
22017
22018                                 AlphaUse
22019                         }))(obj)).DugSnd).deserialize(r)
22020                 }); err != nil {
22021                         if err == io.EOF {
22022                                 chk(io.EOF)
22023                         }
22024                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
22025                 }
22026                 {
22027                         p := &(*(*(struct {
22028                                 Param0 Content
22029
22030                                 Name   string
22031                                 Groups []Group
22032
22033                                 P1Type   Param1Type
22034                                 P2Type   Param2Type
22035                                 DrawType DrawType
22036
22037                                 Mesh  string
22038                                 Scale float32
22039                                 //mt:const uint8(6)
22040                                 Tiles        [6]TileDef
22041                                 OverlayTiles [6]TileDef
22042                                 //mt:const uint8(6)
22043                                 SpecialTiles [6]TileDef
22044
22045                                 Color   color.NRGBA
22046                                 Palette Texture
22047
22048                                 Waving       WaveType
22049                                 ConnectSides uint8
22050                                 ConnectTo    []Content
22051                                 InsideTint   color.NRGBA
22052                                 Level        uint8 // Must be < 128.
22053
22054                                 Translucent bool // Sunlight is scattered and becomes normal light.
22055                                 Transparent bool // Sunlight isn't scattered.
22056                                 LightSrc    uint8
22057
22058                                 GndContent   bool
22059                                 Collides     bool
22060                                 Pointable    bool
22061                                 Diggable     bool
22062                                 Climbable    bool
22063                                 Replaceable  bool
22064                                 OnRightClick bool
22065
22066                                 DmgPerSec int32
22067
22068                                 LiquidType   LiquidType
22069                                 FlowingAlt   string
22070                                 SrcAlt       string
22071                                 Viscosity    uint8 // 0-7
22072                                 LiqRenewable bool
22073                                 FlowRange    uint8
22074                                 DrownDmg     uint8
22075                                 Floodable    bool
22076
22077                                 DrawBox, ColBox, SelBox NodeBox
22078
22079                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22080
22081                                 LegacyFaceDir bool
22082                                 LegacyMounted bool
22083
22084                                 DigPredict string
22085
22086                                 MaxLvl uint8
22087
22088                                 AlphaUse
22089                         }))(obj)).LegacyFaceDir
22090                         switch n := read8(r); n {
22091                         case 0:
22092                                 *p = false
22093                         case 1:
22094                                 *p = true
22095                         default:
22096                                 chk(fmt.Errorf("invalid bool: %d", n))
22097                         }
22098
22099                 }
22100                 {
22101                         p := &(*(*(struct {
22102                                 Param0 Content
22103
22104                                 Name   string
22105                                 Groups []Group
22106
22107                                 P1Type   Param1Type
22108                                 P2Type   Param2Type
22109                                 DrawType DrawType
22110
22111                                 Mesh  string
22112                                 Scale float32
22113                                 //mt:const uint8(6)
22114                                 Tiles        [6]TileDef
22115                                 OverlayTiles [6]TileDef
22116                                 //mt:const uint8(6)
22117                                 SpecialTiles [6]TileDef
22118
22119                                 Color   color.NRGBA
22120                                 Palette Texture
22121
22122                                 Waving       WaveType
22123                                 ConnectSides uint8
22124                                 ConnectTo    []Content
22125                                 InsideTint   color.NRGBA
22126                                 Level        uint8 // Must be < 128.
22127
22128                                 Translucent bool // Sunlight is scattered and becomes normal light.
22129                                 Transparent bool // Sunlight isn't scattered.
22130                                 LightSrc    uint8
22131
22132                                 GndContent   bool
22133                                 Collides     bool
22134                                 Pointable    bool
22135                                 Diggable     bool
22136                                 Climbable    bool
22137                                 Replaceable  bool
22138                                 OnRightClick bool
22139
22140                                 DmgPerSec int32
22141
22142                                 LiquidType   LiquidType
22143                                 FlowingAlt   string
22144                                 SrcAlt       string
22145                                 Viscosity    uint8 // 0-7
22146                                 LiqRenewable bool
22147                                 FlowRange    uint8
22148                                 DrownDmg     uint8
22149                                 Floodable    bool
22150
22151                                 DrawBox, ColBox, SelBox NodeBox
22152
22153                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22154
22155                                 LegacyFaceDir bool
22156                                 LegacyMounted bool
22157
22158                                 DigPredict string
22159
22160                                 MaxLvl uint8
22161
22162                                 AlphaUse
22163                         }))(obj)).LegacyMounted
22164                         switch n := read8(r); n {
22165                         case 0:
22166                                 *p = false
22167                         case 1:
22168                                 *p = true
22169                         default:
22170                                 chk(fmt.Errorf("invalid bool: %d", n))
22171                         }
22172
22173                 }
22174                 var local269 []uint8
22175                 var local270 uint16
22176                 {
22177                         p := &local270
22178                         *p = read16(r)
22179                 }
22180                 (local269) = make([]uint8, local270)
22181                 {
22182                         _, err := io.ReadFull(r, (local269)[:])
22183                         chk(err)
22184                 }
22185                 ((*(*(struct {
22186                         Param0 Content
22187
22188                         Name   string
22189                         Groups []Group
22190
22191                         P1Type   Param1Type
22192                         P2Type   Param2Type
22193                         DrawType DrawType
22194
22195                         Mesh  string
22196                         Scale float32
22197                         //mt:const uint8(6)
22198                         Tiles        [6]TileDef
22199                         OverlayTiles [6]TileDef
22200                         //mt:const uint8(6)
22201                         SpecialTiles [6]TileDef
22202
22203                         Color   color.NRGBA
22204                         Palette Texture
22205
22206                         Waving       WaveType
22207                         ConnectSides uint8
22208                         ConnectTo    []Content
22209                         InsideTint   color.NRGBA
22210                         Level        uint8 // Must be < 128.
22211
22212                         Translucent bool // Sunlight is scattered and becomes normal light.
22213                         Transparent bool // Sunlight isn't scattered.
22214                         LightSrc    uint8
22215
22216                         GndContent   bool
22217                         Collides     bool
22218                         Pointable    bool
22219                         Diggable     bool
22220                         Climbable    bool
22221                         Replaceable  bool
22222                         OnRightClick bool
22223
22224                         DmgPerSec int32
22225
22226                         LiquidType   LiquidType
22227                         FlowingAlt   string
22228                         SrcAlt       string
22229                         Viscosity    uint8 // 0-7
22230                         LiqRenewable bool
22231                         FlowRange    uint8
22232                         DrownDmg     uint8
22233                         Floodable    bool
22234
22235                         DrawBox, ColBox, SelBox NodeBox
22236
22237                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22238
22239                         LegacyFaceDir bool
22240                         LegacyMounted bool
22241
22242                         DigPredict string
22243
22244                         MaxLvl uint8
22245
22246                         AlphaUse
22247                 }))(obj)).DigPredict) = string(local269)
22248                 {
22249                         p := &(*(*(struct {
22250                                 Param0 Content
22251
22252                                 Name   string
22253                                 Groups []Group
22254
22255                                 P1Type   Param1Type
22256                                 P2Type   Param2Type
22257                                 DrawType DrawType
22258
22259                                 Mesh  string
22260                                 Scale float32
22261                                 //mt:const uint8(6)
22262                                 Tiles        [6]TileDef
22263                                 OverlayTiles [6]TileDef
22264                                 //mt:const uint8(6)
22265                                 SpecialTiles [6]TileDef
22266
22267                                 Color   color.NRGBA
22268                                 Palette Texture
22269
22270                                 Waving       WaveType
22271                                 ConnectSides uint8
22272                                 ConnectTo    []Content
22273                                 InsideTint   color.NRGBA
22274                                 Level        uint8 // Must be < 128.
22275
22276                                 Translucent bool // Sunlight is scattered and becomes normal light.
22277                                 Transparent bool // Sunlight isn't scattered.
22278                                 LightSrc    uint8
22279
22280                                 GndContent   bool
22281                                 Collides     bool
22282                                 Pointable    bool
22283                                 Diggable     bool
22284                                 Climbable    bool
22285                                 Replaceable  bool
22286                                 OnRightClick bool
22287
22288                                 DmgPerSec int32
22289
22290                                 LiquidType   LiquidType
22291                                 FlowingAlt   string
22292                                 SrcAlt       string
22293                                 Viscosity    uint8 // 0-7
22294                                 LiqRenewable bool
22295                                 FlowRange    uint8
22296                                 DrownDmg     uint8
22297                                 Floodable    bool
22298
22299                                 DrawBox, ColBox, SelBox NodeBox
22300
22301                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22302
22303                                 LegacyFaceDir bool
22304                                 LegacyMounted bool
22305
22306                                 DigPredict string
22307
22308                                 MaxLvl uint8
22309
22310                                 AlphaUse
22311                         }))(obj)).MaxLvl
22312                         *p = read8(r)
22313                 }
22314                 if err := pcall(func() {
22315                         ((*(*(struct {
22316                                 Param0 Content
22317
22318                                 Name   string
22319                                 Groups []Group
22320
22321                                 P1Type   Param1Type
22322                                 P2Type   Param2Type
22323                                 DrawType DrawType
22324
22325                                 Mesh  string
22326                                 Scale float32
22327                                 //mt:const uint8(6)
22328                                 Tiles        [6]TileDef
22329                                 OverlayTiles [6]TileDef
22330                                 //mt:const uint8(6)
22331                                 SpecialTiles [6]TileDef
22332
22333                                 Color   color.NRGBA
22334                                 Palette Texture
22335
22336                                 Waving       WaveType
22337                                 ConnectSides uint8
22338                                 ConnectTo    []Content
22339                                 InsideTint   color.NRGBA
22340                                 Level        uint8 // Must be < 128.
22341
22342                                 Translucent bool // Sunlight is scattered and becomes normal light.
22343                                 Transparent bool // Sunlight isn't scattered.
22344                                 LightSrc    uint8
22345
22346                                 GndContent   bool
22347                                 Collides     bool
22348                                 Pointable    bool
22349                                 Diggable     bool
22350                                 Climbable    bool
22351                                 Replaceable  bool
22352                                 OnRightClick bool
22353
22354                                 DmgPerSec int32
22355
22356                                 LiquidType   LiquidType
22357                                 FlowingAlt   string
22358                                 SrcAlt       string
22359                                 Viscosity    uint8 // 0-7
22360                                 LiqRenewable bool
22361                                 FlowRange    uint8
22362                                 DrownDmg     uint8
22363                                 Floodable    bool
22364
22365                                 DrawBox, ColBox, SelBox NodeBox
22366
22367                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22368
22369                                 LegacyFaceDir bool
22370                                 LegacyMounted bool
22371
22372                                 DigPredict string
22373
22374                                 MaxLvl uint8
22375
22376                                 AlphaUse
22377                         }))(obj)).AlphaUse).deserialize(r)
22378                 }); err != nil {
22379                         if err == io.EOF {
22380                                 chk(io.EOF)
22381                         }
22382                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlphaUse", err))
22383                 }
22384                 if r.N > 0 {
22385                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
22386                 }
22387         }
22388 }
22389
22390 func (obj *PointedNode) serialize(w io.Writer) {
22391         for local271 := range (*(*(struct {
22392                 Under, Above [3]int16
22393         }))(obj)).Under {
22394                 {
22395                         x := ((*(*(struct {
22396                                 Under, Above [3]int16
22397                         }))(obj)).Under)[local271]
22398                         write16(w, uint16(x))
22399                 }
22400         }
22401         for local272 := range (*(*(struct {
22402                 Under, Above [3]int16
22403         }))(obj)).Above {
22404                 {
22405                         x := ((*(*(struct {
22406                                 Under, Above [3]int16
22407                         }))(obj)).Above)[local272]
22408                         write16(w, uint16(x))
22409                 }
22410         }
22411 }
22412
22413 func (obj *PointedNode) deserialize(r io.Reader) {
22414         for local273 := range (*(*(struct {
22415                 Under, Above [3]int16
22416         }))(obj)).Under {
22417                 {
22418                         p := &((*(*(struct {
22419                                 Under, Above [3]int16
22420                         }))(obj)).Under)[local273]
22421                         *p = int16(read16(r))
22422                 }
22423         }
22424         for local274 := range (*(*(struct {
22425                 Under, Above [3]int16
22426         }))(obj)).Above {
22427                 {
22428                         p := &((*(*(struct {
22429                                 Under, Above [3]int16
22430                         }))(obj)).Above)[local274]
22431                         *p = int16(read16(r))
22432                 }
22433         }
22434 }
22435
22436 func (obj *PointedAO) serialize(w io.Writer) {
22437         if err := pcall(func() {
22438                 ((*(*(struct {
22439                         ID AOID
22440                 }))(obj)).ID).serialize(w)
22441         }); err != nil {
22442                 if err == io.EOF {
22443                         chk(io.EOF)
22444                 }
22445                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
22446         }
22447 }
22448
22449 func (obj *PointedAO) deserialize(r io.Reader) {
22450         if err := pcall(func() {
22451                 ((*(*(struct {
22452                         ID AOID
22453                 }))(obj)).ID).deserialize(r)
22454         }); err != nil {
22455                 if err == io.EOF {
22456                         chk(io.EOF)
22457                 }
22458                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
22459         }
22460 }
22461
22462 func (obj *CompressionModes) serialize(w io.Writer) {
22463         {
22464                 x := *(*(uint16))(obj)
22465                 write16(w, uint16(x))
22466         }
22467 }
22468
22469 func (obj *CompressionModes) deserialize(r io.Reader) {
22470         {
22471                 p := &*(*(uint16))(obj)
22472                 *p = read16(r)
22473         }
22474 }
22475
22476 func (obj *PlayerPos) serialize(w io.Writer) {
22477         for local275 := range (*(*(struct {
22478                 Pos100, Vel100   [3]int32
22479                 Pitch100, Yaw100 int32
22480                 Keys             Keys
22481                 FOV80            uint8
22482                 WantedRange      uint8 // in MapBlks.
22483         }))(obj)).Pos100 {
22484                 {
22485                         x := ((*(*(struct {
22486                                 Pos100, Vel100   [3]int32
22487                                 Pitch100, Yaw100 int32
22488                                 Keys             Keys
22489                                 FOV80            uint8
22490                                 WantedRange      uint8 // in MapBlks.
22491                         }))(obj)).Pos100)[local275]
22492                         write32(w, uint32(x))
22493                 }
22494         }
22495         for local276 := range (*(*(struct {
22496                 Pos100, Vel100   [3]int32
22497                 Pitch100, Yaw100 int32
22498                 Keys             Keys
22499                 FOV80            uint8
22500                 WantedRange      uint8 // in MapBlks.
22501         }))(obj)).Vel100 {
22502                 {
22503                         x := ((*(*(struct {
22504                                 Pos100, Vel100   [3]int32
22505                                 Pitch100, Yaw100 int32
22506                                 Keys             Keys
22507                                 FOV80            uint8
22508                                 WantedRange      uint8 // in MapBlks.
22509                         }))(obj)).Vel100)[local276]
22510                         write32(w, uint32(x))
22511                 }
22512         }
22513         {
22514                 x := (*(*(struct {
22515                         Pos100, Vel100   [3]int32
22516                         Pitch100, Yaw100 int32
22517                         Keys             Keys
22518                         FOV80            uint8
22519                         WantedRange      uint8 // in MapBlks.
22520                 }))(obj)).Pitch100
22521                 write32(w, uint32(x))
22522         }
22523         {
22524                 x := (*(*(struct {
22525                         Pos100, Vel100   [3]int32
22526                         Pitch100, Yaw100 int32
22527                         Keys             Keys
22528                         FOV80            uint8
22529                         WantedRange      uint8 // in MapBlks.
22530                 }))(obj)).Yaw100
22531                 write32(w, uint32(x))
22532         }
22533         if err := pcall(func() {
22534                 ((*(*(struct {
22535                         Pos100, Vel100   [3]int32
22536                         Pitch100, Yaw100 int32
22537                         Keys             Keys
22538                         FOV80            uint8
22539                         WantedRange      uint8 // in MapBlks.
22540                 }))(obj)).Keys).serialize(w)
22541         }); err != nil {
22542                 if err == io.EOF {
22543                         chk(io.EOF)
22544                 }
22545                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Keys", err))
22546         }
22547         {
22548                 x := (*(*(struct {
22549                         Pos100, Vel100   [3]int32
22550                         Pitch100, Yaw100 int32
22551                         Keys             Keys
22552                         FOV80            uint8
22553                         WantedRange      uint8 // in MapBlks.
22554                 }))(obj)).FOV80
22555                 write8(w, uint8(x))
22556         }
22557         {
22558                 x := (*(*(struct {
22559                         Pos100, Vel100   [3]int32
22560                         Pitch100, Yaw100 int32
22561                         Keys             Keys
22562                         FOV80            uint8
22563                         WantedRange      uint8 // in MapBlks.
22564                 }))(obj)).WantedRange
22565                 write8(w, uint8(x))
22566         }
22567 }
22568
22569 func (obj *PlayerPos) deserialize(r io.Reader) {
22570         for local277 := range (*(*(struct {
22571                 Pos100, Vel100   [3]int32
22572                 Pitch100, Yaw100 int32
22573                 Keys             Keys
22574                 FOV80            uint8
22575                 WantedRange      uint8 // in MapBlks.
22576         }))(obj)).Pos100 {
22577                 {
22578                         p := &((*(*(struct {
22579                                 Pos100, Vel100   [3]int32
22580                                 Pitch100, Yaw100 int32
22581                                 Keys             Keys
22582                                 FOV80            uint8
22583                                 WantedRange      uint8 // in MapBlks.
22584                         }))(obj)).Pos100)[local277]
22585                         *p = int32(read32(r))
22586                 }
22587         }
22588         for local278 := range (*(*(struct {
22589                 Pos100, Vel100   [3]int32
22590                 Pitch100, Yaw100 int32
22591                 Keys             Keys
22592                 FOV80            uint8
22593                 WantedRange      uint8 // in MapBlks.
22594         }))(obj)).Vel100 {
22595                 {
22596                         p := &((*(*(struct {
22597                                 Pos100, Vel100   [3]int32
22598                                 Pitch100, Yaw100 int32
22599                                 Keys             Keys
22600                                 FOV80            uint8
22601                                 WantedRange      uint8 // in MapBlks.
22602                         }))(obj)).Vel100)[local278]
22603                         *p = int32(read32(r))
22604                 }
22605         }
22606         {
22607                 p := &(*(*(struct {
22608                         Pos100, Vel100   [3]int32
22609                         Pitch100, Yaw100 int32
22610                         Keys             Keys
22611                         FOV80            uint8
22612                         WantedRange      uint8 // in MapBlks.
22613                 }))(obj)).Pitch100
22614                 *p = int32(read32(r))
22615         }
22616         {
22617                 p := &(*(*(struct {
22618                         Pos100, Vel100   [3]int32
22619                         Pitch100, Yaw100 int32
22620                         Keys             Keys
22621                         FOV80            uint8
22622                         WantedRange      uint8 // in MapBlks.
22623                 }))(obj)).Yaw100
22624                 *p = int32(read32(r))
22625         }
22626         if err := pcall(func() {
22627                 ((*(*(struct {
22628                         Pos100, Vel100   [3]int32
22629                         Pitch100, Yaw100 int32
22630                         Keys             Keys
22631                         FOV80            uint8
22632                         WantedRange      uint8 // in MapBlks.
22633                 }))(obj)).Keys).deserialize(r)
22634         }); err != nil {
22635                 if err == io.EOF {
22636                         chk(io.EOF)
22637                 }
22638                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Keys", err))
22639         }
22640         {
22641                 p := &(*(*(struct {
22642                         Pos100, Vel100   [3]int32
22643                         Pitch100, Yaw100 int32
22644                         Keys             Keys
22645                         FOV80            uint8
22646                         WantedRange      uint8 // in MapBlks.
22647                 }))(obj)).FOV80
22648                 *p = read8(r)
22649         }
22650         {
22651                 p := &(*(*(struct {
22652                         Pos100, Vel100   [3]int32
22653                         Pitch100, Yaw100 int32
22654                         Keys             Keys
22655                         FOV80            uint8
22656                         WantedRange      uint8 // in MapBlks.
22657                 }))(obj)).WantedRange
22658                 *p = read8(r)
22659         }
22660 }
22661
22662 func (obj *Interaction) serialize(w io.Writer) {
22663         {
22664                 x := *(*(uint8))(obj)
22665                 write8(w, uint8(x))
22666         }
22667 }
22668
22669 func (obj *Interaction) deserialize(r io.Reader) {
22670         {
22671                 p := &*(*(uint8))(obj)
22672                 *p = read8(r)
22673         }
22674 }
22675
22676 func (obj *SoundID) serialize(w io.Writer) {
22677         {
22678                 x := *(*(int32))(obj)
22679                 write32(w, uint32(x))
22680         }
22681 }
22682
22683 func (obj *SoundID) deserialize(r io.Reader) {
22684         {
22685                 p := &*(*(int32))(obj)
22686                 *p = int32(read32(r))
22687         }
22688 }
22689
22690 func (obj *Field) serialize(w io.Writer) {
22691         if len(([]byte((*(*(struct {
22692                 Name string
22693
22694                 //mt:len32
22695                 Value string
22696         }))(obj)).Name))) > math.MaxUint16 {
22697                 chk(ErrTooLong)
22698         }
22699         {
22700                 x := uint16(len(([]byte((*(*(struct {
22701                         Name string
22702
22703                         //mt:len32
22704                         Value string
22705                 }))(obj)).Name))))
22706                 write16(w, uint16(x))
22707         }
22708         {
22709                 _, err := w.Write(([]byte((*(*(struct {
22710                         Name string
22711
22712                         //mt:len32
22713                         Value string
22714                 }))(obj)).Name))[:])
22715                 chk(err)
22716         }
22717         if len(([]byte((*(*(struct {
22718                 Name string
22719
22720                 //mt:len32
22721                 Value string
22722         }))(obj)).Value))) > math.MaxUint32 {
22723                 chk(ErrTooLong)
22724         }
22725         {
22726                 x := uint32(len(([]byte((*(*(struct {
22727                         Name string
22728
22729                         //mt:len32
22730                         Value string
22731                 }))(obj)).Value))))
22732                 write32(w, uint32(x))
22733         }
22734         {
22735                 _, err := w.Write(([]byte((*(*(struct {
22736                         Name string
22737
22738                         //mt:len32
22739                         Value string
22740                 }))(obj)).Value))[:])
22741                 chk(err)
22742         }
22743 }
22744
22745 func (obj *Field) deserialize(r io.Reader) {
22746         var local279 []uint8
22747         var local280 uint16
22748         {
22749                 p := &local280
22750                 *p = read16(r)
22751         }
22752         (local279) = make([]uint8, local280)
22753         {
22754                 _, err := io.ReadFull(r, (local279)[:])
22755                 chk(err)
22756         }
22757         ((*(*(struct {
22758                 Name string
22759
22760                 //mt:len32
22761                 Value string
22762         }))(obj)).Name) = string(local279)
22763         var local281 []uint8
22764         var local282 uint32
22765         {
22766                 p := &local282
22767                 *p = read32(r)
22768         }
22769         (local281) = make([]uint8, local282)
22770         {
22771                 _, err := io.ReadFull(r, (local281)[:])
22772                 chk(err)
22773         }
22774         ((*(*(struct {
22775                 Name string
22776
22777                 //mt:len32
22778                 Value string
22779         }))(obj)).Value) = string(local281)
22780 }
22781
22782 func (obj *AuthMethods) serialize(w io.Writer) {
22783         {
22784                 x := *(*(uint32))(obj)
22785                 write32(w, uint32(x))
22786         }
22787 }
22788
22789 func (obj *AuthMethods) deserialize(r io.Reader) {
22790         {
22791                 p := &*(*(uint32))(obj)
22792                 *p = read32(r)
22793         }
22794 }
22795
22796 func (obj *Pos) serialize(w io.Writer) {
22797         if err := pcall(func() {
22798                 (*(*(Vec))(obj)).serialize(w)
22799         }); err != nil {
22800                 if err == io.EOF {
22801                         chk(io.EOF)
22802                 }
22803                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
22804         }
22805 }
22806
22807 func (obj *Pos) deserialize(r io.Reader) {
22808         if err := pcall(func() {
22809                 (*(*(Vec))(obj)).deserialize(r)
22810         }); err != nil {
22811                 if err == io.EOF {
22812                         chk(io.EOF)
22813                 }
22814                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
22815         }
22816 }
22817
22818 func (obj *KickReason) serialize(w io.Writer) {
22819         {
22820                 x := *(*(uint8))(obj)
22821                 write8(w, uint8(x))
22822         }
22823 }
22824
22825 func (obj *KickReason) deserialize(r io.Reader) {
22826         {
22827                 p := &*(*(uint8))(obj)
22828                 *p = read8(r)
22829         }
22830 }
22831
22832 func (obj *MapBlk) serialize(w io.Writer) {
22833         if err := pcall(func() {
22834                 ((*(*(struct {
22835                         Flags   MapBlkFlags
22836                         LitFrom LitFromBlks
22837
22838                         //mt:zstd
22839                         Param0 [4096]Content
22840                         Param1 [4096]uint8
22841                         Param2 [4096]uint8
22842
22843                         NodeMetas map[uint16]*NodeMeta
22844                 }))(obj)).Flags).serialize(w)
22845         }); err != nil {
22846                 if err == io.EOF {
22847                         chk(io.EOF)
22848                 }
22849                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlkFlags", err))
22850         }
22851         if err := pcall(func() {
22852                 ((*(*(struct {
22853                         Flags   MapBlkFlags
22854                         LitFrom LitFromBlks
22855
22856                         //mt:zstd
22857                         Param0 [4096]Content
22858                         Param1 [4096]uint8
22859                         Param2 [4096]uint8
22860
22861                         NodeMetas map[uint16]*NodeMeta
22862                 }))(obj)).LitFrom).serialize(w)
22863         }); err != nil {
22864                 if err == io.EOF {
22865                         chk(io.EOF)
22866                 }
22867                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
22868         }
22869         {
22870                 local283 := uint8(2) // Size of param0 in bytes.
22871                 {
22872                         x := local283
22873                         write8(w, uint8(x))
22874                 }
22875         }
22876         {
22877                 local284 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
22878                 {
22879                         x := local284
22880                         write8(w, uint8(x))
22881                 }
22882         }
22883         {
22884                 w, err := zstd.NewWriter(w)
22885                 chk(err)
22886                 for local285 := range (*(*(struct {
22887                         Flags   MapBlkFlags
22888                         LitFrom LitFromBlks
22889
22890                         //mt:zstd
22891                         Param0 [4096]Content
22892                         Param1 [4096]uint8
22893                         Param2 [4096]uint8
22894
22895                         NodeMetas map[uint16]*NodeMeta
22896                 }))(obj)).Param0 {
22897                         if err := pcall(func() {
22898                                 (((*(*(struct {
22899                                         Flags   MapBlkFlags
22900                                         LitFrom LitFromBlks
22901
22902                                         //mt:zstd
22903                                         Param0 [4096]Content
22904                                         Param1 [4096]uint8
22905                                         Param2 [4096]uint8
22906
22907                                         NodeMetas map[uint16]*NodeMeta
22908                                 }))(obj)).Param0)[local285]).serialize(w)
22909                         }); err != nil {
22910                                 if err == io.EOF {
22911                                         chk(io.EOF)
22912                                 }
22913                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
22914                         }
22915                 }
22916                 {
22917                         _, err := w.Write(((*(*(struct {
22918                                 Flags   MapBlkFlags
22919                                 LitFrom LitFromBlks
22920
22921                                 //mt:zstd
22922                                 Param0 [4096]Content
22923                                 Param1 [4096]uint8
22924                                 Param2 [4096]uint8
22925
22926                                 NodeMetas map[uint16]*NodeMeta
22927                         }))(obj)).Param1)[:])
22928                         chk(err)
22929                 }
22930                 {
22931                         _, err := w.Write(((*(*(struct {
22932                                 Flags   MapBlkFlags
22933                                 LitFrom LitFromBlks
22934
22935                                 //mt:zstd
22936                                 Param0 [4096]Content
22937                                 Param1 [4096]uint8
22938                                 Param2 [4096]uint8
22939
22940                                 NodeMetas map[uint16]*NodeMeta
22941                         }))(obj)).Param2)[:])
22942                         chk(err)
22943                 }
22944                 chk(w.Close())
22945         }
22946         {
22947                 x := (*(*(struct {
22948                         Flags   MapBlkFlags
22949                         LitFrom LitFromBlks
22950
22951                         //mt:zstd
22952                         Param0 [4096]Content
22953                         Param1 [4096]uint8
22954                         Param2 [4096]uint8
22955
22956                         NodeMetas map[uint16]*NodeMeta
22957                 }))(obj)).NodeMetas
22958                 {
22959                         w := zlib.NewWriter(w)
22960
22961                         if x == nil {
22962                                 write8(w, 0)
22963                         } else {
22964                                 write8(w, 2)
22965                                 // len(map[uint16]...) always < math.MaxUint16
22966                                 write16(w, uint16(len(x)))
22967                                 keys := make([]uint16, 0, len(x))
22968                                 for key := range x {
22969                                         keys = append(keys, key)
22970                                 }
22971                                 sort.Slice(keys, func(i, j int) bool {
22972                                         i2pos := func(i int) [3]int16 {
22973                                                 return Blkpos2Pos([3]int16{}, keys[i])
22974                                         }
22975
22976                                         p, q := i2pos(i), i2pos(j)
22977
22978                                         for i := range p {
22979                                                 switch {
22980                                                 case p[i] < q[i]:
22981                                                         return true
22982                                                 case p[i] > q[i]:
22983                                                         return false
22984                                                 }
22985                                         }
22986
22987                                         return false
22988                                 })
22989                                 for _, key := range keys {
22990                                         write16(w, key)
22991                                         chk(serialize(w, x[key]))
22992                                 }
22993                         }
22994
22995                         chk(w.Close())
22996                 }
22997
22998         }
22999         {
23000                 local286 := uint8(2) // version
23001                 {
23002                         x := local286
23003                         write8(w, uint8(x))
23004                 }
23005         }
23006 }
23007
23008 func (obj *MapBlk) deserialize(r io.Reader) {
23009         if err := pcall(func() {
23010                 ((*(*(struct {
23011                         Flags   MapBlkFlags
23012                         LitFrom LitFromBlks
23013
23014                         //mt:zstd
23015                         Param0 [4096]Content
23016                         Param1 [4096]uint8
23017                         Param2 [4096]uint8
23018
23019                         NodeMetas map[uint16]*NodeMeta
23020                 }))(obj)).Flags).deserialize(r)
23021         }); err != nil {
23022                 if err == io.EOF {
23023                         chk(io.EOF)
23024                 }
23025                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlkFlags", err))
23026         }
23027         if err := pcall(func() {
23028                 ((*(*(struct {
23029                         Flags   MapBlkFlags
23030                         LitFrom LitFromBlks
23031
23032                         //mt:zstd
23033                         Param0 [4096]Content
23034                         Param1 [4096]uint8
23035                         Param2 [4096]uint8
23036
23037                         NodeMetas map[uint16]*NodeMeta
23038                 }))(obj)).LitFrom).deserialize(r)
23039         }); err != nil {
23040                 if err == io.EOF {
23041                         chk(io.EOF)
23042                 }
23043                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
23044         }
23045         {
23046                 var local287 uint8
23047                 local288 := uint8(2) // Size of param0 in bytes.
23048                 {
23049                         p := &local287
23050                         *p = read8(r)
23051                 }
23052                 if local287 != local288 {
23053                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local287))
23054                 }
23055         }
23056         {
23057                 var local289 uint8
23058                 local290 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23059                 {
23060                         p := &local289
23061                         *p = read8(r)
23062                 }
23063                 if local289 != local290 {
23064                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local289))
23065                 }
23066         }
23067         {
23068                 r, err := zstd.NewReader(byteReader{r})
23069                 chk(err)
23070                 for local291 := range (*(*(struct {
23071                         Flags   MapBlkFlags
23072                         LitFrom LitFromBlks
23073
23074                         //mt:zstd
23075                         Param0 [4096]Content
23076                         Param1 [4096]uint8
23077                         Param2 [4096]uint8
23078
23079                         NodeMetas map[uint16]*NodeMeta
23080                 }))(obj)).Param0 {
23081                         if err := pcall(func() {
23082                                 (((*(*(struct {
23083                                         Flags   MapBlkFlags
23084                                         LitFrom LitFromBlks
23085
23086                                         //mt:zstd
23087                                         Param0 [4096]Content
23088                                         Param1 [4096]uint8
23089                                         Param2 [4096]uint8
23090
23091                                         NodeMetas map[uint16]*NodeMeta
23092                                 }))(obj)).Param0)[local291]).deserialize(r)
23093                         }); err != nil {
23094                                 if err == io.EOF {
23095                                         chk(io.EOF)
23096                                 }
23097                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23098                         }
23099                 }
23100                 {
23101                         _, err := io.ReadFull(r, ((*(*(struct {
23102                                 Flags   MapBlkFlags
23103                                 LitFrom LitFromBlks
23104
23105                                 //mt:zstd
23106                                 Param0 [4096]Content
23107                                 Param1 [4096]uint8
23108                                 Param2 [4096]uint8
23109
23110                                 NodeMetas map[uint16]*NodeMeta
23111                         }))(obj)).Param1)[:])
23112                         chk(err)
23113                 }
23114                 {
23115                         _, err := io.ReadFull(r, ((*(*(struct {
23116                                 Flags   MapBlkFlags
23117                                 LitFrom LitFromBlks
23118
23119                                 //mt:zstd
23120                                 Param0 [4096]Content
23121                                 Param1 [4096]uint8
23122                                 Param2 [4096]uint8
23123
23124                                 NodeMetas map[uint16]*NodeMeta
23125                         }))(obj)).Param2)[:])
23126                         chk(err)
23127                 }
23128                 r.Close()
23129         }
23130         {
23131                 p := &(*(*(struct {
23132                         Flags   MapBlkFlags
23133                         LitFrom LitFromBlks
23134
23135                         //mt:zstd
23136                         Param0 [4096]Content
23137                         Param1 [4096]uint8
23138                         Param2 [4096]uint8
23139
23140                         NodeMetas map[uint16]*NodeMeta
23141                 }))(obj)).NodeMetas
23142                 {
23143                         r, err := zlib.NewReader(byteReader{r})
23144                         chk(err)
23145
23146                         switch ver := read8(r); ver {
23147                         case 0:
23148                                 *p = nil
23149                         case 2:
23150                                 n := read16(r)
23151                                 *p = make(map[uint16]*NodeMeta, n)
23152                                 for ; n > 0; n-- {
23153                                         pos := read16(r)
23154                                         nm := new(NodeMeta)
23155                                         chk(deserialize(r, nm))
23156                                         (*p)[pos] = nm
23157                                 }
23158                         default:
23159                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
23160                         }
23161
23162                         chk(r.Close())
23163                 }
23164
23165         }
23166         {
23167                 var local292 uint8
23168                 local293 := uint8(2) // version
23169                 {
23170                         p := &local292
23171                         *p = read8(r)
23172                 }
23173                 if local292 != local293 {
23174                         chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local292))
23175                 }
23176         }
23177 }
23178
23179 func (obj *Node) serialize(w io.Writer) {
23180         if err := pcall(func() {
23181                 ((*(*(struct {
23182                         Param0         Content
23183                         Param1, Param2 uint8
23184                 }))(obj)).Param0).serialize(w)
23185         }); err != nil {
23186                 if err == io.EOF {
23187                         chk(io.EOF)
23188                 }
23189                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23190         }
23191         {
23192                 x := (*(*(struct {
23193                         Param0         Content
23194                         Param1, Param2 uint8
23195                 }))(obj)).Param1
23196                 write8(w, uint8(x))
23197         }
23198         {
23199                 x := (*(*(struct {
23200                         Param0         Content
23201                         Param1, Param2 uint8
23202                 }))(obj)).Param2
23203                 write8(w, uint8(x))
23204         }
23205 }
23206
23207 func (obj *Node) deserialize(r io.Reader) {
23208         if err := pcall(func() {
23209                 ((*(*(struct {
23210                         Param0         Content
23211                         Param1, Param2 uint8
23212                 }))(obj)).Param0).deserialize(r)
23213         }); err != nil {
23214                 if err == io.EOF {
23215                         chk(io.EOF)
23216                 }
23217                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23218         }
23219         {
23220                 p := &(*(*(struct {
23221                         Param0         Content
23222                         Param1, Param2 uint8
23223                 }))(obj)).Param1
23224                 *p = read8(r)
23225         }
23226         {
23227                 p := &(*(*(struct {
23228                         Param0         Content
23229                         Param1, Param2 uint8
23230                 }))(obj)).Param2
23231                 *p = read8(r)
23232         }
23233 }
23234
23235 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
23236         {
23237                 x := *(*(uint64))(obj)
23238                 write64(w, uint64(x))
23239
23240         }
23241 }
23242
23243 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
23244         {
23245                 p := &*(*(uint64))(obj)
23246                 *p = read64(r)
23247
23248         }
23249 }
23250
23251 func (obj *Vec) serialize(w io.Writer) {
23252         for local294 := range *(*([3]float32))(obj) {
23253                 {
23254                         x := (*(*([3]float32))(obj))[local294]
23255                         write32(w, math.Float32bits(x))
23256                 }
23257         }
23258 }
23259
23260 func (obj *Vec) deserialize(r io.Reader) {
23261         for local295 := range *(*([3]float32))(obj) {
23262                 {
23263                         p := &(*(*([3]float32))(obj))[local295]
23264                         *p = math.Float32frombits(read32(r))
23265                 }
23266         }
23267 }
23268
23269 func (obj *ChatMsgType) serialize(w io.Writer) {
23270         {
23271                 x := *(*(uint8))(obj)
23272                 write8(w, uint8(x))
23273         }
23274 }
23275
23276 func (obj *ChatMsgType) deserialize(r io.Reader) {
23277         {
23278                 p := &*(*(uint8))(obj)
23279                 *p = read8(r)
23280         }
23281 }
23282
23283 func (obj *AOID) serialize(w io.Writer) {
23284         {
23285                 x := *(*(uint16))(obj)
23286                 write16(w, uint16(x))
23287         }
23288 }
23289
23290 func (obj *AOID) deserialize(r io.Reader) {
23291         {
23292                 p := &*(*(uint16))(obj)
23293                 *p = read16(r)
23294         }
23295 }
23296
23297 func (obj *AOAdd) serialize(w io.Writer) {
23298         if err := pcall(func() {
23299                 ((*(*(struct {
23300                         ID AOID
23301                         //mt:const genericCAO
23302                         //mt:lenhdr 32
23303                         InitData AOInitData
23304                 }))(obj)).ID).serialize(w)
23305         }); err != nil {
23306                 if err == io.EOF {
23307                         chk(io.EOF)
23308                 }
23309                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23310         }
23311         {
23312                 local296 := genericCAO
23313                 if err := pcall(func() {
23314                         (local296).serialize(w)
23315                 }); err != nil {
23316                         if err == io.EOF {
23317                                 chk(io.EOF)
23318                         }
23319                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
23320                 }
23321         }
23322         {
23323                 ow := w
23324                 w := new(bytes.Buffer)
23325                 if err := pcall(func() {
23326                         ((*(*(struct {
23327                                 ID AOID
23328                                 //mt:const genericCAO
23329                                 //mt:lenhdr 32
23330                                 InitData AOInitData
23331                         }))(obj)).InitData).serialize(w)
23332                 }); err != nil {
23333                         if err == io.EOF {
23334                                 chk(io.EOF)
23335                         }
23336                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
23337                 }
23338                 {
23339                         buf := w
23340                         w := ow
23341                         if len((buf.Bytes())) > math.MaxUint32 {
23342                                 chk(ErrTooLong)
23343                         }
23344                         {
23345                                 x := uint32(len((buf.Bytes())))
23346                                 write32(w, uint32(x))
23347                         }
23348                         {
23349                                 _, err := w.Write((buf.Bytes())[:])
23350                                 chk(err)
23351                         }
23352                 }
23353         }
23354 }
23355
23356 func (obj *AOAdd) deserialize(r io.Reader) {
23357         if err := pcall(func() {
23358                 ((*(*(struct {
23359                         ID AOID
23360                         //mt:const genericCAO
23361                         //mt:lenhdr 32
23362                         InitData AOInitData
23363                 }))(obj)).ID).deserialize(r)
23364         }); err != nil {
23365                 if err == io.EOF {
23366                         chk(io.EOF)
23367                 }
23368                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23369         }
23370         {
23371                 var local297 aoType
23372                 local298 := genericCAO
23373                 if err := pcall(func() {
23374                         (local297).deserialize(r)
23375                 }); err != nil {
23376                         if err == io.EOF {
23377                                 chk(io.EOF)
23378                         }
23379                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
23380                 }
23381                 if local297 != local298 {
23382                         chk(fmt.Errorf("const %v: %v", "genericCAO", local297))
23383                 }
23384         }
23385         {
23386                 var n uint32
23387                 {
23388                         p := &n
23389                         *p = read32(r)
23390                 }
23391                 r := &io.LimitedReader{R: r, N: int64(n)}
23392                 if err := pcall(func() {
23393                         ((*(*(struct {
23394                                 ID AOID
23395                                 //mt:const genericCAO
23396                                 //mt:lenhdr 32
23397                                 InitData AOInitData
23398                         }))(obj)).InitData).deserialize(r)
23399                 }); err != nil {
23400                         if err == io.EOF {
23401                                 chk(io.EOF)
23402                         }
23403                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
23404                 }
23405                 if r.N > 0 {
23406                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23407                 }
23408         }
23409 }
23410
23411 func (obj *IDAOMsg) serialize(w io.Writer) {
23412         if err := pcall(func() {
23413                 ((*(*(struct {
23414                         ID AOID
23415                         //mt:lenhdr 16
23416                         Msg AOMsg
23417                 }))(obj)).ID).serialize(w)
23418         }); err != nil {
23419                 if err == io.EOF {
23420                         chk(io.EOF)
23421                 }
23422                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23423         }
23424         {
23425                 ow := w
23426                 w := new(bytes.Buffer)
23427                 {
23428                         x := (*(*(struct {
23429                                 ID AOID
23430                                 //mt:lenhdr 16
23431                                 Msg AOMsg
23432                         }))(obj)).Msg
23433                         writeAOMsg(w, x)
23434
23435                 }
23436                 {
23437                         buf := w
23438                         w := ow
23439                         if len((buf.Bytes())) > math.MaxUint16 {
23440                                 chk(ErrTooLong)
23441                         }
23442                         {
23443                                 x := uint16(len((buf.Bytes())))
23444                                 write16(w, uint16(x))
23445                         }
23446                         {
23447                                 _, err := w.Write((buf.Bytes())[:])
23448                                 chk(err)
23449                         }
23450                 }
23451         }
23452 }
23453
23454 func (obj *IDAOMsg) deserialize(r io.Reader) {
23455         if err := pcall(func() {
23456                 ((*(*(struct {
23457                         ID AOID
23458                         //mt:lenhdr 16
23459                         Msg AOMsg
23460                 }))(obj)).ID).deserialize(r)
23461         }); err != nil {
23462                 if err == io.EOF {
23463                         chk(io.EOF)
23464                 }
23465                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23466         }
23467         {
23468                 var n uint16
23469                 {
23470                         p := &n
23471                         *p = read16(r)
23472                 }
23473                 r := &io.LimitedReader{R: r, N: int64(n)}
23474                 {
23475                         p := &(*(*(struct {
23476                                 ID AOID
23477                                 //mt:lenhdr 16
23478                                 Msg AOMsg
23479                         }))(obj)).Msg
23480                         {
23481                                 var err error
23482                                 *p, err = readAOMsg(r)
23483                                 chk(err)
23484                         }
23485
23486                 }
23487                 if r.N > 0 {
23488                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23489                 }
23490         }
23491 }
23492
23493 func (obj *ItemDef) serialize(w io.Writer) {
23494         {
23495                 ow := w
23496                 w := new(bytes.Buffer)
23497                 {
23498                         local299 := uint8(6)
23499                         {
23500                                 x := local299
23501                                 write8(w, uint8(x))
23502                         }
23503                 }
23504                 if err := pcall(func() {
23505                         ((*(*(struct {
23506                                 Type ItemType
23507
23508                                 Name, Desc string
23509
23510                                 InvImg, WieldImg Texture
23511                                 WieldScale       [3]float32
23512
23513                                 StackMax uint16
23514
23515                                 Usable          bool
23516                                 CanPointLiquids bool
23517
23518                                 ToolCaps ToolCaps
23519
23520                                 Groups []Group
23521
23522                                 PlacePredict string
23523
23524                                 PlaceSnd, PlaceFailSnd SoundDef
23525
23526                                 PointRange float32
23527
23528                                 // Set index in Palette with "palette_index" item meta field,
23529                                 // this overrides Color.
23530                                 Palette Texture
23531                                 Color   color.NRGBA
23532
23533                                 // Texture overlays.
23534                                 InvOverlay, WieldOverlay Texture
23535
23536                                 ShortDesc string
23537                         }))(obj)).Type).serialize(w)
23538                 }); err != nil {
23539                         if err == io.EOF {
23540                                 chk(io.EOF)
23541                         }
23542                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
23543                 }
23544                 if len(([]byte((*(*(struct {
23545                         Type ItemType
23546
23547                         Name, Desc string
23548
23549                         InvImg, WieldImg Texture
23550                         WieldScale       [3]float32
23551
23552                         StackMax uint16
23553
23554                         Usable          bool
23555                         CanPointLiquids bool
23556
23557                         ToolCaps ToolCaps
23558
23559                         Groups []Group
23560
23561                         PlacePredict string
23562
23563                         PlaceSnd, PlaceFailSnd SoundDef
23564
23565                         PointRange float32
23566
23567                         // Set index in Palette with "palette_index" item meta field,
23568                         // this overrides Color.
23569                         Palette Texture
23570                         Color   color.NRGBA
23571
23572                         // Texture overlays.
23573                         InvOverlay, WieldOverlay Texture
23574
23575                         ShortDesc string
23576                 }))(obj)).Name))) > math.MaxUint16 {
23577                         chk(ErrTooLong)
23578                 }
23579                 {
23580                         x := uint16(len(([]byte((*(*(struct {
23581                                 Type ItemType
23582
23583                                 Name, Desc string
23584
23585                                 InvImg, WieldImg Texture
23586                                 WieldScale       [3]float32
23587
23588                                 StackMax uint16
23589
23590                                 Usable          bool
23591                                 CanPointLiquids bool
23592
23593                                 ToolCaps ToolCaps
23594
23595                                 Groups []Group
23596
23597                                 PlacePredict string
23598
23599                                 PlaceSnd, PlaceFailSnd SoundDef
23600
23601                                 PointRange float32
23602
23603                                 // Set index in Palette with "palette_index" item meta field,
23604                                 // this overrides Color.
23605                                 Palette Texture
23606                                 Color   color.NRGBA
23607
23608                                 // Texture overlays.
23609                                 InvOverlay, WieldOverlay Texture
23610
23611                                 ShortDesc string
23612                         }))(obj)).Name))))
23613                         write16(w, uint16(x))
23614                 }
23615                 {
23616                         _, err := w.Write(([]byte((*(*(struct {
23617                                 Type ItemType
23618
23619                                 Name, Desc string
23620
23621                                 InvImg, WieldImg Texture
23622                                 WieldScale       [3]float32
23623
23624                                 StackMax uint16
23625
23626                                 Usable          bool
23627                                 CanPointLiquids bool
23628
23629                                 ToolCaps ToolCaps
23630
23631                                 Groups []Group
23632
23633                                 PlacePredict string
23634
23635                                 PlaceSnd, PlaceFailSnd SoundDef
23636
23637                                 PointRange float32
23638
23639                                 // Set index in Palette with "palette_index" item meta field,
23640                                 // this overrides Color.
23641                                 Palette Texture
23642                                 Color   color.NRGBA
23643
23644                                 // Texture overlays.
23645                                 InvOverlay, WieldOverlay Texture
23646
23647                                 ShortDesc string
23648                         }))(obj)).Name))[:])
23649                         chk(err)
23650                 }
23651                 if len(([]byte((*(*(struct {
23652                         Type ItemType
23653
23654                         Name, Desc string
23655
23656                         InvImg, WieldImg Texture
23657                         WieldScale       [3]float32
23658
23659                         StackMax uint16
23660
23661                         Usable          bool
23662                         CanPointLiquids bool
23663
23664                         ToolCaps ToolCaps
23665
23666                         Groups []Group
23667
23668                         PlacePredict string
23669
23670                         PlaceSnd, PlaceFailSnd SoundDef
23671
23672                         PointRange float32
23673
23674                         // Set index in Palette with "palette_index" item meta field,
23675                         // this overrides Color.
23676                         Palette Texture
23677                         Color   color.NRGBA
23678
23679                         // Texture overlays.
23680                         InvOverlay, WieldOverlay Texture
23681
23682                         ShortDesc string
23683                 }))(obj)).Desc))) > math.MaxUint16 {
23684                         chk(ErrTooLong)
23685                 }
23686                 {
23687                         x := uint16(len(([]byte((*(*(struct {
23688                                 Type ItemType
23689
23690                                 Name, Desc string
23691
23692                                 InvImg, WieldImg Texture
23693                                 WieldScale       [3]float32
23694
23695                                 StackMax uint16
23696
23697                                 Usable          bool
23698                                 CanPointLiquids bool
23699
23700                                 ToolCaps ToolCaps
23701
23702                                 Groups []Group
23703
23704                                 PlacePredict string
23705
23706                                 PlaceSnd, PlaceFailSnd SoundDef
23707
23708                                 PointRange float32
23709
23710                                 // Set index in Palette with "palette_index" item meta field,
23711                                 // this overrides Color.
23712                                 Palette Texture
23713                                 Color   color.NRGBA
23714
23715                                 // Texture overlays.
23716                                 InvOverlay, WieldOverlay Texture
23717
23718                                 ShortDesc string
23719                         }))(obj)).Desc))))
23720                         write16(w, uint16(x))
23721                 }
23722                 {
23723                         _, err := w.Write(([]byte((*(*(struct {
23724                                 Type ItemType
23725
23726                                 Name, Desc string
23727
23728                                 InvImg, WieldImg Texture
23729                                 WieldScale       [3]float32
23730
23731                                 StackMax uint16
23732
23733                                 Usable          bool
23734                                 CanPointLiquids bool
23735
23736                                 ToolCaps ToolCaps
23737
23738                                 Groups []Group
23739
23740                                 PlacePredict string
23741
23742                                 PlaceSnd, PlaceFailSnd SoundDef
23743
23744                                 PointRange float32
23745
23746                                 // Set index in Palette with "palette_index" item meta field,
23747                                 // this overrides Color.
23748                                 Palette Texture
23749                                 Color   color.NRGBA
23750
23751                                 // Texture overlays.
23752                                 InvOverlay, WieldOverlay Texture
23753
23754                                 ShortDesc string
23755                         }))(obj)).Desc))[:])
23756                         chk(err)
23757                 }
23758                 if err := pcall(func() {
23759                         ((*(*(struct {
23760                                 Type ItemType
23761
23762                                 Name, Desc string
23763
23764                                 InvImg, WieldImg Texture
23765                                 WieldScale       [3]float32
23766
23767                                 StackMax uint16
23768
23769                                 Usable          bool
23770                                 CanPointLiquids bool
23771
23772                                 ToolCaps ToolCaps
23773
23774                                 Groups []Group
23775
23776                                 PlacePredict string
23777
23778                                 PlaceSnd, PlaceFailSnd SoundDef
23779
23780                                 PointRange float32
23781
23782                                 // Set index in Palette with "palette_index" item meta field,
23783                                 // this overrides Color.
23784                                 Palette Texture
23785                                 Color   color.NRGBA
23786
23787                                 // Texture overlays.
23788                                 InvOverlay, WieldOverlay Texture
23789
23790                                 ShortDesc string
23791                         }))(obj)).InvImg).serialize(w)
23792                 }); err != nil {
23793                         if err == io.EOF {
23794                                 chk(io.EOF)
23795                         }
23796                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
23797                 }
23798                 if err := pcall(func() {
23799                         ((*(*(struct {
23800                                 Type ItemType
23801
23802                                 Name, Desc string
23803
23804                                 InvImg, WieldImg Texture
23805                                 WieldScale       [3]float32
23806
23807                                 StackMax uint16
23808
23809                                 Usable          bool
23810                                 CanPointLiquids bool
23811
23812                                 ToolCaps ToolCaps
23813
23814                                 Groups []Group
23815
23816                                 PlacePredict string
23817
23818                                 PlaceSnd, PlaceFailSnd SoundDef
23819
23820                                 PointRange float32
23821
23822                                 // Set index in Palette with "palette_index" item meta field,
23823                                 // this overrides Color.
23824                                 Palette Texture
23825                                 Color   color.NRGBA
23826
23827                                 // Texture overlays.
23828                                 InvOverlay, WieldOverlay Texture
23829
23830                                 ShortDesc string
23831                         }))(obj)).WieldImg).serialize(w)
23832                 }); err != nil {
23833                         if err == io.EOF {
23834                                 chk(io.EOF)
23835                         }
23836                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
23837                 }
23838                 for local300 := range (*(*(struct {
23839                         Type ItemType
23840
23841                         Name, Desc string
23842
23843                         InvImg, WieldImg Texture
23844                         WieldScale       [3]float32
23845
23846                         StackMax uint16
23847
23848                         Usable          bool
23849                         CanPointLiquids bool
23850
23851                         ToolCaps ToolCaps
23852
23853                         Groups []Group
23854
23855                         PlacePredict string
23856
23857                         PlaceSnd, PlaceFailSnd SoundDef
23858
23859                         PointRange float32
23860
23861                         // Set index in Palette with "palette_index" item meta field,
23862                         // this overrides Color.
23863                         Palette Texture
23864                         Color   color.NRGBA
23865
23866                         // Texture overlays.
23867                         InvOverlay, WieldOverlay Texture
23868
23869                         ShortDesc string
23870                 }))(obj)).WieldScale {
23871                         {
23872                                 x := ((*(*(struct {
23873                                         Type ItemType
23874
23875                                         Name, Desc string
23876
23877                                         InvImg, WieldImg Texture
23878                                         WieldScale       [3]float32
23879
23880                                         StackMax uint16
23881
23882                                         Usable          bool
23883                                         CanPointLiquids bool
23884
23885                                         ToolCaps ToolCaps
23886
23887                                         Groups []Group
23888
23889                                         PlacePredict string
23890
23891                                         PlaceSnd, PlaceFailSnd SoundDef
23892
23893                                         PointRange float32
23894
23895                                         // Set index in Palette with "palette_index" item meta field,
23896                                         // this overrides Color.
23897                                         Palette Texture
23898                                         Color   color.NRGBA
23899
23900                                         // Texture overlays.
23901                                         InvOverlay, WieldOverlay Texture
23902
23903                                         ShortDesc string
23904                                 }))(obj)).WieldScale)[local300]
23905                                 write32(w, math.Float32bits(x))
23906                         }
23907                 }
23908                 {
23909                         x := (*(*(struct {
23910                                 Type ItemType
23911
23912                                 Name, Desc string
23913
23914                                 InvImg, WieldImg Texture
23915                                 WieldScale       [3]float32
23916
23917                                 StackMax uint16
23918
23919                                 Usable          bool
23920                                 CanPointLiquids bool
23921
23922                                 ToolCaps ToolCaps
23923
23924                                 Groups []Group
23925
23926                                 PlacePredict string
23927
23928                                 PlaceSnd, PlaceFailSnd SoundDef
23929
23930                                 PointRange float32
23931
23932                                 // Set index in Palette with "palette_index" item meta field,
23933                                 // this overrides Color.
23934                                 Palette Texture
23935                                 Color   color.NRGBA
23936
23937                                 // Texture overlays.
23938                                 InvOverlay, WieldOverlay Texture
23939
23940                                 ShortDesc string
23941                         }))(obj)).StackMax
23942                         write16(w, uint16(x))
23943                 }
23944                 {
23945                         x := (*(*(struct {
23946                                 Type ItemType
23947
23948                                 Name, Desc string
23949
23950                                 InvImg, WieldImg Texture
23951                                 WieldScale       [3]float32
23952
23953                                 StackMax uint16
23954
23955                                 Usable          bool
23956                                 CanPointLiquids bool
23957
23958                                 ToolCaps ToolCaps
23959
23960                                 Groups []Group
23961
23962                                 PlacePredict string
23963
23964                                 PlaceSnd, PlaceFailSnd SoundDef
23965
23966                                 PointRange float32
23967
23968                                 // Set index in Palette with "palette_index" item meta field,
23969                                 // this overrides Color.
23970                                 Palette Texture
23971                                 Color   color.NRGBA
23972
23973                                 // Texture overlays.
23974                                 InvOverlay, WieldOverlay Texture
23975
23976                                 ShortDesc string
23977                         }))(obj)).Usable
23978                         if x {
23979                                 write8(w, 1)
23980                         } else {
23981                                 write8(w, 0)
23982                         }
23983
23984                 }
23985                 {
23986                         x := (*(*(struct {
23987                                 Type ItemType
23988
23989                                 Name, Desc string
23990
23991                                 InvImg, WieldImg Texture
23992                                 WieldScale       [3]float32
23993
23994                                 StackMax uint16
23995
23996                                 Usable          bool
23997                                 CanPointLiquids bool
23998
23999                                 ToolCaps ToolCaps
24000
24001                                 Groups []Group
24002
24003                                 PlacePredict string
24004
24005                                 PlaceSnd, PlaceFailSnd SoundDef
24006
24007                                 PointRange float32
24008
24009                                 // Set index in Palette with "palette_index" item meta field,
24010                                 // this overrides Color.
24011                                 Palette Texture
24012                                 Color   color.NRGBA
24013
24014                                 // Texture overlays.
24015                                 InvOverlay, WieldOverlay Texture
24016
24017                                 ShortDesc string
24018                         }))(obj)).CanPointLiquids
24019                         if x {
24020                                 write8(w, 1)
24021                         } else {
24022                                 write8(w, 0)
24023                         }
24024
24025                 }
24026                 if err := pcall(func() {
24027                         ((*(*(struct {
24028                                 Type ItemType
24029
24030                                 Name, Desc string
24031
24032                                 InvImg, WieldImg Texture
24033                                 WieldScale       [3]float32
24034
24035                                 StackMax uint16
24036
24037                                 Usable          bool
24038                                 CanPointLiquids bool
24039
24040                                 ToolCaps ToolCaps
24041
24042                                 Groups []Group
24043
24044                                 PlacePredict string
24045
24046                                 PlaceSnd, PlaceFailSnd SoundDef
24047
24048                                 PointRange float32
24049
24050                                 // Set index in Palette with "palette_index" item meta field,
24051                                 // this overrides Color.
24052                                 Palette Texture
24053                                 Color   color.NRGBA
24054
24055                                 // Texture overlays.
24056                                 InvOverlay, WieldOverlay Texture
24057
24058                                 ShortDesc string
24059                         }))(obj)).ToolCaps).serialize(w)
24060                 }); err != nil {
24061                         if err == io.EOF {
24062                                 chk(io.EOF)
24063                         }
24064                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
24065                 }
24066                 if len(((*(*(struct {
24067                         Type ItemType
24068
24069                         Name, Desc string
24070
24071                         InvImg, WieldImg Texture
24072                         WieldScale       [3]float32
24073
24074                         StackMax uint16
24075
24076                         Usable          bool
24077                         CanPointLiquids bool
24078
24079                         ToolCaps ToolCaps
24080
24081                         Groups []Group
24082
24083                         PlacePredict string
24084
24085                         PlaceSnd, PlaceFailSnd SoundDef
24086
24087                         PointRange float32
24088
24089                         // Set index in Palette with "palette_index" item meta field,
24090                         // this overrides Color.
24091                         Palette Texture
24092                         Color   color.NRGBA
24093
24094                         // Texture overlays.
24095                         InvOverlay, WieldOverlay Texture
24096
24097                         ShortDesc string
24098                 }))(obj)).Groups)) > math.MaxUint16 {
24099                         chk(ErrTooLong)
24100                 }
24101                 {
24102                         x := uint16(len(((*(*(struct {
24103                                 Type ItemType
24104
24105                                 Name, Desc string
24106
24107                                 InvImg, WieldImg Texture
24108                                 WieldScale       [3]float32
24109
24110                                 StackMax uint16
24111
24112                                 Usable          bool
24113                                 CanPointLiquids bool
24114
24115                                 ToolCaps ToolCaps
24116
24117                                 Groups []Group
24118
24119                                 PlacePredict string
24120
24121                                 PlaceSnd, PlaceFailSnd SoundDef
24122
24123                                 PointRange float32
24124
24125                                 // Set index in Palette with "palette_index" item meta field,
24126                                 // this overrides Color.
24127                                 Palette Texture
24128                                 Color   color.NRGBA
24129
24130                                 // Texture overlays.
24131                                 InvOverlay, WieldOverlay Texture
24132
24133                                 ShortDesc string
24134                         }))(obj)).Groups)))
24135                         write16(w, uint16(x))
24136                 }
24137                 for local301 := range (*(*(struct {
24138                         Type ItemType
24139
24140                         Name, Desc string
24141
24142                         InvImg, WieldImg Texture
24143                         WieldScale       [3]float32
24144
24145                         StackMax uint16
24146
24147                         Usable          bool
24148                         CanPointLiquids bool
24149
24150                         ToolCaps ToolCaps
24151
24152                         Groups []Group
24153
24154                         PlacePredict string
24155
24156                         PlaceSnd, PlaceFailSnd SoundDef
24157
24158                         PointRange float32
24159
24160                         // Set index in Palette with "palette_index" item meta field,
24161                         // this overrides Color.
24162                         Palette Texture
24163                         Color   color.NRGBA
24164
24165                         // Texture overlays.
24166                         InvOverlay, WieldOverlay Texture
24167
24168                         ShortDesc string
24169                 }))(obj)).Groups {
24170                         if err := pcall(func() {
24171                                 (((*(*(struct {
24172                                         Type ItemType
24173
24174                                         Name, Desc string
24175
24176                                         InvImg, WieldImg Texture
24177                                         WieldScale       [3]float32
24178
24179                                         StackMax uint16
24180
24181                                         Usable          bool
24182                                         CanPointLiquids bool
24183
24184                                         ToolCaps ToolCaps
24185
24186                                         Groups []Group
24187
24188                                         PlacePredict string
24189
24190                                         PlaceSnd, PlaceFailSnd SoundDef
24191
24192                                         PointRange float32
24193
24194                                         // Set index in Palette with "palette_index" item meta field,
24195                                         // this overrides Color.
24196                                         Palette Texture
24197                                         Color   color.NRGBA
24198
24199                                         // Texture overlays.
24200                                         InvOverlay, WieldOverlay Texture
24201
24202                                         ShortDesc string
24203                                 }))(obj)).Groups)[local301]).serialize(w)
24204                         }); err != nil {
24205                                 if err == io.EOF {
24206                                         chk(io.EOF)
24207                                 }
24208                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
24209                         }
24210                 }
24211                 if len(([]byte((*(*(struct {
24212                         Type ItemType
24213
24214                         Name, Desc string
24215
24216                         InvImg, WieldImg Texture
24217                         WieldScale       [3]float32
24218
24219                         StackMax uint16
24220
24221                         Usable          bool
24222                         CanPointLiquids bool
24223
24224                         ToolCaps ToolCaps
24225
24226                         Groups []Group
24227
24228                         PlacePredict string
24229
24230                         PlaceSnd, PlaceFailSnd SoundDef
24231
24232                         PointRange float32
24233
24234                         // Set index in Palette with "palette_index" item meta field,
24235                         // this overrides Color.
24236                         Palette Texture
24237                         Color   color.NRGBA
24238
24239                         // Texture overlays.
24240                         InvOverlay, WieldOverlay Texture
24241
24242                         ShortDesc string
24243                 }))(obj)).PlacePredict))) > math.MaxUint16 {
24244                         chk(ErrTooLong)
24245                 }
24246                 {
24247                         x := uint16(len(([]byte((*(*(struct {
24248                                 Type ItemType
24249
24250                                 Name, Desc string
24251
24252                                 InvImg, WieldImg Texture
24253                                 WieldScale       [3]float32
24254
24255                                 StackMax uint16
24256
24257                                 Usable          bool
24258                                 CanPointLiquids bool
24259
24260                                 ToolCaps ToolCaps
24261
24262                                 Groups []Group
24263
24264                                 PlacePredict string
24265
24266                                 PlaceSnd, PlaceFailSnd SoundDef
24267
24268                                 PointRange float32
24269
24270                                 // Set index in Palette with "palette_index" item meta field,
24271                                 // this overrides Color.
24272                                 Palette Texture
24273                                 Color   color.NRGBA
24274
24275                                 // Texture overlays.
24276                                 InvOverlay, WieldOverlay Texture
24277
24278                                 ShortDesc string
24279                         }))(obj)).PlacePredict))))
24280                         write16(w, uint16(x))
24281                 }
24282                 {
24283                         _, err := w.Write(([]byte((*(*(struct {
24284                                 Type ItemType
24285
24286                                 Name, Desc string
24287
24288                                 InvImg, WieldImg Texture
24289                                 WieldScale       [3]float32
24290
24291                                 StackMax uint16
24292
24293                                 Usable          bool
24294                                 CanPointLiquids bool
24295
24296                                 ToolCaps ToolCaps
24297
24298                                 Groups []Group
24299
24300                                 PlacePredict string
24301
24302                                 PlaceSnd, PlaceFailSnd SoundDef
24303
24304                                 PointRange float32
24305
24306                                 // Set index in Palette with "palette_index" item meta field,
24307                                 // this overrides Color.
24308                                 Palette Texture
24309                                 Color   color.NRGBA
24310
24311                                 // Texture overlays.
24312                                 InvOverlay, WieldOverlay Texture
24313
24314                                 ShortDesc string
24315                         }))(obj)).PlacePredict))[:])
24316                         chk(err)
24317                 }
24318                 if err := pcall(func() {
24319                         ((*(*(struct {
24320                                 Type ItemType
24321
24322                                 Name, Desc string
24323
24324                                 InvImg, WieldImg Texture
24325                                 WieldScale       [3]float32
24326
24327                                 StackMax uint16
24328
24329                                 Usable          bool
24330                                 CanPointLiquids bool
24331
24332                                 ToolCaps ToolCaps
24333
24334                                 Groups []Group
24335
24336                                 PlacePredict string
24337
24338                                 PlaceSnd, PlaceFailSnd SoundDef
24339
24340                                 PointRange float32
24341
24342                                 // Set index in Palette with "palette_index" item meta field,
24343                                 // this overrides Color.
24344                                 Palette Texture
24345                                 Color   color.NRGBA
24346
24347                                 // Texture overlays.
24348                                 InvOverlay, WieldOverlay Texture
24349
24350                                 ShortDesc string
24351                         }))(obj)).PlaceSnd).serialize(w)
24352                 }); err != nil {
24353                         if err == io.EOF {
24354                                 chk(io.EOF)
24355                         }
24356                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
24357                 }
24358                 if err := pcall(func() {
24359                         ((*(*(struct {
24360                                 Type ItemType
24361
24362                                 Name, Desc string
24363
24364                                 InvImg, WieldImg Texture
24365                                 WieldScale       [3]float32
24366
24367                                 StackMax uint16
24368
24369                                 Usable          bool
24370                                 CanPointLiquids bool
24371
24372                                 ToolCaps ToolCaps
24373
24374                                 Groups []Group
24375
24376                                 PlacePredict string
24377
24378                                 PlaceSnd, PlaceFailSnd SoundDef
24379
24380                                 PointRange float32
24381
24382                                 // Set index in Palette with "palette_index" item meta field,
24383                                 // this overrides Color.
24384                                 Palette Texture
24385                                 Color   color.NRGBA
24386
24387                                 // Texture overlays.
24388                                 InvOverlay, WieldOverlay Texture
24389
24390                                 ShortDesc string
24391                         }))(obj)).PlaceFailSnd).serialize(w)
24392                 }); err != nil {
24393                         if err == io.EOF {
24394                                 chk(io.EOF)
24395                         }
24396                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
24397                 }
24398                 {
24399                         x := (*(*(struct {
24400                                 Type ItemType
24401
24402                                 Name, Desc string
24403
24404                                 InvImg, WieldImg Texture
24405                                 WieldScale       [3]float32
24406
24407                                 StackMax uint16
24408
24409                                 Usable          bool
24410                                 CanPointLiquids bool
24411
24412                                 ToolCaps ToolCaps
24413
24414                                 Groups []Group
24415
24416                                 PlacePredict string
24417
24418                                 PlaceSnd, PlaceFailSnd SoundDef
24419
24420                                 PointRange float32
24421
24422                                 // Set index in Palette with "palette_index" item meta field,
24423                                 // this overrides Color.
24424                                 Palette Texture
24425                                 Color   color.NRGBA
24426
24427                                 // Texture overlays.
24428                                 InvOverlay, WieldOverlay Texture
24429
24430                                 ShortDesc string
24431                         }))(obj)).PointRange
24432                         write32(w, math.Float32bits(x))
24433                 }
24434                 if err := pcall(func() {
24435                         ((*(*(struct {
24436                                 Type ItemType
24437
24438                                 Name, Desc string
24439
24440                                 InvImg, WieldImg Texture
24441                                 WieldScale       [3]float32
24442
24443                                 StackMax uint16
24444
24445                                 Usable          bool
24446                                 CanPointLiquids bool
24447
24448                                 ToolCaps ToolCaps
24449
24450                                 Groups []Group
24451
24452                                 PlacePredict string
24453
24454                                 PlaceSnd, PlaceFailSnd SoundDef
24455
24456                                 PointRange float32
24457
24458                                 // Set index in Palette with "palette_index" item meta field,
24459                                 // this overrides Color.
24460                                 Palette Texture
24461                                 Color   color.NRGBA
24462
24463                                 // Texture overlays.
24464                                 InvOverlay, WieldOverlay Texture
24465
24466                                 ShortDesc string
24467                         }))(obj)).Palette).serialize(w)
24468                 }); err != nil {
24469                         if err == io.EOF {
24470                                 chk(io.EOF)
24471                         }
24472                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24473                 }
24474                 {
24475                         x := (*(*(struct {
24476                                 Type ItemType
24477
24478                                 Name, Desc string
24479
24480                                 InvImg, WieldImg Texture
24481                                 WieldScale       [3]float32
24482
24483                                 StackMax uint16
24484
24485                                 Usable          bool
24486                                 CanPointLiquids bool
24487
24488                                 ToolCaps ToolCaps
24489
24490                                 Groups []Group
24491
24492                                 PlacePredict string
24493
24494                                 PlaceSnd, PlaceFailSnd SoundDef
24495
24496                                 PointRange float32
24497
24498                                 // Set index in Palette with "palette_index" item meta field,
24499                                 // this overrides Color.
24500                                 Palette Texture
24501                                 Color   color.NRGBA
24502
24503                                 // Texture overlays.
24504                                 InvOverlay, WieldOverlay Texture
24505
24506                                 ShortDesc string
24507                         }))(obj)).Color
24508                         w.Write([]byte{x.A, x.R, x.G, x.B})
24509
24510                 }
24511                 if err := pcall(func() {
24512                         ((*(*(struct {
24513                                 Type ItemType
24514
24515                                 Name, Desc string
24516
24517                                 InvImg, WieldImg Texture
24518                                 WieldScale       [3]float32
24519
24520                                 StackMax uint16
24521
24522                                 Usable          bool
24523                                 CanPointLiquids bool
24524
24525                                 ToolCaps ToolCaps
24526
24527                                 Groups []Group
24528
24529                                 PlacePredict string
24530
24531                                 PlaceSnd, PlaceFailSnd SoundDef
24532
24533                                 PointRange float32
24534
24535                                 // Set index in Palette with "palette_index" item meta field,
24536                                 // this overrides Color.
24537                                 Palette Texture
24538                                 Color   color.NRGBA
24539
24540                                 // Texture overlays.
24541                                 InvOverlay, WieldOverlay Texture
24542
24543                                 ShortDesc string
24544                         }))(obj)).InvOverlay).serialize(w)
24545                 }); err != nil {
24546                         if err == io.EOF {
24547                                 chk(io.EOF)
24548                         }
24549                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24550                 }
24551                 if err := pcall(func() {
24552                         ((*(*(struct {
24553                                 Type ItemType
24554
24555                                 Name, Desc string
24556
24557                                 InvImg, WieldImg Texture
24558                                 WieldScale       [3]float32
24559
24560                                 StackMax uint16
24561
24562                                 Usable          bool
24563                                 CanPointLiquids bool
24564
24565                                 ToolCaps ToolCaps
24566
24567                                 Groups []Group
24568
24569                                 PlacePredict string
24570
24571                                 PlaceSnd, PlaceFailSnd SoundDef
24572
24573                                 PointRange float32
24574
24575                                 // Set index in Palette with "palette_index" item meta field,
24576                                 // this overrides Color.
24577                                 Palette Texture
24578                                 Color   color.NRGBA
24579
24580                                 // Texture overlays.
24581                                 InvOverlay, WieldOverlay Texture
24582
24583                                 ShortDesc string
24584                         }))(obj)).WieldOverlay).serialize(w)
24585                 }); err != nil {
24586                         if err == io.EOF {
24587                                 chk(io.EOF)
24588                         }
24589                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24590                 }
24591                 if len(([]byte((*(*(struct {
24592                         Type ItemType
24593
24594                         Name, Desc string
24595
24596                         InvImg, WieldImg Texture
24597                         WieldScale       [3]float32
24598
24599                         StackMax uint16
24600
24601                         Usable          bool
24602                         CanPointLiquids bool
24603
24604                         ToolCaps ToolCaps
24605
24606                         Groups []Group
24607
24608                         PlacePredict string
24609
24610                         PlaceSnd, PlaceFailSnd SoundDef
24611
24612                         PointRange float32
24613
24614                         // Set index in Palette with "palette_index" item meta field,
24615                         // this overrides Color.
24616                         Palette Texture
24617                         Color   color.NRGBA
24618
24619                         // Texture overlays.
24620                         InvOverlay, WieldOverlay Texture
24621
24622                         ShortDesc string
24623                 }))(obj)).ShortDesc))) > math.MaxUint16 {
24624                         chk(ErrTooLong)
24625                 }
24626                 {
24627                         x := uint16(len(([]byte((*(*(struct {
24628                                 Type ItemType
24629
24630                                 Name, Desc string
24631
24632                                 InvImg, WieldImg Texture
24633                                 WieldScale       [3]float32
24634
24635                                 StackMax uint16
24636
24637                                 Usable          bool
24638                                 CanPointLiquids bool
24639
24640                                 ToolCaps ToolCaps
24641
24642                                 Groups []Group
24643
24644                                 PlacePredict string
24645
24646                                 PlaceSnd, PlaceFailSnd SoundDef
24647
24648                                 PointRange float32
24649
24650                                 // Set index in Palette with "palette_index" item meta field,
24651                                 // this overrides Color.
24652                                 Palette Texture
24653                                 Color   color.NRGBA
24654
24655                                 // Texture overlays.
24656                                 InvOverlay, WieldOverlay Texture
24657
24658                                 ShortDesc string
24659                         }))(obj)).ShortDesc))))
24660                         write16(w, uint16(x))
24661                 }
24662                 {
24663                         _, err := w.Write(([]byte((*(*(struct {
24664                                 Type ItemType
24665
24666                                 Name, Desc string
24667
24668                                 InvImg, WieldImg Texture
24669                                 WieldScale       [3]float32
24670
24671                                 StackMax uint16
24672
24673                                 Usable          bool
24674                                 CanPointLiquids bool
24675
24676                                 ToolCaps ToolCaps
24677
24678                                 Groups []Group
24679
24680                                 PlacePredict string
24681
24682                                 PlaceSnd, PlaceFailSnd SoundDef
24683
24684                                 PointRange float32
24685
24686                                 // Set index in Palette with "palette_index" item meta field,
24687                                 // this overrides Color.
24688                                 Palette Texture
24689                                 Color   color.NRGBA
24690
24691                                 // Texture overlays.
24692                                 InvOverlay, WieldOverlay Texture
24693
24694                                 ShortDesc string
24695                         }))(obj)).ShortDesc))[:])
24696                         chk(err)
24697                 }
24698                 {
24699                         buf := w
24700                         w := ow
24701                         if len((buf.Bytes())) > math.MaxUint16 {
24702                                 chk(ErrTooLong)
24703                         }
24704                         {
24705                                 x := uint16(len((buf.Bytes())))
24706                                 write16(w, uint16(x))
24707                         }
24708                         {
24709                                 _, err := w.Write((buf.Bytes())[:])
24710                                 chk(err)
24711                         }
24712                 }
24713         }
24714 }
24715
24716 func (obj *ItemDef) deserialize(r io.Reader) {
24717         {
24718                 var n uint16
24719                 {
24720                         p := &n
24721                         *p = read16(r)
24722                 }
24723                 r := &io.LimitedReader{R: r, N: int64(n)}
24724                 {
24725                         var local302 uint8
24726                         local303 := uint8(6)
24727                         {
24728                                 p := &local302
24729                                 *p = read8(r)
24730                         }
24731                         if local302 != local303 {
24732                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local302))
24733                         }
24734                 }
24735                 if err := pcall(func() {
24736                         ((*(*(struct {
24737                                 Type ItemType
24738
24739                                 Name, Desc string
24740
24741                                 InvImg, WieldImg Texture
24742                                 WieldScale       [3]float32
24743
24744                                 StackMax uint16
24745
24746                                 Usable          bool
24747                                 CanPointLiquids bool
24748
24749                                 ToolCaps ToolCaps
24750
24751                                 Groups []Group
24752
24753                                 PlacePredict string
24754
24755                                 PlaceSnd, PlaceFailSnd SoundDef
24756
24757                                 PointRange float32
24758
24759                                 // Set index in Palette with "palette_index" item meta field,
24760                                 // this overrides Color.
24761                                 Palette Texture
24762                                 Color   color.NRGBA
24763
24764                                 // Texture overlays.
24765                                 InvOverlay, WieldOverlay Texture
24766
24767                                 ShortDesc string
24768                         }))(obj)).Type).deserialize(r)
24769                 }); err != nil {
24770                         if err == io.EOF {
24771                                 chk(io.EOF)
24772                         }
24773                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
24774                 }
24775                 var local304 []uint8
24776                 var local305 uint16
24777                 {
24778                         p := &local305
24779                         *p = read16(r)
24780                 }
24781                 (local304) = make([]uint8, local305)
24782                 {
24783                         _, err := io.ReadFull(r, (local304)[:])
24784                         chk(err)
24785                 }
24786                 ((*(*(struct {
24787                         Type ItemType
24788
24789                         Name, Desc string
24790
24791                         InvImg, WieldImg Texture
24792                         WieldScale       [3]float32
24793
24794                         StackMax uint16
24795
24796                         Usable          bool
24797                         CanPointLiquids bool
24798
24799                         ToolCaps ToolCaps
24800
24801                         Groups []Group
24802
24803                         PlacePredict string
24804
24805                         PlaceSnd, PlaceFailSnd SoundDef
24806
24807                         PointRange float32
24808
24809                         // Set index in Palette with "palette_index" item meta field,
24810                         // this overrides Color.
24811                         Palette Texture
24812                         Color   color.NRGBA
24813
24814                         // Texture overlays.
24815                         InvOverlay, WieldOverlay Texture
24816
24817                         ShortDesc string
24818                 }))(obj)).Name) = string(local304)
24819                 var local306 []uint8
24820                 var local307 uint16
24821                 {
24822                         p := &local307
24823                         *p = read16(r)
24824                 }
24825                 (local306) = make([]uint8, local307)
24826                 {
24827                         _, err := io.ReadFull(r, (local306)[:])
24828                         chk(err)
24829                 }
24830                 ((*(*(struct {
24831                         Type ItemType
24832
24833                         Name, Desc string
24834
24835                         InvImg, WieldImg Texture
24836                         WieldScale       [3]float32
24837
24838                         StackMax uint16
24839
24840                         Usable          bool
24841                         CanPointLiquids bool
24842
24843                         ToolCaps ToolCaps
24844
24845                         Groups []Group
24846
24847                         PlacePredict string
24848
24849                         PlaceSnd, PlaceFailSnd SoundDef
24850
24851                         PointRange float32
24852
24853                         // Set index in Palette with "palette_index" item meta field,
24854                         // this overrides Color.
24855                         Palette Texture
24856                         Color   color.NRGBA
24857
24858                         // Texture overlays.
24859                         InvOverlay, WieldOverlay Texture
24860
24861                         ShortDesc string
24862                 }))(obj)).Desc) = string(local306)
24863                 if err := pcall(func() {
24864                         ((*(*(struct {
24865                                 Type ItemType
24866
24867                                 Name, Desc string
24868
24869                                 InvImg, WieldImg Texture
24870                                 WieldScale       [3]float32
24871
24872                                 StackMax uint16
24873
24874                                 Usable          bool
24875                                 CanPointLiquids bool
24876
24877                                 ToolCaps ToolCaps
24878
24879                                 Groups []Group
24880
24881                                 PlacePredict string
24882
24883                                 PlaceSnd, PlaceFailSnd SoundDef
24884
24885                                 PointRange float32
24886
24887                                 // Set index in Palette with "palette_index" item meta field,
24888                                 // this overrides Color.
24889                                 Palette Texture
24890                                 Color   color.NRGBA
24891
24892                                 // Texture overlays.
24893                                 InvOverlay, WieldOverlay Texture
24894
24895                                 ShortDesc string
24896                         }))(obj)).InvImg).deserialize(r)
24897                 }); err != nil {
24898                         if err == io.EOF {
24899                                 chk(io.EOF)
24900                         }
24901                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24902                 }
24903                 if err := pcall(func() {
24904                         ((*(*(struct {
24905                                 Type ItemType
24906
24907                                 Name, Desc string
24908
24909                                 InvImg, WieldImg Texture
24910                                 WieldScale       [3]float32
24911
24912                                 StackMax uint16
24913
24914                                 Usable          bool
24915                                 CanPointLiquids bool
24916
24917                                 ToolCaps ToolCaps
24918
24919                                 Groups []Group
24920
24921                                 PlacePredict string
24922
24923                                 PlaceSnd, PlaceFailSnd SoundDef
24924
24925                                 PointRange float32
24926
24927                                 // Set index in Palette with "palette_index" item meta field,
24928                                 // this overrides Color.
24929                                 Palette Texture
24930                                 Color   color.NRGBA
24931
24932                                 // Texture overlays.
24933                                 InvOverlay, WieldOverlay Texture
24934
24935                                 ShortDesc string
24936                         }))(obj)).WieldImg).deserialize(r)
24937                 }); err != nil {
24938                         if err == io.EOF {
24939                                 chk(io.EOF)
24940                         }
24941                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24942                 }
24943                 for local308 := range (*(*(struct {
24944                         Type ItemType
24945
24946                         Name, Desc string
24947
24948                         InvImg, WieldImg Texture
24949                         WieldScale       [3]float32
24950
24951                         StackMax uint16
24952
24953                         Usable          bool
24954                         CanPointLiquids bool
24955
24956                         ToolCaps ToolCaps
24957
24958                         Groups []Group
24959
24960                         PlacePredict string
24961
24962                         PlaceSnd, PlaceFailSnd SoundDef
24963
24964                         PointRange float32
24965
24966                         // Set index in Palette with "palette_index" item meta field,
24967                         // this overrides Color.
24968                         Palette Texture
24969                         Color   color.NRGBA
24970
24971                         // Texture overlays.
24972                         InvOverlay, WieldOverlay Texture
24973
24974                         ShortDesc string
24975                 }))(obj)).WieldScale {
24976                         {
24977                                 p := &((*(*(struct {
24978                                         Type ItemType
24979
24980                                         Name, Desc string
24981
24982                                         InvImg, WieldImg Texture
24983                                         WieldScale       [3]float32
24984
24985                                         StackMax uint16
24986
24987                                         Usable          bool
24988                                         CanPointLiquids bool
24989
24990                                         ToolCaps ToolCaps
24991
24992                                         Groups []Group
24993
24994                                         PlacePredict string
24995
24996                                         PlaceSnd, PlaceFailSnd SoundDef
24997
24998                                         PointRange float32
24999
25000                                         // Set index in Palette with "palette_index" item meta field,
25001                                         // this overrides Color.
25002                                         Palette Texture
25003                                         Color   color.NRGBA
25004
25005                                         // Texture overlays.
25006                                         InvOverlay, WieldOverlay Texture
25007
25008                                         ShortDesc string
25009                                 }))(obj)).WieldScale)[local308]
25010                                 *p = math.Float32frombits(read32(r))
25011                         }
25012                 }
25013                 {
25014                         p := &(*(*(struct {
25015                                 Type ItemType
25016
25017                                 Name, Desc string
25018
25019                                 InvImg, WieldImg Texture
25020                                 WieldScale       [3]float32
25021
25022                                 StackMax uint16
25023
25024                                 Usable          bool
25025                                 CanPointLiquids bool
25026
25027                                 ToolCaps ToolCaps
25028
25029                                 Groups []Group
25030
25031                                 PlacePredict string
25032
25033                                 PlaceSnd, PlaceFailSnd SoundDef
25034
25035                                 PointRange float32
25036
25037                                 // Set index in Palette with "palette_index" item meta field,
25038                                 // this overrides Color.
25039                                 Palette Texture
25040                                 Color   color.NRGBA
25041
25042                                 // Texture overlays.
25043                                 InvOverlay, WieldOverlay Texture
25044
25045                                 ShortDesc string
25046                         }))(obj)).StackMax
25047                         *p = read16(r)
25048                 }
25049                 {
25050                         p := &(*(*(struct {
25051                                 Type ItemType
25052
25053                                 Name, Desc string
25054
25055                                 InvImg, WieldImg Texture
25056                                 WieldScale       [3]float32
25057
25058                                 StackMax uint16
25059
25060                                 Usable          bool
25061                                 CanPointLiquids bool
25062
25063                                 ToolCaps ToolCaps
25064
25065                                 Groups []Group
25066
25067                                 PlacePredict string
25068
25069                                 PlaceSnd, PlaceFailSnd SoundDef
25070
25071                                 PointRange float32
25072
25073                                 // Set index in Palette with "palette_index" item meta field,
25074                                 // this overrides Color.
25075                                 Palette Texture
25076                                 Color   color.NRGBA
25077
25078                                 // Texture overlays.
25079                                 InvOverlay, WieldOverlay Texture
25080
25081                                 ShortDesc string
25082                         }))(obj)).Usable
25083                         switch n := read8(r); n {
25084                         case 0:
25085                                 *p = false
25086                         case 1:
25087                                 *p = true
25088                         default:
25089                                 chk(fmt.Errorf("invalid bool: %d", n))
25090                         }
25091
25092                 }
25093                 {
25094                         p := &(*(*(struct {
25095                                 Type ItemType
25096
25097                                 Name, Desc string
25098
25099                                 InvImg, WieldImg Texture
25100                                 WieldScale       [3]float32
25101
25102                                 StackMax uint16
25103
25104                                 Usable          bool
25105                                 CanPointLiquids bool
25106
25107                                 ToolCaps ToolCaps
25108
25109                                 Groups []Group
25110
25111                                 PlacePredict string
25112
25113                                 PlaceSnd, PlaceFailSnd SoundDef
25114
25115                                 PointRange float32
25116
25117                                 // Set index in Palette with "palette_index" item meta field,
25118                                 // this overrides Color.
25119                                 Palette Texture
25120                                 Color   color.NRGBA
25121
25122                                 // Texture overlays.
25123                                 InvOverlay, WieldOverlay Texture
25124
25125                                 ShortDesc string
25126                         }))(obj)).CanPointLiquids
25127                         switch n := read8(r); n {
25128                         case 0:
25129                                 *p = false
25130                         case 1:
25131                                 *p = true
25132                         default:
25133                                 chk(fmt.Errorf("invalid bool: %d", n))
25134                         }
25135
25136                 }
25137                 if err := pcall(func() {
25138                         ((*(*(struct {
25139                                 Type ItemType
25140
25141                                 Name, Desc string
25142
25143                                 InvImg, WieldImg Texture
25144                                 WieldScale       [3]float32
25145
25146                                 StackMax uint16
25147
25148                                 Usable          bool
25149                                 CanPointLiquids bool
25150
25151                                 ToolCaps ToolCaps
25152
25153                                 Groups []Group
25154
25155                                 PlacePredict string
25156
25157                                 PlaceSnd, PlaceFailSnd SoundDef
25158
25159                                 PointRange float32
25160
25161                                 // Set index in Palette with "palette_index" item meta field,
25162                                 // this overrides Color.
25163                                 Palette Texture
25164                                 Color   color.NRGBA
25165
25166                                 // Texture overlays.
25167                                 InvOverlay, WieldOverlay Texture
25168
25169                                 ShortDesc string
25170                         }))(obj)).ToolCaps).deserialize(r)
25171                 }); err != nil {
25172                         if err == io.EOF {
25173                                 chk(io.EOF)
25174                         }
25175                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
25176                 }
25177                 var local309 uint16
25178                 {
25179                         p := &local309
25180                         *p = read16(r)
25181                 }
25182                 ((*(*(struct {
25183                         Type ItemType
25184
25185                         Name, Desc string
25186
25187                         InvImg, WieldImg Texture
25188                         WieldScale       [3]float32
25189
25190                         StackMax uint16
25191
25192                         Usable          bool
25193                         CanPointLiquids bool
25194
25195                         ToolCaps ToolCaps
25196
25197                         Groups []Group
25198
25199                         PlacePredict string
25200
25201                         PlaceSnd, PlaceFailSnd SoundDef
25202
25203                         PointRange float32
25204
25205                         // Set index in Palette with "palette_index" item meta field,
25206                         // this overrides Color.
25207                         Palette Texture
25208                         Color   color.NRGBA
25209
25210                         // Texture overlays.
25211                         InvOverlay, WieldOverlay Texture
25212
25213                         ShortDesc string
25214                 }))(obj)).Groups) = make([]Group, local309)
25215                 for local310 := range (*(*(struct {
25216                         Type ItemType
25217
25218                         Name, Desc string
25219
25220                         InvImg, WieldImg Texture
25221                         WieldScale       [3]float32
25222
25223                         StackMax uint16
25224
25225                         Usable          bool
25226                         CanPointLiquids bool
25227
25228                         ToolCaps ToolCaps
25229
25230                         Groups []Group
25231
25232                         PlacePredict string
25233
25234                         PlaceSnd, PlaceFailSnd SoundDef
25235
25236                         PointRange float32
25237
25238                         // Set index in Palette with "palette_index" item meta field,
25239                         // this overrides Color.
25240                         Palette Texture
25241                         Color   color.NRGBA
25242
25243                         // Texture overlays.
25244                         InvOverlay, WieldOverlay Texture
25245
25246                         ShortDesc string
25247                 }))(obj)).Groups {
25248                         if err := pcall(func() {
25249                                 (((*(*(struct {
25250                                         Type ItemType
25251
25252                                         Name, Desc string
25253
25254                                         InvImg, WieldImg Texture
25255                                         WieldScale       [3]float32
25256
25257                                         StackMax uint16
25258
25259                                         Usable          bool
25260                                         CanPointLiquids bool
25261
25262                                         ToolCaps ToolCaps
25263
25264                                         Groups []Group
25265
25266                                         PlacePredict string
25267
25268                                         PlaceSnd, PlaceFailSnd SoundDef
25269
25270                                         PointRange float32
25271
25272                                         // Set index in Palette with "palette_index" item meta field,
25273                                         // this overrides Color.
25274                                         Palette Texture
25275                                         Color   color.NRGBA
25276
25277                                         // Texture overlays.
25278                                         InvOverlay, WieldOverlay Texture
25279
25280                                         ShortDesc string
25281                                 }))(obj)).Groups)[local310]).deserialize(r)
25282                         }); err != nil {
25283                                 if err == io.EOF {
25284                                         chk(io.EOF)
25285                                 }
25286                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
25287                         }
25288                 }
25289                 var local311 []uint8
25290                 var local312 uint16
25291                 {
25292                         p := &local312
25293                         *p = read16(r)
25294                 }
25295                 (local311) = make([]uint8, local312)
25296                 {
25297                         _, err := io.ReadFull(r, (local311)[:])
25298                         chk(err)
25299                 }
25300                 ((*(*(struct {
25301                         Type ItemType
25302
25303                         Name, Desc string
25304
25305                         InvImg, WieldImg Texture
25306                         WieldScale       [3]float32
25307
25308                         StackMax uint16
25309
25310                         Usable          bool
25311                         CanPointLiquids bool
25312
25313                         ToolCaps ToolCaps
25314
25315                         Groups []Group
25316
25317                         PlacePredict string
25318
25319                         PlaceSnd, PlaceFailSnd SoundDef
25320
25321                         PointRange float32
25322
25323                         // Set index in Palette with "palette_index" item meta field,
25324                         // this overrides Color.
25325                         Palette Texture
25326                         Color   color.NRGBA
25327
25328                         // Texture overlays.
25329                         InvOverlay, WieldOverlay Texture
25330
25331                         ShortDesc string
25332                 }))(obj)).PlacePredict) = string(local311)
25333                 if err := pcall(func() {
25334                         ((*(*(struct {
25335                                 Type ItemType
25336
25337                                 Name, Desc string
25338
25339                                 InvImg, WieldImg Texture
25340                                 WieldScale       [3]float32
25341
25342                                 StackMax uint16
25343
25344                                 Usable          bool
25345                                 CanPointLiquids bool
25346
25347                                 ToolCaps ToolCaps
25348
25349                                 Groups []Group
25350
25351                                 PlacePredict string
25352
25353                                 PlaceSnd, PlaceFailSnd SoundDef
25354
25355                                 PointRange float32
25356
25357                                 // Set index in Palette with "palette_index" item meta field,
25358                                 // this overrides Color.
25359                                 Palette Texture
25360                                 Color   color.NRGBA
25361
25362                                 // Texture overlays.
25363                                 InvOverlay, WieldOverlay Texture
25364
25365                                 ShortDesc string
25366                         }))(obj)).PlaceSnd).deserialize(r)
25367                 }); err != nil {
25368                         if err == io.EOF {
25369                                 chk(io.EOF)
25370                         }
25371                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25372                 }
25373                 if err := pcall(func() {
25374                         ((*(*(struct {
25375                                 Type ItemType
25376
25377                                 Name, Desc string
25378
25379                                 InvImg, WieldImg Texture
25380                                 WieldScale       [3]float32
25381
25382                                 StackMax uint16
25383
25384                                 Usable          bool
25385                                 CanPointLiquids bool
25386
25387                                 ToolCaps ToolCaps
25388
25389                                 Groups []Group
25390
25391                                 PlacePredict string
25392
25393                                 PlaceSnd, PlaceFailSnd SoundDef
25394
25395                                 PointRange float32
25396
25397                                 // Set index in Palette with "palette_index" item meta field,
25398                                 // this overrides Color.
25399                                 Palette Texture
25400                                 Color   color.NRGBA
25401
25402                                 // Texture overlays.
25403                                 InvOverlay, WieldOverlay Texture
25404
25405                                 ShortDesc string
25406                         }))(obj)).PlaceFailSnd).deserialize(r)
25407                 }); err != nil {
25408                         if err == io.EOF {
25409                                 chk(io.EOF)
25410                         }
25411                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25412                 }
25413                 {
25414                         p := &(*(*(struct {
25415                                 Type ItemType
25416
25417                                 Name, Desc string
25418
25419                                 InvImg, WieldImg Texture
25420                                 WieldScale       [3]float32
25421
25422                                 StackMax uint16
25423
25424                                 Usable          bool
25425                                 CanPointLiquids bool
25426
25427                                 ToolCaps ToolCaps
25428
25429                                 Groups []Group
25430
25431                                 PlacePredict string
25432
25433                                 PlaceSnd, PlaceFailSnd SoundDef
25434
25435                                 PointRange float32
25436
25437                                 // Set index in Palette with "palette_index" item meta field,
25438                                 // this overrides Color.
25439                                 Palette Texture
25440                                 Color   color.NRGBA
25441
25442                                 // Texture overlays.
25443                                 InvOverlay, WieldOverlay Texture
25444
25445                                 ShortDesc string
25446                         }))(obj)).PointRange
25447                         *p = math.Float32frombits(read32(r))
25448                 }
25449                 if err := pcall(func() {
25450                         ((*(*(struct {
25451                                 Type ItemType
25452
25453                                 Name, Desc string
25454
25455                                 InvImg, WieldImg Texture
25456                                 WieldScale       [3]float32
25457
25458                                 StackMax uint16
25459
25460                                 Usable          bool
25461                                 CanPointLiquids bool
25462
25463                                 ToolCaps ToolCaps
25464
25465                                 Groups []Group
25466
25467                                 PlacePredict string
25468
25469                                 PlaceSnd, PlaceFailSnd SoundDef
25470
25471                                 PointRange float32
25472
25473                                 // Set index in Palette with "palette_index" item meta field,
25474                                 // this overrides Color.
25475                                 Palette Texture
25476                                 Color   color.NRGBA
25477
25478                                 // Texture overlays.
25479                                 InvOverlay, WieldOverlay Texture
25480
25481                                 ShortDesc string
25482                         }))(obj)).Palette).deserialize(r)
25483                 }); err != nil {
25484                         if err == io.EOF {
25485                                 chk(io.EOF)
25486                         }
25487                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25488                 }
25489                 {
25490                         p := &(*(*(struct {
25491                                 Type ItemType
25492
25493                                 Name, Desc string
25494
25495                                 InvImg, WieldImg Texture
25496                                 WieldScale       [3]float32
25497
25498                                 StackMax uint16
25499
25500                                 Usable          bool
25501                                 CanPointLiquids bool
25502
25503                                 ToolCaps ToolCaps
25504
25505                                 Groups []Group
25506
25507                                 PlacePredict string
25508
25509                                 PlaceSnd, PlaceFailSnd SoundDef
25510
25511                                 PointRange float32
25512
25513                                 // Set index in Palette with "palette_index" item meta field,
25514                                 // this overrides Color.
25515                                 Palette Texture
25516                                 Color   color.NRGBA
25517
25518                                 // Texture overlays.
25519                                 InvOverlay, WieldOverlay Texture
25520
25521                                 ShortDesc string
25522                         }))(obj)).Color
25523                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
25524
25525                 }
25526                 if err := pcall(func() {
25527                         ((*(*(struct {
25528                                 Type ItemType
25529
25530                                 Name, Desc string
25531
25532                                 InvImg, WieldImg Texture
25533                                 WieldScale       [3]float32
25534
25535                                 StackMax uint16
25536
25537                                 Usable          bool
25538                                 CanPointLiquids bool
25539
25540                                 ToolCaps ToolCaps
25541
25542                                 Groups []Group
25543
25544                                 PlacePredict string
25545
25546                                 PlaceSnd, PlaceFailSnd SoundDef
25547
25548                                 PointRange float32
25549
25550                                 // Set index in Palette with "palette_index" item meta field,
25551                                 // this overrides Color.
25552                                 Palette Texture
25553                                 Color   color.NRGBA
25554
25555                                 // Texture overlays.
25556                                 InvOverlay, WieldOverlay Texture
25557
25558                                 ShortDesc string
25559                         }))(obj)).InvOverlay).deserialize(r)
25560                 }); err != nil {
25561                         if err == io.EOF {
25562                                 chk(io.EOF)
25563                         }
25564                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25565                 }
25566                 if err := pcall(func() {
25567                         ((*(*(struct {
25568                                 Type ItemType
25569
25570                                 Name, Desc string
25571
25572                                 InvImg, WieldImg Texture
25573                                 WieldScale       [3]float32
25574
25575                                 StackMax uint16
25576
25577                                 Usable          bool
25578                                 CanPointLiquids bool
25579
25580                                 ToolCaps ToolCaps
25581
25582                                 Groups []Group
25583
25584                                 PlacePredict string
25585
25586                                 PlaceSnd, PlaceFailSnd SoundDef
25587
25588                                 PointRange float32
25589
25590                                 // Set index in Palette with "palette_index" item meta field,
25591                                 // this overrides Color.
25592                                 Palette Texture
25593                                 Color   color.NRGBA
25594
25595                                 // Texture overlays.
25596                                 InvOverlay, WieldOverlay Texture
25597
25598                                 ShortDesc string
25599                         }))(obj)).WieldOverlay).deserialize(r)
25600                 }); err != nil {
25601                         if err == io.EOF {
25602                                 chk(io.EOF)
25603                         }
25604                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25605                 }
25606                 var local313 []uint8
25607                 var local314 uint16
25608                 {
25609                         p := &local314
25610                         *p = read16(r)
25611                 }
25612                 (local313) = make([]uint8, local314)
25613                 {
25614                         _, err := io.ReadFull(r, (local313)[:])
25615                         chk(err)
25616                 }
25617                 ((*(*(struct {
25618                         Type ItemType
25619
25620                         Name, Desc string
25621
25622                         InvImg, WieldImg Texture
25623                         WieldScale       [3]float32
25624
25625                         StackMax uint16
25626
25627                         Usable          bool
25628                         CanPointLiquids bool
25629
25630                         ToolCaps ToolCaps
25631
25632                         Groups []Group
25633
25634                         PlacePredict string
25635
25636                         PlaceSnd, PlaceFailSnd SoundDef
25637
25638                         PointRange float32
25639
25640                         // Set index in Palette with "palette_index" item meta field,
25641                         // this overrides Color.
25642                         Palette Texture
25643                         Color   color.NRGBA
25644
25645                         // Texture overlays.
25646                         InvOverlay, WieldOverlay Texture
25647
25648                         ShortDesc string
25649                 }))(obj)).ShortDesc) = string(local313)
25650                 if r.N > 0 {
25651                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
25652                 }
25653         }
25654 }
25655
25656 func (obj *SoundSrcType) serialize(w io.Writer) {
25657         {
25658                 x := *(*(uint8))(obj)
25659                 write8(w, uint8(x))
25660         }
25661 }
25662
25663 func (obj *SoundSrcType) deserialize(r io.Reader) {
25664         {
25665                 p := &*(*(uint8))(obj)
25666                 *p = read8(r)
25667         }
25668 }
25669
25670 func (obj *TileAnim) serialize(w io.Writer) {
25671         if err := pcall(func() {
25672                 ((*(*(struct {
25673                         Type AnimType
25674
25675                         //mt:if %s.Type == SpriteSheetAnim
25676                         AspectRatio [2]uint8
25677
25678                         //mt:if %s.Type == VerticalFrameAnim
25679                         NFrames [2]uint16
25680
25681                         //mt:if %s.Type != NoAnim
25682                         Duration float32 // in seconds
25683
25684                 }))(obj)).Type).serialize(w)
25685         }); err != nil {
25686                 if err == io.EOF {
25687                         chk(io.EOF)
25688                 }
25689                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
25690         }
25691         if !((*(*(struct {
25692                 Type AnimType
25693
25694                 //mt:if %s.Type == SpriteSheetAnim
25695                 AspectRatio [2]uint8
25696
25697                 //mt:if %s.Type == VerticalFrameAnim
25698                 NFrames [2]uint16
25699
25700                 //mt:if %s.Type != NoAnim
25701                 Duration float32 // in seconds
25702
25703         }))(obj)).Type < maxAnim) {
25704                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25705         }
25706         if (*(*(struct {
25707                 Type AnimType
25708
25709                 //mt:if %s.Type == SpriteSheetAnim
25710                 AspectRatio [2]uint8
25711
25712                 //mt:if %s.Type == VerticalFrameAnim
25713                 NFrames [2]uint16
25714
25715                 //mt:if %s.Type != NoAnim
25716                 Duration float32 // in seconds
25717
25718         }))(obj)).Type == SpriteSheetAnim {
25719                 {
25720                         _, err := w.Write(((*(*(struct {
25721                                 Type AnimType
25722
25723                                 //mt:if %s.Type == SpriteSheetAnim
25724                                 AspectRatio [2]uint8
25725
25726                                 //mt:if %s.Type == VerticalFrameAnim
25727                                 NFrames [2]uint16
25728
25729                                 //mt:if %s.Type != NoAnim
25730                                 Duration float32 // in seconds
25731
25732                         }))(obj)).AspectRatio)[:])
25733                         chk(err)
25734                 }
25735         }
25736         if (*(*(struct {
25737                 Type AnimType
25738
25739                 //mt:if %s.Type == SpriteSheetAnim
25740                 AspectRatio [2]uint8
25741
25742                 //mt:if %s.Type == VerticalFrameAnim
25743                 NFrames [2]uint16
25744
25745                 //mt:if %s.Type != NoAnim
25746                 Duration float32 // in seconds
25747
25748         }))(obj)).Type == VerticalFrameAnim {
25749                 for local315 := range (*(*(struct {
25750                         Type AnimType
25751
25752                         //mt:if %s.Type == SpriteSheetAnim
25753                         AspectRatio [2]uint8
25754
25755                         //mt:if %s.Type == VerticalFrameAnim
25756                         NFrames [2]uint16
25757
25758                         //mt:if %s.Type != NoAnim
25759                         Duration float32 // in seconds
25760
25761                 }))(obj)).NFrames {
25762                         {
25763                                 x := ((*(*(struct {
25764                                         Type AnimType
25765
25766                                         //mt:if %s.Type == SpriteSheetAnim
25767                                         AspectRatio [2]uint8
25768
25769                                         //mt:if %s.Type == VerticalFrameAnim
25770                                         NFrames [2]uint16
25771
25772                                         //mt:if %s.Type != NoAnim
25773                                         Duration float32 // in seconds
25774
25775                                 }))(obj)).NFrames)[local315]
25776                                 write16(w, uint16(x))
25777                         }
25778                 }
25779         }
25780         if (*(*(struct {
25781                 Type AnimType
25782
25783                 //mt:if %s.Type == SpriteSheetAnim
25784                 AspectRatio [2]uint8
25785
25786                 //mt:if %s.Type == VerticalFrameAnim
25787                 NFrames [2]uint16
25788
25789                 //mt:if %s.Type != NoAnim
25790                 Duration float32 // in seconds
25791
25792         }))(obj)).Type != NoAnim {
25793                 {
25794                         x := (*(*(struct {
25795                                 Type AnimType
25796
25797                                 //mt:if %s.Type == SpriteSheetAnim
25798                                 AspectRatio [2]uint8
25799
25800                                 //mt:if %s.Type == VerticalFrameAnim
25801                                 NFrames [2]uint16
25802
25803                                 //mt:if %s.Type != NoAnim
25804                                 Duration float32 // in seconds
25805
25806                         }))(obj)).Duration
25807                         write32(w, math.Float32bits(x))
25808                 }
25809         }
25810 }
25811
25812 func (obj *TileAnim) deserialize(r io.Reader) {
25813         if err := pcall(func() {
25814                 ((*(*(struct {
25815                         Type AnimType
25816
25817                         //mt:if %s.Type == SpriteSheetAnim
25818                         AspectRatio [2]uint8
25819
25820                         //mt:if %s.Type == VerticalFrameAnim
25821                         NFrames [2]uint16
25822
25823                         //mt:if %s.Type != NoAnim
25824                         Duration float32 // in seconds
25825
25826                 }))(obj)).Type).deserialize(r)
25827         }); err != nil {
25828                 if err == io.EOF {
25829                         chk(io.EOF)
25830                 }
25831                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
25832         }
25833         if !((*(*(struct {
25834                 Type AnimType
25835
25836                 //mt:if %s.Type == SpriteSheetAnim
25837                 AspectRatio [2]uint8
25838
25839                 //mt:if %s.Type == VerticalFrameAnim
25840                 NFrames [2]uint16
25841
25842                 //mt:if %s.Type != NoAnim
25843                 Duration float32 // in seconds
25844
25845         }))(obj)).Type < maxAnim) {
25846                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25847         }
25848         if (*(*(struct {
25849                 Type AnimType
25850
25851                 //mt:if %s.Type == SpriteSheetAnim
25852                 AspectRatio [2]uint8
25853
25854                 //mt:if %s.Type == VerticalFrameAnim
25855                 NFrames [2]uint16
25856
25857                 //mt:if %s.Type != NoAnim
25858                 Duration float32 // in seconds
25859
25860         }))(obj)).Type == SpriteSheetAnim {
25861                 {
25862                         _, err := io.ReadFull(r, ((*(*(struct {
25863                                 Type AnimType
25864
25865                                 //mt:if %s.Type == SpriteSheetAnim
25866                                 AspectRatio [2]uint8
25867
25868                                 //mt:if %s.Type == VerticalFrameAnim
25869                                 NFrames [2]uint16
25870
25871                                 //mt:if %s.Type != NoAnim
25872                                 Duration float32 // in seconds
25873
25874                         }))(obj)).AspectRatio)[:])
25875                         chk(err)
25876                 }
25877         }
25878         if (*(*(struct {
25879                 Type AnimType
25880
25881                 //mt:if %s.Type == SpriteSheetAnim
25882                 AspectRatio [2]uint8
25883
25884                 //mt:if %s.Type == VerticalFrameAnim
25885                 NFrames [2]uint16
25886
25887                 //mt:if %s.Type != NoAnim
25888                 Duration float32 // in seconds
25889
25890         }))(obj)).Type == VerticalFrameAnim {
25891                 for local316 := range (*(*(struct {
25892                         Type AnimType
25893
25894                         //mt:if %s.Type == SpriteSheetAnim
25895                         AspectRatio [2]uint8
25896
25897                         //mt:if %s.Type == VerticalFrameAnim
25898                         NFrames [2]uint16
25899
25900                         //mt:if %s.Type != NoAnim
25901                         Duration float32 // in seconds
25902
25903                 }))(obj)).NFrames {
25904                         {
25905                                 p := &((*(*(struct {
25906                                         Type AnimType
25907
25908                                         //mt:if %s.Type == SpriteSheetAnim
25909                                         AspectRatio [2]uint8
25910
25911                                         //mt:if %s.Type == VerticalFrameAnim
25912                                         NFrames [2]uint16
25913
25914                                         //mt:if %s.Type != NoAnim
25915                                         Duration float32 // in seconds
25916
25917                                 }))(obj)).NFrames)[local316]
25918                                 *p = read16(r)
25919                         }
25920                 }
25921         }
25922         if (*(*(struct {
25923                 Type AnimType
25924
25925                 //mt:if %s.Type == SpriteSheetAnim
25926                 AspectRatio [2]uint8
25927
25928                 //mt:if %s.Type == VerticalFrameAnim
25929                 NFrames [2]uint16
25930
25931                 //mt:if %s.Type != NoAnim
25932                 Duration float32 // in seconds
25933
25934         }))(obj)).Type != NoAnim {
25935                 {
25936                         p := &(*(*(struct {
25937                                 Type AnimType
25938
25939                                 //mt:if %s.Type == SpriteSheetAnim
25940                                 AspectRatio [2]uint8
25941
25942                                 //mt:if %s.Type == VerticalFrameAnim
25943                                 NFrames [2]uint16
25944
25945                                 //mt:if %s.Type != NoAnim
25946                                 Duration float32 // in seconds
25947
25948                         }))(obj)).Duration
25949                         *p = math.Float32frombits(read32(r))
25950                 }
25951         }
25952 }
25953
25954 func (obj *Content) serialize(w io.Writer) {
25955         {
25956                 x := *(*(uint16))(obj)
25957                 write16(w, uint16(x))
25958         }
25959 }
25960
25961 func (obj *Content) deserialize(r io.Reader) {
25962         {
25963                 p := &*(*(uint16))(obj)
25964                 *p = read16(r)
25965         }
25966 }
25967
25968 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
25969         {
25970                 x := *(*(uint32))(obj)
25971                 write32(w, uint32(x))
25972         }
25973 }
25974
25975 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
25976         {
25977                 p := &*(*(uint32))(obj)
25978                 *p = read32(r)
25979         }
25980 }
25981
25982 func (obj *HUDID) serialize(w io.Writer) {
25983         {
25984                 x := *(*(uint32))(obj)
25985                 write32(w, uint32(x))
25986         }
25987 }
25988
25989 func (obj *HUDID) deserialize(r io.Reader) {
25990         {
25991                 p := &*(*(uint32))(obj)
25992                 *p = read32(r)
25993         }
25994 }
25995
25996 func (obj *HUD) serialize(w io.Writer) {
25997         if err := pcall(func() {
25998                 ((*(*(struct {
25999                         Type HUDType
26000
26001                         Pos      [2]float32
26002                         Name     string
26003                         Scale    [2]float32
26004                         Text     string
26005                         Number   uint32
26006                         Item     uint32
26007                         Dir      uint32
26008                         Align    [2]float32
26009                         Offset   [2]float32
26010                         WorldPos Pos
26011                         Size     [2]int32
26012                         ZIndex   int16
26013                         Text2    string
26014                 }))(obj)).Type).serialize(w)
26015         }); err != nil {
26016                 if err == io.EOF {
26017                         chk(io.EOF)
26018                 }
26019                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
26020         }
26021         for local317 := range (*(*(struct {
26022                 Type HUDType
26023
26024                 Pos      [2]float32
26025                 Name     string
26026                 Scale    [2]float32
26027                 Text     string
26028                 Number   uint32
26029                 Item     uint32
26030                 Dir      uint32
26031                 Align    [2]float32
26032                 Offset   [2]float32
26033                 WorldPos Pos
26034                 Size     [2]int32
26035                 ZIndex   int16
26036                 Text2    string
26037         }))(obj)).Pos {
26038                 {
26039                         x := ((*(*(struct {
26040                                 Type HUDType
26041
26042                                 Pos      [2]float32
26043                                 Name     string
26044                                 Scale    [2]float32
26045                                 Text     string
26046                                 Number   uint32
26047                                 Item     uint32
26048                                 Dir      uint32
26049                                 Align    [2]float32
26050                                 Offset   [2]float32
26051                                 WorldPos Pos
26052                                 Size     [2]int32
26053                                 ZIndex   int16
26054                                 Text2    string
26055                         }))(obj)).Pos)[local317]
26056                         write32(w, math.Float32bits(x))
26057                 }
26058         }
26059         if len(([]byte((*(*(struct {
26060                 Type HUDType
26061
26062                 Pos      [2]float32
26063                 Name     string
26064                 Scale    [2]float32
26065                 Text     string
26066                 Number   uint32
26067                 Item     uint32
26068                 Dir      uint32
26069                 Align    [2]float32
26070                 Offset   [2]float32
26071                 WorldPos Pos
26072                 Size     [2]int32
26073                 ZIndex   int16
26074                 Text2    string
26075         }))(obj)).Name))) > math.MaxUint16 {
26076                 chk(ErrTooLong)
26077         }
26078         {
26079                 x := uint16(len(([]byte((*(*(struct {
26080                         Type HUDType
26081
26082                         Pos      [2]float32
26083                         Name     string
26084                         Scale    [2]float32
26085                         Text     string
26086                         Number   uint32
26087                         Item     uint32
26088                         Dir      uint32
26089                         Align    [2]float32
26090                         Offset   [2]float32
26091                         WorldPos Pos
26092                         Size     [2]int32
26093                         ZIndex   int16
26094                         Text2    string
26095                 }))(obj)).Name))))
26096                 write16(w, uint16(x))
26097         }
26098         {
26099                 _, err := w.Write(([]byte((*(*(struct {
26100                         Type HUDType
26101
26102                         Pos      [2]float32
26103                         Name     string
26104                         Scale    [2]float32
26105                         Text     string
26106                         Number   uint32
26107                         Item     uint32
26108                         Dir      uint32
26109                         Align    [2]float32
26110                         Offset   [2]float32
26111                         WorldPos Pos
26112                         Size     [2]int32
26113                         ZIndex   int16
26114                         Text2    string
26115                 }))(obj)).Name))[:])
26116                 chk(err)
26117         }
26118         for local318 := range (*(*(struct {
26119                 Type HUDType
26120
26121                 Pos      [2]float32
26122                 Name     string
26123                 Scale    [2]float32
26124                 Text     string
26125                 Number   uint32
26126                 Item     uint32
26127                 Dir      uint32
26128                 Align    [2]float32
26129                 Offset   [2]float32
26130                 WorldPos Pos
26131                 Size     [2]int32
26132                 ZIndex   int16
26133                 Text2    string
26134         }))(obj)).Scale {
26135                 {
26136                         x := ((*(*(struct {
26137                                 Type HUDType
26138
26139                                 Pos      [2]float32
26140                                 Name     string
26141                                 Scale    [2]float32
26142                                 Text     string
26143                                 Number   uint32
26144                                 Item     uint32
26145                                 Dir      uint32
26146                                 Align    [2]float32
26147                                 Offset   [2]float32
26148                                 WorldPos Pos
26149                                 Size     [2]int32
26150                                 ZIndex   int16
26151                                 Text2    string
26152                         }))(obj)).Scale)[local318]
26153                         write32(w, math.Float32bits(x))
26154                 }
26155         }
26156         if len(([]byte((*(*(struct {
26157                 Type HUDType
26158
26159                 Pos      [2]float32
26160                 Name     string
26161                 Scale    [2]float32
26162                 Text     string
26163                 Number   uint32
26164                 Item     uint32
26165                 Dir      uint32
26166                 Align    [2]float32
26167                 Offset   [2]float32
26168                 WorldPos Pos
26169                 Size     [2]int32
26170                 ZIndex   int16
26171                 Text2    string
26172         }))(obj)).Text))) > math.MaxUint16 {
26173                 chk(ErrTooLong)
26174         }
26175         {
26176                 x := uint16(len(([]byte((*(*(struct {
26177                         Type HUDType
26178
26179                         Pos      [2]float32
26180                         Name     string
26181                         Scale    [2]float32
26182                         Text     string
26183                         Number   uint32
26184                         Item     uint32
26185                         Dir      uint32
26186                         Align    [2]float32
26187                         Offset   [2]float32
26188                         WorldPos Pos
26189                         Size     [2]int32
26190                         ZIndex   int16
26191                         Text2    string
26192                 }))(obj)).Text))))
26193                 write16(w, uint16(x))
26194         }
26195         {
26196                 _, err := w.Write(([]byte((*(*(struct {
26197                         Type HUDType
26198
26199                         Pos      [2]float32
26200                         Name     string
26201                         Scale    [2]float32
26202                         Text     string
26203                         Number   uint32
26204                         Item     uint32
26205                         Dir      uint32
26206                         Align    [2]float32
26207                         Offset   [2]float32
26208                         WorldPos Pos
26209                         Size     [2]int32
26210                         ZIndex   int16
26211                         Text2    string
26212                 }))(obj)).Text))[:])
26213                 chk(err)
26214         }
26215         {
26216                 x := (*(*(struct {
26217                         Type HUDType
26218
26219                         Pos      [2]float32
26220                         Name     string
26221                         Scale    [2]float32
26222                         Text     string
26223                         Number   uint32
26224                         Item     uint32
26225                         Dir      uint32
26226                         Align    [2]float32
26227                         Offset   [2]float32
26228                         WorldPos Pos
26229                         Size     [2]int32
26230                         ZIndex   int16
26231                         Text2    string
26232                 }))(obj)).Number
26233                 write32(w, uint32(x))
26234         }
26235         {
26236                 x := (*(*(struct {
26237                         Type HUDType
26238
26239                         Pos      [2]float32
26240                         Name     string
26241                         Scale    [2]float32
26242                         Text     string
26243                         Number   uint32
26244                         Item     uint32
26245                         Dir      uint32
26246                         Align    [2]float32
26247                         Offset   [2]float32
26248                         WorldPos Pos
26249                         Size     [2]int32
26250                         ZIndex   int16
26251                         Text2    string
26252                 }))(obj)).Item
26253                 write32(w, uint32(x))
26254         }
26255         {
26256                 x := (*(*(struct {
26257                         Type HUDType
26258
26259                         Pos      [2]float32
26260                         Name     string
26261                         Scale    [2]float32
26262                         Text     string
26263                         Number   uint32
26264                         Item     uint32
26265                         Dir      uint32
26266                         Align    [2]float32
26267                         Offset   [2]float32
26268                         WorldPos Pos
26269                         Size     [2]int32
26270                         ZIndex   int16
26271                         Text2    string
26272                 }))(obj)).Dir
26273                 write32(w, uint32(x))
26274         }
26275         for local319 := range (*(*(struct {
26276                 Type HUDType
26277
26278                 Pos      [2]float32
26279                 Name     string
26280                 Scale    [2]float32
26281                 Text     string
26282                 Number   uint32
26283                 Item     uint32
26284                 Dir      uint32
26285                 Align    [2]float32
26286                 Offset   [2]float32
26287                 WorldPos Pos
26288                 Size     [2]int32
26289                 ZIndex   int16
26290                 Text2    string
26291         }))(obj)).Align {
26292                 {
26293                         x := ((*(*(struct {
26294                                 Type HUDType
26295
26296                                 Pos      [2]float32
26297                                 Name     string
26298                                 Scale    [2]float32
26299                                 Text     string
26300                                 Number   uint32
26301                                 Item     uint32
26302                                 Dir      uint32
26303                                 Align    [2]float32
26304                                 Offset   [2]float32
26305                                 WorldPos Pos
26306                                 Size     [2]int32
26307                                 ZIndex   int16
26308                                 Text2    string
26309                         }))(obj)).Align)[local319]
26310                         write32(w, math.Float32bits(x))
26311                 }
26312         }
26313         for local320 := range (*(*(struct {
26314                 Type HUDType
26315
26316                 Pos      [2]float32
26317                 Name     string
26318                 Scale    [2]float32
26319                 Text     string
26320                 Number   uint32
26321                 Item     uint32
26322                 Dir      uint32
26323                 Align    [2]float32
26324                 Offset   [2]float32
26325                 WorldPos Pos
26326                 Size     [2]int32
26327                 ZIndex   int16
26328                 Text2    string
26329         }))(obj)).Offset {
26330                 {
26331                         x := ((*(*(struct {
26332                                 Type HUDType
26333
26334                                 Pos      [2]float32
26335                                 Name     string
26336                                 Scale    [2]float32
26337                                 Text     string
26338                                 Number   uint32
26339                                 Item     uint32
26340                                 Dir      uint32
26341                                 Align    [2]float32
26342                                 Offset   [2]float32
26343                                 WorldPos Pos
26344                                 Size     [2]int32
26345                                 ZIndex   int16
26346                                 Text2    string
26347                         }))(obj)).Offset)[local320]
26348                         write32(w, math.Float32bits(x))
26349                 }
26350         }
26351         if err := pcall(func() {
26352                 ((*(*(struct {
26353                         Type HUDType
26354
26355                         Pos      [2]float32
26356                         Name     string
26357                         Scale    [2]float32
26358                         Text     string
26359                         Number   uint32
26360                         Item     uint32
26361                         Dir      uint32
26362                         Align    [2]float32
26363                         Offset   [2]float32
26364                         WorldPos Pos
26365                         Size     [2]int32
26366                         ZIndex   int16
26367                         Text2    string
26368                 }))(obj)).WorldPos).serialize(w)
26369         }); err != nil {
26370                 if err == io.EOF {
26371                         chk(io.EOF)
26372                 }
26373                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
26374         }
26375         for local321 := range (*(*(struct {
26376                 Type HUDType
26377
26378                 Pos      [2]float32
26379                 Name     string
26380                 Scale    [2]float32
26381                 Text     string
26382                 Number   uint32
26383                 Item     uint32
26384                 Dir      uint32
26385                 Align    [2]float32
26386                 Offset   [2]float32
26387                 WorldPos Pos
26388                 Size     [2]int32
26389                 ZIndex   int16
26390                 Text2    string
26391         }))(obj)).Size {
26392                 {
26393                         x := ((*(*(struct {
26394                                 Type HUDType
26395
26396                                 Pos      [2]float32
26397                                 Name     string
26398                                 Scale    [2]float32
26399                                 Text     string
26400                                 Number   uint32
26401                                 Item     uint32
26402                                 Dir      uint32
26403                                 Align    [2]float32
26404                                 Offset   [2]float32
26405                                 WorldPos Pos
26406                                 Size     [2]int32
26407                                 ZIndex   int16
26408                                 Text2    string
26409                         }))(obj)).Size)[local321]
26410                         write32(w, uint32(x))
26411                 }
26412         }
26413         {
26414                 x := (*(*(struct {
26415                         Type HUDType
26416
26417                         Pos      [2]float32
26418                         Name     string
26419                         Scale    [2]float32
26420                         Text     string
26421                         Number   uint32
26422                         Item     uint32
26423                         Dir      uint32
26424                         Align    [2]float32
26425                         Offset   [2]float32
26426                         WorldPos Pos
26427                         Size     [2]int32
26428                         ZIndex   int16
26429                         Text2    string
26430                 }))(obj)).ZIndex
26431                 write16(w, uint16(x))
26432         }
26433         if len(([]byte((*(*(struct {
26434                 Type HUDType
26435
26436                 Pos      [2]float32
26437                 Name     string
26438                 Scale    [2]float32
26439                 Text     string
26440                 Number   uint32
26441                 Item     uint32
26442                 Dir      uint32
26443                 Align    [2]float32
26444                 Offset   [2]float32
26445                 WorldPos Pos
26446                 Size     [2]int32
26447                 ZIndex   int16
26448                 Text2    string
26449         }))(obj)).Text2))) > math.MaxUint16 {
26450                 chk(ErrTooLong)
26451         }
26452         {
26453                 x := uint16(len(([]byte((*(*(struct {
26454                         Type HUDType
26455
26456                         Pos      [2]float32
26457                         Name     string
26458                         Scale    [2]float32
26459                         Text     string
26460                         Number   uint32
26461                         Item     uint32
26462                         Dir      uint32
26463                         Align    [2]float32
26464                         Offset   [2]float32
26465                         WorldPos Pos
26466                         Size     [2]int32
26467                         ZIndex   int16
26468                         Text2    string
26469                 }))(obj)).Text2))))
26470                 write16(w, uint16(x))
26471         }
26472         {
26473                 _, err := w.Write(([]byte((*(*(struct {
26474                         Type HUDType
26475
26476                         Pos      [2]float32
26477                         Name     string
26478                         Scale    [2]float32
26479                         Text     string
26480                         Number   uint32
26481                         Item     uint32
26482                         Dir      uint32
26483                         Align    [2]float32
26484                         Offset   [2]float32
26485                         WorldPos Pos
26486                         Size     [2]int32
26487                         ZIndex   int16
26488                         Text2    string
26489                 }))(obj)).Text2))[:])
26490                 chk(err)
26491         }
26492 }
26493
26494 func (obj *HUD) deserialize(r io.Reader) {
26495         if err := pcall(func() {
26496                 ((*(*(struct {
26497                         Type HUDType
26498
26499                         Pos      [2]float32
26500                         Name     string
26501                         Scale    [2]float32
26502                         Text     string
26503                         Number   uint32
26504                         Item     uint32
26505                         Dir      uint32
26506                         Align    [2]float32
26507                         Offset   [2]float32
26508                         WorldPos Pos
26509                         Size     [2]int32
26510                         ZIndex   int16
26511                         Text2    string
26512                 }))(obj)).Type).deserialize(r)
26513         }); err != nil {
26514                 if err == io.EOF {
26515                         chk(io.EOF)
26516                 }
26517                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
26518         }
26519         for local322 := range (*(*(struct {
26520                 Type HUDType
26521
26522                 Pos      [2]float32
26523                 Name     string
26524                 Scale    [2]float32
26525                 Text     string
26526                 Number   uint32
26527                 Item     uint32
26528                 Dir      uint32
26529                 Align    [2]float32
26530                 Offset   [2]float32
26531                 WorldPos Pos
26532                 Size     [2]int32
26533                 ZIndex   int16
26534                 Text2    string
26535         }))(obj)).Pos {
26536                 {
26537                         p := &((*(*(struct {
26538                                 Type HUDType
26539
26540                                 Pos      [2]float32
26541                                 Name     string
26542                                 Scale    [2]float32
26543                                 Text     string
26544                                 Number   uint32
26545                                 Item     uint32
26546                                 Dir      uint32
26547                                 Align    [2]float32
26548                                 Offset   [2]float32
26549                                 WorldPos Pos
26550                                 Size     [2]int32
26551                                 ZIndex   int16
26552                                 Text2    string
26553                         }))(obj)).Pos)[local322]
26554                         *p = math.Float32frombits(read32(r))
26555                 }
26556         }
26557         var local323 []uint8
26558         var local324 uint16
26559         {
26560                 p := &local324
26561                 *p = read16(r)
26562         }
26563         (local323) = make([]uint8, local324)
26564         {
26565                 _, err := io.ReadFull(r, (local323)[:])
26566                 chk(err)
26567         }
26568         ((*(*(struct {
26569                 Type HUDType
26570
26571                 Pos      [2]float32
26572                 Name     string
26573                 Scale    [2]float32
26574                 Text     string
26575                 Number   uint32
26576                 Item     uint32
26577                 Dir      uint32
26578                 Align    [2]float32
26579                 Offset   [2]float32
26580                 WorldPos Pos
26581                 Size     [2]int32
26582                 ZIndex   int16
26583                 Text2    string
26584         }))(obj)).Name) = string(local323)
26585         for local325 := range (*(*(struct {
26586                 Type HUDType
26587
26588                 Pos      [2]float32
26589                 Name     string
26590                 Scale    [2]float32
26591                 Text     string
26592                 Number   uint32
26593                 Item     uint32
26594                 Dir      uint32
26595                 Align    [2]float32
26596                 Offset   [2]float32
26597                 WorldPos Pos
26598                 Size     [2]int32
26599                 ZIndex   int16
26600                 Text2    string
26601         }))(obj)).Scale {
26602                 {
26603                         p := &((*(*(struct {
26604                                 Type HUDType
26605
26606                                 Pos      [2]float32
26607                                 Name     string
26608                                 Scale    [2]float32
26609                                 Text     string
26610                                 Number   uint32
26611                                 Item     uint32
26612                                 Dir      uint32
26613                                 Align    [2]float32
26614                                 Offset   [2]float32
26615                                 WorldPos Pos
26616                                 Size     [2]int32
26617                                 ZIndex   int16
26618                                 Text2    string
26619                         }))(obj)).Scale)[local325]
26620                         *p = math.Float32frombits(read32(r))
26621                 }
26622         }
26623         var local326 []uint8
26624         var local327 uint16
26625         {
26626                 p := &local327
26627                 *p = read16(r)
26628         }
26629         (local326) = make([]uint8, local327)
26630         {
26631                 _, err := io.ReadFull(r, (local326)[:])
26632                 chk(err)
26633         }
26634         ((*(*(struct {
26635                 Type HUDType
26636
26637                 Pos      [2]float32
26638                 Name     string
26639                 Scale    [2]float32
26640                 Text     string
26641                 Number   uint32
26642                 Item     uint32
26643                 Dir      uint32
26644                 Align    [2]float32
26645                 Offset   [2]float32
26646                 WorldPos Pos
26647                 Size     [2]int32
26648                 ZIndex   int16
26649                 Text2    string
26650         }))(obj)).Text) = string(local326)
26651         {
26652                 p := &(*(*(struct {
26653                         Type HUDType
26654
26655                         Pos      [2]float32
26656                         Name     string
26657                         Scale    [2]float32
26658                         Text     string
26659                         Number   uint32
26660                         Item     uint32
26661                         Dir      uint32
26662                         Align    [2]float32
26663                         Offset   [2]float32
26664                         WorldPos Pos
26665                         Size     [2]int32
26666                         ZIndex   int16
26667                         Text2    string
26668                 }))(obj)).Number
26669                 *p = read32(r)
26670         }
26671         {
26672                 p := &(*(*(struct {
26673                         Type HUDType
26674
26675                         Pos      [2]float32
26676                         Name     string
26677                         Scale    [2]float32
26678                         Text     string
26679                         Number   uint32
26680                         Item     uint32
26681                         Dir      uint32
26682                         Align    [2]float32
26683                         Offset   [2]float32
26684                         WorldPos Pos
26685                         Size     [2]int32
26686                         ZIndex   int16
26687                         Text2    string
26688                 }))(obj)).Item
26689                 *p = read32(r)
26690         }
26691         {
26692                 p := &(*(*(struct {
26693                         Type HUDType
26694
26695                         Pos      [2]float32
26696                         Name     string
26697                         Scale    [2]float32
26698                         Text     string
26699                         Number   uint32
26700                         Item     uint32
26701                         Dir      uint32
26702                         Align    [2]float32
26703                         Offset   [2]float32
26704                         WorldPos Pos
26705                         Size     [2]int32
26706                         ZIndex   int16
26707                         Text2    string
26708                 }))(obj)).Dir
26709                 *p = read32(r)
26710         }
26711         for local328 := range (*(*(struct {
26712                 Type HUDType
26713
26714                 Pos      [2]float32
26715                 Name     string
26716                 Scale    [2]float32
26717                 Text     string
26718                 Number   uint32
26719                 Item     uint32
26720                 Dir      uint32
26721                 Align    [2]float32
26722                 Offset   [2]float32
26723                 WorldPos Pos
26724                 Size     [2]int32
26725                 ZIndex   int16
26726                 Text2    string
26727         }))(obj)).Align {
26728                 {
26729                         p := &((*(*(struct {
26730                                 Type HUDType
26731
26732                                 Pos      [2]float32
26733                                 Name     string
26734                                 Scale    [2]float32
26735                                 Text     string
26736                                 Number   uint32
26737                                 Item     uint32
26738                                 Dir      uint32
26739                                 Align    [2]float32
26740                                 Offset   [2]float32
26741                                 WorldPos Pos
26742                                 Size     [2]int32
26743                                 ZIndex   int16
26744                                 Text2    string
26745                         }))(obj)).Align)[local328]
26746                         *p = math.Float32frombits(read32(r))
26747                 }
26748         }
26749         for local329 := range (*(*(struct {
26750                 Type HUDType
26751
26752                 Pos      [2]float32
26753                 Name     string
26754                 Scale    [2]float32
26755                 Text     string
26756                 Number   uint32
26757                 Item     uint32
26758                 Dir      uint32
26759                 Align    [2]float32
26760                 Offset   [2]float32
26761                 WorldPos Pos
26762                 Size     [2]int32
26763                 ZIndex   int16
26764                 Text2    string
26765         }))(obj)).Offset {
26766                 {
26767                         p := &((*(*(struct {
26768                                 Type HUDType
26769
26770                                 Pos      [2]float32
26771                                 Name     string
26772                                 Scale    [2]float32
26773                                 Text     string
26774                                 Number   uint32
26775                                 Item     uint32
26776                                 Dir      uint32
26777                                 Align    [2]float32
26778                                 Offset   [2]float32
26779                                 WorldPos Pos
26780                                 Size     [2]int32
26781                                 ZIndex   int16
26782                                 Text2    string
26783                         }))(obj)).Offset)[local329]
26784                         *p = math.Float32frombits(read32(r))
26785                 }
26786         }
26787         if err := pcall(func() {
26788                 ((*(*(struct {
26789                         Type HUDType
26790
26791                         Pos      [2]float32
26792                         Name     string
26793                         Scale    [2]float32
26794                         Text     string
26795                         Number   uint32
26796                         Item     uint32
26797                         Dir      uint32
26798                         Align    [2]float32
26799                         Offset   [2]float32
26800                         WorldPos Pos
26801                         Size     [2]int32
26802                         ZIndex   int16
26803                         Text2    string
26804                 }))(obj)).WorldPos).deserialize(r)
26805         }); err != nil {
26806                 if err == io.EOF {
26807                         chk(io.EOF)
26808                 }
26809                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
26810         }
26811         for local330 := range (*(*(struct {
26812                 Type HUDType
26813
26814                 Pos      [2]float32
26815                 Name     string
26816                 Scale    [2]float32
26817                 Text     string
26818                 Number   uint32
26819                 Item     uint32
26820                 Dir      uint32
26821                 Align    [2]float32
26822                 Offset   [2]float32
26823                 WorldPos Pos
26824                 Size     [2]int32
26825                 ZIndex   int16
26826                 Text2    string
26827         }))(obj)).Size {
26828                 {
26829                         p := &((*(*(struct {
26830                                 Type HUDType
26831
26832                                 Pos      [2]float32
26833                                 Name     string
26834                                 Scale    [2]float32
26835                                 Text     string
26836                                 Number   uint32
26837                                 Item     uint32
26838                                 Dir      uint32
26839                                 Align    [2]float32
26840                                 Offset   [2]float32
26841                                 WorldPos Pos
26842                                 Size     [2]int32
26843                                 ZIndex   int16
26844                                 Text2    string
26845                         }))(obj)).Size)[local330]
26846                         *p = int32(read32(r))
26847                 }
26848         }
26849         {
26850                 p := &(*(*(struct {
26851                         Type HUDType
26852
26853                         Pos      [2]float32
26854                         Name     string
26855                         Scale    [2]float32
26856                         Text     string
26857                         Number   uint32
26858                         Item     uint32
26859                         Dir      uint32
26860                         Align    [2]float32
26861                         Offset   [2]float32
26862                         WorldPos Pos
26863                         Size     [2]int32
26864                         ZIndex   int16
26865                         Text2    string
26866                 }))(obj)).ZIndex
26867                 *p = int16(read16(r))
26868         }
26869         var local331 []uint8
26870         var local332 uint16
26871         {
26872                 p := &local332
26873                 *p = read16(r)
26874         }
26875         (local331) = make([]uint8, local332)
26876         {
26877                 _, err := io.ReadFull(r, (local331)[:])
26878                 chk(err)
26879         }
26880         ((*(*(struct {
26881                 Type HUDType
26882
26883                 Pos      [2]float32
26884                 Name     string
26885                 Scale    [2]float32
26886                 Text     string
26887                 Number   uint32
26888                 Item     uint32
26889                 Dir      uint32
26890                 Align    [2]float32
26891                 Offset   [2]float32
26892                 WorldPos Pos
26893                 Size     [2]int32
26894                 ZIndex   int16
26895                 Text2    string
26896         }))(obj)).Text2) = string(local331)
26897 }
26898
26899 func (obj *HUDField) serialize(w io.Writer) {
26900         {
26901                 x := *(*(uint8))(obj)
26902                 write8(w, uint8(x))
26903         }
26904 }
26905
26906 func (obj *HUDField) deserialize(r io.Reader) {
26907         {
26908                 p := &*(*(uint8))(obj)
26909                 *p = read8(r)
26910         }
26911 }
26912
26913 func (obj *HUDFlags) serialize(w io.Writer) {
26914         {
26915                 x := *(*(uint32))(obj)
26916                 write32(w, uint32(x))
26917         }
26918 }
26919
26920 func (obj *HUDFlags) deserialize(r io.Reader) {
26921         {
26922                 p := &*(*(uint32))(obj)
26923                 *p = read32(r)
26924         }
26925 }
26926
26927 func (obj *HotbarParam) serialize(w io.Writer) {
26928         {
26929                 x := *(*(uint16))(obj)
26930                 write16(w, uint16(x))
26931         }
26932 }
26933
26934 func (obj *HotbarParam) deserialize(r io.Reader) {
26935         {
26936                 p := &*(*(uint16))(obj)
26937                 *p = read16(r)
26938         }
26939 }
26940
26941 func (obj *Texture) serialize(w io.Writer) {
26942         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
26943                 chk(ErrTooLong)
26944         }
26945         {
26946                 x := uint16(len(([]byte(*(*(string))(obj)))))
26947                 write16(w, uint16(x))
26948         }
26949         {
26950                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
26951                 chk(err)
26952         }
26953 }
26954
26955 func (obj *Texture) deserialize(r io.Reader) {
26956         var local333 []uint8
26957         var local334 uint16
26958         {
26959                 p := &local334
26960                 *p = read16(r)
26961         }
26962         (local333) = make([]uint8, local334)
26963         {
26964                 _, err := io.ReadFull(r, (local333)[:])
26965                 chk(err)
26966         }
26967         (*(*(string))(obj)) = string(local333)
26968 }
26969
26970 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
26971         {
26972                 x := *(*(uint8))(obj)
26973                 write8(w, uint8(x))
26974         }
26975 }
26976
26977 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
26978         {
26979                 p := &*(*(uint8))(obj)
26980                 *p = read8(r)
26981         }
26982 }
26983
26984 func (obj *ModChanSig) serialize(w io.Writer) {
26985         {
26986                 x := *(*(uint8))(obj)
26987                 write8(w, uint8(x))
26988         }
26989 }
26990
26991 func (obj *ModChanSig) deserialize(r io.Reader) {
26992         {
26993                 p := &*(*(uint8))(obj)
26994                 *p = read8(r)
26995         }
26996 }
26997
26998 func (obj *AOProps) serialize(w io.Writer) {
26999         {
27000                 local335 := uint8(4)
27001                 {
27002                         x := local335
27003                         write8(w, uint8(x))
27004                 }
27005         }
27006         {
27007                 x := (*(*(struct {
27008                         MaxHP            uint16 // Player only.
27009                         CollideWithNodes bool
27010                         Weight           float32 // deprecated
27011                         ColBox, SelBox   Box
27012                         Pointable        bool
27013                         Visual           string
27014                         VisualSize       [3]float32
27015                         Textures         []Texture
27016                         SpriteSheetSize  [2]int16 // in sprites.
27017                         SpritePos        [2]int16 // in sprite sheet.
27018                         Visible          bool
27019                         MakeFootstepSnds bool
27020                         RotateSpeed      float32 // in radians per second.
27021                         Mesh             string
27022                         Colors           []color.NRGBA
27023                         CollideWithAOs   bool
27024                         StepHeight       float32
27025                         FaceRotateDir    bool
27026                         FaceRotateDirOff float32 // in degrees.
27027                         BackfaceCull     bool
27028                         Nametag          string
27029                         NametagColor     color.NRGBA
27030                         FaceRotateSpeed  float32 // in degrees per second.
27031                         Infotext         string
27032                         Itemstring       string
27033                         Glow             int8
27034                         MaxBreath        uint16  // Player only.
27035                         EyeHeight        float32 // Player only.
27036                         ZoomFOV          float32 // in degrees. Player only.
27037                         UseTextureAlpha  bool
27038                         DmgTextureMod    Texture // suffix
27039                         Shaded           bool
27040                         ShowOnMinimap    bool
27041                         NametagBG        color.NRGBA
27042                 }))(obj)).MaxHP
27043                 write16(w, uint16(x))
27044         }
27045         {
27046                 x := (*(*(struct {
27047                         MaxHP            uint16 // Player only.
27048                         CollideWithNodes bool
27049                         Weight           float32 // deprecated
27050                         ColBox, SelBox   Box
27051                         Pointable        bool
27052                         Visual           string
27053                         VisualSize       [3]float32
27054                         Textures         []Texture
27055                         SpriteSheetSize  [2]int16 // in sprites.
27056                         SpritePos        [2]int16 // in sprite sheet.
27057                         Visible          bool
27058                         MakeFootstepSnds bool
27059                         RotateSpeed      float32 // in radians per second.
27060                         Mesh             string
27061                         Colors           []color.NRGBA
27062                         CollideWithAOs   bool
27063                         StepHeight       float32
27064                         FaceRotateDir    bool
27065                         FaceRotateDirOff float32 // in degrees.
27066                         BackfaceCull     bool
27067                         Nametag          string
27068                         NametagColor     color.NRGBA
27069                         FaceRotateSpeed  float32 // in degrees per second.
27070                         Infotext         string
27071                         Itemstring       string
27072                         Glow             int8
27073                         MaxBreath        uint16  // Player only.
27074                         EyeHeight        float32 // Player only.
27075                         ZoomFOV          float32 // in degrees. Player only.
27076                         UseTextureAlpha  bool
27077                         DmgTextureMod    Texture // suffix
27078                         Shaded           bool
27079                         ShowOnMinimap    bool
27080                         NametagBG        color.NRGBA
27081                 }))(obj)).CollideWithNodes
27082                 if x {
27083                         write8(w, 1)
27084                 } else {
27085                         write8(w, 0)
27086                 }
27087
27088         }
27089         {
27090                 x := (*(*(struct {
27091                         MaxHP            uint16 // Player only.
27092                         CollideWithNodes bool
27093                         Weight           float32 // deprecated
27094                         ColBox, SelBox   Box
27095                         Pointable        bool
27096                         Visual           string
27097                         VisualSize       [3]float32
27098                         Textures         []Texture
27099                         SpriteSheetSize  [2]int16 // in sprites.
27100                         SpritePos        [2]int16 // in sprite sheet.
27101                         Visible          bool
27102                         MakeFootstepSnds bool
27103                         RotateSpeed      float32 // in radians per second.
27104                         Mesh             string
27105                         Colors           []color.NRGBA
27106                         CollideWithAOs   bool
27107                         StepHeight       float32
27108                         FaceRotateDir    bool
27109                         FaceRotateDirOff float32 // in degrees.
27110                         BackfaceCull     bool
27111                         Nametag          string
27112                         NametagColor     color.NRGBA
27113                         FaceRotateSpeed  float32 // in degrees per second.
27114                         Infotext         string
27115                         Itemstring       string
27116                         Glow             int8
27117                         MaxBreath        uint16  // Player only.
27118                         EyeHeight        float32 // Player only.
27119                         ZoomFOV          float32 // in degrees. Player only.
27120                         UseTextureAlpha  bool
27121                         DmgTextureMod    Texture // suffix
27122                         Shaded           bool
27123                         ShowOnMinimap    bool
27124                         NametagBG        color.NRGBA
27125                 }))(obj)).Weight
27126                 write32(w, math.Float32bits(x))
27127         }
27128         if err := pcall(func() {
27129                 ((*(*(struct {
27130                         MaxHP            uint16 // Player only.
27131                         CollideWithNodes bool
27132                         Weight           float32 // deprecated
27133                         ColBox, SelBox   Box
27134                         Pointable        bool
27135                         Visual           string
27136                         VisualSize       [3]float32
27137                         Textures         []Texture
27138                         SpriteSheetSize  [2]int16 // in sprites.
27139                         SpritePos        [2]int16 // in sprite sheet.
27140                         Visible          bool
27141                         MakeFootstepSnds bool
27142                         RotateSpeed      float32 // in radians per second.
27143                         Mesh             string
27144                         Colors           []color.NRGBA
27145                         CollideWithAOs   bool
27146                         StepHeight       float32
27147                         FaceRotateDir    bool
27148                         FaceRotateDirOff float32 // in degrees.
27149                         BackfaceCull     bool
27150                         Nametag          string
27151                         NametagColor     color.NRGBA
27152                         FaceRotateSpeed  float32 // in degrees per second.
27153                         Infotext         string
27154                         Itemstring       string
27155                         Glow             int8
27156                         MaxBreath        uint16  // Player only.
27157                         EyeHeight        float32 // Player only.
27158                         ZoomFOV          float32 // in degrees. Player only.
27159                         UseTextureAlpha  bool
27160                         DmgTextureMod    Texture // suffix
27161                         Shaded           bool
27162                         ShowOnMinimap    bool
27163                         NametagBG        color.NRGBA
27164                 }))(obj)).ColBox).serialize(w)
27165         }); err != nil {
27166                 if err == io.EOF {
27167                         chk(io.EOF)
27168                 }
27169                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27170         }
27171         if err := pcall(func() {
27172                 ((*(*(struct {
27173                         MaxHP            uint16 // Player only.
27174                         CollideWithNodes bool
27175                         Weight           float32 // deprecated
27176                         ColBox, SelBox   Box
27177                         Pointable        bool
27178                         Visual           string
27179                         VisualSize       [3]float32
27180                         Textures         []Texture
27181                         SpriteSheetSize  [2]int16 // in sprites.
27182                         SpritePos        [2]int16 // in sprite sheet.
27183                         Visible          bool
27184                         MakeFootstepSnds bool
27185                         RotateSpeed      float32 // in radians per second.
27186                         Mesh             string
27187                         Colors           []color.NRGBA
27188                         CollideWithAOs   bool
27189                         StepHeight       float32
27190                         FaceRotateDir    bool
27191                         FaceRotateDirOff float32 // in degrees.
27192                         BackfaceCull     bool
27193                         Nametag          string
27194                         NametagColor     color.NRGBA
27195                         FaceRotateSpeed  float32 // in degrees per second.
27196                         Infotext         string
27197                         Itemstring       string
27198                         Glow             int8
27199                         MaxBreath        uint16  // Player only.
27200                         EyeHeight        float32 // Player only.
27201                         ZoomFOV          float32 // in degrees. Player only.
27202                         UseTextureAlpha  bool
27203                         DmgTextureMod    Texture // suffix
27204                         Shaded           bool
27205                         ShowOnMinimap    bool
27206                         NametagBG        color.NRGBA
27207                 }))(obj)).SelBox).serialize(w)
27208         }); err != nil {
27209                 if err == io.EOF {
27210                         chk(io.EOF)
27211                 }
27212                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27213         }
27214         {
27215                 x := (*(*(struct {
27216                         MaxHP            uint16 // Player only.
27217                         CollideWithNodes bool
27218                         Weight           float32 // deprecated
27219                         ColBox, SelBox   Box
27220                         Pointable        bool
27221                         Visual           string
27222                         VisualSize       [3]float32
27223                         Textures         []Texture
27224                         SpriteSheetSize  [2]int16 // in sprites.
27225                         SpritePos        [2]int16 // in sprite sheet.
27226                         Visible          bool
27227                         MakeFootstepSnds bool
27228                         RotateSpeed      float32 // in radians per second.
27229                         Mesh             string
27230                         Colors           []color.NRGBA
27231                         CollideWithAOs   bool
27232                         StepHeight       float32
27233                         FaceRotateDir    bool
27234                         FaceRotateDirOff float32 // in degrees.
27235                         BackfaceCull     bool
27236                         Nametag          string
27237                         NametagColor     color.NRGBA
27238                         FaceRotateSpeed  float32 // in degrees per second.
27239                         Infotext         string
27240                         Itemstring       string
27241                         Glow             int8
27242                         MaxBreath        uint16  // Player only.
27243                         EyeHeight        float32 // Player only.
27244                         ZoomFOV          float32 // in degrees. Player only.
27245                         UseTextureAlpha  bool
27246                         DmgTextureMod    Texture // suffix
27247                         Shaded           bool
27248                         ShowOnMinimap    bool
27249                         NametagBG        color.NRGBA
27250                 }))(obj)).Pointable
27251                 if x {
27252                         write8(w, 1)
27253                 } else {
27254                         write8(w, 0)
27255                 }
27256
27257         }
27258         if len(([]byte((*(*(struct {
27259                 MaxHP            uint16 // Player only.
27260                 CollideWithNodes bool
27261                 Weight           float32 // deprecated
27262                 ColBox, SelBox   Box
27263                 Pointable        bool
27264                 Visual           string
27265                 VisualSize       [3]float32
27266                 Textures         []Texture
27267                 SpriteSheetSize  [2]int16 // in sprites.
27268                 SpritePos        [2]int16 // in sprite sheet.
27269                 Visible          bool
27270                 MakeFootstepSnds bool
27271                 RotateSpeed      float32 // in radians per second.
27272                 Mesh             string
27273                 Colors           []color.NRGBA
27274                 CollideWithAOs   bool
27275                 StepHeight       float32
27276                 FaceRotateDir    bool
27277                 FaceRotateDirOff float32 // in degrees.
27278                 BackfaceCull     bool
27279                 Nametag          string
27280                 NametagColor     color.NRGBA
27281                 FaceRotateSpeed  float32 // in degrees per second.
27282                 Infotext         string
27283                 Itemstring       string
27284                 Glow             int8
27285                 MaxBreath        uint16  // Player only.
27286                 EyeHeight        float32 // Player only.
27287                 ZoomFOV          float32 // in degrees. Player only.
27288                 UseTextureAlpha  bool
27289                 DmgTextureMod    Texture // suffix
27290                 Shaded           bool
27291                 ShowOnMinimap    bool
27292                 NametagBG        color.NRGBA
27293         }))(obj)).Visual))) > math.MaxUint16 {
27294                 chk(ErrTooLong)
27295         }
27296         {
27297                 x := uint16(len(([]byte((*(*(struct {
27298                         MaxHP            uint16 // Player only.
27299                         CollideWithNodes bool
27300                         Weight           float32 // deprecated
27301                         ColBox, SelBox   Box
27302                         Pointable        bool
27303                         Visual           string
27304                         VisualSize       [3]float32
27305                         Textures         []Texture
27306                         SpriteSheetSize  [2]int16 // in sprites.
27307                         SpritePos        [2]int16 // in sprite sheet.
27308                         Visible          bool
27309                         MakeFootstepSnds bool
27310                         RotateSpeed      float32 // in radians per second.
27311                         Mesh             string
27312                         Colors           []color.NRGBA
27313                         CollideWithAOs   bool
27314                         StepHeight       float32
27315                         FaceRotateDir    bool
27316                         FaceRotateDirOff float32 // in degrees.
27317                         BackfaceCull     bool
27318                         Nametag          string
27319                         NametagColor     color.NRGBA
27320                         FaceRotateSpeed  float32 // in degrees per second.
27321                         Infotext         string
27322                         Itemstring       string
27323                         Glow             int8
27324                         MaxBreath        uint16  // Player only.
27325                         EyeHeight        float32 // Player only.
27326                         ZoomFOV          float32 // in degrees. Player only.
27327                         UseTextureAlpha  bool
27328                         DmgTextureMod    Texture // suffix
27329                         Shaded           bool
27330                         ShowOnMinimap    bool
27331                         NametagBG        color.NRGBA
27332                 }))(obj)).Visual))))
27333                 write16(w, uint16(x))
27334         }
27335         {
27336                 _, err := w.Write(([]byte((*(*(struct {
27337                         MaxHP            uint16 // Player only.
27338                         CollideWithNodes bool
27339                         Weight           float32 // deprecated
27340                         ColBox, SelBox   Box
27341                         Pointable        bool
27342                         Visual           string
27343                         VisualSize       [3]float32
27344                         Textures         []Texture
27345                         SpriteSheetSize  [2]int16 // in sprites.
27346                         SpritePos        [2]int16 // in sprite sheet.
27347                         Visible          bool
27348                         MakeFootstepSnds bool
27349                         RotateSpeed      float32 // in radians per second.
27350                         Mesh             string
27351                         Colors           []color.NRGBA
27352                         CollideWithAOs   bool
27353                         StepHeight       float32
27354                         FaceRotateDir    bool
27355                         FaceRotateDirOff float32 // in degrees.
27356                         BackfaceCull     bool
27357                         Nametag          string
27358                         NametagColor     color.NRGBA
27359                         FaceRotateSpeed  float32 // in degrees per second.
27360                         Infotext         string
27361                         Itemstring       string
27362                         Glow             int8
27363                         MaxBreath        uint16  // Player only.
27364                         EyeHeight        float32 // Player only.
27365                         ZoomFOV          float32 // in degrees. Player only.
27366                         UseTextureAlpha  bool
27367                         DmgTextureMod    Texture // suffix
27368                         Shaded           bool
27369                         ShowOnMinimap    bool
27370                         NametagBG        color.NRGBA
27371                 }))(obj)).Visual))[:])
27372                 chk(err)
27373         }
27374         for local336 := range (*(*(struct {
27375                 MaxHP            uint16 // Player only.
27376                 CollideWithNodes bool
27377                 Weight           float32 // deprecated
27378                 ColBox, SelBox   Box
27379                 Pointable        bool
27380                 Visual           string
27381                 VisualSize       [3]float32
27382                 Textures         []Texture
27383                 SpriteSheetSize  [2]int16 // in sprites.
27384                 SpritePos        [2]int16 // in sprite sheet.
27385                 Visible          bool
27386                 MakeFootstepSnds bool
27387                 RotateSpeed      float32 // in radians per second.
27388                 Mesh             string
27389                 Colors           []color.NRGBA
27390                 CollideWithAOs   bool
27391                 StepHeight       float32
27392                 FaceRotateDir    bool
27393                 FaceRotateDirOff float32 // in degrees.
27394                 BackfaceCull     bool
27395                 Nametag          string
27396                 NametagColor     color.NRGBA
27397                 FaceRotateSpeed  float32 // in degrees per second.
27398                 Infotext         string
27399                 Itemstring       string
27400                 Glow             int8
27401                 MaxBreath        uint16  // Player only.
27402                 EyeHeight        float32 // Player only.
27403                 ZoomFOV          float32 // in degrees. Player only.
27404                 UseTextureAlpha  bool
27405                 DmgTextureMod    Texture // suffix
27406                 Shaded           bool
27407                 ShowOnMinimap    bool
27408                 NametagBG        color.NRGBA
27409         }))(obj)).VisualSize {
27410                 {
27411                         x := ((*(*(struct {
27412                                 MaxHP            uint16 // Player only.
27413                                 CollideWithNodes bool
27414                                 Weight           float32 // deprecated
27415                                 ColBox, SelBox   Box
27416                                 Pointable        bool
27417                                 Visual           string
27418                                 VisualSize       [3]float32
27419                                 Textures         []Texture
27420                                 SpriteSheetSize  [2]int16 // in sprites.
27421                                 SpritePos        [2]int16 // in sprite sheet.
27422                                 Visible          bool
27423                                 MakeFootstepSnds bool
27424                                 RotateSpeed      float32 // in radians per second.
27425                                 Mesh             string
27426                                 Colors           []color.NRGBA
27427                                 CollideWithAOs   bool
27428                                 StepHeight       float32
27429                                 FaceRotateDir    bool
27430                                 FaceRotateDirOff float32 // in degrees.
27431                                 BackfaceCull     bool
27432                                 Nametag          string
27433                                 NametagColor     color.NRGBA
27434                                 FaceRotateSpeed  float32 // in degrees per second.
27435                                 Infotext         string
27436                                 Itemstring       string
27437                                 Glow             int8
27438                                 MaxBreath        uint16  // Player only.
27439                                 EyeHeight        float32 // Player only.
27440                                 ZoomFOV          float32 // in degrees. Player only.
27441                                 UseTextureAlpha  bool
27442                                 DmgTextureMod    Texture // suffix
27443                                 Shaded           bool
27444                                 ShowOnMinimap    bool
27445                                 NametagBG        color.NRGBA
27446                         }))(obj)).VisualSize)[local336]
27447                         write32(w, math.Float32bits(x))
27448                 }
27449         }
27450         if len(((*(*(struct {
27451                 MaxHP            uint16 // Player only.
27452                 CollideWithNodes bool
27453                 Weight           float32 // deprecated
27454                 ColBox, SelBox   Box
27455                 Pointable        bool
27456                 Visual           string
27457                 VisualSize       [3]float32
27458                 Textures         []Texture
27459                 SpriteSheetSize  [2]int16 // in sprites.
27460                 SpritePos        [2]int16 // in sprite sheet.
27461                 Visible          bool
27462                 MakeFootstepSnds bool
27463                 RotateSpeed      float32 // in radians per second.
27464                 Mesh             string
27465                 Colors           []color.NRGBA
27466                 CollideWithAOs   bool
27467                 StepHeight       float32
27468                 FaceRotateDir    bool
27469                 FaceRotateDirOff float32 // in degrees.
27470                 BackfaceCull     bool
27471                 Nametag          string
27472                 NametagColor     color.NRGBA
27473                 FaceRotateSpeed  float32 // in degrees per second.
27474                 Infotext         string
27475                 Itemstring       string
27476                 Glow             int8
27477                 MaxBreath        uint16  // Player only.
27478                 EyeHeight        float32 // Player only.
27479                 ZoomFOV          float32 // in degrees. Player only.
27480                 UseTextureAlpha  bool
27481                 DmgTextureMod    Texture // suffix
27482                 Shaded           bool
27483                 ShowOnMinimap    bool
27484                 NametagBG        color.NRGBA
27485         }))(obj)).Textures)) > math.MaxUint16 {
27486                 chk(ErrTooLong)
27487         }
27488         {
27489                 x := uint16(len(((*(*(struct {
27490                         MaxHP            uint16 // Player only.
27491                         CollideWithNodes bool
27492                         Weight           float32 // deprecated
27493                         ColBox, SelBox   Box
27494                         Pointable        bool
27495                         Visual           string
27496                         VisualSize       [3]float32
27497                         Textures         []Texture
27498                         SpriteSheetSize  [2]int16 // in sprites.
27499                         SpritePos        [2]int16 // in sprite sheet.
27500                         Visible          bool
27501                         MakeFootstepSnds bool
27502                         RotateSpeed      float32 // in radians per second.
27503                         Mesh             string
27504                         Colors           []color.NRGBA
27505                         CollideWithAOs   bool
27506                         StepHeight       float32
27507                         FaceRotateDir    bool
27508                         FaceRotateDirOff float32 // in degrees.
27509                         BackfaceCull     bool
27510                         Nametag          string
27511                         NametagColor     color.NRGBA
27512                         FaceRotateSpeed  float32 // in degrees per second.
27513                         Infotext         string
27514                         Itemstring       string
27515                         Glow             int8
27516                         MaxBreath        uint16  // Player only.
27517                         EyeHeight        float32 // Player only.
27518                         ZoomFOV          float32 // in degrees. Player only.
27519                         UseTextureAlpha  bool
27520                         DmgTextureMod    Texture // suffix
27521                         Shaded           bool
27522                         ShowOnMinimap    bool
27523                         NametagBG        color.NRGBA
27524                 }))(obj)).Textures)))
27525                 write16(w, uint16(x))
27526         }
27527         for local337 := range (*(*(struct {
27528                 MaxHP            uint16 // Player only.
27529                 CollideWithNodes bool
27530                 Weight           float32 // deprecated
27531                 ColBox, SelBox   Box
27532                 Pointable        bool
27533                 Visual           string
27534                 VisualSize       [3]float32
27535                 Textures         []Texture
27536                 SpriteSheetSize  [2]int16 // in sprites.
27537                 SpritePos        [2]int16 // in sprite sheet.
27538                 Visible          bool
27539                 MakeFootstepSnds bool
27540                 RotateSpeed      float32 // in radians per second.
27541                 Mesh             string
27542                 Colors           []color.NRGBA
27543                 CollideWithAOs   bool
27544                 StepHeight       float32
27545                 FaceRotateDir    bool
27546                 FaceRotateDirOff float32 // in degrees.
27547                 BackfaceCull     bool
27548                 Nametag          string
27549                 NametagColor     color.NRGBA
27550                 FaceRotateSpeed  float32 // in degrees per second.
27551                 Infotext         string
27552                 Itemstring       string
27553                 Glow             int8
27554                 MaxBreath        uint16  // Player only.
27555                 EyeHeight        float32 // Player only.
27556                 ZoomFOV          float32 // in degrees. Player only.
27557                 UseTextureAlpha  bool
27558                 DmgTextureMod    Texture // suffix
27559                 Shaded           bool
27560                 ShowOnMinimap    bool
27561                 NametagBG        color.NRGBA
27562         }))(obj)).Textures {
27563                 if err := pcall(func() {
27564                         (((*(*(struct {
27565                                 MaxHP            uint16 // Player only.
27566                                 CollideWithNodes bool
27567                                 Weight           float32 // deprecated
27568                                 ColBox, SelBox   Box
27569                                 Pointable        bool
27570                                 Visual           string
27571                                 VisualSize       [3]float32
27572                                 Textures         []Texture
27573                                 SpriteSheetSize  [2]int16 // in sprites.
27574                                 SpritePos        [2]int16 // in sprite sheet.
27575                                 Visible          bool
27576                                 MakeFootstepSnds bool
27577                                 RotateSpeed      float32 // in radians per second.
27578                                 Mesh             string
27579                                 Colors           []color.NRGBA
27580                                 CollideWithAOs   bool
27581                                 StepHeight       float32
27582                                 FaceRotateDir    bool
27583                                 FaceRotateDirOff float32 // in degrees.
27584                                 BackfaceCull     bool
27585                                 Nametag          string
27586                                 NametagColor     color.NRGBA
27587                                 FaceRotateSpeed  float32 // in degrees per second.
27588                                 Infotext         string
27589                                 Itemstring       string
27590                                 Glow             int8
27591                                 MaxBreath        uint16  // Player only.
27592                                 EyeHeight        float32 // Player only.
27593                                 ZoomFOV          float32 // in degrees. Player only.
27594                                 UseTextureAlpha  bool
27595                                 DmgTextureMod    Texture // suffix
27596                                 Shaded           bool
27597                                 ShowOnMinimap    bool
27598                                 NametagBG        color.NRGBA
27599                         }))(obj)).Textures)[local337]).serialize(w)
27600                 }); err != nil {
27601                         if err == io.EOF {
27602                                 chk(io.EOF)
27603                         }
27604                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
27605                 }
27606         }
27607         for local338 := range (*(*(struct {
27608                 MaxHP            uint16 // Player only.
27609                 CollideWithNodes bool
27610                 Weight           float32 // deprecated
27611                 ColBox, SelBox   Box
27612                 Pointable        bool
27613                 Visual           string
27614                 VisualSize       [3]float32
27615                 Textures         []Texture
27616                 SpriteSheetSize  [2]int16 // in sprites.
27617                 SpritePos        [2]int16 // in sprite sheet.
27618                 Visible          bool
27619                 MakeFootstepSnds bool
27620                 RotateSpeed      float32 // in radians per second.
27621                 Mesh             string
27622                 Colors           []color.NRGBA
27623                 CollideWithAOs   bool
27624                 StepHeight       float32
27625                 FaceRotateDir    bool
27626                 FaceRotateDirOff float32 // in degrees.
27627                 BackfaceCull     bool
27628                 Nametag          string
27629                 NametagColor     color.NRGBA
27630                 FaceRotateSpeed  float32 // in degrees per second.
27631                 Infotext         string
27632                 Itemstring       string
27633                 Glow             int8
27634                 MaxBreath        uint16  // Player only.
27635                 EyeHeight        float32 // Player only.
27636                 ZoomFOV          float32 // in degrees. Player only.
27637                 UseTextureAlpha  bool
27638                 DmgTextureMod    Texture // suffix
27639                 Shaded           bool
27640                 ShowOnMinimap    bool
27641                 NametagBG        color.NRGBA
27642         }))(obj)).SpriteSheetSize {
27643                 {
27644                         x := ((*(*(struct {
27645                                 MaxHP            uint16 // Player only.
27646                                 CollideWithNodes bool
27647                                 Weight           float32 // deprecated
27648                                 ColBox, SelBox   Box
27649                                 Pointable        bool
27650                                 Visual           string
27651                                 VisualSize       [3]float32
27652                                 Textures         []Texture
27653                                 SpriteSheetSize  [2]int16 // in sprites.
27654                                 SpritePos        [2]int16 // in sprite sheet.
27655                                 Visible          bool
27656                                 MakeFootstepSnds bool
27657                                 RotateSpeed      float32 // in radians per second.
27658                                 Mesh             string
27659                                 Colors           []color.NRGBA
27660                                 CollideWithAOs   bool
27661                                 StepHeight       float32
27662                                 FaceRotateDir    bool
27663                                 FaceRotateDirOff float32 // in degrees.
27664                                 BackfaceCull     bool
27665                                 Nametag          string
27666                                 NametagColor     color.NRGBA
27667                                 FaceRotateSpeed  float32 // in degrees per second.
27668                                 Infotext         string
27669                                 Itemstring       string
27670                                 Glow             int8
27671                                 MaxBreath        uint16  // Player only.
27672                                 EyeHeight        float32 // Player only.
27673                                 ZoomFOV          float32 // in degrees. Player only.
27674                                 UseTextureAlpha  bool
27675                                 DmgTextureMod    Texture // suffix
27676                                 Shaded           bool
27677                                 ShowOnMinimap    bool
27678                                 NametagBG        color.NRGBA
27679                         }))(obj)).SpriteSheetSize)[local338]
27680                         write16(w, uint16(x))
27681                 }
27682         }
27683         for local339 := range (*(*(struct {
27684                 MaxHP            uint16 // Player only.
27685                 CollideWithNodes bool
27686                 Weight           float32 // deprecated
27687                 ColBox, SelBox   Box
27688                 Pointable        bool
27689                 Visual           string
27690                 VisualSize       [3]float32
27691                 Textures         []Texture
27692                 SpriteSheetSize  [2]int16 // in sprites.
27693                 SpritePos        [2]int16 // in sprite sheet.
27694                 Visible          bool
27695                 MakeFootstepSnds bool
27696                 RotateSpeed      float32 // in radians per second.
27697                 Mesh             string
27698                 Colors           []color.NRGBA
27699                 CollideWithAOs   bool
27700                 StepHeight       float32
27701                 FaceRotateDir    bool
27702                 FaceRotateDirOff float32 // in degrees.
27703                 BackfaceCull     bool
27704                 Nametag          string
27705                 NametagColor     color.NRGBA
27706                 FaceRotateSpeed  float32 // in degrees per second.
27707                 Infotext         string
27708                 Itemstring       string
27709                 Glow             int8
27710                 MaxBreath        uint16  // Player only.
27711                 EyeHeight        float32 // Player only.
27712                 ZoomFOV          float32 // in degrees. Player only.
27713                 UseTextureAlpha  bool
27714                 DmgTextureMod    Texture // suffix
27715                 Shaded           bool
27716                 ShowOnMinimap    bool
27717                 NametagBG        color.NRGBA
27718         }))(obj)).SpritePos {
27719                 {
27720                         x := ((*(*(struct {
27721                                 MaxHP            uint16 // Player only.
27722                                 CollideWithNodes bool
27723                                 Weight           float32 // deprecated
27724                                 ColBox, SelBox   Box
27725                                 Pointable        bool
27726                                 Visual           string
27727                                 VisualSize       [3]float32
27728                                 Textures         []Texture
27729                                 SpriteSheetSize  [2]int16 // in sprites.
27730                                 SpritePos        [2]int16 // in sprite sheet.
27731                                 Visible          bool
27732                                 MakeFootstepSnds bool
27733                                 RotateSpeed      float32 // in radians per second.
27734                                 Mesh             string
27735                                 Colors           []color.NRGBA
27736                                 CollideWithAOs   bool
27737                                 StepHeight       float32
27738                                 FaceRotateDir    bool
27739                                 FaceRotateDirOff float32 // in degrees.
27740                                 BackfaceCull     bool
27741                                 Nametag          string
27742                                 NametagColor     color.NRGBA
27743                                 FaceRotateSpeed  float32 // in degrees per second.
27744                                 Infotext         string
27745                                 Itemstring       string
27746                                 Glow             int8
27747                                 MaxBreath        uint16  // Player only.
27748                                 EyeHeight        float32 // Player only.
27749                                 ZoomFOV          float32 // in degrees. Player only.
27750                                 UseTextureAlpha  bool
27751                                 DmgTextureMod    Texture // suffix
27752                                 Shaded           bool
27753                                 ShowOnMinimap    bool
27754                                 NametagBG        color.NRGBA
27755                         }))(obj)).SpritePos)[local339]
27756                         write16(w, uint16(x))
27757                 }
27758         }
27759         {
27760                 x := (*(*(struct {
27761                         MaxHP            uint16 // Player only.
27762                         CollideWithNodes bool
27763                         Weight           float32 // deprecated
27764                         ColBox, SelBox   Box
27765                         Pointable        bool
27766                         Visual           string
27767                         VisualSize       [3]float32
27768                         Textures         []Texture
27769                         SpriteSheetSize  [2]int16 // in sprites.
27770                         SpritePos        [2]int16 // in sprite sheet.
27771                         Visible          bool
27772                         MakeFootstepSnds bool
27773                         RotateSpeed      float32 // in radians per second.
27774                         Mesh             string
27775                         Colors           []color.NRGBA
27776                         CollideWithAOs   bool
27777                         StepHeight       float32
27778                         FaceRotateDir    bool
27779                         FaceRotateDirOff float32 // in degrees.
27780                         BackfaceCull     bool
27781                         Nametag          string
27782                         NametagColor     color.NRGBA
27783                         FaceRotateSpeed  float32 // in degrees per second.
27784                         Infotext         string
27785                         Itemstring       string
27786                         Glow             int8
27787                         MaxBreath        uint16  // Player only.
27788                         EyeHeight        float32 // Player only.
27789                         ZoomFOV          float32 // in degrees. Player only.
27790                         UseTextureAlpha  bool
27791                         DmgTextureMod    Texture // suffix
27792                         Shaded           bool
27793                         ShowOnMinimap    bool
27794                         NametagBG        color.NRGBA
27795                 }))(obj)).Visible
27796                 if x {
27797                         write8(w, 1)
27798                 } else {
27799                         write8(w, 0)
27800                 }
27801
27802         }
27803         {
27804                 x := (*(*(struct {
27805                         MaxHP            uint16 // Player only.
27806                         CollideWithNodes bool
27807                         Weight           float32 // deprecated
27808                         ColBox, SelBox   Box
27809                         Pointable        bool
27810                         Visual           string
27811                         VisualSize       [3]float32
27812                         Textures         []Texture
27813                         SpriteSheetSize  [2]int16 // in sprites.
27814                         SpritePos        [2]int16 // in sprite sheet.
27815                         Visible          bool
27816                         MakeFootstepSnds bool
27817                         RotateSpeed      float32 // in radians per second.
27818                         Mesh             string
27819                         Colors           []color.NRGBA
27820                         CollideWithAOs   bool
27821                         StepHeight       float32
27822                         FaceRotateDir    bool
27823                         FaceRotateDirOff float32 // in degrees.
27824                         BackfaceCull     bool
27825                         Nametag          string
27826                         NametagColor     color.NRGBA
27827                         FaceRotateSpeed  float32 // in degrees per second.
27828                         Infotext         string
27829                         Itemstring       string
27830                         Glow             int8
27831                         MaxBreath        uint16  // Player only.
27832                         EyeHeight        float32 // Player only.
27833                         ZoomFOV          float32 // in degrees. Player only.
27834                         UseTextureAlpha  bool
27835                         DmgTextureMod    Texture // suffix
27836                         Shaded           bool
27837                         ShowOnMinimap    bool
27838                         NametagBG        color.NRGBA
27839                 }))(obj)).MakeFootstepSnds
27840                 if x {
27841                         write8(w, 1)
27842                 } else {
27843                         write8(w, 0)
27844                 }
27845
27846         }
27847         {
27848                 x := (*(*(struct {
27849                         MaxHP            uint16 // Player only.
27850                         CollideWithNodes bool
27851                         Weight           float32 // deprecated
27852                         ColBox, SelBox   Box
27853                         Pointable        bool
27854                         Visual           string
27855                         VisualSize       [3]float32
27856                         Textures         []Texture
27857                         SpriteSheetSize  [2]int16 // in sprites.
27858                         SpritePos        [2]int16 // in sprite sheet.
27859                         Visible          bool
27860                         MakeFootstepSnds bool
27861                         RotateSpeed      float32 // in radians per second.
27862                         Mesh             string
27863                         Colors           []color.NRGBA
27864                         CollideWithAOs   bool
27865                         StepHeight       float32
27866                         FaceRotateDir    bool
27867                         FaceRotateDirOff float32 // in degrees.
27868                         BackfaceCull     bool
27869                         Nametag          string
27870                         NametagColor     color.NRGBA
27871                         FaceRotateSpeed  float32 // in degrees per second.
27872                         Infotext         string
27873                         Itemstring       string
27874                         Glow             int8
27875                         MaxBreath        uint16  // Player only.
27876                         EyeHeight        float32 // Player only.
27877                         ZoomFOV          float32 // in degrees. Player only.
27878                         UseTextureAlpha  bool
27879                         DmgTextureMod    Texture // suffix
27880                         Shaded           bool
27881                         ShowOnMinimap    bool
27882                         NametagBG        color.NRGBA
27883                 }))(obj)).RotateSpeed
27884                 write32(w, math.Float32bits(x))
27885         }
27886         if len(([]byte((*(*(struct {
27887                 MaxHP            uint16 // Player only.
27888                 CollideWithNodes bool
27889                 Weight           float32 // deprecated
27890                 ColBox, SelBox   Box
27891                 Pointable        bool
27892                 Visual           string
27893                 VisualSize       [3]float32
27894                 Textures         []Texture
27895                 SpriteSheetSize  [2]int16 // in sprites.
27896                 SpritePos        [2]int16 // in sprite sheet.
27897                 Visible          bool
27898                 MakeFootstepSnds bool
27899                 RotateSpeed      float32 // in radians per second.
27900                 Mesh             string
27901                 Colors           []color.NRGBA
27902                 CollideWithAOs   bool
27903                 StepHeight       float32
27904                 FaceRotateDir    bool
27905                 FaceRotateDirOff float32 // in degrees.
27906                 BackfaceCull     bool
27907                 Nametag          string
27908                 NametagColor     color.NRGBA
27909                 FaceRotateSpeed  float32 // in degrees per second.
27910                 Infotext         string
27911                 Itemstring       string
27912                 Glow             int8
27913                 MaxBreath        uint16  // Player only.
27914                 EyeHeight        float32 // Player only.
27915                 ZoomFOV          float32 // in degrees. Player only.
27916                 UseTextureAlpha  bool
27917                 DmgTextureMod    Texture // suffix
27918                 Shaded           bool
27919                 ShowOnMinimap    bool
27920                 NametagBG        color.NRGBA
27921         }))(obj)).Mesh))) > math.MaxUint16 {
27922                 chk(ErrTooLong)
27923         }
27924         {
27925                 x := uint16(len(([]byte((*(*(struct {
27926                         MaxHP            uint16 // Player only.
27927                         CollideWithNodes bool
27928                         Weight           float32 // deprecated
27929                         ColBox, SelBox   Box
27930                         Pointable        bool
27931                         Visual           string
27932                         VisualSize       [3]float32
27933                         Textures         []Texture
27934                         SpriteSheetSize  [2]int16 // in sprites.
27935                         SpritePos        [2]int16 // in sprite sheet.
27936                         Visible          bool
27937                         MakeFootstepSnds bool
27938                         RotateSpeed      float32 // in radians per second.
27939                         Mesh             string
27940                         Colors           []color.NRGBA
27941                         CollideWithAOs   bool
27942                         StepHeight       float32
27943                         FaceRotateDir    bool
27944                         FaceRotateDirOff float32 // in degrees.
27945                         BackfaceCull     bool
27946                         Nametag          string
27947                         NametagColor     color.NRGBA
27948                         FaceRotateSpeed  float32 // in degrees per second.
27949                         Infotext         string
27950                         Itemstring       string
27951                         Glow             int8
27952                         MaxBreath        uint16  // Player only.
27953                         EyeHeight        float32 // Player only.
27954                         ZoomFOV          float32 // in degrees. Player only.
27955                         UseTextureAlpha  bool
27956                         DmgTextureMod    Texture // suffix
27957                         Shaded           bool
27958                         ShowOnMinimap    bool
27959                         NametagBG        color.NRGBA
27960                 }))(obj)).Mesh))))
27961                 write16(w, uint16(x))
27962         }
27963         {
27964                 _, err := w.Write(([]byte((*(*(struct {
27965                         MaxHP            uint16 // Player only.
27966                         CollideWithNodes bool
27967                         Weight           float32 // deprecated
27968                         ColBox, SelBox   Box
27969                         Pointable        bool
27970                         Visual           string
27971                         VisualSize       [3]float32
27972                         Textures         []Texture
27973                         SpriteSheetSize  [2]int16 // in sprites.
27974                         SpritePos        [2]int16 // in sprite sheet.
27975                         Visible          bool
27976                         MakeFootstepSnds bool
27977                         RotateSpeed      float32 // in radians per second.
27978                         Mesh             string
27979                         Colors           []color.NRGBA
27980                         CollideWithAOs   bool
27981                         StepHeight       float32
27982                         FaceRotateDir    bool
27983                         FaceRotateDirOff float32 // in degrees.
27984                         BackfaceCull     bool
27985                         Nametag          string
27986                         NametagColor     color.NRGBA
27987                         FaceRotateSpeed  float32 // in degrees per second.
27988                         Infotext         string
27989                         Itemstring       string
27990                         Glow             int8
27991                         MaxBreath        uint16  // Player only.
27992                         EyeHeight        float32 // Player only.
27993                         ZoomFOV          float32 // in degrees. Player only.
27994                         UseTextureAlpha  bool
27995                         DmgTextureMod    Texture // suffix
27996                         Shaded           bool
27997                         ShowOnMinimap    bool
27998                         NametagBG        color.NRGBA
27999                 }))(obj)).Mesh))[:])
28000                 chk(err)
28001         }
28002         if len(((*(*(struct {
28003                 MaxHP            uint16 // Player only.
28004                 CollideWithNodes bool
28005                 Weight           float32 // deprecated
28006                 ColBox, SelBox   Box
28007                 Pointable        bool
28008                 Visual           string
28009                 VisualSize       [3]float32
28010                 Textures         []Texture
28011                 SpriteSheetSize  [2]int16 // in sprites.
28012                 SpritePos        [2]int16 // in sprite sheet.
28013                 Visible          bool
28014                 MakeFootstepSnds bool
28015                 RotateSpeed      float32 // in radians per second.
28016                 Mesh             string
28017                 Colors           []color.NRGBA
28018                 CollideWithAOs   bool
28019                 StepHeight       float32
28020                 FaceRotateDir    bool
28021                 FaceRotateDirOff float32 // in degrees.
28022                 BackfaceCull     bool
28023                 Nametag          string
28024                 NametagColor     color.NRGBA
28025                 FaceRotateSpeed  float32 // in degrees per second.
28026                 Infotext         string
28027                 Itemstring       string
28028                 Glow             int8
28029                 MaxBreath        uint16  // Player only.
28030                 EyeHeight        float32 // Player only.
28031                 ZoomFOV          float32 // in degrees. Player only.
28032                 UseTextureAlpha  bool
28033                 DmgTextureMod    Texture // suffix
28034                 Shaded           bool
28035                 ShowOnMinimap    bool
28036                 NametagBG        color.NRGBA
28037         }))(obj)).Colors)) > math.MaxUint16 {
28038                 chk(ErrTooLong)
28039         }
28040         {
28041                 x := uint16(len(((*(*(struct {
28042                         MaxHP            uint16 // Player only.
28043                         CollideWithNodes bool
28044                         Weight           float32 // deprecated
28045                         ColBox, SelBox   Box
28046                         Pointable        bool
28047                         Visual           string
28048                         VisualSize       [3]float32
28049                         Textures         []Texture
28050                         SpriteSheetSize  [2]int16 // in sprites.
28051                         SpritePos        [2]int16 // in sprite sheet.
28052                         Visible          bool
28053                         MakeFootstepSnds bool
28054                         RotateSpeed      float32 // in radians per second.
28055                         Mesh             string
28056                         Colors           []color.NRGBA
28057                         CollideWithAOs   bool
28058                         StepHeight       float32
28059                         FaceRotateDir    bool
28060                         FaceRotateDirOff float32 // in degrees.
28061                         BackfaceCull     bool
28062                         Nametag          string
28063                         NametagColor     color.NRGBA
28064                         FaceRotateSpeed  float32 // in degrees per second.
28065                         Infotext         string
28066                         Itemstring       string
28067                         Glow             int8
28068                         MaxBreath        uint16  // Player only.
28069                         EyeHeight        float32 // Player only.
28070                         ZoomFOV          float32 // in degrees. Player only.
28071                         UseTextureAlpha  bool
28072                         DmgTextureMod    Texture // suffix
28073                         Shaded           bool
28074                         ShowOnMinimap    bool
28075                         NametagBG        color.NRGBA
28076                 }))(obj)).Colors)))
28077                 write16(w, uint16(x))
28078         }
28079         for local340 := range (*(*(struct {
28080                 MaxHP            uint16 // Player only.
28081                 CollideWithNodes bool
28082                 Weight           float32 // deprecated
28083                 ColBox, SelBox   Box
28084                 Pointable        bool
28085                 Visual           string
28086                 VisualSize       [3]float32
28087                 Textures         []Texture
28088                 SpriteSheetSize  [2]int16 // in sprites.
28089                 SpritePos        [2]int16 // in sprite sheet.
28090                 Visible          bool
28091                 MakeFootstepSnds bool
28092                 RotateSpeed      float32 // in radians per second.
28093                 Mesh             string
28094                 Colors           []color.NRGBA
28095                 CollideWithAOs   bool
28096                 StepHeight       float32
28097                 FaceRotateDir    bool
28098                 FaceRotateDirOff float32 // in degrees.
28099                 BackfaceCull     bool
28100                 Nametag          string
28101                 NametagColor     color.NRGBA
28102                 FaceRotateSpeed  float32 // in degrees per second.
28103                 Infotext         string
28104                 Itemstring       string
28105                 Glow             int8
28106                 MaxBreath        uint16  // Player only.
28107                 EyeHeight        float32 // Player only.
28108                 ZoomFOV          float32 // in degrees. Player only.
28109                 UseTextureAlpha  bool
28110                 DmgTextureMod    Texture // suffix
28111                 Shaded           bool
28112                 ShowOnMinimap    bool
28113                 NametagBG        color.NRGBA
28114         }))(obj)).Colors {
28115                 {
28116                         x := ((*(*(struct {
28117                                 MaxHP            uint16 // Player only.
28118                                 CollideWithNodes bool
28119                                 Weight           float32 // deprecated
28120                                 ColBox, SelBox   Box
28121                                 Pointable        bool
28122                                 Visual           string
28123                                 VisualSize       [3]float32
28124                                 Textures         []Texture
28125                                 SpriteSheetSize  [2]int16 // in sprites.
28126                                 SpritePos        [2]int16 // in sprite sheet.
28127                                 Visible          bool
28128                                 MakeFootstepSnds bool
28129                                 RotateSpeed      float32 // in radians per second.
28130                                 Mesh             string
28131                                 Colors           []color.NRGBA
28132                                 CollideWithAOs   bool
28133                                 StepHeight       float32
28134                                 FaceRotateDir    bool
28135                                 FaceRotateDirOff float32 // in degrees.
28136                                 BackfaceCull     bool
28137                                 Nametag          string
28138                                 NametagColor     color.NRGBA
28139                                 FaceRotateSpeed  float32 // in degrees per second.
28140                                 Infotext         string
28141                                 Itemstring       string
28142                                 Glow             int8
28143                                 MaxBreath        uint16  // Player only.
28144                                 EyeHeight        float32 // Player only.
28145                                 ZoomFOV          float32 // in degrees. Player only.
28146                                 UseTextureAlpha  bool
28147                                 DmgTextureMod    Texture // suffix
28148                                 Shaded           bool
28149                                 ShowOnMinimap    bool
28150                                 NametagBG        color.NRGBA
28151                         }))(obj)).Colors)[local340]
28152                         w.Write([]byte{x.A, x.R, x.G, x.B})
28153
28154                 }
28155         }
28156         {
28157                 x := (*(*(struct {
28158                         MaxHP            uint16 // Player only.
28159                         CollideWithNodes bool
28160                         Weight           float32 // deprecated
28161                         ColBox, SelBox   Box
28162                         Pointable        bool
28163                         Visual           string
28164                         VisualSize       [3]float32
28165                         Textures         []Texture
28166                         SpriteSheetSize  [2]int16 // in sprites.
28167                         SpritePos        [2]int16 // in sprite sheet.
28168                         Visible          bool
28169                         MakeFootstepSnds bool
28170                         RotateSpeed      float32 // in radians per second.
28171                         Mesh             string
28172                         Colors           []color.NRGBA
28173                         CollideWithAOs   bool
28174                         StepHeight       float32
28175                         FaceRotateDir    bool
28176                         FaceRotateDirOff float32 // in degrees.
28177                         BackfaceCull     bool
28178                         Nametag          string
28179                         NametagColor     color.NRGBA
28180                         FaceRotateSpeed  float32 // in degrees per second.
28181                         Infotext         string
28182                         Itemstring       string
28183                         Glow             int8
28184                         MaxBreath        uint16  // Player only.
28185                         EyeHeight        float32 // Player only.
28186                         ZoomFOV          float32 // in degrees. Player only.
28187                         UseTextureAlpha  bool
28188                         DmgTextureMod    Texture // suffix
28189                         Shaded           bool
28190                         ShowOnMinimap    bool
28191                         NametagBG        color.NRGBA
28192                 }))(obj)).CollideWithAOs
28193                 if x {
28194                         write8(w, 1)
28195                 } else {
28196                         write8(w, 0)
28197                 }
28198
28199         }
28200         {
28201                 x := (*(*(struct {
28202                         MaxHP            uint16 // Player only.
28203                         CollideWithNodes bool
28204                         Weight           float32 // deprecated
28205                         ColBox, SelBox   Box
28206                         Pointable        bool
28207                         Visual           string
28208                         VisualSize       [3]float32
28209                         Textures         []Texture
28210                         SpriteSheetSize  [2]int16 // in sprites.
28211                         SpritePos        [2]int16 // in sprite sheet.
28212                         Visible          bool
28213                         MakeFootstepSnds bool
28214                         RotateSpeed      float32 // in radians per second.
28215                         Mesh             string
28216                         Colors           []color.NRGBA
28217                         CollideWithAOs   bool
28218                         StepHeight       float32
28219                         FaceRotateDir    bool
28220                         FaceRotateDirOff float32 // in degrees.
28221                         BackfaceCull     bool
28222                         Nametag          string
28223                         NametagColor     color.NRGBA
28224                         FaceRotateSpeed  float32 // in degrees per second.
28225                         Infotext         string
28226                         Itemstring       string
28227                         Glow             int8
28228                         MaxBreath        uint16  // Player only.
28229                         EyeHeight        float32 // Player only.
28230                         ZoomFOV          float32 // in degrees. Player only.
28231                         UseTextureAlpha  bool
28232                         DmgTextureMod    Texture // suffix
28233                         Shaded           bool
28234                         ShowOnMinimap    bool
28235                         NametagBG        color.NRGBA
28236                 }))(obj)).StepHeight
28237                 write32(w, math.Float32bits(x))
28238         }
28239         {
28240                 x := (*(*(struct {
28241                         MaxHP            uint16 // Player only.
28242                         CollideWithNodes bool
28243                         Weight           float32 // deprecated
28244                         ColBox, SelBox   Box
28245                         Pointable        bool
28246                         Visual           string
28247                         VisualSize       [3]float32
28248                         Textures         []Texture
28249                         SpriteSheetSize  [2]int16 // in sprites.
28250                         SpritePos        [2]int16 // in sprite sheet.
28251                         Visible          bool
28252                         MakeFootstepSnds bool
28253                         RotateSpeed      float32 // in radians per second.
28254                         Mesh             string
28255                         Colors           []color.NRGBA
28256                         CollideWithAOs   bool
28257                         StepHeight       float32
28258                         FaceRotateDir    bool
28259                         FaceRotateDirOff float32 // in degrees.
28260                         BackfaceCull     bool
28261                         Nametag          string
28262                         NametagColor     color.NRGBA
28263                         FaceRotateSpeed  float32 // in degrees per second.
28264                         Infotext         string
28265                         Itemstring       string
28266                         Glow             int8
28267                         MaxBreath        uint16  // Player only.
28268                         EyeHeight        float32 // Player only.
28269                         ZoomFOV          float32 // in degrees. Player only.
28270                         UseTextureAlpha  bool
28271                         DmgTextureMod    Texture // suffix
28272                         Shaded           bool
28273                         ShowOnMinimap    bool
28274                         NametagBG        color.NRGBA
28275                 }))(obj)).FaceRotateDir
28276                 if x {
28277                         write8(w, 1)
28278                 } else {
28279                         write8(w, 0)
28280                 }
28281
28282         }
28283         {
28284                 x := (*(*(struct {
28285                         MaxHP            uint16 // Player only.
28286                         CollideWithNodes bool
28287                         Weight           float32 // deprecated
28288                         ColBox, SelBox   Box
28289                         Pointable        bool
28290                         Visual           string
28291                         VisualSize       [3]float32
28292                         Textures         []Texture
28293                         SpriteSheetSize  [2]int16 // in sprites.
28294                         SpritePos        [2]int16 // in sprite sheet.
28295                         Visible          bool
28296                         MakeFootstepSnds bool
28297                         RotateSpeed      float32 // in radians per second.
28298                         Mesh             string
28299                         Colors           []color.NRGBA
28300                         CollideWithAOs   bool
28301                         StepHeight       float32
28302                         FaceRotateDir    bool
28303                         FaceRotateDirOff float32 // in degrees.
28304                         BackfaceCull     bool
28305                         Nametag          string
28306                         NametagColor     color.NRGBA
28307                         FaceRotateSpeed  float32 // in degrees per second.
28308                         Infotext         string
28309                         Itemstring       string
28310                         Glow             int8
28311                         MaxBreath        uint16  // Player only.
28312                         EyeHeight        float32 // Player only.
28313                         ZoomFOV          float32 // in degrees. Player only.
28314                         UseTextureAlpha  bool
28315                         DmgTextureMod    Texture // suffix
28316                         Shaded           bool
28317                         ShowOnMinimap    bool
28318                         NametagBG        color.NRGBA
28319                 }))(obj)).FaceRotateDirOff
28320                 write32(w, math.Float32bits(x))
28321         }
28322         {
28323                 x := (*(*(struct {
28324                         MaxHP            uint16 // Player only.
28325                         CollideWithNodes bool
28326                         Weight           float32 // deprecated
28327                         ColBox, SelBox   Box
28328                         Pointable        bool
28329                         Visual           string
28330                         VisualSize       [3]float32
28331                         Textures         []Texture
28332                         SpriteSheetSize  [2]int16 // in sprites.
28333                         SpritePos        [2]int16 // in sprite sheet.
28334                         Visible          bool
28335                         MakeFootstepSnds bool
28336                         RotateSpeed      float32 // in radians per second.
28337                         Mesh             string
28338                         Colors           []color.NRGBA
28339                         CollideWithAOs   bool
28340                         StepHeight       float32
28341                         FaceRotateDir    bool
28342                         FaceRotateDirOff float32 // in degrees.
28343                         BackfaceCull     bool
28344                         Nametag          string
28345                         NametagColor     color.NRGBA
28346                         FaceRotateSpeed  float32 // in degrees per second.
28347                         Infotext         string
28348                         Itemstring       string
28349                         Glow             int8
28350                         MaxBreath        uint16  // Player only.
28351                         EyeHeight        float32 // Player only.
28352                         ZoomFOV          float32 // in degrees. Player only.
28353                         UseTextureAlpha  bool
28354                         DmgTextureMod    Texture // suffix
28355                         Shaded           bool
28356                         ShowOnMinimap    bool
28357                         NametagBG        color.NRGBA
28358                 }))(obj)).BackfaceCull
28359                 if x {
28360                         write8(w, 1)
28361                 } else {
28362                         write8(w, 0)
28363                 }
28364
28365         }
28366         if len(([]byte((*(*(struct {
28367                 MaxHP            uint16 // Player only.
28368                 CollideWithNodes bool
28369                 Weight           float32 // deprecated
28370                 ColBox, SelBox   Box
28371                 Pointable        bool
28372                 Visual           string
28373                 VisualSize       [3]float32
28374                 Textures         []Texture
28375                 SpriteSheetSize  [2]int16 // in sprites.
28376                 SpritePos        [2]int16 // in sprite sheet.
28377                 Visible          bool
28378                 MakeFootstepSnds bool
28379                 RotateSpeed      float32 // in radians per second.
28380                 Mesh             string
28381                 Colors           []color.NRGBA
28382                 CollideWithAOs   bool
28383                 StepHeight       float32
28384                 FaceRotateDir    bool
28385                 FaceRotateDirOff float32 // in degrees.
28386                 BackfaceCull     bool
28387                 Nametag          string
28388                 NametagColor     color.NRGBA
28389                 FaceRotateSpeed  float32 // in degrees per second.
28390                 Infotext         string
28391                 Itemstring       string
28392                 Glow             int8
28393                 MaxBreath        uint16  // Player only.
28394                 EyeHeight        float32 // Player only.
28395                 ZoomFOV          float32 // in degrees. Player only.
28396                 UseTextureAlpha  bool
28397                 DmgTextureMod    Texture // suffix
28398                 Shaded           bool
28399                 ShowOnMinimap    bool
28400                 NametagBG        color.NRGBA
28401         }))(obj)).Nametag))) > math.MaxUint16 {
28402                 chk(ErrTooLong)
28403         }
28404         {
28405                 x := uint16(len(([]byte((*(*(struct {
28406                         MaxHP            uint16 // Player only.
28407                         CollideWithNodes bool
28408                         Weight           float32 // deprecated
28409                         ColBox, SelBox   Box
28410                         Pointable        bool
28411                         Visual           string
28412                         VisualSize       [3]float32
28413                         Textures         []Texture
28414                         SpriteSheetSize  [2]int16 // in sprites.
28415                         SpritePos        [2]int16 // in sprite sheet.
28416                         Visible          bool
28417                         MakeFootstepSnds bool
28418                         RotateSpeed      float32 // in radians per second.
28419                         Mesh             string
28420                         Colors           []color.NRGBA
28421                         CollideWithAOs   bool
28422                         StepHeight       float32
28423                         FaceRotateDir    bool
28424                         FaceRotateDirOff float32 // in degrees.
28425                         BackfaceCull     bool
28426                         Nametag          string
28427                         NametagColor     color.NRGBA
28428                         FaceRotateSpeed  float32 // in degrees per second.
28429                         Infotext         string
28430                         Itemstring       string
28431                         Glow             int8
28432                         MaxBreath        uint16  // Player only.
28433                         EyeHeight        float32 // Player only.
28434                         ZoomFOV          float32 // in degrees. Player only.
28435                         UseTextureAlpha  bool
28436                         DmgTextureMod    Texture // suffix
28437                         Shaded           bool
28438                         ShowOnMinimap    bool
28439                         NametagBG        color.NRGBA
28440                 }))(obj)).Nametag))))
28441                 write16(w, uint16(x))
28442         }
28443         {
28444                 _, err := w.Write(([]byte((*(*(struct {
28445                         MaxHP            uint16 // Player only.
28446                         CollideWithNodes bool
28447                         Weight           float32 // deprecated
28448                         ColBox, SelBox   Box
28449                         Pointable        bool
28450                         Visual           string
28451                         VisualSize       [3]float32
28452                         Textures         []Texture
28453                         SpriteSheetSize  [2]int16 // in sprites.
28454                         SpritePos        [2]int16 // in sprite sheet.
28455                         Visible          bool
28456                         MakeFootstepSnds bool
28457                         RotateSpeed      float32 // in radians per second.
28458                         Mesh             string
28459                         Colors           []color.NRGBA
28460                         CollideWithAOs   bool
28461                         StepHeight       float32
28462                         FaceRotateDir    bool
28463                         FaceRotateDirOff float32 // in degrees.
28464                         BackfaceCull     bool
28465                         Nametag          string
28466                         NametagColor     color.NRGBA
28467                         FaceRotateSpeed  float32 // in degrees per second.
28468                         Infotext         string
28469                         Itemstring       string
28470                         Glow             int8
28471                         MaxBreath        uint16  // Player only.
28472                         EyeHeight        float32 // Player only.
28473                         ZoomFOV          float32 // in degrees. Player only.
28474                         UseTextureAlpha  bool
28475                         DmgTextureMod    Texture // suffix
28476                         Shaded           bool
28477                         ShowOnMinimap    bool
28478                         NametagBG        color.NRGBA
28479                 }))(obj)).Nametag))[:])
28480                 chk(err)
28481         }
28482         {
28483                 x := (*(*(struct {
28484                         MaxHP            uint16 // Player only.
28485                         CollideWithNodes bool
28486                         Weight           float32 // deprecated
28487                         ColBox, SelBox   Box
28488                         Pointable        bool
28489                         Visual           string
28490                         VisualSize       [3]float32
28491                         Textures         []Texture
28492                         SpriteSheetSize  [2]int16 // in sprites.
28493                         SpritePos        [2]int16 // in sprite sheet.
28494                         Visible          bool
28495                         MakeFootstepSnds bool
28496                         RotateSpeed      float32 // in radians per second.
28497                         Mesh             string
28498                         Colors           []color.NRGBA
28499                         CollideWithAOs   bool
28500                         StepHeight       float32
28501                         FaceRotateDir    bool
28502                         FaceRotateDirOff float32 // in degrees.
28503                         BackfaceCull     bool
28504                         Nametag          string
28505                         NametagColor     color.NRGBA
28506                         FaceRotateSpeed  float32 // in degrees per second.
28507                         Infotext         string
28508                         Itemstring       string
28509                         Glow             int8
28510                         MaxBreath        uint16  // Player only.
28511                         EyeHeight        float32 // Player only.
28512                         ZoomFOV          float32 // in degrees. Player only.
28513                         UseTextureAlpha  bool
28514                         DmgTextureMod    Texture // suffix
28515                         Shaded           bool
28516                         ShowOnMinimap    bool
28517                         NametagBG        color.NRGBA
28518                 }))(obj)).NametagColor
28519                 w.Write([]byte{x.A, x.R, x.G, x.B})
28520
28521         }
28522         {
28523                 x := (*(*(struct {
28524                         MaxHP            uint16 // Player only.
28525                         CollideWithNodes bool
28526                         Weight           float32 // deprecated
28527                         ColBox, SelBox   Box
28528                         Pointable        bool
28529                         Visual           string
28530                         VisualSize       [3]float32
28531                         Textures         []Texture
28532                         SpriteSheetSize  [2]int16 // in sprites.
28533                         SpritePos        [2]int16 // in sprite sheet.
28534                         Visible          bool
28535                         MakeFootstepSnds bool
28536                         RotateSpeed      float32 // in radians per second.
28537                         Mesh             string
28538                         Colors           []color.NRGBA
28539                         CollideWithAOs   bool
28540                         StepHeight       float32
28541                         FaceRotateDir    bool
28542                         FaceRotateDirOff float32 // in degrees.
28543                         BackfaceCull     bool
28544                         Nametag          string
28545                         NametagColor     color.NRGBA
28546                         FaceRotateSpeed  float32 // in degrees per second.
28547                         Infotext         string
28548                         Itemstring       string
28549                         Glow             int8
28550                         MaxBreath        uint16  // Player only.
28551                         EyeHeight        float32 // Player only.
28552                         ZoomFOV          float32 // in degrees. Player only.
28553                         UseTextureAlpha  bool
28554                         DmgTextureMod    Texture // suffix
28555                         Shaded           bool
28556                         ShowOnMinimap    bool
28557                         NametagBG        color.NRGBA
28558                 }))(obj)).FaceRotateSpeed
28559                 write32(w, math.Float32bits(x))
28560         }
28561         if len(([]byte((*(*(struct {
28562                 MaxHP            uint16 // Player only.
28563                 CollideWithNodes bool
28564                 Weight           float32 // deprecated
28565                 ColBox, SelBox   Box
28566                 Pointable        bool
28567                 Visual           string
28568                 VisualSize       [3]float32
28569                 Textures         []Texture
28570                 SpriteSheetSize  [2]int16 // in sprites.
28571                 SpritePos        [2]int16 // in sprite sheet.
28572                 Visible          bool
28573                 MakeFootstepSnds bool
28574                 RotateSpeed      float32 // in radians per second.
28575                 Mesh             string
28576                 Colors           []color.NRGBA
28577                 CollideWithAOs   bool
28578                 StepHeight       float32
28579                 FaceRotateDir    bool
28580                 FaceRotateDirOff float32 // in degrees.
28581                 BackfaceCull     bool
28582                 Nametag          string
28583                 NametagColor     color.NRGBA
28584                 FaceRotateSpeed  float32 // in degrees per second.
28585                 Infotext         string
28586                 Itemstring       string
28587                 Glow             int8
28588                 MaxBreath        uint16  // Player only.
28589                 EyeHeight        float32 // Player only.
28590                 ZoomFOV          float32 // in degrees. Player only.
28591                 UseTextureAlpha  bool
28592                 DmgTextureMod    Texture // suffix
28593                 Shaded           bool
28594                 ShowOnMinimap    bool
28595                 NametagBG        color.NRGBA
28596         }))(obj)).Infotext))) > math.MaxUint16 {
28597                 chk(ErrTooLong)
28598         }
28599         {
28600                 x := uint16(len(([]byte((*(*(struct {
28601                         MaxHP            uint16 // Player only.
28602                         CollideWithNodes bool
28603                         Weight           float32 // deprecated
28604                         ColBox, SelBox   Box
28605                         Pointable        bool
28606                         Visual           string
28607                         VisualSize       [3]float32
28608                         Textures         []Texture
28609                         SpriteSheetSize  [2]int16 // in sprites.
28610                         SpritePos        [2]int16 // in sprite sheet.
28611                         Visible          bool
28612                         MakeFootstepSnds bool
28613                         RotateSpeed      float32 // in radians per second.
28614                         Mesh             string
28615                         Colors           []color.NRGBA
28616                         CollideWithAOs   bool
28617                         StepHeight       float32
28618                         FaceRotateDir    bool
28619                         FaceRotateDirOff float32 // in degrees.
28620                         BackfaceCull     bool
28621                         Nametag          string
28622                         NametagColor     color.NRGBA
28623                         FaceRotateSpeed  float32 // in degrees per second.
28624                         Infotext         string
28625                         Itemstring       string
28626                         Glow             int8
28627                         MaxBreath        uint16  // Player only.
28628                         EyeHeight        float32 // Player only.
28629                         ZoomFOV          float32 // in degrees. Player only.
28630                         UseTextureAlpha  bool
28631                         DmgTextureMod    Texture // suffix
28632                         Shaded           bool
28633                         ShowOnMinimap    bool
28634                         NametagBG        color.NRGBA
28635                 }))(obj)).Infotext))))
28636                 write16(w, uint16(x))
28637         }
28638         {
28639                 _, err := w.Write(([]byte((*(*(struct {
28640                         MaxHP            uint16 // Player only.
28641                         CollideWithNodes bool
28642                         Weight           float32 // deprecated
28643                         ColBox, SelBox   Box
28644                         Pointable        bool
28645                         Visual           string
28646                         VisualSize       [3]float32
28647                         Textures         []Texture
28648                         SpriteSheetSize  [2]int16 // in sprites.
28649                         SpritePos        [2]int16 // in sprite sheet.
28650                         Visible          bool
28651                         MakeFootstepSnds bool
28652                         RotateSpeed      float32 // in radians per second.
28653                         Mesh             string
28654                         Colors           []color.NRGBA
28655                         CollideWithAOs   bool
28656                         StepHeight       float32
28657                         FaceRotateDir    bool
28658                         FaceRotateDirOff float32 // in degrees.
28659                         BackfaceCull     bool
28660                         Nametag          string
28661                         NametagColor     color.NRGBA
28662                         FaceRotateSpeed  float32 // in degrees per second.
28663                         Infotext         string
28664                         Itemstring       string
28665                         Glow             int8
28666                         MaxBreath        uint16  // Player only.
28667                         EyeHeight        float32 // Player only.
28668                         ZoomFOV          float32 // in degrees. Player only.
28669                         UseTextureAlpha  bool
28670                         DmgTextureMod    Texture // suffix
28671                         Shaded           bool
28672                         ShowOnMinimap    bool
28673                         NametagBG        color.NRGBA
28674                 }))(obj)).Infotext))[:])
28675                 chk(err)
28676         }
28677         if len(([]byte((*(*(struct {
28678                 MaxHP            uint16 // Player only.
28679                 CollideWithNodes bool
28680                 Weight           float32 // deprecated
28681                 ColBox, SelBox   Box
28682                 Pointable        bool
28683                 Visual           string
28684                 VisualSize       [3]float32
28685                 Textures         []Texture
28686                 SpriteSheetSize  [2]int16 // in sprites.
28687                 SpritePos        [2]int16 // in sprite sheet.
28688                 Visible          bool
28689                 MakeFootstepSnds bool
28690                 RotateSpeed      float32 // in radians per second.
28691                 Mesh             string
28692                 Colors           []color.NRGBA
28693                 CollideWithAOs   bool
28694                 StepHeight       float32
28695                 FaceRotateDir    bool
28696                 FaceRotateDirOff float32 // in degrees.
28697                 BackfaceCull     bool
28698                 Nametag          string
28699                 NametagColor     color.NRGBA
28700                 FaceRotateSpeed  float32 // in degrees per second.
28701                 Infotext         string
28702                 Itemstring       string
28703                 Glow             int8
28704                 MaxBreath        uint16  // Player only.
28705                 EyeHeight        float32 // Player only.
28706                 ZoomFOV          float32 // in degrees. Player only.
28707                 UseTextureAlpha  bool
28708                 DmgTextureMod    Texture // suffix
28709                 Shaded           bool
28710                 ShowOnMinimap    bool
28711                 NametagBG        color.NRGBA
28712         }))(obj)).Itemstring))) > math.MaxUint16 {
28713                 chk(ErrTooLong)
28714         }
28715         {
28716                 x := uint16(len(([]byte((*(*(struct {
28717                         MaxHP            uint16 // Player only.
28718                         CollideWithNodes bool
28719                         Weight           float32 // deprecated
28720                         ColBox, SelBox   Box
28721                         Pointable        bool
28722                         Visual           string
28723                         VisualSize       [3]float32
28724                         Textures         []Texture
28725                         SpriteSheetSize  [2]int16 // in sprites.
28726                         SpritePos        [2]int16 // in sprite sheet.
28727                         Visible          bool
28728                         MakeFootstepSnds bool
28729                         RotateSpeed      float32 // in radians per second.
28730                         Mesh             string
28731                         Colors           []color.NRGBA
28732                         CollideWithAOs   bool
28733                         StepHeight       float32
28734                         FaceRotateDir    bool
28735                         FaceRotateDirOff float32 // in degrees.
28736                         BackfaceCull     bool
28737                         Nametag          string
28738                         NametagColor     color.NRGBA
28739                         FaceRotateSpeed  float32 // in degrees per second.
28740                         Infotext         string
28741                         Itemstring       string
28742                         Glow             int8
28743                         MaxBreath        uint16  // Player only.
28744                         EyeHeight        float32 // Player only.
28745                         ZoomFOV          float32 // in degrees. Player only.
28746                         UseTextureAlpha  bool
28747                         DmgTextureMod    Texture // suffix
28748                         Shaded           bool
28749                         ShowOnMinimap    bool
28750                         NametagBG        color.NRGBA
28751                 }))(obj)).Itemstring))))
28752                 write16(w, uint16(x))
28753         }
28754         {
28755                 _, err := w.Write(([]byte((*(*(struct {
28756                         MaxHP            uint16 // Player only.
28757                         CollideWithNodes bool
28758                         Weight           float32 // deprecated
28759                         ColBox, SelBox   Box
28760                         Pointable        bool
28761                         Visual           string
28762                         VisualSize       [3]float32
28763                         Textures         []Texture
28764                         SpriteSheetSize  [2]int16 // in sprites.
28765                         SpritePos        [2]int16 // in sprite sheet.
28766                         Visible          bool
28767                         MakeFootstepSnds bool
28768                         RotateSpeed      float32 // in radians per second.
28769                         Mesh             string
28770                         Colors           []color.NRGBA
28771                         CollideWithAOs   bool
28772                         StepHeight       float32
28773                         FaceRotateDir    bool
28774                         FaceRotateDirOff float32 // in degrees.
28775                         BackfaceCull     bool
28776                         Nametag          string
28777                         NametagColor     color.NRGBA
28778                         FaceRotateSpeed  float32 // in degrees per second.
28779                         Infotext         string
28780                         Itemstring       string
28781                         Glow             int8
28782                         MaxBreath        uint16  // Player only.
28783                         EyeHeight        float32 // Player only.
28784                         ZoomFOV          float32 // in degrees. Player only.
28785                         UseTextureAlpha  bool
28786                         DmgTextureMod    Texture // suffix
28787                         Shaded           bool
28788                         ShowOnMinimap    bool
28789                         NametagBG        color.NRGBA
28790                 }))(obj)).Itemstring))[:])
28791                 chk(err)
28792         }
28793         {
28794                 x := (*(*(struct {
28795                         MaxHP            uint16 // Player only.
28796                         CollideWithNodes bool
28797                         Weight           float32 // deprecated
28798                         ColBox, SelBox   Box
28799                         Pointable        bool
28800                         Visual           string
28801                         VisualSize       [3]float32
28802                         Textures         []Texture
28803                         SpriteSheetSize  [2]int16 // in sprites.
28804                         SpritePos        [2]int16 // in sprite sheet.
28805                         Visible          bool
28806                         MakeFootstepSnds bool
28807                         RotateSpeed      float32 // in radians per second.
28808                         Mesh             string
28809                         Colors           []color.NRGBA
28810                         CollideWithAOs   bool
28811                         StepHeight       float32
28812                         FaceRotateDir    bool
28813                         FaceRotateDirOff float32 // in degrees.
28814                         BackfaceCull     bool
28815                         Nametag          string
28816                         NametagColor     color.NRGBA
28817                         FaceRotateSpeed  float32 // in degrees per second.
28818                         Infotext         string
28819                         Itemstring       string
28820                         Glow             int8
28821                         MaxBreath        uint16  // Player only.
28822                         EyeHeight        float32 // Player only.
28823                         ZoomFOV          float32 // in degrees. Player only.
28824                         UseTextureAlpha  bool
28825                         DmgTextureMod    Texture // suffix
28826                         Shaded           bool
28827                         ShowOnMinimap    bool
28828                         NametagBG        color.NRGBA
28829                 }))(obj)).Glow
28830                 write8(w, uint8(x))
28831         }
28832         {
28833                 x := (*(*(struct {
28834                         MaxHP            uint16 // Player only.
28835                         CollideWithNodes bool
28836                         Weight           float32 // deprecated
28837                         ColBox, SelBox   Box
28838                         Pointable        bool
28839                         Visual           string
28840                         VisualSize       [3]float32
28841                         Textures         []Texture
28842                         SpriteSheetSize  [2]int16 // in sprites.
28843                         SpritePos        [2]int16 // in sprite sheet.
28844                         Visible          bool
28845                         MakeFootstepSnds bool
28846                         RotateSpeed      float32 // in radians per second.
28847                         Mesh             string
28848                         Colors           []color.NRGBA
28849                         CollideWithAOs   bool
28850                         StepHeight       float32
28851                         FaceRotateDir    bool
28852                         FaceRotateDirOff float32 // in degrees.
28853                         BackfaceCull     bool
28854                         Nametag          string
28855                         NametagColor     color.NRGBA
28856                         FaceRotateSpeed  float32 // in degrees per second.
28857                         Infotext         string
28858                         Itemstring       string
28859                         Glow             int8
28860                         MaxBreath        uint16  // Player only.
28861                         EyeHeight        float32 // Player only.
28862                         ZoomFOV          float32 // in degrees. Player only.
28863                         UseTextureAlpha  bool
28864                         DmgTextureMod    Texture // suffix
28865                         Shaded           bool
28866                         ShowOnMinimap    bool
28867                         NametagBG        color.NRGBA
28868                 }))(obj)).MaxBreath
28869                 write16(w, uint16(x))
28870         }
28871         {
28872                 x := (*(*(struct {
28873                         MaxHP            uint16 // Player only.
28874                         CollideWithNodes bool
28875                         Weight           float32 // deprecated
28876                         ColBox, SelBox   Box
28877                         Pointable        bool
28878                         Visual           string
28879                         VisualSize       [3]float32
28880                         Textures         []Texture
28881                         SpriteSheetSize  [2]int16 // in sprites.
28882                         SpritePos        [2]int16 // in sprite sheet.
28883                         Visible          bool
28884                         MakeFootstepSnds bool
28885                         RotateSpeed      float32 // in radians per second.
28886                         Mesh             string
28887                         Colors           []color.NRGBA
28888                         CollideWithAOs   bool
28889                         StepHeight       float32
28890                         FaceRotateDir    bool
28891                         FaceRotateDirOff float32 // in degrees.
28892                         BackfaceCull     bool
28893                         Nametag          string
28894                         NametagColor     color.NRGBA
28895                         FaceRotateSpeed  float32 // in degrees per second.
28896                         Infotext         string
28897                         Itemstring       string
28898                         Glow             int8
28899                         MaxBreath        uint16  // Player only.
28900                         EyeHeight        float32 // Player only.
28901                         ZoomFOV          float32 // in degrees. Player only.
28902                         UseTextureAlpha  bool
28903                         DmgTextureMod    Texture // suffix
28904                         Shaded           bool
28905                         ShowOnMinimap    bool
28906                         NametagBG        color.NRGBA
28907                 }))(obj)).EyeHeight
28908                 write32(w, math.Float32bits(x))
28909         }
28910         {
28911                 x := (*(*(struct {
28912                         MaxHP            uint16 // Player only.
28913                         CollideWithNodes bool
28914                         Weight           float32 // deprecated
28915                         ColBox, SelBox   Box
28916                         Pointable        bool
28917                         Visual           string
28918                         VisualSize       [3]float32
28919                         Textures         []Texture
28920                         SpriteSheetSize  [2]int16 // in sprites.
28921                         SpritePos        [2]int16 // in sprite sheet.
28922                         Visible          bool
28923                         MakeFootstepSnds bool
28924                         RotateSpeed      float32 // in radians per second.
28925                         Mesh             string
28926                         Colors           []color.NRGBA
28927                         CollideWithAOs   bool
28928                         StepHeight       float32
28929                         FaceRotateDir    bool
28930                         FaceRotateDirOff float32 // in degrees.
28931                         BackfaceCull     bool
28932                         Nametag          string
28933                         NametagColor     color.NRGBA
28934                         FaceRotateSpeed  float32 // in degrees per second.
28935                         Infotext         string
28936                         Itemstring       string
28937                         Glow             int8
28938                         MaxBreath        uint16  // Player only.
28939                         EyeHeight        float32 // Player only.
28940                         ZoomFOV          float32 // in degrees. Player only.
28941                         UseTextureAlpha  bool
28942                         DmgTextureMod    Texture // suffix
28943                         Shaded           bool
28944                         ShowOnMinimap    bool
28945                         NametagBG        color.NRGBA
28946                 }))(obj)).ZoomFOV
28947                 write32(w, math.Float32bits(x))
28948         }
28949         {
28950                 x := (*(*(struct {
28951                         MaxHP            uint16 // Player only.
28952                         CollideWithNodes bool
28953                         Weight           float32 // deprecated
28954                         ColBox, SelBox   Box
28955                         Pointable        bool
28956                         Visual           string
28957                         VisualSize       [3]float32
28958                         Textures         []Texture
28959                         SpriteSheetSize  [2]int16 // in sprites.
28960                         SpritePos        [2]int16 // in sprite sheet.
28961                         Visible          bool
28962                         MakeFootstepSnds bool
28963                         RotateSpeed      float32 // in radians per second.
28964                         Mesh             string
28965                         Colors           []color.NRGBA
28966                         CollideWithAOs   bool
28967                         StepHeight       float32
28968                         FaceRotateDir    bool
28969                         FaceRotateDirOff float32 // in degrees.
28970                         BackfaceCull     bool
28971                         Nametag          string
28972                         NametagColor     color.NRGBA
28973                         FaceRotateSpeed  float32 // in degrees per second.
28974                         Infotext         string
28975                         Itemstring       string
28976                         Glow             int8
28977                         MaxBreath        uint16  // Player only.
28978                         EyeHeight        float32 // Player only.
28979                         ZoomFOV          float32 // in degrees. Player only.
28980                         UseTextureAlpha  bool
28981                         DmgTextureMod    Texture // suffix
28982                         Shaded           bool
28983                         ShowOnMinimap    bool
28984                         NametagBG        color.NRGBA
28985                 }))(obj)).UseTextureAlpha
28986                 if x {
28987                         write8(w, 1)
28988                 } else {
28989                         write8(w, 0)
28990                 }
28991
28992         }
28993         if err := pcall(func() {
28994                 ((*(*(struct {
28995                         MaxHP            uint16 // Player only.
28996                         CollideWithNodes bool
28997                         Weight           float32 // deprecated
28998                         ColBox, SelBox   Box
28999                         Pointable        bool
29000                         Visual           string
29001                         VisualSize       [3]float32
29002                         Textures         []Texture
29003                         SpriteSheetSize  [2]int16 // in sprites.
29004                         SpritePos        [2]int16 // in sprite sheet.
29005                         Visible          bool
29006                         MakeFootstepSnds bool
29007                         RotateSpeed      float32 // in radians per second.
29008                         Mesh             string
29009                         Colors           []color.NRGBA
29010                         CollideWithAOs   bool
29011                         StepHeight       float32
29012                         FaceRotateDir    bool
29013                         FaceRotateDirOff float32 // in degrees.
29014                         BackfaceCull     bool
29015                         Nametag          string
29016                         NametagColor     color.NRGBA
29017                         FaceRotateSpeed  float32 // in degrees per second.
29018                         Infotext         string
29019                         Itemstring       string
29020                         Glow             int8
29021                         MaxBreath        uint16  // Player only.
29022                         EyeHeight        float32 // Player only.
29023                         ZoomFOV          float32 // in degrees. Player only.
29024                         UseTextureAlpha  bool
29025                         DmgTextureMod    Texture // suffix
29026                         Shaded           bool
29027                         ShowOnMinimap    bool
29028                         NametagBG        color.NRGBA
29029                 }))(obj)).DmgTextureMod).serialize(w)
29030         }); err != nil {
29031                 if err == io.EOF {
29032                         chk(io.EOF)
29033                 }
29034                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
29035         }
29036         {
29037                 x := (*(*(struct {
29038                         MaxHP            uint16 // Player only.
29039                         CollideWithNodes bool
29040                         Weight           float32 // deprecated
29041                         ColBox, SelBox   Box
29042                         Pointable        bool
29043                         Visual           string
29044                         VisualSize       [3]float32
29045                         Textures         []Texture
29046                         SpriteSheetSize  [2]int16 // in sprites.
29047                         SpritePos        [2]int16 // in sprite sheet.
29048                         Visible          bool
29049                         MakeFootstepSnds bool
29050                         RotateSpeed      float32 // in radians per second.
29051                         Mesh             string
29052                         Colors           []color.NRGBA
29053                         CollideWithAOs   bool
29054                         StepHeight       float32
29055                         FaceRotateDir    bool
29056                         FaceRotateDirOff float32 // in degrees.
29057                         BackfaceCull     bool
29058                         Nametag          string
29059                         NametagColor     color.NRGBA
29060                         FaceRotateSpeed  float32 // in degrees per second.
29061                         Infotext         string
29062                         Itemstring       string
29063                         Glow             int8
29064                         MaxBreath        uint16  // Player only.
29065                         EyeHeight        float32 // Player only.
29066                         ZoomFOV          float32 // in degrees. Player only.
29067                         UseTextureAlpha  bool
29068                         DmgTextureMod    Texture // suffix
29069                         Shaded           bool
29070                         ShowOnMinimap    bool
29071                         NametagBG        color.NRGBA
29072                 }))(obj)).Shaded
29073                 if x {
29074                         write8(w, 1)
29075                 } else {
29076                         write8(w, 0)
29077                 }
29078
29079         }
29080         {
29081                 x := (*(*(struct {
29082                         MaxHP            uint16 // Player only.
29083                         CollideWithNodes bool
29084                         Weight           float32 // deprecated
29085                         ColBox, SelBox   Box
29086                         Pointable        bool
29087                         Visual           string
29088                         VisualSize       [3]float32
29089                         Textures         []Texture
29090                         SpriteSheetSize  [2]int16 // in sprites.
29091                         SpritePos        [2]int16 // in sprite sheet.
29092                         Visible          bool
29093                         MakeFootstepSnds bool
29094                         RotateSpeed      float32 // in radians per second.
29095                         Mesh             string
29096                         Colors           []color.NRGBA
29097                         CollideWithAOs   bool
29098                         StepHeight       float32
29099                         FaceRotateDir    bool
29100                         FaceRotateDirOff float32 // in degrees.
29101                         BackfaceCull     bool
29102                         Nametag          string
29103                         NametagColor     color.NRGBA
29104                         FaceRotateSpeed  float32 // in degrees per second.
29105                         Infotext         string
29106                         Itemstring       string
29107                         Glow             int8
29108                         MaxBreath        uint16  // Player only.
29109                         EyeHeight        float32 // Player only.
29110                         ZoomFOV          float32 // in degrees. Player only.
29111                         UseTextureAlpha  bool
29112                         DmgTextureMod    Texture // suffix
29113                         Shaded           bool
29114                         ShowOnMinimap    bool
29115                         NametagBG        color.NRGBA
29116                 }))(obj)).ShowOnMinimap
29117                 if x {
29118                         write8(w, 1)
29119                 } else {
29120                         write8(w, 0)
29121                 }
29122
29123         }
29124         {
29125                 x := (*(*(struct {
29126                         MaxHP            uint16 // Player only.
29127                         CollideWithNodes bool
29128                         Weight           float32 // deprecated
29129                         ColBox, SelBox   Box
29130                         Pointable        bool
29131                         Visual           string
29132                         VisualSize       [3]float32
29133                         Textures         []Texture
29134                         SpriteSheetSize  [2]int16 // in sprites.
29135                         SpritePos        [2]int16 // in sprite sheet.
29136                         Visible          bool
29137                         MakeFootstepSnds bool
29138                         RotateSpeed      float32 // in radians per second.
29139                         Mesh             string
29140                         Colors           []color.NRGBA
29141                         CollideWithAOs   bool
29142                         StepHeight       float32
29143                         FaceRotateDir    bool
29144                         FaceRotateDirOff float32 // in degrees.
29145                         BackfaceCull     bool
29146                         Nametag          string
29147                         NametagColor     color.NRGBA
29148                         FaceRotateSpeed  float32 // in degrees per second.
29149                         Infotext         string
29150                         Itemstring       string
29151                         Glow             int8
29152                         MaxBreath        uint16  // Player only.
29153                         EyeHeight        float32 // Player only.
29154                         ZoomFOV          float32 // in degrees. Player only.
29155                         UseTextureAlpha  bool
29156                         DmgTextureMod    Texture // suffix
29157                         Shaded           bool
29158                         ShowOnMinimap    bool
29159                         NametagBG        color.NRGBA
29160                 }))(obj)).NametagBG
29161                 w.Write([]byte{x.A, x.R, x.G, x.B})
29162
29163         }
29164 }
29165
29166 func (obj *AOProps) deserialize(r io.Reader) {
29167         {
29168                 var local341 uint8
29169                 local342 := uint8(4)
29170                 {
29171                         p := &local341
29172                         *p = read8(r)
29173                 }
29174                 if local341 != local342 {
29175                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local341))
29176                 }
29177         }
29178         {
29179                 p := &(*(*(struct {
29180                         MaxHP            uint16 // Player only.
29181                         CollideWithNodes bool
29182                         Weight           float32 // deprecated
29183                         ColBox, SelBox   Box
29184                         Pointable        bool
29185                         Visual           string
29186                         VisualSize       [3]float32
29187                         Textures         []Texture
29188                         SpriteSheetSize  [2]int16 // in sprites.
29189                         SpritePos        [2]int16 // in sprite sheet.
29190                         Visible          bool
29191                         MakeFootstepSnds bool
29192                         RotateSpeed      float32 // in radians per second.
29193                         Mesh             string
29194                         Colors           []color.NRGBA
29195                         CollideWithAOs   bool
29196                         StepHeight       float32
29197                         FaceRotateDir    bool
29198                         FaceRotateDirOff float32 // in degrees.
29199                         BackfaceCull     bool
29200                         Nametag          string
29201                         NametagColor     color.NRGBA
29202                         FaceRotateSpeed  float32 // in degrees per second.
29203                         Infotext         string
29204                         Itemstring       string
29205                         Glow             int8
29206                         MaxBreath        uint16  // Player only.
29207                         EyeHeight        float32 // Player only.
29208                         ZoomFOV          float32 // in degrees. Player only.
29209                         UseTextureAlpha  bool
29210                         DmgTextureMod    Texture // suffix
29211                         Shaded           bool
29212                         ShowOnMinimap    bool
29213                         NametagBG        color.NRGBA
29214                 }))(obj)).MaxHP
29215                 *p = read16(r)
29216         }
29217         {
29218                 p := &(*(*(struct {
29219                         MaxHP            uint16 // Player only.
29220                         CollideWithNodes bool
29221                         Weight           float32 // deprecated
29222                         ColBox, SelBox   Box
29223                         Pointable        bool
29224                         Visual           string
29225                         VisualSize       [3]float32
29226                         Textures         []Texture
29227                         SpriteSheetSize  [2]int16 // in sprites.
29228                         SpritePos        [2]int16 // in sprite sheet.
29229                         Visible          bool
29230                         MakeFootstepSnds bool
29231                         RotateSpeed      float32 // in radians per second.
29232                         Mesh             string
29233                         Colors           []color.NRGBA
29234                         CollideWithAOs   bool
29235                         StepHeight       float32
29236                         FaceRotateDir    bool
29237                         FaceRotateDirOff float32 // in degrees.
29238                         BackfaceCull     bool
29239                         Nametag          string
29240                         NametagColor     color.NRGBA
29241                         FaceRotateSpeed  float32 // in degrees per second.
29242                         Infotext         string
29243                         Itemstring       string
29244                         Glow             int8
29245                         MaxBreath        uint16  // Player only.
29246                         EyeHeight        float32 // Player only.
29247                         ZoomFOV          float32 // in degrees. Player only.
29248                         UseTextureAlpha  bool
29249                         DmgTextureMod    Texture // suffix
29250                         Shaded           bool
29251                         ShowOnMinimap    bool
29252                         NametagBG        color.NRGBA
29253                 }))(obj)).CollideWithNodes
29254                 switch n := read8(r); n {
29255                 case 0:
29256                         *p = false
29257                 case 1:
29258                         *p = true
29259                 default:
29260                         chk(fmt.Errorf("invalid bool: %d", n))
29261                 }
29262
29263         }
29264         {
29265                 p := &(*(*(struct {
29266                         MaxHP            uint16 // Player only.
29267                         CollideWithNodes bool
29268                         Weight           float32 // deprecated
29269                         ColBox, SelBox   Box
29270                         Pointable        bool
29271                         Visual           string
29272                         VisualSize       [3]float32
29273                         Textures         []Texture
29274                         SpriteSheetSize  [2]int16 // in sprites.
29275                         SpritePos        [2]int16 // in sprite sheet.
29276                         Visible          bool
29277                         MakeFootstepSnds bool
29278                         RotateSpeed      float32 // in radians per second.
29279                         Mesh             string
29280                         Colors           []color.NRGBA
29281                         CollideWithAOs   bool
29282                         StepHeight       float32
29283                         FaceRotateDir    bool
29284                         FaceRotateDirOff float32 // in degrees.
29285                         BackfaceCull     bool
29286                         Nametag          string
29287                         NametagColor     color.NRGBA
29288                         FaceRotateSpeed  float32 // in degrees per second.
29289                         Infotext         string
29290                         Itemstring       string
29291                         Glow             int8
29292                         MaxBreath        uint16  // Player only.
29293                         EyeHeight        float32 // Player only.
29294                         ZoomFOV          float32 // in degrees. Player only.
29295                         UseTextureAlpha  bool
29296                         DmgTextureMod    Texture // suffix
29297                         Shaded           bool
29298                         ShowOnMinimap    bool
29299                         NametagBG        color.NRGBA
29300                 }))(obj)).Weight
29301                 *p = math.Float32frombits(read32(r))
29302         }
29303         if err := pcall(func() {
29304                 ((*(*(struct {
29305                         MaxHP            uint16 // Player only.
29306                         CollideWithNodes bool
29307                         Weight           float32 // deprecated
29308                         ColBox, SelBox   Box
29309                         Pointable        bool
29310                         Visual           string
29311                         VisualSize       [3]float32
29312                         Textures         []Texture
29313                         SpriteSheetSize  [2]int16 // in sprites.
29314                         SpritePos        [2]int16 // in sprite sheet.
29315                         Visible          bool
29316                         MakeFootstepSnds bool
29317                         RotateSpeed      float32 // in radians per second.
29318                         Mesh             string
29319                         Colors           []color.NRGBA
29320                         CollideWithAOs   bool
29321                         StepHeight       float32
29322                         FaceRotateDir    bool
29323                         FaceRotateDirOff float32 // in degrees.
29324                         BackfaceCull     bool
29325                         Nametag          string
29326                         NametagColor     color.NRGBA
29327                         FaceRotateSpeed  float32 // in degrees per second.
29328                         Infotext         string
29329                         Itemstring       string
29330                         Glow             int8
29331                         MaxBreath        uint16  // Player only.
29332                         EyeHeight        float32 // Player only.
29333                         ZoomFOV          float32 // in degrees. Player only.
29334                         UseTextureAlpha  bool
29335                         DmgTextureMod    Texture // suffix
29336                         Shaded           bool
29337                         ShowOnMinimap    bool
29338                         NametagBG        color.NRGBA
29339                 }))(obj)).ColBox).deserialize(r)
29340         }); err != nil {
29341                 if err == io.EOF {
29342                         chk(io.EOF)
29343                 }
29344                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29345         }
29346         if err := pcall(func() {
29347                 ((*(*(struct {
29348                         MaxHP            uint16 // Player only.
29349                         CollideWithNodes bool
29350                         Weight           float32 // deprecated
29351                         ColBox, SelBox   Box
29352                         Pointable        bool
29353                         Visual           string
29354                         VisualSize       [3]float32
29355                         Textures         []Texture
29356                         SpriteSheetSize  [2]int16 // in sprites.
29357                         SpritePos        [2]int16 // in sprite sheet.
29358                         Visible          bool
29359                         MakeFootstepSnds bool
29360                         RotateSpeed      float32 // in radians per second.
29361                         Mesh             string
29362                         Colors           []color.NRGBA
29363                         CollideWithAOs   bool
29364                         StepHeight       float32
29365                         FaceRotateDir    bool
29366                         FaceRotateDirOff float32 // in degrees.
29367                         BackfaceCull     bool
29368                         Nametag          string
29369                         NametagColor     color.NRGBA
29370                         FaceRotateSpeed  float32 // in degrees per second.
29371                         Infotext         string
29372                         Itemstring       string
29373                         Glow             int8
29374                         MaxBreath        uint16  // Player only.
29375                         EyeHeight        float32 // Player only.
29376                         ZoomFOV          float32 // in degrees. Player only.
29377                         UseTextureAlpha  bool
29378                         DmgTextureMod    Texture // suffix
29379                         Shaded           bool
29380                         ShowOnMinimap    bool
29381                         NametagBG        color.NRGBA
29382                 }))(obj)).SelBox).deserialize(r)
29383         }); err != nil {
29384                 if err == io.EOF {
29385                         chk(io.EOF)
29386                 }
29387                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29388         }
29389         {
29390                 p := &(*(*(struct {
29391                         MaxHP            uint16 // Player only.
29392                         CollideWithNodes bool
29393                         Weight           float32 // deprecated
29394                         ColBox, SelBox   Box
29395                         Pointable        bool
29396                         Visual           string
29397                         VisualSize       [3]float32
29398                         Textures         []Texture
29399                         SpriteSheetSize  [2]int16 // in sprites.
29400                         SpritePos        [2]int16 // in sprite sheet.
29401                         Visible          bool
29402                         MakeFootstepSnds bool
29403                         RotateSpeed      float32 // in radians per second.
29404                         Mesh             string
29405                         Colors           []color.NRGBA
29406                         CollideWithAOs   bool
29407                         StepHeight       float32
29408                         FaceRotateDir    bool
29409                         FaceRotateDirOff float32 // in degrees.
29410                         BackfaceCull     bool
29411                         Nametag          string
29412                         NametagColor     color.NRGBA
29413                         FaceRotateSpeed  float32 // in degrees per second.
29414                         Infotext         string
29415                         Itemstring       string
29416                         Glow             int8
29417                         MaxBreath        uint16  // Player only.
29418                         EyeHeight        float32 // Player only.
29419                         ZoomFOV          float32 // in degrees. Player only.
29420                         UseTextureAlpha  bool
29421                         DmgTextureMod    Texture // suffix
29422                         Shaded           bool
29423                         ShowOnMinimap    bool
29424                         NametagBG        color.NRGBA
29425                 }))(obj)).Pointable
29426                 switch n := read8(r); n {
29427                 case 0:
29428                         *p = false
29429                 case 1:
29430                         *p = true
29431                 default:
29432                         chk(fmt.Errorf("invalid bool: %d", n))
29433                 }
29434
29435         }
29436         var local343 []uint8
29437         var local344 uint16
29438         {
29439                 p := &local344
29440                 *p = read16(r)
29441         }
29442         (local343) = make([]uint8, local344)
29443         {
29444                 _, err := io.ReadFull(r, (local343)[:])
29445                 chk(err)
29446         }
29447         ((*(*(struct {
29448                 MaxHP            uint16 // Player only.
29449                 CollideWithNodes bool
29450                 Weight           float32 // deprecated
29451                 ColBox, SelBox   Box
29452                 Pointable        bool
29453                 Visual           string
29454                 VisualSize       [3]float32
29455                 Textures         []Texture
29456                 SpriteSheetSize  [2]int16 // in sprites.
29457                 SpritePos        [2]int16 // in sprite sheet.
29458                 Visible          bool
29459                 MakeFootstepSnds bool
29460                 RotateSpeed      float32 // in radians per second.
29461                 Mesh             string
29462                 Colors           []color.NRGBA
29463                 CollideWithAOs   bool
29464                 StepHeight       float32
29465                 FaceRotateDir    bool
29466                 FaceRotateDirOff float32 // in degrees.
29467                 BackfaceCull     bool
29468                 Nametag          string
29469                 NametagColor     color.NRGBA
29470                 FaceRotateSpeed  float32 // in degrees per second.
29471                 Infotext         string
29472                 Itemstring       string
29473                 Glow             int8
29474                 MaxBreath        uint16  // Player only.
29475                 EyeHeight        float32 // Player only.
29476                 ZoomFOV          float32 // in degrees. Player only.
29477                 UseTextureAlpha  bool
29478                 DmgTextureMod    Texture // suffix
29479                 Shaded           bool
29480                 ShowOnMinimap    bool
29481                 NametagBG        color.NRGBA
29482         }))(obj)).Visual) = string(local343)
29483         for local345 := range (*(*(struct {
29484                 MaxHP            uint16 // Player only.
29485                 CollideWithNodes bool
29486                 Weight           float32 // deprecated
29487                 ColBox, SelBox   Box
29488                 Pointable        bool
29489                 Visual           string
29490                 VisualSize       [3]float32
29491                 Textures         []Texture
29492                 SpriteSheetSize  [2]int16 // in sprites.
29493                 SpritePos        [2]int16 // in sprite sheet.
29494                 Visible          bool
29495                 MakeFootstepSnds bool
29496                 RotateSpeed      float32 // in radians per second.
29497                 Mesh             string
29498                 Colors           []color.NRGBA
29499                 CollideWithAOs   bool
29500                 StepHeight       float32
29501                 FaceRotateDir    bool
29502                 FaceRotateDirOff float32 // in degrees.
29503                 BackfaceCull     bool
29504                 Nametag          string
29505                 NametagColor     color.NRGBA
29506                 FaceRotateSpeed  float32 // in degrees per second.
29507                 Infotext         string
29508                 Itemstring       string
29509                 Glow             int8
29510                 MaxBreath        uint16  // Player only.
29511                 EyeHeight        float32 // Player only.
29512                 ZoomFOV          float32 // in degrees. Player only.
29513                 UseTextureAlpha  bool
29514                 DmgTextureMod    Texture // suffix
29515                 Shaded           bool
29516                 ShowOnMinimap    bool
29517                 NametagBG        color.NRGBA
29518         }))(obj)).VisualSize {
29519                 {
29520                         p := &((*(*(struct {
29521                                 MaxHP            uint16 // Player only.
29522                                 CollideWithNodes bool
29523                                 Weight           float32 // deprecated
29524                                 ColBox, SelBox   Box
29525                                 Pointable        bool
29526                                 Visual           string
29527                                 VisualSize       [3]float32
29528                                 Textures         []Texture
29529                                 SpriteSheetSize  [2]int16 // in sprites.
29530                                 SpritePos        [2]int16 // in sprite sheet.
29531                                 Visible          bool
29532                                 MakeFootstepSnds bool
29533                                 RotateSpeed      float32 // in radians per second.
29534                                 Mesh             string
29535                                 Colors           []color.NRGBA
29536                                 CollideWithAOs   bool
29537                                 StepHeight       float32
29538                                 FaceRotateDir    bool
29539                                 FaceRotateDirOff float32 // in degrees.
29540                                 BackfaceCull     bool
29541                                 Nametag          string
29542                                 NametagColor     color.NRGBA
29543                                 FaceRotateSpeed  float32 // in degrees per second.
29544                                 Infotext         string
29545                                 Itemstring       string
29546                                 Glow             int8
29547                                 MaxBreath        uint16  // Player only.
29548                                 EyeHeight        float32 // Player only.
29549                                 ZoomFOV          float32 // in degrees. Player only.
29550                                 UseTextureAlpha  bool
29551                                 DmgTextureMod    Texture // suffix
29552                                 Shaded           bool
29553                                 ShowOnMinimap    bool
29554                                 NametagBG        color.NRGBA
29555                         }))(obj)).VisualSize)[local345]
29556                         *p = math.Float32frombits(read32(r))
29557                 }
29558         }
29559         var local346 uint16
29560         {
29561                 p := &local346
29562                 *p = read16(r)
29563         }
29564         ((*(*(struct {
29565                 MaxHP            uint16 // Player only.
29566                 CollideWithNodes bool
29567                 Weight           float32 // deprecated
29568                 ColBox, SelBox   Box
29569                 Pointable        bool
29570                 Visual           string
29571                 VisualSize       [3]float32
29572                 Textures         []Texture
29573                 SpriteSheetSize  [2]int16 // in sprites.
29574                 SpritePos        [2]int16 // in sprite sheet.
29575                 Visible          bool
29576                 MakeFootstepSnds bool
29577                 RotateSpeed      float32 // in radians per second.
29578                 Mesh             string
29579                 Colors           []color.NRGBA
29580                 CollideWithAOs   bool
29581                 StepHeight       float32
29582                 FaceRotateDir    bool
29583                 FaceRotateDirOff float32 // in degrees.
29584                 BackfaceCull     bool
29585                 Nametag          string
29586                 NametagColor     color.NRGBA
29587                 FaceRotateSpeed  float32 // in degrees per second.
29588                 Infotext         string
29589                 Itemstring       string
29590                 Glow             int8
29591                 MaxBreath        uint16  // Player only.
29592                 EyeHeight        float32 // Player only.
29593                 ZoomFOV          float32 // in degrees. Player only.
29594                 UseTextureAlpha  bool
29595                 DmgTextureMod    Texture // suffix
29596                 Shaded           bool
29597                 ShowOnMinimap    bool
29598                 NametagBG        color.NRGBA
29599         }))(obj)).Textures) = make([]Texture, local346)
29600         for local347 := range (*(*(struct {
29601                 MaxHP            uint16 // Player only.
29602                 CollideWithNodes bool
29603                 Weight           float32 // deprecated
29604                 ColBox, SelBox   Box
29605                 Pointable        bool
29606                 Visual           string
29607                 VisualSize       [3]float32
29608                 Textures         []Texture
29609                 SpriteSheetSize  [2]int16 // in sprites.
29610                 SpritePos        [2]int16 // in sprite sheet.
29611                 Visible          bool
29612                 MakeFootstepSnds bool
29613                 RotateSpeed      float32 // in radians per second.
29614                 Mesh             string
29615                 Colors           []color.NRGBA
29616                 CollideWithAOs   bool
29617                 StepHeight       float32
29618                 FaceRotateDir    bool
29619                 FaceRotateDirOff float32 // in degrees.
29620                 BackfaceCull     bool
29621                 Nametag          string
29622                 NametagColor     color.NRGBA
29623                 FaceRotateSpeed  float32 // in degrees per second.
29624                 Infotext         string
29625                 Itemstring       string
29626                 Glow             int8
29627                 MaxBreath        uint16  // Player only.
29628                 EyeHeight        float32 // Player only.
29629                 ZoomFOV          float32 // in degrees. Player only.
29630                 UseTextureAlpha  bool
29631                 DmgTextureMod    Texture // suffix
29632                 Shaded           bool
29633                 ShowOnMinimap    bool
29634                 NametagBG        color.NRGBA
29635         }))(obj)).Textures {
29636                 if err := pcall(func() {
29637                         (((*(*(struct {
29638                                 MaxHP            uint16 // Player only.
29639                                 CollideWithNodes bool
29640                                 Weight           float32 // deprecated
29641                                 ColBox, SelBox   Box
29642                                 Pointable        bool
29643                                 Visual           string
29644                                 VisualSize       [3]float32
29645                                 Textures         []Texture
29646                                 SpriteSheetSize  [2]int16 // in sprites.
29647                                 SpritePos        [2]int16 // in sprite sheet.
29648                                 Visible          bool
29649                                 MakeFootstepSnds bool
29650                                 RotateSpeed      float32 // in radians per second.
29651                                 Mesh             string
29652                                 Colors           []color.NRGBA
29653                                 CollideWithAOs   bool
29654                                 StepHeight       float32
29655                                 FaceRotateDir    bool
29656                                 FaceRotateDirOff float32 // in degrees.
29657                                 BackfaceCull     bool
29658                                 Nametag          string
29659                                 NametagColor     color.NRGBA
29660                                 FaceRotateSpeed  float32 // in degrees per second.
29661                                 Infotext         string
29662                                 Itemstring       string
29663                                 Glow             int8
29664                                 MaxBreath        uint16  // Player only.
29665                                 EyeHeight        float32 // Player only.
29666                                 ZoomFOV          float32 // in degrees. Player only.
29667                                 UseTextureAlpha  bool
29668                                 DmgTextureMod    Texture // suffix
29669                                 Shaded           bool
29670                                 ShowOnMinimap    bool
29671                                 NametagBG        color.NRGBA
29672                         }))(obj)).Textures)[local347]).deserialize(r)
29673                 }); err != nil {
29674                         if err == io.EOF {
29675                                 chk(io.EOF)
29676                         }
29677                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
29678                 }
29679         }
29680         for local348 := range (*(*(struct {
29681                 MaxHP            uint16 // Player only.
29682                 CollideWithNodes bool
29683                 Weight           float32 // deprecated
29684                 ColBox, SelBox   Box
29685                 Pointable        bool
29686                 Visual           string
29687                 VisualSize       [3]float32
29688                 Textures         []Texture
29689                 SpriteSheetSize  [2]int16 // in sprites.
29690                 SpritePos        [2]int16 // in sprite sheet.
29691                 Visible          bool
29692                 MakeFootstepSnds bool
29693                 RotateSpeed      float32 // in radians per second.
29694                 Mesh             string
29695                 Colors           []color.NRGBA
29696                 CollideWithAOs   bool
29697                 StepHeight       float32
29698                 FaceRotateDir    bool
29699                 FaceRotateDirOff float32 // in degrees.
29700                 BackfaceCull     bool
29701                 Nametag          string
29702                 NametagColor     color.NRGBA
29703                 FaceRotateSpeed  float32 // in degrees per second.
29704                 Infotext         string
29705                 Itemstring       string
29706                 Glow             int8
29707                 MaxBreath        uint16  // Player only.
29708                 EyeHeight        float32 // Player only.
29709                 ZoomFOV          float32 // in degrees. Player only.
29710                 UseTextureAlpha  bool
29711                 DmgTextureMod    Texture // suffix
29712                 Shaded           bool
29713                 ShowOnMinimap    bool
29714                 NametagBG        color.NRGBA
29715         }))(obj)).SpriteSheetSize {
29716                 {
29717                         p := &((*(*(struct {
29718                                 MaxHP            uint16 // Player only.
29719                                 CollideWithNodes bool
29720                                 Weight           float32 // deprecated
29721                                 ColBox, SelBox   Box
29722                                 Pointable        bool
29723                                 Visual           string
29724                                 VisualSize       [3]float32
29725                                 Textures         []Texture
29726                                 SpriteSheetSize  [2]int16 // in sprites.
29727                                 SpritePos        [2]int16 // in sprite sheet.
29728                                 Visible          bool
29729                                 MakeFootstepSnds bool
29730                                 RotateSpeed      float32 // in radians per second.
29731                                 Mesh             string
29732                                 Colors           []color.NRGBA
29733                                 CollideWithAOs   bool
29734                                 StepHeight       float32
29735                                 FaceRotateDir    bool
29736                                 FaceRotateDirOff float32 // in degrees.
29737                                 BackfaceCull     bool
29738                                 Nametag          string
29739                                 NametagColor     color.NRGBA
29740                                 FaceRotateSpeed  float32 // in degrees per second.
29741                                 Infotext         string
29742                                 Itemstring       string
29743                                 Glow             int8
29744                                 MaxBreath        uint16  // Player only.
29745                                 EyeHeight        float32 // Player only.
29746                                 ZoomFOV          float32 // in degrees. Player only.
29747                                 UseTextureAlpha  bool
29748                                 DmgTextureMod    Texture // suffix
29749                                 Shaded           bool
29750                                 ShowOnMinimap    bool
29751                                 NametagBG        color.NRGBA
29752                         }))(obj)).SpriteSheetSize)[local348]
29753                         *p = int16(read16(r))
29754                 }
29755         }
29756         for local349 := range (*(*(struct {
29757                 MaxHP            uint16 // Player only.
29758                 CollideWithNodes bool
29759                 Weight           float32 // deprecated
29760                 ColBox, SelBox   Box
29761                 Pointable        bool
29762                 Visual           string
29763                 VisualSize       [3]float32
29764                 Textures         []Texture
29765                 SpriteSheetSize  [2]int16 // in sprites.
29766                 SpritePos        [2]int16 // in sprite sheet.
29767                 Visible          bool
29768                 MakeFootstepSnds bool
29769                 RotateSpeed      float32 // in radians per second.
29770                 Mesh             string
29771                 Colors           []color.NRGBA
29772                 CollideWithAOs   bool
29773                 StepHeight       float32
29774                 FaceRotateDir    bool
29775                 FaceRotateDirOff float32 // in degrees.
29776                 BackfaceCull     bool
29777                 Nametag          string
29778                 NametagColor     color.NRGBA
29779                 FaceRotateSpeed  float32 // in degrees per second.
29780                 Infotext         string
29781                 Itemstring       string
29782                 Glow             int8
29783                 MaxBreath        uint16  // Player only.
29784                 EyeHeight        float32 // Player only.
29785                 ZoomFOV          float32 // in degrees. Player only.
29786                 UseTextureAlpha  bool
29787                 DmgTextureMod    Texture // suffix
29788                 Shaded           bool
29789                 ShowOnMinimap    bool
29790                 NametagBG        color.NRGBA
29791         }))(obj)).SpritePos {
29792                 {
29793                         p := &((*(*(struct {
29794                                 MaxHP            uint16 // Player only.
29795                                 CollideWithNodes bool
29796                                 Weight           float32 // deprecated
29797                                 ColBox, SelBox   Box
29798                                 Pointable        bool
29799                                 Visual           string
29800                                 VisualSize       [3]float32
29801                                 Textures         []Texture
29802                                 SpriteSheetSize  [2]int16 // in sprites.
29803                                 SpritePos        [2]int16 // in sprite sheet.
29804                                 Visible          bool
29805                                 MakeFootstepSnds bool
29806                                 RotateSpeed      float32 // in radians per second.
29807                                 Mesh             string
29808                                 Colors           []color.NRGBA
29809                                 CollideWithAOs   bool
29810                                 StepHeight       float32
29811                                 FaceRotateDir    bool
29812                                 FaceRotateDirOff float32 // in degrees.
29813                                 BackfaceCull     bool
29814                                 Nametag          string
29815                                 NametagColor     color.NRGBA
29816                                 FaceRotateSpeed  float32 // in degrees per second.
29817                                 Infotext         string
29818                                 Itemstring       string
29819                                 Glow             int8
29820                                 MaxBreath        uint16  // Player only.
29821                                 EyeHeight        float32 // Player only.
29822                                 ZoomFOV          float32 // in degrees. Player only.
29823                                 UseTextureAlpha  bool
29824                                 DmgTextureMod    Texture // suffix
29825                                 Shaded           bool
29826                                 ShowOnMinimap    bool
29827                                 NametagBG        color.NRGBA
29828                         }))(obj)).SpritePos)[local349]
29829                         *p = int16(read16(r))
29830                 }
29831         }
29832         {
29833                 p := &(*(*(struct {
29834                         MaxHP            uint16 // Player only.
29835                         CollideWithNodes bool
29836                         Weight           float32 // deprecated
29837                         ColBox, SelBox   Box
29838                         Pointable        bool
29839                         Visual           string
29840                         VisualSize       [3]float32
29841                         Textures         []Texture
29842                         SpriteSheetSize  [2]int16 // in sprites.
29843                         SpritePos        [2]int16 // in sprite sheet.
29844                         Visible          bool
29845                         MakeFootstepSnds bool
29846                         RotateSpeed      float32 // in radians per second.
29847                         Mesh             string
29848                         Colors           []color.NRGBA
29849                         CollideWithAOs   bool
29850                         StepHeight       float32
29851                         FaceRotateDir    bool
29852                         FaceRotateDirOff float32 // in degrees.
29853                         BackfaceCull     bool
29854                         Nametag          string
29855                         NametagColor     color.NRGBA
29856                         FaceRotateSpeed  float32 // in degrees per second.
29857                         Infotext         string
29858                         Itemstring       string
29859                         Glow             int8
29860                         MaxBreath        uint16  // Player only.
29861                         EyeHeight        float32 // Player only.
29862                         ZoomFOV          float32 // in degrees. Player only.
29863                         UseTextureAlpha  bool
29864                         DmgTextureMod    Texture // suffix
29865                         Shaded           bool
29866                         ShowOnMinimap    bool
29867                         NametagBG        color.NRGBA
29868                 }))(obj)).Visible
29869                 switch n := read8(r); n {
29870                 case 0:
29871                         *p = false
29872                 case 1:
29873                         *p = true
29874                 default:
29875                         chk(fmt.Errorf("invalid bool: %d", n))
29876                 }
29877
29878         }
29879         {
29880                 p := &(*(*(struct {
29881                         MaxHP            uint16 // Player only.
29882                         CollideWithNodes bool
29883                         Weight           float32 // deprecated
29884                         ColBox, SelBox   Box
29885                         Pointable        bool
29886                         Visual           string
29887                         VisualSize       [3]float32
29888                         Textures         []Texture
29889                         SpriteSheetSize  [2]int16 // in sprites.
29890                         SpritePos        [2]int16 // in sprite sheet.
29891                         Visible          bool
29892                         MakeFootstepSnds bool
29893                         RotateSpeed      float32 // in radians per second.
29894                         Mesh             string
29895                         Colors           []color.NRGBA
29896                         CollideWithAOs   bool
29897                         StepHeight       float32
29898                         FaceRotateDir    bool
29899                         FaceRotateDirOff float32 // in degrees.
29900                         BackfaceCull     bool
29901                         Nametag          string
29902                         NametagColor     color.NRGBA
29903                         FaceRotateSpeed  float32 // in degrees per second.
29904                         Infotext         string
29905                         Itemstring       string
29906                         Glow             int8
29907                         MaxBreath        uint16  // Player only.
29908                         EyeHeight        float32 // Player only.
29909                         ZoomFOV          float32 // in degrees. Player only.
29910                         UseTextureAlpha  bool
29911                         DmgTextureMod    Texture // suffix
29912                         Shaded           bool
29913                         ShowOnMinimap    bool
29914                         NametagBG        color.NRGBA
29915                 }))(obj)).MakeFootstepSnds
29916                 switch n := read8(r); n {
29917                 case 0:
29918                         *p = false
29919                 case 1:
29920                         *p = true
29921                 default:
29922                         chk(fmt.Errorf("invalid bool: %d", n))
29923                 }
29924
29925         }
29926         {
29927                 p := &(*(*(struct {
29928                         MaxHP            uint16 // Player only.
29929                         CollideWithNodes bool
29930                         Weight           float32 // deprecated
29931                         ColBox, SelBox   Box
29932                         Pointable        bool
29933                         Visual           string
29934                         VisualSize       [3]float32
29935                         Textures         []Texture
29936                         SpriteSheetSize  [2]int16 // in sprites.
29937                         SpritePos        [2]int16 // in sprite sheet.
29938                         Visible          bool
29939                         MakeFootstepSnds bool
29940                         RotateSpeed      float32 // in radians per second.
29941                         Mesh             string
29942                         Colors           []color.NRGBA
29943                         CollideWithAOs   bool
29944                         StepHeight       float32
29945                         FaceRotateDir    bool
29946                         FaceRotateDirOff float32 // in degrees.
29947                         BackfaceCull     bool
29948                         Nametag          string
29949                         NametagColor     color.NRGBA
29950                         FaceRotateSpeed  float32 // in degrees per second.
29951                         Infotext         string
29952                         Itemstring       string
29953                         Glow             int8
29954                         MaxBreath        uint16  // Player only.
29955                         EyeHeight        float32 // Player only.
29956                         ZoomFOV          float32 // in degrees. Player only.
29957                         UseTextureAlpha  bool
29958                         DmgTextureMod    Texture // suffix
29959                         Shaded           bool
29960                         ShowOnMinimap    bool
29961                         NametagBG        color.NRGBA
29962                 }))(obj)).RotateSpeed
29963                 *p = math.Float32frombits(read32(r))
29964         }
29965         var local350 []uint8
29966         var local351 uint16
29967         {
29968                 p := &local351
29969                 *p = read16(r)
29970         }
29971         (local350) = make([]uint8, local351)
29972         {
29973                 _, err := io.ReadFull(r, (local350)[:])
29974                 chk(err)
29975         }
29976         ((*(*(struct {
29977                 MaxHP            uint16 // Player only.
29978                 CollideWithNodes bool
29979                 Weight           float32 // deprecated
29980                 ColBox, SelBox   Box
29981                 Pointable        bool
29982                 Visual           string
29983                 VisualSize       [3]float32
29984                 Textures         []Texture
29985                 SpriteSheetSize  [2]int16 // in sprites.
29986                 SpritePos        [2]int16 // in sprite sheet.
29987                 Visible          bool
29988                 MakeFootstepSnds bool
29989                 RotateSpeed      float32 // in radians per second.
29990                 Mesh             string
29991                 Colors           []color.NRGBA
29992                 CollideWithAOs   bool
29993                 StepHeight       float32
29994                 FaceRotateDir    bool
29995                 FaceRotateDirOff float32 // in degrees.
29996                 BackfaceCull     bool
29997                 Nametag          string
29998                 NametagColor     color.NRGBA
29999                 FaceRotateSpeed  float32 // in degrees per second.
30000                 Infotext         string
30001                 Itemstring       string
30002                 Glow             int8
30003                 MaxBreath        uint16  // Player only.
30004                 EyeHeight        float32 // Player only.
30005                 ZoomFOV          float32 // in degrees. Player only.
30006                 UseTextureAlpha  bool
30007                 DmgTextureMod    Texture // suffix
30008                 Shaded           bool
30009                 ShowOnMinimap    bool
30010                 NametagBG        color.NRGBA
30011         }))(obj)).Mesh) = string(local350)
30012         var local352 uint16
30013         {
30014                 p := &local352
30015                 *p = read16(r)
30016         }
30017         ((*(*(struct {
30018                 MaxHP            uint16 // Player only.
30019                 CollideWithNodes bool
30020                 Weight           float32 // deprecated
30021                 ColBox, SelBox   Box
30022                 Pointable        bool
30023                 Visual           string
30024                 VisualSize       [3]float32
30025                 Textures         []Texture
30026                 SpriteSheetSize  [2]int16 // in sprites.
30027                 SpritePos        [2]int16 // in sprite sheet.
30028                 Visible          bool
30029                 MakeFootstepSnds bool
30030                 RotateSpeed      float32 // in radians per second.
30031                 Mesh             string
30032                 Colors           []color.NRGBA
30033                 CollideWithAOs   bool
30034                 StepHeight       float32
30035                 FaceRotateDir    bool
30036                 FaceRotateDirOff float32 // in degrees.
30037                 BackfaceCull     bool
30038                 Nametag          string
30039                 NametagColor     color.NRGBA
30040                 FaceRotateSpeed  float32 // in degrees per second.
30041                 Infotext         string
30042                 Itemstring       string
30043                 Glow             int8
30044                 MaxBreath        uint16  // Player only.
30045                 EyeHeight        float32 // Player only.
30046                 ZoomFOV          float32 // in degrees. Player only.
30047                 UseTextureAlpha  bool
30048                 DmgTextureMod    Texture // suffix
30049                 Shaded           bool
30050                 ShowOnMinimap    bool
30051                 NametagBG        color.NRGBA
30052         }))(obj)).Colors) = make([]color.NRGBA, local352)
30053         for local353 := range (*(*(struct {
30054                 MaxHP            uint16 // Player only.
30055                 CollideWithNodes bool
30056                 Weight           float32 // deprecated
30057                 ColBox, SelBox   Box
30058                 Pointable        bool
30059                 Visual           string
30060                 VisualSize       [3]float32
30061                 Textures         []Texture
30062                 SpriteSheetSize  [2]int16 // in sprites.
30063                 SpritePos        [2]int16 // in sprite sheet.
30064                 Visible          bool
30065                 MakeFootstepSnds bool
30066                 RotateSpeed      float32 // in radians per second.
30067                 Mesh             string
30068                 Colors           []color.NRGBA
30069                 CollideWithAOs   bool
30070                 StepHeight       float32
30071                 FaceRotateDir    bool
30072                 FaceRotateDirOff float32 // in degrees.
30073                 BackfaceCull     bool
30074                 Nametag          string
30075                 NametagColor     color.NRGBA
30076                 FaceRotateSpeed  float32 // in degrees per second.
30077                 Infotext         string
30078                 Itemstring       string
30079                 Glow             int8
30080                 MaxBreath        uint16  // Player only.
30081                 EyeHeight        float32 // Player only.
30082                 ZoomFOV          float32 // in degrees. Player only.
30083                 UseTextureAlpha  bool
30084                 DmgTextureMod    Texture // suffix
30085                 Shaded           bool
30086                 ShowOnMinimap    bool
30087                 NametagBG        color.NRGBA
30088         }))(obj)).Colors {
30089                 {
30090                         p := &((*(*(struct {
30091                                 MaxHP            uint16 // Player only.
30092                                 CollideWithNodes bool
30093                                 Weight           float32 // deprecated
30094                                 ColBox, SelBox   Box
30095                                 Pointable        bool
30096                                 Visual           string
30097                                 VisualSize       [3]float32
30098                                 Textures         []Texture
30099                                 SpriteSheetSize  [2]int16 // in sprites.
30100                                 SpritePos        [2]int16 // in sprite sheet.
30101                                 Visible          bool
30102                                 MakeFootstepSnds bool
30103                                 RotateSpeed      float32 // in radians per second.
30104                                 Mesh             string
30105                                 Colors           []color.NRGBA
30106                                 CollideWithAOs   bool
30107                                 StepHeight       float32
30108                                 FaceRotateDir    bool
30109                                 FaceRotateDirOff float32 // in degrees.
30110                                 BackfaceCull     bool
30111                                 Nametag          string
30112                                 NametagColor     color.NRGBA
30113                                 FaceRotateSpeed  float32 // in degrees per second.
30114                                 Infotext         string
30115                                 Itemstring       string
30116                                 Glow             int8
30117                                 MaxBreath        uint16  // Player only.
30118                                 EyeHeight        float32 // Player only.
30119                                 ZoomFOV          float32 // in degrees. Player only.
30120                                 UseTextureAlpha  bool
30121                                 DmgTextureMod    Texture // suffix
30122                                 Shaded           bool
30123                                 ShowOnMinimap    bool
30124                                 NametagBG        color.NRGBA
30125                         }))(obj)).Colors)[local353]
30126                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30127
30128                 }
30129         }
30130         {
30131                 p := &(*(*(struct {
30132                         MaxHP            uint16 // Player only.
30133                         CollideWithNodes bool
30134                         Weight           float32 // deprecated
30135                         ColBox, SelBox   Box
30136                         Pointable        bool
30137                         Visual           string
30138                         VisualSize       [3]float32
30139                         Textures         []Texture
30140                         SpriteSheetSize  [2]int16 // in sprites.
30141                         SpritePos        [2]int16 // in sprite sheet.
30142                         Visible          bool
30143                         MakeFootstepSnds bool
30144                         RotateSpeed      float32 // in radians per second.
30145                         Mesh             string
30146                         Colors           []color.NRGBA
30147                         CollideWithAOs   bool
30148                         StepHeight       float32
30149                         FaceRotateDir    bool
30150                         FaceRotateDirOff float32 // in degrees.
30151                         BackfaceCull     bool
30152                         Nametag          string
30153                         NametagColor     color.NRGBA
30154                         FaceRotateSpeed  float32 // in degrees per second.
30155                         Infotext         string
30156                         Itemstring       string
30157                         Glow             int8
30158                         MaxBreath        uint16  // Player only.
30159                         EyeHeight        float32 // Player only.
30160                         ZoomFOV          float32 // in degrees. Player only.
30161                         UseTextureAlpha  bool
30162                         DmgTextureMod    Texture // suffix
30163                         Shaded           bool
30164                         ShowOnMinimap    bool
30165                         NametagBG        color.NRGBA
30166                 }))(obj)).CollideWithAOs
30167                 switch n := read8(r); n {
30168                 case 0:
30169                         *p = false
30170                 case 1:
30171                         *p = true
30172                 default:
30173                         chk(fmt.Errorf("invalid bool: %d", n))
30174                 }
30175
30176         }
30177         {
30178                 p := &(*(*(struct {
30179                         MaxHP            uint16 // Player only.
30180                         CollideWithNodes bool
30181                         Weight           float32 // deprecated
30182                         ColBox, SelBox   Box
30183                         Pointable        bool
30184                         Visual           string
30185                         VisualSize       [3]float32
30186                         Textures         []Texture
30187                         SpriteSheetSize  [2]int16 // in sprites.
30188                         SpritePos        [2]int16 // in sprite sheet.
30189                         Visible          bool
30190                         MakeFootstepSnds bool
30191                         RotateSpeed      float32 // in radians per second.
30192                         Mesh             string
30193                         Colors           []color.NRGBA
30194                         CollideWithAOs   bool
30195                         StepHeight       float32
30196                         FaceRotateDir    bool
30197                         FaceRotateDirOff float32 // in degrees.
30198                         BackfaceCull     bool
30199                         Nametag          string
30200                         NametagColor     color.NRGBA
30201                         FaceRotateSpeed  float32 // in degrees per second.
30202                         Infotext         string
30203                         Itemstring       string
30204                         Glow             int8
30205                         MaxBreath        uint16  // Player only.
30206                         EyeHeight        float32 // Player only.
30207                         ZoomFOV          float32 // in degrees. Player only.
30208                         UseTextureAlpha  bool
30209                         DmgTextureMod    Texture // suffix
30210                         Shaded           bool
30211                         ShowOnMinimap    bool
30212                         NametagBG        color.NRGBA
30213                 }))(obj)).StepHeight
30214                 *p = math.Float32frombits(read32(r))
30215         }
30216         {
30217                 p := &(*(*(struct {
30218                         MaxHP            uint16 // Player only.
30219                         CollideWithNodes bool
30220                         Weight           float32 // deprecated
30221                         ColBox, SelBox   Box
30222                         Pointable        bool
30223                         Visual           string
30224                         VisualSize       [3]float32
30225                         Textures         []Texture
30226                         SpriteSheetSize  [2]int16 // in sprites.
30227                         SpritePos        [2]int16 // in sprite sheet.
30228                         Visible          bool
30229                         MakeFootstepSnds bool
30230                         RotateSpeed      float32 // in radians per second.
30231                         Mesh             string
30232                         Colors           []color.NRGBA
30233                         CollideWithAOs   bool
30234                         StepHeight       float32
30235                         FaceRotateDir    bool
30236                         FaceRotateDirOff float32 // in degrees.
30237                         BackfaceCull     bool
30238                         Nametag          string
30239                         NametagColor     color.NRGBA
30240                         FaceRotateSpeed  float32 // in degrees per second.
30241                         Infotext         string
30242                         Itemstring       string
30243                         Glow             int8
30244                         MaxBreath        uint16  // Player only.
30245                         EyeHeight        float32 // Player only.
30246                         ZoomFOV          float32 // in degrees. Player only.
30247                         UseTextureAlpha  bool
30248                         DmgTextureMod    Texture // suffix
30249                         Shaded           bool
30250                         ShowOnMinimap    bool
30251                         NametagBG        color.NRGBA
30252                 }))(obj)).FaceRotateDir
30253                 switch n := read8(r); n {
30254                 case 0:
30255                         *p = false
30256                 case 1:
30257                         *p = true
30258                 default:
30259                         chk(fmt.Errorf("invalid bool: %d", n))
30260                 }
30261
30262         }
30263         {
30264                 p := &(*(*(struct {
30265                         MaxHP            uint16 // Player only.
30266                         CollideWithNodes bool
30267                         Weight           float32 // deprecated
30268                         ColBox, SelBox   Box
30269                         Pointable        bool
30270                         Visual           string
30271                         VisualSize       [3]float32
30272                         Textures         []Texture
30273                         SpriteSheetSize  [2]int16 // in sprites.
30274                         SpritePos        [2]int16 // in sprite sheet.
30275                         Visible          bool
30276                         MakeFootstepSnds bool
30277                         RotateSpeed      float32 // in radians per second.
30278                         Mesh             string
30279                         Colors           []color.NRGBA
30280                         CollideWithAOs   bool
30281                         StepHeight       float32
30282                         FaceRotateDir    bool
30283                         FaceRotateDirOff float32 // in degrees.
30284                         BackfaceCull     bool
30285                         Nametag          string
30286                         NametagColor     color.NRGBA
30287                         FaceRotateSpeed  float32 // in degrees per second.
30288                         Infotext         string
30289                         Itemstring       string
30290                         Glow             int8
30291                         MaxBreath        uint16  // Player only.
30292                         EyeHeight        float32 // Player only.
30293                         ZoomFOV          float32 // in degrees. Player only.
30294                         UseTextureAlpha  bool
30295                         DmgTextureMod    Texture // suffix
30296                         Shaded           bool
30297                         ShowOnMinimap    bool
30298                         NametagBG        color.NRGBA
30299                 }))(obj)).FaceRotateDirOff
30300                 *p = math.Float32frombits(read32(r))
30301         }
30302         {
30303                 p := &(*(*(struct {
30304                         MaxHP            uint16 // Player only.
30305                         CollideWithNodes bool
30306                         Weight           float32 // deprecated
30307                         ColBox, SelBox   Box
30308                         Pointable        bool
30309                         Visual           string
30310                         VisualSize       [3]float32
30311                         Textures         []Texture
30312                         SpriteSheetSize  [2]int16 // in sprites.
30313                         SpritePos        [2]int16 // in sprite sheet.
30314                         Visible          bool
30315                         MakeFootstepSnds bool
30316                         RotateSpeed      float32 // in radians per second.
30317                         Mesh             string
30318                         Colors           []color.NRGBA
30319                         CollideWithAOs   bool
30320                         StepHeight       float32
30321                         FaceRotateDir    bool
30322                         FaceRotateDirOff float32 // in degrees.
30323                         BackfaceCull     bool
30324                         Nametag          string
30325                         NametagColor     color.NRGBA
30326                         FaceRotateSpeed  float32 // in degrees per second.
30327                         Infotext         string
30328                         Itemstring       string
30329                         Glow             int8
30330                         MaxBreath        uint16  // Player only.
30331                         EyeHeight        float32 // Player only.
30332                         ZoomFOV          float32 // in degrees. Player only.
30333                         UseTextureAlpha  bool
30334                         DmgTextureMod    Texture // suffix
30335                         Shaded           bool
30336                         ShowOnMinimap    bool
30337                         NametagBG        color.NRGBA
30338                 }))(obj)).BackfaceCull
30339                 switch n := read8(r); n {
30340                 case 0:
30341                         *p = false
30342                 case 1:
30343                         *p = true
30344                 default:
30345                         chk(fmt.Errorf("invalid bool: %d", n))
30346                 }
30347
30348         }
30349         var local354 []uint8
30350         var local355 uint16
30351         {
30352                 p := &local355
30353                 *p = read16(r)
30354         }
30355         (local354) = make([]uint8, local355)
30356         {
30357                 _, err := io.ReadFull(r, (local354)[:])
30358                 chk(err)
30359         }
30360         ((*(*(struct {
30361                 MaxHP            uint16 // Player only.
30362                 CollideWithNodes bool
30363                 Weight           float32 // deprecated
30364                 ColBox, SelBox   Box
30365                 Pointable        bool
30366                 Visual           string
30367                 VisualSize       [3]float32
30368                 Textures         []Texture
30369                 SpriteSheetSize  [2]int16 // in sprites.
30370                 SpritePos        [2]int16 // in sprite sheet.
30371                 Visible          bool
30372                 MakeFootstepSnds bool
30373                 RotateSpeed      float32 // in radians per second.
30374                 Mesh             string
30375                 Colors           []color.NRGBA
30376                 CollideWithAOs   bool
30377                 StepHeight       float32
30378                 FaceRotateDir    bool
30379                 FaceRotateDirOff float32 // in degrees.
30380                 BackfaceCull     bool
30381                 Nametag          string
30382                 NametagColor     color.NRGBA
30383                 FaceRotateSpeed  float32 // in degrees per second.
30384                 Infotext         string
30385                 Itemstring       string
30386                 Glow             int8
30387                 MaxBreath        uint16  // Player only.
30388                 EyeHeight        float32 // Player only.
30389                 ZoomFOV          float32 // in degrees. Player only.
30390                 UseTextureAlpha  bool
30391                 DmgTextureMod    Texture // suffix
30392                 Shaded           bool
30393                 ShowOnMinimap    bool
30394                 NametagBG        color.NRGBA
30395         }))(obj)).Nametag) = string(local354)
30396         {
30397                 p := &(*(*(struct {
30398                         MaxHP            uint16 // Player only.
30399                         CollideWithNodes bool
30400                         Weight           float32 // deprecated
30401                         ColBox, SelBox   Box
30402                         Pointable        bool
30403                         Visual           string
30404                         VisualSize       [3]float32
30405                         Textures         []Texture
30406                         SpriteSheetSize  [2]int16 // in sprites.
30407                         SpritePos        [2]int16 // in sprite sheet.
30408                         Visible          bool
30409                         MakeFootstepSnds bool
30410                         RotateSpeed      float32 // in radians per second.
30411                         Mesh             string
30412                         Colors           []color.NRGBA
30413                         CollideWithAOs   bool
30414                         StepHeight       float32
30415                         FaceRotateDir    bool
30416                         FaceRotateDirOff float32 // in degrees.
30417                         BackfaceCull     bool
30418                         Nametag          string
30419                         NametagColor     color.NRGBA
30420                         FaceRotateSpeed  float32 // in degrees per second.
30421                         Infotext         string
30422                         Itemstring       string
30423                         Glow             int8
30424                         MaxBreath        uint16  // Player only.
30425                         EyeHeight        float32 // Player only.
30426                         ZoomFOV          float32 // in degrees. Player only.
30427                         UseTextureAlpha  bool
30428                         DmgTextureMod    Texture // suffix
30429                         Shaded           bool
30430                         ShowOnMinimap    bool
30431                         NametagBG        color.NRGBA
30432                 }))(obj)).NametagColor
30433                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30434
30435         }
30436         {
30437                 p := &(*(*(struct {
30438                         MaxHP            uint16 // Player only.
30439                         CollideWithNodes bool
30440                         Weight           float32 // deprecated
30441                         ColBox, SelBox   Box
30442                         Pointable        bool
30443                         Visual           string
30444                         VisualSize       [3]float32
30445                         Textures         []Texture
30446                         SpriteSheetSize  [2]int16 // in sprites.
30447                         SpritePos        [2]int16 // in sprite sheet.
30448                         Visible          bool
30449                         MakeFootstepSnds bool
30450                         RotateSpeed      float32 // in radians per second.
30451                         Mesh             string
30452                         Colors           []color.NRGBA
30453                         CollideWithAOs   bool
30454                         StepHeight       float32
30455                         FaceRotateDir    bool
30456                         FaceRotateDirOff float32 // in degrees.
30457                         BackfaceCull     bool
30458                         Nametag          string
30459                         NametagColor     color.NRGBA
30460                         FaceRotateSpeed  float32 // in degrees per second.
30461                         Infotext         string
30462                         Itemstring       string
30463                         Glow             int8
30464                         MaxBreath        uint16  // Player only.
30465                         EyeHeight        float32 // Player only.
30466                         ZoomFOV          float32 // in degrees. Player only.
30467                         UseTextureAlpha  bool
30468                         DmgTextureMod    Texture // suffix
30469                         Shaded           bool
30470                         ShowOnMinimap    bool
30471                         NametagBG        color.NRGBA
30472                 }))(obj)).FaceRotateSpeed
30473                 *p = math.Float32frombits(read32(r))
30474         }
30475         var local356 []uint8
30476         var local357 uint16
30477         {
30478                 p := &local357
30479                 *p = read16(r)
30480         }
30481         (local356) = make([]uint8, local357)
30482         {
30483                 _, err := io.ReadFull(r, (local356)[:])
30484                 chk(err)
30485         }
30486         ((*(*(struct {
30487                 MaxHP            uint16 // Player only.
30488                 CollideWithNodes bool
30489                 Weight           float32 // deprecated
30490                 ColBox, SelBox   Box
30491                 Pointable        bool
30492                 Visual           string
30493                 VisualSize       [3]float32
30494                 Textures         []Texture
30495                 SpriteSheetSize  [2]int16 // in sprites.
30496                 SpritePos        [2]int16 // in sprite sheet.
30497                 Visible          bool
30498                 MakeFootstepSnds bool
30499                 RotateSpeed      float32 // in radians per second.
30500                 Mesh             string
30501                 Colors           []color.NRGBA
30502                 CollideWithAOs   bool
30503                 StepHeight       float32
30504                 FaceRotateDir    bool
30505                 FaceRotateDirOff float32 // in degrees.
30506                 BackfaceCull     bool
30507                 Nametag          string
30508                 NametagColor     color.NRGBA
30509                 FaceRotateSpeed  float32 // in degrees per second.
30510                 Infotext         string
30511                 Itemstring       string
30512                 Glow             int8
30513                 MaxBreath        uint16  // Player only.
30514                 EyeHeight        float32 // Player only.
30515                 ZoomFOV          float32 // in degrees. Player only.
30516                 UseTextureAlpha  bool
30517                 DmgTextureMod    Texture // suffix
30518                 Shaded           bool
30519                 ShowOnMinimap    bool
30520                 NametagBG        color.NRGBA
30521         }))(obj)).Infotext) = string(local356)
30522         var local358 []uint8
30523         var local359 uint16
30524         {
30525                 p := &local359
30526                 *p = read16(r)
30527         }
30528         (local358) = make([]uint8, local359)
30529         {
30530                 _, err := io.ReadFull(r, (local358)[:])
30531                 chk(err)
30532         }
30533         ((*(*(struct {
30534                 MaxHP            uint16 // Player only.
30535                 CollideWithNodes bool
30536                 Weight           float32 // deprecated
30537                 ColBox, SelBox   Box
30538                 Pointable        bool
30539                 Visual           string
30540                 VisualSize       [3]float32
30541                 Textures         []Texture
30542                 SpriteSheetSize  [2]int16 // in sprites.
30543                 SpritePos        [2]int16 // in sprite sheet.
30544                 Visible          bool
30545                 MakeFootstepSnds bool
30546                 RotateSpeed      float32 // in radians per second.
30547                 Mesh             string
30548                 Colors           []color.NRGBA
30549                 CollideWithAOs   bool
30550                 StepHeight       float32
30551                 FaceRotateDir    bool
30552                 FaceRotateDirOff float32 // in degrees.
30553                 BackfaceCull     bool
30554                 Nametag          string
30555                 NametagColor     color.NRGBA
30556                 FaceRotateSpeed  float32 // in degrees per second.
30557                 Infotext         string
30558                 Itemstring       string
30559                 Glow             int8
30560                 MaxBreath        uint16  // Player only.
30561                 EyeHeight        float32 // Player only.
30562                 ZoomFOV          float32 // in degrees. Player only.
30563                 UseTextureAlpha  bool
30564                 DmgTextureMod    Texture // suffix
30565                 Shaded           bool
30566                 ShowOnMinimap    bool
30567                 NametagBG        color.NRGBA
30568         }))(obj)).Itemstring) = string(local358)
30569         {
30570                 p := &(*(*(struct {
30571                         MaxHP            uint16 // Player only.
30572                         CollideWithNodes bool
30573                         Weight           float32 // deprecated
30574                         ColBox, SelBox   Box
30575                         Pointable        bool
30576                         Visual           string
30577                         VisualSize       [3]float32
30578                         Textures         []Texture
30579                         SpriteSheetSize  [2]int16 // in sprites.
30580                         SpritePos        [2]int16 // in sprite sheet.
30581                         Visible          bool
30582                         MakeFootstepSnds bool
30583                         RotateSpeed      float32 // in radians per second.
30584                         Mesh             string
30585                         Colors           []color.NRGBA
30586                         CollideWithAOs   bool
30587                         StepHeight       float32
30588                         FaceRotateDir    bool
30589                         FaceRotateDirOff float32 // in degrees.
30590                         BackfaceCull     bool
30591                         Nametag          string
30592                         NametagColor     color.NRGBA
30593                         FaceRotateSpeed  float32 // in degrees per second.
30594                         Infotext         string
30595                         Itemstring       string
30596                         Glow             int8
30597                         MaxBreath        uint16  // Player only.
30598                         EyeHeight        float32 // Player only.
30599                         ZoomFOV          float32 // in degrees. Player only.
30600                         UseTextureAlpha  bool
30601                         DmgTextureMod    Texture // suffix
30602                         Shaded           bool
30603                         ShowOnMinimap    bool
30604                         NametagBG        color.NRGBA
30605                 }))(obj)).Glow
30606                 *p = int8(read8(r))
30607         }
30608         {
30609                 p := &(*(*(struct {
30610                         MaxHP            uint16 // Player only.
30611                         CollideWithNodes bool
30612                         Weight           float32 // deprecated
30613                         ColBox, SelBox   Box
30614                         Pointable        bool
30615                         Visual           string
30616                         VisualSize       [3]float32
30617                         Textures         []Texture
30618                         SpriteSheetSize  [2]int16 // in sprites.
30619                         SpritePos        [2]int16 // in sprite sheet.
30620                         Visible          bool
30621                         MakeFootstepSnds bool
30622                         RotateSpeed      float32 // in radians per second.
30623                         Mesh             string
30624                         Colors           []color.NRGBA
30625                         CollideWithAOs   bool
30626                         StepHeight       float32
30627                         FaceRotateDir    bool
30628                         FaceRotateDirOff float32 // in degrees.
30629                         BackfaceCull     bool
30630                         Nametag          string
30631                         NametagColor     color.NRGBA
30632                         FaceRotateSpeed  float32 // in degrees per second.
30633                         Infotext         string
30634                         Itemstring       string
30635                         Glow             int8
30636                         MaxBreath        uint16  // Player only.
30637                         EyeHeight        float32 // Player only.
30638                         ZoomFOV          float32 // in degrees. Player only.
30639                         UseTextureAlpha  bool
30640                         DmgTextureMod    Texture // suffix
30641                         Shaded           bool
30642                         ShowOnMinimap    bool
30643                         NametagBG        color.NRGBA
30644                 }))(obj)).MaxBreath
30645                 *p = read16(r)
30646         }
30647         {
30648                 p := &(*(*(struct {
30649                         MaxHP            uint16 // Player only.
30650                         CollideWithNodes bool
30651                         Weight           float32 // deprecated
30652                         ColBox, SelBox   Box
30653                         Pointable        bool
30654                         Visual           string
30655                         VisualSize       [3]float32
30656                         Textures         []Texture
30657                         SpriteSheetSize  [2]int16 // in sprites.
30658                         SpritePos        [2]int16 // in sprite sheet.
30659                         Visible          bool
30660                         MakeFootstepSnds bool
30661                         RotateSpeed      float32 // in radians per second.
30662                         Mesh             string
30663                         Colors           []color.NRGBA
30664                         CollideWithAOs   bool
30665                         StepHeight       float32
30666                         FaceRotateDir    bool
30667                         FaceRotateDirOff float32 // in degrees.
30668                         BackfaceCull     bool
30669                         Nametag          string
30670                         NametagColor     color.NRGBA
30671                         FaceRotateSpeed  float32 // in degrees per second.
30672                         Infotext         string
30673                         Itemstring       string
30674                         Glow             int8
30675                         MaxBreath        uint16  // Player only.
30676                         EyeHeight        float32 // Player only.
30677                         ZoomFOV          float32 // in degrees. Player only.
30678                         UseTextureAlpha  bool
30679                         DmgTextureMod    Texture // suffix
30680                         Shaded           bool
30681                         ShowOnMinimap    bool
30682                         NametagBG        color.NRGBA
30683                 }))(obj)).EyeHeight
30684                 *p = math.Float32frombits(read32(r))
30685         }
30686         {
30687                 p := &(*(*(struct {
30688                         MaxHP            uint16 // Player only.
30689                         CollideWithNodes bool
30690                         Weight           float32 // deprecated
30691                         ColBox, SelBox   Box
30692                         Pointable        bool
30693                         Visual           string
30694                         VisualSize       [3]float32
30695                         Textures         []Texture
30696                         SpriteSheetSize  [2]int16 // in sprites.
30697                         SpritePos        [2]int16 // in sprite sheet.
30698                         Visible          bool
30699                         MakeFootstepSnds bool
30700                         RotateSpeed      float32 // in radians per second.
30701                         Mesh             string
30702                         Colors           []color.NRGBA
30703                         CollideWithAOs   bool
30704                         StepHeight       float32
30705                         FaceRotateDir    bool
30706                         FaceRotateDirOff float32 // in degrees.
30707                         BackfaceCull     bool
30708                         Nametag          string
30709                         NametagColor     color.NRGBA
30710                         FaceRotateSpeed  float32 // in degrees per second.
30711                         Infotext         string
30712                         Itemstring       string
30713                         Glow             int8
30714                         MaxBreath        uint16  // Player only.
30715                         EyeHeight        float32 // Player only.
30716                         ZoomFOV          float32 // in degrees. Player only.
30717                         UseTextureAlpha  bool
30718                         DmgTextureMod    Texture // suffix
30719                         Shaded           bool
30720                         ShowOnMinimap    bool
30721                         NametagBG        color.NRGBA
30722                 }))(obj)).ZoomFOV
30723                 *p = math.Float32frombits(read32(r))
30724         }
30725         {
30726                 p := &(*(*(struct {
30727                         MaxHP            uint16 // Player only.
30728                         CollideWithNodes bool
30729                         Weight           float32 // deprecated
30730                         ColBox, SelBox   Box
30731                         Pointable        bool
30732                         Visual           string
30733                         VisualSize       [3]float32
30734                         Textures         []Texture
30735                         SpriteSheetSize  [2]int16 // in sprites.
30736                         SpritePos        [2]int16 // in sprite sheet.
30737                         Visible          bool
30738                         MakeFootstepSnds bool
30739                         RotateSpeed      float32 // in radians per second.
30740                         Mesh             string
30741                         Colors           []color.NRGBA
30742                         CollideWithAOs   bool
30743                         StepHeight       float32
30744                         FaceRotateDir    bool
30745                         FaceRotateDirOff float32 // in degrees.
30746                         BackfaceCull     bool
30747                         Nametag          string
30748                         NametagColor     color.NRGBA
30749                         FaceRotateSpeed  float32 // in degrees per second.
30750                         Infotext         string
30751                         Itemstring       string
30752                         Glow             int8
30753                         MaxBreath        uint16  // Player only.
30754                         EyeHeight        float32 // Player only.
30755                         ZoomFOV          float32 // in degrees. Player only.
30756                         UseTextureAlpha  bool
30757                         DmgTextureMod    Texture // suffix
30758                         Shaded           bool
30759                         ShowOnMinimap    bool
30760                         NametagBG        color.NRGBA
30761                 }))(obj)).UseTextureAlpha
30762                 switch n := read8(r); n {
30763                 case 0:
30764                         *p = false
30765                 case 1:
30766                         *p = true
30767                 default:
30768                         chk(fmt.Errorf("invalid bool: %d", n))
30769                 }
30770
30771         }
30772         if err := pcall(func() {
30773                 ((*(*(struct {
30774                         MaxHP            uint16 // Player only.
30775                         CollideWithNodes bool
30776                         Weight           float32 // deprecated
30777                         ColBox, SelBox   Box
30778                         Pointable        bool
30779                         Visual           string
30780                         VisualSize       [3]float32
30781                         Textures         []Texture
30782                         SpriteSheetSize  [2]int16 // in sprites.
30783                         SpritePos        [2]int16 // in sprite sheet.
30784                         Visible          bool
30785                         MakeFootstepSnds bool
30786                         RotateSpeed      float32 // in radians per second.
30787                         Mesh             string
30788                         Colors           []color.NRGBA
30789                         CollideWithAOs   bool
30790                         StepHeight       float32
30791                         FaceRotateDir    bool
30792                         FaceRotateDirOff float32 // in degrees.
30793                         BackfaceCull     bool
30794                         Nametag          string
30795                         NametagColor     color.NRGBA
30796                         FaceRotateSpeed  float32 // in degrees per second.
30797                         Infotext         string
30798                         Itemstring       string
30799                         Glow             int8
30800                         MaxBreath        uint16  // Player only.
30801                         EyeHeight        float32 // Player only.
30802                         ZoomFOV          float32 // in degrees. Player only.
30803                         UseTextureAlpha  bool
30804                         DmgTextureMod    Texture // suffix
30805                         Shaded           bool
30806                         ShowOnMinimap    bool
30807                         NametagBG        color.NRGBA
30808                 }))(obj)).DmgTextureMod).deserialize(r)
30809         }); err != nil {
30810                 if err == io.EOF {
30811                         chk(io.EOF)
30812                 }
30813                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
30814         }
30815         {
30816                 p := &(*(*(struct {
30817                         MaxHP            uint16 // Player only.
30818                         CollideWithNodes bool
30819                         Weight           float32 // deprecated
30820                         ColBox, SelBox   Box
30821                         Pointable        bool
30822                         Visual           string
30823                         VisualSize       [3]float32
30824                         Textures         []Texture
30825                         SpriteSheetSize  [2]int16 // in sprites.
30826                         SpritePos        [2]int16 // in sprite sheet.
30827                         Visible          bool
30828                         MakeFootstepSnds bool
30829                         RotateSpeed      float32 // in radians per second.
30830                         Mesh             string
30831                         Colors           []color.NRGBA
30832                         CollideWithAOs   bool
30833                         StepHeight       float32
30834                         FaceRotateDir    bool
30835                         FaceRotateDirOff float32 // in degrees.
30836                         BackfaceCull     bool
30837                         Nametag          string
30838                         NametagColor     color.NRGBA
30839                         FaceRotateSpeed  float32 // in degrees per second.
30840                         Infotext         string
30841                         Itemstring       string
30842                         Glow             int8
30843                         MaxBreath        uint16  // Player only.
30844                         EyeHeight        float32 // Player only.
30845                         ZoomFOV          float32 // in degrees. Player only.
30846                         UseTextureAlpha  bool
30847                         DmgTextureMod    Texture // suffix
30848                         Shaded           bool
30849                         ShowOnMinimap    bool
30850                         NametagBG        color.NRGBA
30851                 }))(obj)).Shaded
30852                 switch n := read8(r); n {
30853                 case 0:
30854                         *p = false
30855                 case 1:
30856                         *p = true
30857                 default:
30858                         chk(fmt.Errorf("invalid bool: %d", n))
30859                 }
30860
30861         }
30862         {
30863                 p := &(*(*(struct {
30864                         MaxHP            uint16 // Player only.
30865                         CollideWithNodes bool
30866                         Weight           float32 // deprecated
30867                         ColBox, SelBox   Box
30868                         Pointable        bool
30869                         Visual           string
30870                         VisualSize       [3]float32
30871                         Textures         []Texture
30872                         SpriteSheetSize  [2]int16 // in sprites.
30873                         SpritePos        [2]int16 // in sprite sheet.
30874                         Visible          bool
30875                         MakeFootstepSnds bool
30876                         RotateSpeed      float32 // in radians per second.
30877                         Mesh             string
30878                         Colors           []color.NRGBA
30879                         CollideWithAOs   bool
30880                         StepHeight       float32
30881                         FaceRotateDir    bool
30882                         FaceRotateDirOff float32 // in degrees.
30883                         BackfaceCull     bool
30884                         Nametag          string
30885                         NametagColor     color.NRGBA
30886                         FaceRotateSpeed  float32 // in degrees per second.
30887                         Infotext         string
30888                         Itemstring       string
30889                         Glow             int8
30890                         MaxBreath        uint16  // Player only.
30891                         EyeHeight        float32 // Player only.
30892                         ZoomFOV          float32 // in degrees. Player only.
30893                         UseTextureAlpha  bool
30894                         DmgTextureMod    Texture // suffix
30895                         Shaded           bool
30896                         ShowOnMinimap    bool
30897                         NametagBG        color.NRGBA
30898                 }))(obj)).ShowOnMinimap
30899                 switch n := read8(r); n {
30900                 case 0:
30901                         *p = false
30902                 case 1:
30903                         *p = true
30904                 default:
30905                         chk(fmt.Errorf("invalid bool: %d", n))
30906                 }
30907
30908         }
30909         {
30910                 p := &(*(*(struct {
30911                         MaxHP            uint16 // Player only.
30912                         CollideWithNodes bool
30913                         Weight           float32 // deprecated
30914                         ColBox, SelBox   Box
30915                         Pointable        bool
30916                         Visual           string
30917                         VisualSize       [3]float32
30918                         Textures         []Texture
30919                         SpriteSheetSize  [2]int16 // in sprites.
30920                         SpritePos        [2]int16 // in sprite sheet.
30921                         Visible          bool
30922                         MakeFootstepSnds bool
30923                         RotateSpeed      float32 // in radians per second.
30924                         Mesh             string
30925                         Colors           []color.NRGBA
30926                         CollideWithAOs   bool
30927                         StepHeight       float32
30928                         FaceRotateDir    bool
30929                         FaceRotateDirOff float32 // in degrees.
30930                         BackfaceCull     bool
30931                         Nametag          string
30932                         NametagColor     color.NRGBA
30933                         FaceRotateSpeed  float32 // in degrees per second.
30934                         Infotext         string
30935                         Itemstring       string
30936                         Glow             int8
30937                         MaxBreath        uint16  // Player only.
30938                         EyeHeight        float32 // Player only.
30939                         ZoomFOV          float32 // in degrees. Player only.
30940                         UseTextureAlpha  bool
30941                         DmgTextureMod    Texture // suffix
30942                         Shaded           bool
30943                         ShowOnMinimap    bool
30944                         NametagBG        color.NRGBA
30945                 }))(obj)).NametagBG
30946                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30947
30948         }
30949 }
30950
30951 func (obj *AOPos) serialize(w io.Writer) {
30952         if err := pcall(func() {
30953                 ((*(*(struct {
30954                         Pos
30955                         Vel, Acc Vec
30956                         Rot      [3]float32
30957
30958                         Interpolate    bool
30959                         End            bool
30960                         UpdateInterval float32
30961                 }))(obj)).Pos).serialize(w)
30962         }); err != nil {
30963                 if err == io.EOF {
30964                         chk(io.EOF)
30965                 }
30966                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
30967         }
30968         if err := pcall(func() {
30969                 ((*(*(struct {
30970                         Pos
30971                         Vel, Acc Vec
30972                         Rot      [3]float32
30973
30974                         Interpolate    bool
30975                         End            bool
30976                         UpdateInterval float32
30977                 }))(obj)).Vel).serialize(w)
30978         }); err != nil {
30979                 if err == io.EOF {
30980                         chk(io.EOF)
30981                 }
30982                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30983         }
30984         if err := pcall(func() {
30985                 ((*(*(struct {
30986                         Pos
30987                         Vel, Acc Vec
30988                         Rot      [3]float32
30989
30990                         Interpolate    bool
30991                         End            bool
30992                         UpdateInterval float32
30993                 }))(obj)).Acc).serialize(w)
30994         }); err != nil {
30995                 if err == io.EOF {
30996                         chk(io.EOF)
30997                 }
30998                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30999         }
31000         for local360 := range (*(*(struct {
31001                 Pos
31002                 Vel, Acc Vec
31003                 Rot      [3]float32
31004
31005                 Interpolate    bool
31006                 End            bool
31007                 UpdateInterval float32
31008         }))(obj)).Rot {
31009                 {
31010                         x := ((*(*(struct {
31011                                 Pos
31012                                 Vel, Acc Vec
31013                                 Rot      [3]float32
31014
31015                                 Interpolate    bool
31016                                 End            bool
31017                                 UpdateInterval float32
31018                         }))(obj)).Rot)[local360]
31019                         write32(w, math.Float32bits(x))
31020                 }
31021         }
31022         {
31023                 x := (*(*(struct {
31024                         Pos
31025                         Vel, Acc Vec
31026                         Rot      [3]float32
31027
31028                         Interpolate    bool
31029                         End            bool
31030                         UpdateInterval float32
31031                 }))(obj)).Interpolate
31032                 if x {
31033                         write8(w, 1)
31034                 } else {
31035                         write8(w, 0)
31036                 }
31037
31038         }
31039         {
31040                 x := (*(*(struct {
31041                         Pos
31042                         Vel, Acc Vec
31043                         Rot      [3]float32
31044
31045                         Interpolate    bool
31046                         End            bool
31047                         UpdateInterval float32
31048                 }))(obj)).End
31049                 if x {
31050                         write8(w, 1)
31051                 } else {
31052                         write8(w, 0)
31053                 }
31054
31055         }
31056         {
31057                 x := (*(*(struct {
31058                         Pos
31059                         Vel, Acc Vec
31060                         Rot      [3]float32
31061
31062                         Interpolate    bool
31063                         End            bool
31064                         UpdateInterval float32
31065                 }))(obj)).UpdateInterval
31066                 write32(w, math.Float32bits(x))
31067         }
31068 }
31069
31070 func (obj *AOPos) deserialize(r io.Reader) {
31071         if err := pcall(func() {
31072                 ((*(*(struct {
31073                         Pos
31074                         Vel, Acc Vec
31075                         Rot      [3]float32
31076
31077                         Interpolate    bool
31078                         End            bool
31079                         UpdateInterval float32
31080                 }))(obj)).Pos).deserialize(r)
31081         }); err != nil {
31082                 if err == io.EOF {
31083                         chk(io.EOF)
31084                 }
31085                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
31086         }
31087         if err := pcall(func() {
31088                 ((*(*(struct {
31089                         Pos
31090                         Vel, Acc Vec
31091                         Rot      [3]float32
31092
31093                         Interpolate    bool
31094                         End            bool
31095                         UpdateInterval float32
31096                 }))(obj)).Vel).deserialize(r)
31097         }); err != nil {
31098                 if err == io.EOF {
31099                         chk(io.EOF)
31100                 }
31101                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31102         }
31103         if err := pcall(func() {
31104                 ((*(*(struct {
31105                         Pos
31106                         Vel, Acc Vec
31107                         Rot      [3]float32
31108
31109                         Interpolate    bool
31110                         End            bool
31111                         UpdateInterval float32
31112                 }))(obj)).Acc).deserialize(r)
31113         }); err != nil {
31114                 if err == io.EOF {
31115                         chk(io.EOF)
31116                 }
31117                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31118         }
31119         for local361 := range (*(*(struct {
31120                 Pos
31121                 Vel, Acc Vec
31122                 Rot      [3]float32
31123
31124                 Interpolate    bool
31125                 End            bool
31126                 UpdateInterval float32
31127         }))(obj)).Rot {
31128                 {
31129                         p := &((*(*(struct {
31130                                 Pos
31131                                 Vel, Acc Vec
31132                                 Rot      [3]float32
31133
31134                                 Interpolate    bool
31135                                 End            bool
31136                                 UpdateInterval float32
31137                         }))(obj)).Rot)[local361]
31138                         *p = math.Float32frombits(read32(r))
31139                 }
31140         }
31141         {
31142                 p := &(*(*(struct {
31143                         Pos
31144                         Vel, Acc Vec
31145                         Rot      [3]float32
31146
31147                         Interpolate    bool
31148                         End            bool
31149                         UpdateInterval float32
31150                 }))(obj)).Interpolate
31151                 switch n := read8(r); n {
31152                 case 0:
31153                         *p = false
31154                 case 1:
31155                         *p = true
31156                 default:
31157                         chk(fmt.Errorf("invalid bool: %d", n))
31158                 }
31159
31160         }
31161         {
31162                 p := &(*(*(struct {
31163                         Pos
31164                         Vel, Acc Vec
31165                         Rot      [3]float32
31166
31167                         Interpolate    bool
31168                         End            bool
31169                         UpdateInterval float32
31170                 }))(obj)).End
31171                 switch n := read8(r); n {
31172                 case 0:
31173                         *p = false
31174                 case 1:
31175                         *p = true
31176                 default:
31177                         chk(fmt.Errorf("invalid bool: %d", n))
31178                 }
31179
31180         }
31181         {
31182                 p := &(*(*(struct {
31183                         Pos
31184                         Vel, Acc Vec
31185                         Rot      [3]float32
31186
31187                         Interpolate    bool
31188                         End            bool
31189                         UpdateInterval float32
31190                 }))(obj)).UpdateInterval
31191                 *p = math.Float32frombits(read32(r))
31192         }
31193 }
31194
31195 func (obj *AOSprite) serialize(w io.Writer) {
31196         for local362 := range (*(*(struct {
31197                 Frame0          [2]int16
31198                 Frames          uint16
31199                 FrameDuration   float32
31200                 ViewAngleFrames bool
31201         }))(obj)).Frame0 {
31202                 {
31203                         x := ((*(*(struct {
31204                                 Frame0          [2]int16
31205                                 Frames          uint16
31206                                 FrameDuration   float32
31207                                 ViewAngleFrames bool
31208                         }))(obj)).Frame0)[local362]
31209                         write16(w, uint16(x))
31210                 }
31211         }
31212         {
31213                 x := (*(*(struct {
31214                         Frame0          [2]int16
31215                         Frames          uint16
31216                         FrameDuration   float32
31217                         ViewAngleFrames bool
31218                 }))(obj)).Frames
31219                 write16(w, uint16(x))
31220         }
31221         {
31222                 x := (*(*(struct {
31223                         Frame0          [2]int16
31224                         Frames          uint16
31225                         FrameDuration   float32
31226                         ViewAngleFrames bool
31227                 }))(obj)).FrameDuration
31228                 write32(w, math.Float32bits(x))
31229         }
31230         {
31231                 x := (*(*(struct {
31232                         Frame0          [2]int16
31233                         Frames          uint16
31234                         FrameDuration   float32
31235                         ViewAngleFrames bool
31236                 }))(obj)).ViewAngleFrames
31237                 if x {
31238                         write8(w, 1)
31239                 } else {
31240                         write8(w, 0)
31241                 }
31242
31243         }
31244 }
31245
31246 func (obj *AOSprite) deserialize(r io.Reader) {
31247         for local363 := range (*(*(struct {
31248                 Frame0          [2]int16
31249                 Frames          uint16
31250                 FrameDuration   float32
31251                 ViewAngleFrames bool
31252         }))(obj)).Frame0 {
31253                 {
31254                         p := &((*(*(struct {
31255                                 Frame0          [2]int16
31256                                 Frames          uint16
31257                                 FrameDuration   float32
31258                                 ViewAngleFrames bool
31259                         }))(obj)).Frame0)[local363]
31260                         *p = int16(read16(r))
31261                 }
31262         }
31263         {
31264                 p := &(*(*(struct {
31265                         Frame0          [2]int16
31266                         Frames          uint16
31267                         FrameDuration   float32
31268                         ViewAngleFrames bool
31269                 }))(obj)).Frames
31270                 *p = read16(r)
31271         }
31272         {
31273                 p := &(*(*(struct {
31274                         Frame0          [2]int16
31275                         Frames          uint16
31276                         FrameDuration   float32
31277                         ViewAngleFrames bool
31278                 }))(obj)).FrameDuration
31279                 *p = math.Float32frombits(read32(r))
31280         }
31281         {
31282                 p := &(*(*(struct {
31283                         Frame0          [2]int16
31284                         Frames          uint16
31285                         FrameDuration   float32
31286                         ViewAngleFrames bool
31287                 }))(obj)).ViewAngleFrames
31288                 switch n := read8(r); n {
31289                 case 0:
31290                         *p = false
31291                 case 1:
31292                         *p = true
31293                 default:
31294                         chk(fmt.Errorf("invalid bool: %d", n))
31295                 }
31296
31297         }
31298 }
31299
31300 func (obj *Group) serialize(w io.Writer) {
31301         if len(([]byte((*(*(struct {
31302                 Name   string
31303                 Rating int16
31304         }))(obj)).Name))) > math.MaxUint16 {
31305                 chk(ErrTooLong)
31306         }
31307         {
31308                 x := uint16(len(([]byte((*(*(struct {
31309                         Name   string
31310                         Rating int16
31311                 }))(obj)).Name))))
31312                 write16(w, uint16(x))
31313         }
31314         {
31315                 _, err := w.Write(([]byte((*(*(struct {
31316                         Name   string
31317                         Rating int16
31318                 }))(obj)).Name))[:])
31319                 chk(err)
31320         }
31321         {
31322                 x := (*(*(struct {
31323                         Name   string
31324                         Rating int16
31325                 }))(obj)).Rating
31326                 write16(w, uint16(x))
31327         }
31328 }
31329
31330 func (obj *Group) deserialize(r io.Reader) {
31331         var local364 []uint8
31332         var local365 uint16
31333         {
31334                 p := &local365
31335                 *p = read16(r)
31336         }
31337         (local364) = make([]uint8, local365)
31338         {
31339                 _, err := io.ReadFull(r, (local364)[:])
31340                 chk(err)
31341         }
31342         ((*(*(struct {
31343                 Name   string
31344                 Rating int16
31345         }))(obj)).Name) = string(local364)
31346         {
31347                 p := &(*(*(struct {
31348                         Name   string
31349                         Rating int16
31350                 }))(obj)).Rating
31351                 *p = int16(read16(r))
31352         }
31353 }
31354
31355 func (obj *AOAnim) serialize(w io.Writer) {
31356         for local366 := range (*(*(struct {
31357                 Frames [2]int32
31358                 Speed  float32
31359                 Blend  float32
31360                 NoLoop bool
31361         }))(obj)).Frames {
31362                 {
31363                         x := ((*(*(struct {
31364                                 Frames [2]int32
31365                                 Speed  float32
31366                                 Blend  float32
31367                                 NoLoop bool
31368                         }))(obj)).Frames)[local366]
31369                         write32(w, uint32(x))
31370                 }
31371         }
31372         {
31373                 x := (*(*(struct {
31374                         Frames [2]int32
31375                         Speed  float32
31376                         Blend  float32
31377                         NoLoop bool
31378                 }))(obj)).Speed
31379                 write32(w, math.Float32bits(x))
31380         }
31381         {
31382                 x := (*(*(struct {
31383                         Frames [2]int32
31384                         Speed  float32
31385                         Blend  float32
31386                         NoLoop bool
31387                 }))(obj)).Blend
31388                 write32(w, math.Float32bits(x))
31389         }
31390         {
31391                 x := (*(*(struct {
31392                         Frames [2]int32
31393                         Speed  float32
31394                         Blend  float32
31395                         NoLoop bool
31396                 }))(obj)).NoLoop
31397                 if x {
31398                         write8(w, 1)
31399                 } else {
31400                         write8(w, 0)
31401                 }
31402
31403         }
31404 }
31405
31406 func (obj *AOAnim) deserialize(r io.Reader) {
31407         for local367 := range (*(*(struct {
31408                 Frames [2]int32
31409                 Speed  float32
31410                 Blend  float32
31411                 NoLoop bool
31412         }))(obj)).Frames {
31413                 {
31414                         p := &((*(*(struct {
31415                                 Frames [2]int32
31416                                 Speed  float32
31417                                 Blend  float32
31418                                 NoLoop bool
31419                         }))(obj)).Frames)[local367]
31420                         *p = int32(read32(r))
31421                 }
31422         }
31423         {
31424                 p := &(*(*(struct {
31425                         Frames [2]int32
31426                         Speed  float32
31427                         Blend  float32
31428                         NoLoop bool
31429                 }))(obj)).Speed
31430                 *p = math.Float32frombits(read32(r))
31431         }
31432         {
31433                 p := &(*(*(struct {
31434                         Frames [2]int32
31435                         Speed  float32
31436                         Blend  float32
31437                         NoLoop bool
31438                 }))(obj)).Blend
31439                 *p = math.Float32frombits(read32(r))
31440         }
31441         {
31442                 p := &(*(*(struct {
31443                         Frames [2]int32
31444                         Speed  float32
31445                         Blend  float32
31446                         NoLoop bool
31447                 }))(obj)).NoLoop
31448                 switch n := read8(r); n {
31449                 case 0:
31450                         *p = false
31451                 case 1:
31452                         *p = true
31453                 default:
31454                         chk(fmt.Errorf("invalid bool: %d", n))
31455                 }
31456
31457         }
31458 }
31459
31460 func (obj *AOBonePos) serialize(w io.Writer) {
31461         if err := pcall(func() {
31462                 ((*(*(struct {
31463                         Pos Vec
31464                         Rot [3]float32
31465                 }))(obj)).Pos).serialize(w)
31466         }); err != nil {
31467                 if err == io.EOF {
31468                         chk(io.EOF)
31469                 }
31470                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31471         }
31472         for local368 := range (*(*(struct {
31473                 Pos Vec
31474                 Rot [3]float32
31475         }))(obj)).Rot {
31476                 {
31477                         x := ((*(*(struct {
31478                                 Pos Vec
31479                                 Rot [3]float32
31480                         }))(obj)).Rot)[local368]
31481                         write32(w, math.Float32bits(x))
31482                 }
31483         }
31484 }
31485
31486 func (obj *AOBonePos) deserialize(r io.Reader) {
31487         if err := pcall(func() {
31488                 ((*(*(struct {
31489                         Pos Vec
31490                         Rot [3]float32
31491                 }))(obj)).Pos).deserialize(r)
31492         }); err != nil {
31493                 if err == io.EOF {
31494                         chk(io.EOF)
31495                 }
31496                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31497         }
31498         for local369 := range (*(*(struct {
31499                 Pos Vec
31500                 Rot [3]float32
31501         }))(obj)).Rot {
31502                 {
31503                         p := &((*(*(struct {
31504                                 Pos Vec
31505                                 Rot [3]float32
31506                         }))(obj)).Rot)[local369]
31507                         *p = math.Float32frombits(read32(r))
31508                 }
31509         }
31510 }
31511
31512 func (obj *AOAttach) serialize(w io.Writer) {
31513         if err := pcall(func() {
31514                 ((*(*(struct {
31515                         ParentID     AOID
31516                         Bone         string
31517                         Pos          Vec
31518                         Rot          [3]float32
31519                         ForceVisible bool
31520                 }))(obj)).ParentID).serialize(w)
31521         }); err != nil {
31522                 if err == io.EOF {
31523                         chk(io.EOF)
31524                 }
31525                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
31526         }
31527         if len(([]byte((*(*(struct {
31528                 ParentID     AOID
31529                 Bone         string
31530                 Pos          Vec
31531                 Rot          [3]float32
31532                 ForceVisible bool
31533         }))(obj)).Bone))) > math.MaxUint16 {
31534                 chk(ErrTooLong)
31535         }
31536         {
31537                 x := uint16(len(([]byte((*(*(struct {
31538                         ParentID     AOID
31539                         Bone         string
31540                         Pos          Vec
31541                         Rot          [3]float32
31542                         ForceVisible bool
31543                 }))(obj)).Bone))))
31544                 write16(w, uint16(x))
31545         }
31546         {
31547                 _, err := w.Write(([]byte((*(*(struct {
31548                         ParentID     AOID
31549                         Bone         string
31550                         Pos          Vec
31551                         Rot          [3]float32
31552                         ForceVisible bool
31553                 }))(obj)).Bone))[:])
31554                 chk(err)
31555         }
31556         if err := pcall(func() {
31557                 ((*(*(struct {
31558                         ParentID     AOID
31559                         Bone         string
31560                         Pos          Vec
31561                         Rot          [3]float32
31562                         ForceVisible bool
31563                 }))(obj)).Pos).serialize(w)
31564         }); err != nil {
31565                 if err == io.EOF {
31566                         chk(io.EOF)
31567                 }
31568                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31569         }
31570         for local370 := range (*(*(struct {
31571                 ParentID     AOID
31572                 Bone         string
31573                 Pos          Vec
31574                 Rot          [3]float32
31575                 ForceVisible bool
31576         }))(obj)).Rot {
31577                 {
31578                         x := ((*(*(struct {
31579                                 ParentID     AOID
31580                                 Bone         string
31581                                 Pos          Vec
31582                                 Rot          [3]float32
31583                                 ForceVisible bool
31584                         }))(obj)).Rot)[local370]
31585                         write32(w, math.Float32bits(x))
31586                 }
31587         }
31588         {
31589                 x := (*(*(struct {
31590                         ParentID     AOID
31591                         Bone         string
31592                         Pos          Vec
31593                         Rot          [3]float32
31594                         ForceVisible bool
31595                 }))(obj)).ForceVisible
31596                 if x {
31597                         write8(w, 1)
31598                 } else {
31599                         write8(w, 0)
31600                 }
31601
31602         }
31603 }
31604
31605 func (obj *AOAttach) deserialize(r io.Reader) {
31606         if err := pcall(func() {
31607                 ((*(*(struct {
31608                         ParentID     AOID
31609                         Bone         string
31610                         Pos          Vec
31611                         Rot          [3]float32
31612                         ForceVisible bool
31613                 }))(obj)).ParentID).deserialize(r)
31614         }); err != nil {
31615                 if err == io.EOF {
31616                         chk(io.EOF)
31617                 }
31618                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
31619         }
31620         var local371 []uint8
31621         var local372 uint16
31622         {
31623                 p := &local372
31624                 *p = read16(r)
31625         }
31626         (local371) = make([]uint8, local372)
31627         {
31628                 _, err := io.ReadFull(r, (local371)[:])
31629                 chk(err)
31630         }
31631         ((*(*(struct {
31632                 ParentID     AOID
31633                 Bone         string
31634                 Pos          Vec
31635                 Rot          [3]float32
31636                 ForceVisible bool
31637         }))(obj)).Bone) = string(local371)
31638         if err := pcall(func() {
31639                 ((*(*(struct {
31640                         ParentID     AOID
31641                         Bone         string
31642                         Pos          Vec
31643                         Rot          [3]float32
31644                         ForceVisible bool
31645                 }))(obj)).Pos).deserialize(r)
31646         }); err != nil {
31647                 if err == io.EOF {
31648                         chk(io.EOF)
31649                 }
31650                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31651         }
31652         for local373 := range (*(*(struct {
31653                 ParentID     AOID
31654                 Bone         string
31655                 Pos          Vec
31656                 Rot          [3]float32
31657                 ForceVisible bool
31658         }))(obj)).Rot {
31659                 {
31660                         p := &((*(*(struct {
31661                                 ParentID     AOID
31662                                 Bone         string
31663                                 Pos          Vec
31664                                 Rot          [3]float32
31665                                 ForceVisible bool
31666                         }))(obj)).Rot)[local373]
31667                         *p = math.Float32frombits(read32(r))
31668                 }
31669         }
31670         {
31671                 p := &(*(*(struct {
31672                         ParentID     AOID
31673                         Bone         string
31674                         Pos          Vec
31675                         Rot          [3]float32
31676                         ForceVisible bool
31677                 }))(obj)).ForceVisible
31678                 switch n := read8(r); n {
31679                 case 0:
31680                         *p = false
31681                 case 1:
31682                         *p = true
31683                 default:
31684                         chk(fmt.Errorf("invalid bool: %d", n))
31685                 }
31686
31687         }
31688 }
31689
31690 func (obj *AOPhysOverride) serialize(w io.Writer) {
31691         {
31692                 x := (*(*(struct {
31693                         Walk, Jump, Gravity float32
31694
31695                         // Player only.
31696                         NoSneak, NoSneakGlitch, OldSneak bool
31697                 }))(obj)).Walk
31698                 write32(w, math.Float32bits(x))
31699         }
31700         {
31701                 x := (*(*(struct {
31702                         Walk, Jump, Gravity float32
31703
31704                         // Player only.
31705                         NoSneak, NoSneakGlitch, OldSneak bool
31706                 }))(obj)).Jump
31707                 write32(w, math.Float32bits(x))
31708         }
31709         {
31710                 x := (*(*(struct {
31711                         Walk, Jump, Gravity float32
31712
31713                         // Player only.
31714                         NoSneak, NoSneakGlitch, OldSneak bool
31715                 }))(obj)).Gravity
31716                 write32(w, math.Float32bits(x))
31717         }
31718         {
31719                 x := (*(*(struct {
31720                         Walk, Jump, Gravity float32
31721
31722                         // Player only.
31723                         NoSneak, NoSneakGlitch, OldSneak bool
31724                 }))(obj)).NoSneak
31725                 if x {
31726                         write8(w, 1)
31727                 } else {
31728                         write8(w, 0)
31729                 }
31730
31731         }
31732         {
31733                 x := (*(*(struct {
31734                         Walk, Jump, Gravity float32
31735
31736                         // Player only.
31737                         NoSneak, NoSneakGlitch, OldSneak bool
31738                 }))(obj)).NoSneakGlitch
31739                 if x {
31740                         write8(w, 1)
31741                 } else {
31742                         write8(w, 0)
31743                 }
31744
31745         }
31746         {
31747                 x := (*(*(struct {
31748                         Walk, Jump, Gravity float32
31749
31750                         // Player only.
31751                         NoSneak, NoSneakGlitch, OldSneak bool
31752                 }))(obj)).OldSneak
31753                 if x {
31754                         write8(w, 1)
31755                 } else {
31756                         write8(w, 0)
31757                 }
31758
31759         }
31760 }
31761
31762 func (obj *AOPhysOverride) deserialize(r io.Reader) {
31763         {
31764                 p := &(*(*(struct {
31765                         Walk, Jump, Gravity float32
31766
31767                         // Player only.
31768                         NoSneak, NoSneakGlitch, OldSneak bool
31769                 }))(obj)).Walk
31770                 *p = math.Float32frombits(read32(r))
31771         }
31772         {
31773                 p := &(*(*(struct {
31774                         Walk, Jump, Gravity float32
31775
31776                         // Player only.
31777                         NoSneak, NoSneakGlitch, OldSneak bool
31778                 }))(obj)).Jump
31779                 *p = math.Float32frombits(read32(r))
31780         }
31781         {
31782                 p := &(*(*(struct {
31783                         Walk, Jump, Gravity float32
31784
31785                         // Player only.
31786                         NoSneak, NoSneakGlitch, OldSneak bool
31787                 }))(obj)).Gravity
31788                 *p = math.Float32frombits(read32(r))
31789         }
31790         {
31791                 p := &(*(*(struct {
31792                         Walk, Jump, Gravity float32
31793
31794                         // Player only.
31795                         NoSneak, NoSneakGlitch, OldSneak bool
31796                 }))(obj)).NoSneak
31797                 switch n := read8(r); n {
31798                 case 0:
31799                         *p = false
31800                 case 1:
31801                         *p = true
31802                 default:
31803                         chk(fmt.Errorf("invalid bool: %d", n))
31804                 }
31805
31806         }
31807         {
31808                 p := &(*(*(struct {
31809                         Walk, Jump, Gravity float32
31810
31811                         // Player only.
31812                         NoSneak, NoSneakGlitch, OldSneak bool
31813                 }))(obj)).NoSneakGlitch
31814                 switch n := read8(r); n {
31815                 case 0:
31816                         *p = false
31817                 case 1:
31818                         *p = true
31819                 default:
31820                         chk(fmt.Errorf("invalid bool: %d", n))
31821                 }
31822
31823         }
31824         {
31825                 p := &(*(*(struct {
31826                         Walk, Jump, Gravity float32
31827
31828                         // Player only.
31829                         NoSneak, NoSneakGlitch, OldSneak bool
31830                 }))(obj)).OldSneak
31831                 switch n := read8(r); n {
31832                 case 0:
31833                         *p = false
31834                 case 1:
31835                         *p = true
31836                 default:
31837                         chk(fmt.Errorf("invalid bool: %d", n))
31838                 }
31839
31840         }
31841 }
31842
31843 func (obj *aoType) serialize(w io.Writer) {
31844         {
31845                 x := *(*(uint8))(obj)
31846                 write8(w, uint8(x))
31847         }
31848 }
31849
31850 func (obj *aoType) deserialize(r io.Reader) {
31851         {
31852                 p := &*(*(uint8))(obj)
31853                 *p = read8(r)
31854         }
31855 }
31856
31857 func (obj *NodeMetaField) serialize(w io.Writer) {
31858         if err := pcall(func() {
31859                 ((*(*(struct {
31860                         Field
31861                         Private bool
31862                 }))(obj)).Field).serialize(w)
31863         }); err != nil {
31864                 if err == io.EOF {
31865                         chk(io.EOF)
31866                 }
31867                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
31868         }
31869         {
31870                 x := (*(*(struct {
31871                         Field
31872                         Private bool
31873                 }))(obj)).Private
31874                 if x {
31875                         write8(w, 1)
31876                 } else {
31877                         write8(w, 0)
31878                 }
31879
31880         }
31881 }
31882
31883 func (obj *NodeMetaField) deserialize(r io.Reader) {
31884         if err := pcall(func() {
31885                 ((*(*(struct {
31886                         Field
31887                         Private bool
31888                 }))(obj)).Field).deserialize(r)
31889         }); err != nil {
31890                 if err == io.EOF {
31891                         chk(io.EOF)
31892                 }
31893                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
31894         }
31895         {
31896                 p := &(*(*(struct {
31897                         Field
31898                         Private bool
31899                 }))(obj)).Private
31900                 switch n := read8(r); n {
31901                 case 0:
31902                         *p = false
31903                 case 1:
31904                         *p = true
31905                 default:
31906                         chk(fmt.Errorf("invalid bool: %d", n))
31907                 }
31908
31909         }
31910 }
31911
31912 func (obj *MinimapType) serialize(w io.Writer) {
31913         {
31914                 x := *(*(uint16))(obj)
31915                 write16(w, uint16(x))
31916         }
31917 }
31918
31919 func (obj *MinimapType) deserialize(r io.Reader) {
31920         {
31921                 p := &*(*(uint16))(obj)
31922                 *p = read16(r)
31923         }
31924 }
31925
31926 func (obj *Param1Type) serialize(w io.Writer) {
31927         {
31928                 x := *(*(uint8))(obj)
31929                 write8(w, uint8(x))
31930         }
31931 }
31932
31933 func (obj *Param1Type) deserialize(r io.Reader) {
31934         {
31935                 p := &*(*(uint8))(obj)
31936                 *p = read8(r)
31937         }
31938 }
31939
31940 func (obj *Param2Type) serialize(w io.Writer) {
31941         {
31942                 x := *(*(uint8))(obj)
31943                 write8(w, uint8(x))
31944         }
31945 }
31946
31947 func (obj *Param2Type) deserialize(r io.Reader) {
31948         {
31949                 p := &*(*(uint8))(obj)
31950                 *p = read8(r)
31951         }
31952 }
31953
31954 func (obj *DrawType) serialize(w io.Writer) {
31955         {
31956                 x := *(*(uint8))(obj)
31957                 write8(w, uint8(x))
31958         }
31959 }
31960
31961 func (obj *DrawType) deserialize(r io.Reader) {
31962         {
31963                 p := &*(*(uint8))(obj)
31964                 *p = read8(r)
31965         }
31966 }
31967
31968 func (obj *TileDef) serialize(w io.Writer) {
31969         {
31970                 local374 := uint8(6)
31971                 {
31972                         x := local374
31973                         write8(w, uint8(x))
31974                 }
31975         }
31976         if err := pcall(func() {
31977                 ((*(*(struct {
31978                         Texture
31979                         Anim  TileAnim
31980                         Flags TileFlags
31981
31982                         //mt:if %s.Flags&TileColor != 0
31983                         R, G, B uint8
31984
31985                         //mt:if %s.Flags&TileScale != 0
31986                         Scale uint8
31987
31988                         //mt:if %s.Flags&TileAlign != 0
31989                         Align AlignType
31990                 }))(obj)).Texture).serialize(w)
31991         }); err != nil {
31992                 if err == io.EOF {
31993                         chk(io.EOF)
31994                 }
31995                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
31996         }
31997         if err := pcall(func() {
31998                 ((*(*(struct {
31999                         Texture
32000                         Anim  TileAnim
32001                         Flags TileFlags
32002
32003                         //mt:if %s.Flags&TileColor != 0
32004                         R, G, B uint8
32005
32006                         //mt:if %s.Flags&TileScale != 0
32007                         Scale uint8
32008
32009                         //mt:if %s.Flags&TileAlign != 0
32010                         Align AlignType
32011                 }))(obj)).Anim).serialize(w)
32012         }); err != nil {
32013                 if err == io.EOF {
32014                         chk(io.EOF)
32015                 }
32016                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32017         }
32018         if err := pcall(func() {
32019                 ((*(*(struct {
32020                         Texture
32021                         Anim  TileAnim
32022                         Flags TileFlags
32023
32024                         //mt:if %s.Flags&TileColor != 0
32025                         R, G, B uint8
32026
32027                         //mt:if %s.Flags&TileScale != 0
32028                         Scale uint8
32029
32030                         //mt:if %s.Flags&TileAlign != 0
32031                         Align AlignType
32032                 }))(obj)).Flags).serialize(w)
32033         }); err != nil {
32034                 if err == io.EOF {
32035                         chk(io.EOF)
32036                 }
32037                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32038         }
32039         if (*(*(struct {
32040                 Texture
32041                 Anim  TileAnim
32042                 Flags TileFlags
32043
32044                 //mt:if %s.Flags&TileColor != 0
32045                 R, G, B uint8
32046
32047                 //mt:if %s.Flags&TileScale != 0
32048                 Scale uint8
32049
32050                 //mt:if %s.Flags&TileAlign != 0
32051                 Align AlignType
32052         }))(obj)).Flags&TileColor != 0 {
32053                 {
32054                         x := (*(*(struct {
32055                                 Texture
32056                                 Anim  TileAnim
32057                                 Flags TileFlags
32058
32059                                 //mt:if %s.Flags&TileColor != 0
32060                                 R, G, B uint8
32061
32062                                 //mt:if %s.Flags&TileScale != 0
32063                                 Scale uint8
32064
32065                                 //mt:if %s.Flags&TileAlign != 0
32066                                 Align AlignType
32067                         }))(obj)).R
32068                         write8(w, uint8(x))
32069                 }
32070                 {
32071                         x := (*(*(struct {
32072                                 Texture
32073                                 Anim  TileAnim
32074                                 Flags TileFlags
32075
32076                                 //mt:if %s.Flags&TileColor != 0
32077                                 R, G, B uint8
32078
32079                                 //mt:if %s.Flags&TileScale != 0
32080                                 Scale uint8
32081
32082                                 //mt:if %s.Flags&TileAlign != 0
32083                                 Align AlignType
32084                         }))(obj)).G
32085                         write8(w, uint8(x))
32086                 }
32087                 {
32088                         x := (*(*(struct {
32089                                 Texture
32090                                 Anim  TileAnim
32091                                 Flags TileFlags
32092
32093                                 //mt:if %s.Flags&TileColor != 0
32094                                 R, G, B uint8
32095
32096                                 //mt:if %s.Flags&TileScale != 0
32097                                 Scale uint8
32098
32099                                 //mt:if %s.Flags&TileAlign != 0
32100                                 Align AlignType
32101                         }))(obj)).B
32102                         write8(w, uint8(x))
32103                 }
32104         }
32105         if (*(*(struct {
32106                 Texture
32107                 Anim  TileAnim
32108                 Flags TileFlags
32109
32110                 //mt:if %s.Flags&TileColor != 0
32111                 R, G, B uint8
32112
32113                 //mt:if %s.Flags&TileScale != 0
32114                 Scale uint8
32115
32116                 //mt:if %s.Flags&TileAlign != 0
32117                 Align AlignType
32118         }))(obj)).Flags&TileScale != 0 {
32119                 {
32120                         x := (*(*(struct {
32121                                 Texture
32122                                 Anim  TileAnim
32123                                 Flags TileFlags
32124
32125                                 //mt:if %s.Flags&TileColor != 0
32126                                 R, G, B uint8
32127
32128                                 //mt:if %s.Flags&TileScale != 0
32129                                 Scale uint8
32130
32131                                 //mt:if %s.Flags&TileAlign != 0
32132                                 Align AlignType
32133                         }))(obj)).Scale
32134                         write8(w, uint8(x))
32135                 }
32136         }
32137         if (*(*(struct {
32138                 Texture
32139                 Anim  TileAnim
32140                 Flags TileFlags
32141
32142                 //mt:if %s.Flags&TileColor != 0
32143                 R, G, B uint8
32144
32145                 //mt:if %s.Flags&TileScale != 0
32146                 Scale uint8
32147
32148                 //mt:if %s.Flags&TileAlign != 0
32149                 Align AlignType
32150         }))(obj)).Flags&TileAlign != 0 {
32151                 if err := pcall(func() {
32152                         ((*(*(struct {
32153                                 Texture
32154                                 Anim  TileAnim
32155                                 Flags TileFlags
32156
32157                                 //mt:if %s.Flags&TileColor != 0
32158                                 R, G, B uint8
32159
32160                                 //mt:if %s.Flags&TileScale != 0
32161                                 Scale uint8
32162
32163                                 //mt:if %s.Flags&TileAlign != 0
32164                                 Align AlignType
32165                         }))(obj)).Align).serialize(w)
32166                 }); err != nil {
32167                         if err == io.EOF {
32168                                 chk(io.EOF)
32169                         }
32170                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32171                 }
32172         }
32173 }
32174
32175 func (obj *TileDef) deserialize(r io.Reader) {
32176         {
32177                 var local375 uint8
32178                 local376 := uint8(6)
32179                 {
32180                         p := &local375
32181                         *p = read8(r)
32182                 }
32183                 if local375 != local376 {
32184                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local375))
32185                 }
32186         }
32187         if err := pcall(func() {
32188                 ((*(*(struct {
32189                         Texture
32190                         Anim  TileAnim
32191                         Flags TileFlags
32192
32193                         //mt:if %s.Flags&TileColor != 0
32194                         R, G, B uint8
32195
32196                         //mt:if %s.Flags&TileScale != 0
32197                         Scale uint8
32198
32199                         //mt:if %s.Flags&TileAlign != 0
32200                         Align AlignType
32201                 }))(obj)).Texture).deserialize(r)
32202         }); err != nil {
32203                 if err == io.EOF {
32204                         chk(io.EOF)
32205                 }
32206                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
32207         }
32208         if err := pcall(func() {
32209                 ((*(*(struct {
32210                         Texture
32211                         Anim  TileAnim
32212                         Flags TileFlags
32213
32214                         //mt:if %s.Flags&TileColor != 0
32215                         R, G, B uint8
32216
32217                         //mt:if %s.Flags&TileScale != 0
32218                         Scale uint8
32219
32220                         //mt:if %s.Flags&TileAlign != 0
32221                         Align AlignType
32222                 }))(obj)).Anim).deserialize(r)
32223         }); err != nil {
32224                 if err == io.EOF {
32225                         chk(io.EOF)
32226                 }
32227                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32228         }
32229         if err := pcall(func() {
32230                 ((*(*(struct {
32231                         Texture
32232                         Anim  TileAnim
32233                         Flags TileFlags
32234
32235                         //mt:if %s.Flags&TileColor != 0
32236                         R, G, B uint8
32237
32238                         //mt:if %s.Flags&TileScale != 0
32239                         Scale uint8
32240
32241                         //mt:if %s.Flags&TileAlign != 0
32242                         Align AlignType
32243                 }))(obj)).Flags).deserialize(r)
32244         }); err != nil {
32245                 if err == io.EOF {
32246                         chk(io.EOF)
32247                 }
32248                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32249         }
32250         if (*(*(struct {
32251                 Texture
32252                 Anim  TileAnim
32253                 Flags TileFlags
32254
32255                 //mt:if %s.Flags&TileColor != 0
32256                 R, G, B uint8
32257
32258                 //mt:if %s.Flags&TileScale != 0
32259                 Scale uint8
32260
32261                 //mt:if %s.Flags&TileAlign != 0
32262                 Align AlignType
32263         }))(obj)).Flags&TileColor != 0 {
32264                 {
32265                         p := &(*(*(struct {
32266                                 Texture
32267                                 Anim  TileAnim
32268                                 Flags TileFlags
32269
32270                                 //mt:if %s.Flags&TileColor != 0
32271                                 R, G, B uint8
32272
32273                                 //mt:if %s.Flags&TileScale != 0
32274                                 Scale uint8
32275
32276                                 //mt:if %s.Flags&TileAlign != 0
32277                                 Align AlignType
32278                         }))(obj)).R
32279                         *p = read8(r)
32280                 }
32281                 {
32282                         p := &(*(*(struct {
32283                                 Texture
32284                                 Anim  TileAnim
32285                                 Flags TileFlags
32286
32287                                 //mt:if %s.Flags&TileColor != 0
32288                                 R, G, B uint8
32289
32290                                 //mt:if %s.Flags&TileScale != 0
32291                                 Scale uint8
32292
32293                                 //mt:if %s.Flags&TileAlign != 0
32294                                 Align AlignType
32295                         }))(obj)).G
32296                         *p = read8(r)
32297                 }
32298                 {
32299                         p := &(*(*(struct {
32300                                 Texture
32301                                 Anim  TileAnim
32302                                 Flags TileFlags
32303
32304                                 //mt:if %s.Flags&TileColor != 0
32305                                 R, G, B uint8
32306
32307                                 //mt:if %s.Flags&TileScale != 0
32308                                 Scale uint8
32309
32310                                 //mt:if %s.Flags&TileAlign != 0
32311                                 Align AlignType
32312                         }))(obj)).B
32313                         *p = read8(r)
32314                 }
32315         }
32316         if (*(*(struct {
32317                 Texture
32318                 Anim  TileAnim
32319                 Flags TileFlags
32320
32321                 //mt:if %s.Flags&TileColor != 0
32322                 R, G, B uint8
32323
32324                 //mt:if %s.Flags&TileScale != 0
32325                 Scale uint8
32326
32327                 //mt:if %s.Flags&TileAlign != 0
32328                 Align AlignType
32329         }))(obj)).Flags&TileScale != 0 {
32330                 {
32331                         p := &(*(*(struct {
32332                                 Texture
32333                                 Anim  TileAnim
32334                                 Flags TileFlags
32335
32336                                 //mt:if %s.Flags&TileColor != 0
32337                                 R, G, B uint8
32338
32339                                 //mt:if %s.Flags&TileScale != 0
32340                                 Scale uint8
32341
32342                                 //mt:if %s.Flags&TileAlign != 0
32343                                 Align AlignType
32344                         }))(obj)).Scale
32345                         *p = read8(r)
32346                 }
32347         }
32348         if (*(*(struct {
32349                 Texture
32350                 Anim  TileAnim
32351                 Flags TileFlags
32352
32353                 //mt:if %s.Flags&TileColor != 0
32354                 R, G, B uint8
32355
32356                 //mt:if %s.Flags&TileScale != 0
32357                 Scale uint8
32358
32359                 //mt:if %s.Flags&TileAlign != 0
32360                 Align AlignType
32361         }))(obj)).Flags&TileAlign != 0 {
32362                 if err := pcall(func() {
32363                         ((*(*(struct {
32364                                 Texture
32365                                 Anim  TileAnim
32366                                 Flags TileFlags
32367
32368                                 //mt:if %s.Flags&TileColor != 0
32369                                 R, G, B uint8
32370
32371                                 //mt:if %s.Flags&TileScale != 0
32372                                 Scale uint8
32373
32374                                 //mt:if %s.Flags&TileAlign != 0
32375                                 Align AlignType
32376                         }))(obj)).Align).deserialize(r)
32377                 }); err != nil {
32378                         if err == io.EOF {
32379                                 chk(io.EOF)
32380                         }
32381                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32382                 }
32383         }
32384 }
32385
32386 func (obj *WaveType) serialize(w io.Writer) {
32387         {
32388                 x := *(*(uint8))(obj)
32389                 write8(w, uint8(x))
32390         }
32391 }
32392
32393 func (obj *WaveType) deserialize(r io.Reader) {
32394         {
32395                 p := &*(*(uint8))(obj)
32396                 *p = read8(r)
32397         }
32398 }
32399
32400 func (obj *LiquidType) serialize(w io.Writer) {
32401         {
32402                 x := *(*(uint8))(obj)
32403                 write8(w, uint8(x))
32404         }
32405 }
32406
32407 func (obj *LiquidType) deserialize(r io.Reader) {
32408         {
32409                 p := &*(*(uint8))(obj)
32410                 *p = read8(r)
32411         }
32412 }
32413
32414 func (obj *NodeBox) serialize(w io.Writer) {
32415         {
32416                 local377 := uint8(6)
32417                 {
32418                         x := local377
32419                         write8(w, uint8(x))
32420                 }
32421         }
32422         if err := pcall(func() {
32423                 ((*(*(struct {
32424                         Type NodeBoxType
32425
32426                         //mt:if %s.Type == MountedBox
32427                         WallTop, WallBot, WallSides Box
32428
32429                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32430                         Fixed []Box
32431
32432                         //mt:if %s.Type == ConnectedBox
32433                         ConnDirs, DiscoDirs  DirBoxes
32434                         DiscoAll, DiscoSides []Box
32435                 }))(obj)).Type).serialize(w)
32436         }); err != nil {
32437                 if err == io.EOF {
32438                         chk(io.EOF)
32439                 }
32440                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
32441         }
32442         if !((*(*(struct {
32443                 Type NodeBoxType
32444
32445                 //mt:if %s.Type == MountedBox
32446                 WallTop, WallBot, WallSides Box
32447
32448                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32449                 Fixed []Box
32450
32451                 //mt:if %s.Type == ConnectedBox
32452                 ConnDirs, DiscoDirs  DirBoxes
32453                 DiscoAll, DiscoSides []Box
32454         }))(obj)).Type < maxBox) {
32455                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32456         }
32457         if (*(*(struct {
32458                 Type NodeBoxType
32459
32460                 //mt:if %s.Type == MountedBox
32461                 WallTop, WallBot, WallSides Box
32462
32463                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32464                 Fixed []Box
32465
32466                 //mt:if %s.Type == ConnectedBox
32467                 ConnDirs, DiscoDirs  DirBoxes
32468                 DiscoAll, DiscoSides []Box
32469         }))(obj)).Type == MountedBox {
32470                 if err := pcall(func() {
32471                         ((*(*(struct {
32472                                 Type NodeBoxType
32473
32474                                 //mt:if %s.Type == MountedBox
32475                                 WallTop, WallBot, WallSides Box
32476
32477                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32478                                 Fixed []Box
32479
32480                                 //mt:if %s.Type == ConnectedBox
32481                                 ConnDirs, DiscoDirs  DirBoxes
32482                                 DiscoAll, DiscoSides []Box
32483                         }))(obj)).WallTop).serialize(w)
32484                 }); err != nil {
32485                         if err == io.EOF {
32486                                 chk(io.EOF)
32487                         }
32488                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32489                 }
32490                 if err := pcall(func() {
32491                         ((*(*(struct {
32492                                 Type NodeBoxType
32493
32494                                 //mt:if %s.Type == MountedBox
32495                                 WallTop, WallBot, WallSides Box
32496
32497                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32498                                 Fixed []Box
32499
32500                                 //mt:if %s.Type == ConnectedBox
32501                                 ConnDirs, DiscoDirs  DirBoxes
32502                                 DiscoAll, DiscoSides []Box
32503                         }))(obj)).WallBot).serialize(w)
32504                 }); err != nil {
32505                         if err == io.EOF {
32506                                 chk(io.EOF)
32507                         }
32508                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32509                 }
32510                 if err := pcall(func() {
32511                         ((*(*(struct {
32512                                 Type NodeBoxType
32513
32514                                 //mt:if %s.Type == MountedBox
32515                                 WallTop, WallBot, WallSides Box
32516
32517                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32518                                 Fixed []Box
32519
32520                                 //mt:if %s.Type == ConnectedBox
32521                                 ConnDirs, DiscoDirs  DirBoxes
32522                                 DiscoAll, DiscoSides []Box
32523                         }))(obj)).WallSides).serialize(w)
32524                 }); err != nil {
32525                         if err == io.EOF {
32526                                 chk(io.EOF)
32527                         }
32528                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32529                 }
32530         }
32531         if t := (*(*(struct {
32532                 Type NodeBoxType
32533
32534                 //mt:if %s.Type == MountedBox
32535                 WallTop, WallBot, WallSides Box
32536
32537                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32538                 Fixed []Box
32539
32540                 //mt:if %s.Type == ConnectedBox
32541                 ConnDirs, DiscoDirs  DirBoxes
32542                 DiscoAll, DiscoSides []Box
32543         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32544                 if len(((*(*(struct {
32545                         Type NodeBoxType
32546
32547                         //mt:if %s.Type == MountedBox
32548                         WallTop, WallBot, WallSides Box
32549
32550                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32551                         Fixed []Box
32552
32553                         //mt:if %s.Type == ConnectedBox
32554                         ConnDirs, DiscoDirs  DirBoxes
32555                         DiscoAll, DiscoSides []Box
32556                 }))(obj)).Fixed)) > math.MaxUint16 {
32557                         chk(ErrTooLong)
32558                 }
32559                 {
32560                         x := uint16(len(((*(*(struct {
32561                                 Type NodeBoxType
32562
32563                                 //mt:if %s.Type == MountedBox
32564                                 WallTop, WallBot, WallSides Box
32565
32566                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32567                                 Fixed []Box
32568
32569                                 //mt:if %s.Type == ConnectedBox
32570                                 ConnDirs, DiscoDirs  DirBoxes
32571                                 DiscoAll, DiscoSides []Box
32572                         }))(obj)).Fixed)))
32573                         write16(w, uint16(x))
32574                 }
32575                 for local378 := range (*(*(struct {
32576                         Type NodeBoxType
32577
32578                         //mt:if %s.Type == MountedBox
32579                         WallTop, WallBot, WallSides Box
32580
32581                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32582                         Fixed []Box
32583
32584                         //mt:if %s.Type == ConnectedBox
32585                         ConnDirs, DiscoDirs  DirBoxes
32586                         DiscoAll, DiscoSides []Box
32587                 }))(obj)).Fixed {
32588                         if err := pcall(func() {
32589                                 (((*(*(struct {
32590                                         Type NodeBoxType
32591
32592                                         //mt:if %s.Type == MountedBox
32593                                         WallTop, WallBot, WallSides Box
32594
32595                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32596                                         Fixed []Box
32597
32598                                         //mt:if %s.Type == ConnectedBox
32599                                         ConnDirs, DiscoDirs  DirBoxes
32600                                         DiscoAll, DiscoSides []Box
32601                                 }))(obj)).Fixed)[local378]).serialize(w)
32602                         }); err != nil {
32603                                 if err == io.EOF {
32604                                         chk(io.EOF)
32605                                 }
32606                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32607                         }
32608                 }
32609         }
32610         if (*(*(struct {
32611                 Type NodeBoxType
32612
32613                 //mt:if %s.Type == MountedBox
32614                 WallTop, WallBot, WallSides Box
32615
32616                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32617                 Fixed []Box
32618
32619                 //mt:if %s.Type == ConnectedBox
32620                 ConnDirs, DiscoDirs  DirBoxes
32621                 DiscoAll, DiscoSides []Box
32622         }))(obj)).Type == ConnectedBox {
32623                 if err := pcall(func() {
32624                         ((*(*(struct {
32625                                 Type NodeBoxType
32626
32627                                 //mt:if %s.Type == MountedBox
32628                                 WallTop, WallBot, WallSides Box
32629
32630                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32631                                 Fixed []Box
32632
32633                                 //mt:if %s.Type == ConnectedBox
32634                                 ConnDirs, DiscoDirs  DirBoxes
32635                                 DiscoAll, DiscoSides []Box
32636                         }))(obj)).ConnDirs).serialize(w)
32637                 }); err != nil {
32638                         if err == io.EOF {
32639                                 chk(io.EOF)
32640                         }
32641                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32642                 }
32643                 if err := pcall(func() {
32644                         ((*(*(struct {
32645                                 Type NodeBoxType
32646
32647                                 //mt:if %s.Type == MountedBox
32648                                 WallTop, WallBot, WallSides Box
32649
32650                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32651                                 Fixed []Box
32652
32653                                 //mt:if %s.Type == ConnectedBox
32654                                 ConnDirs, DiscoDirs  DirBoxes
32655                                 DiscoAll, DiscoSides []Box
32656                         }))(obj)).DiscoDirs).serialize(w)
32657                 }); err != nil {
32658                         if err == io.EOF {
32659                                 chk(io.EOF)
32660                         }
32661                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32662                 }
32663                 if len(((*(*(struct {
32664                         Type NodeBoxType
32665
32666                         //mt:if %s.Type == MountedBox
32667                         WallTop, WallBot, WallSides Box
32668
32669                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32670                         Fixed []Box
32671
32672                         //mt:if %s.Type == ConnectedBox
32673                         ConnDirs, DiscoDirs  DirBoxes
32674                         DiscoAll, DiscoSides []Box
32675                 }))(obj)).DiscoAll)) > math.MaxUint16 {
32676                         chk(ErrTooLong)
32677                 }
32678                 {
32679                         x := uint16(len(((*(*(struct {
32680                                 Type NodeBoxType
32681
32682                                 //mt:if %s.Type == MountedBox
32683                                 WallTop, WallBot, WallSides Box
32684
32685                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32686                                 Fixed []Box
32687
32688                                 //mt:if %s.Type == ConnectedBox
32689                                 ConnDirs, DiscoDirs  DirBoxes
32690                                 DiscoAll, DiscoSides []Box
32691                         }))(obj)).DiscoAll)))
32692                         write16(w, uint16(x))
32693                 }
32694                 for local379 := range (*(*(struct {
32695                         Type NodeBoxType
32696
32697                         //mt:if %s.Type == MountedBox
32698                         WallTop, WallBot, WallSides Box
32699
32700                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32701                         Fixed []Box
32702
32703                         //mt:if %s.Type == ConnectedBox
32704                         ConnDirs, DiscoDirs  DirBoxes
32705                         DiscoAll, DiscoSides []Box
32706                 }))(obj)).DiscoAll {
32707                         if err := pcall(func() {
32708                                 (((*(*(struct {
32709                                         Type NodeBoxType
32710
32711                                         //mt:if %s.Type == MountedBox
32712                                         WallTop, WallBot, WallSides Box
32713
32714                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32715                                         Fixed []Box
32716
32717                                         //mt:if %s.Type == ConnectedBox
32718                                         ConnDirs, DiscoDirs  DirBoxes
32719                                         DiscoAll, DiscoSides []Box
32720                                 }))(obj)).DiscoAll)[local379]).serialize(w)
32721                         }); err != nil {
32722                                 if err == io.EOF {
32723                                         chk(io.EOF)
32724                                 }
32725                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32726                         }
32727                 }
32728                 if len(((*(*(struct {
32729                         Type NodeBoxType
32730
32731                         //mt:if %s.Type == MountedBox
32732                         WallTop, WallBot, WallSides Box
32733
32734                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32735                         Fixed []Box
32736
32737                         //mt:if %s.Type == ConnectedBox
32738                         ConnDirs, DiscoDirs  DirBoxes
32739                         DiscoAll, DiscoSides []Box
32740                 }))(obj)).DiscoSides)) > math.MaxUint16 {
32741                         chk(ErrTooLong)
32742                 }
32743                 {
32744                         x := uint16(len(((*(*(struct {
32745                                 Type NodeBoxType
32746
32747                                 //mt:if %s.Type == MountedBox
32748                                 WallTop, WallBot, WallSides Box
32749
32750                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32751                                 Fixed []Box
32752
32753                                 //mt:if %s.Type == ConnectedBox
32754                                 ConnDirs, DiscoDirs  DirBoxes
32755                                 DiscoAll, DiscoSides []Box
32756                         }))(obj)).DiscoSides)))
32757                         write16(w, uint16(x))
32758                 }
32759                 for local380 := range (*(*(struct {
32760                         Type NodeBoxType
32761
32762                         //mt:if %s.Type == MountedBox
32763                         WallTop, WallBot, WallSides Box
32764
32765                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32766                         Fixed []Box
32767
32768                         //mt:if %s.Type == ConnectedBox
32769                         ConnDirs, DiscoDirs  DirBoxes
32770                         DiscoAll, DiscoSides []Box
32771                 }))(obj)).DiscoSides {
32772                         if err := pcall(func() {
32773                                 (((*(*(struct {
32774                                         Type NodeBoxType
32775
32776                                         //mt:if %s.Type == MountedBox
32777                                         WallTop, WallBot, WallSides Box
32778
32779                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32780                                         Fixed []Box
32781
32782                                         //mt:if %s.Type == ConnectedBox
32783                                         ConnDirs, DiscoDirs  DirBoxes
32784                                         DiscoAll, DiscoSides []Box
32785                                 }))(obj)).DiscoSides)[local380]).serialize(w)
32786                         }); err != nil {
32787                                 if err == io.EOF {
32788                                         chk(io.EOF)
32789                                 }
32790                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32791                         }
32792                 }
32793         }
32794 }
32795
32796 func (obj *NodeBox) deserialize(r io.Reader) {
32797         {
32798                 var local381 uint8
32799                 local382 := uint8(6)
32800                 {
32801                         p := &local381
32802                         *p = read8(r)
32803                 }
32804                 if local381 != local382 {
32805                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local381))
32806                 }
32807         }
32808         if err := pcall(func() {
32809                 ((*(*(struct {
32810                         Type NodeBoxType
32811
32812                         //mt:if %s.Type == MountedBox
32813                         WallTop, WallBot, WallSides Box
32814
32815                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32816                         Fixed []Box
32817
32818                         //mt:if %s.Type == ConnectedBox
32819                         ConnDirs, DiscoDirs  DirBoxes
32820                         DiscoAll, DiscoSides []Box
32821                 }))(obj)).Type).deserialize(r)
32822         }); err != nil {
32823                 if err == io.EOF {
32824                         chk(io.EOF)
32825                 }
32826                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
32827         }
32828         if !((*(*(struct {
32829                 Type NodeBoxType
32830
32831                 //mt:if %s.Type == MountedBox
32832                 WallTop, WallBot, WallSides Box
32833
32834                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32835                 Fixed []Box
32836
32837                 //mt:if %s.Type == ConnectedBox
32838                 ConnDirs, DiscoDirs  DirBoxes
32839                 DiscoAll, DiscoSides []Box
32840         }))(obj)).Type < maxBox) {
32841                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32842         }
32843         if (*(*(struct {
32844                 Type NodeBoxType
32845
32846                 //mt:if %s.Type == MountedBox
32847                 WallTop, WallBot, WallSides Box
32848
32849                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32850                 Fixed []Box
32851
32852                 //mt:if %s.Type == ConnectedBox
32853                 ConnDirs, DiscoDirs  DirBoxes
32854                 DiscoAll, DiscoSides []Box
32855         }))(obj)).Type == MountedBox {
32856                 if err := pcall(func() {
32857                         ((*(*(struct {
32858                                 Type NodeBoxType
32859
32860                                 //mt:if %s.Type == MountedBox
32861                                 WallTop, WallBot, WallSides Box
32862
32863                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32864                                 Fixed []Box
32865
32866                                 //mt:if %s.Type == ConnectedBox
32867                                 ConnDirs, DiscoDirs  DirBoxes
32868                                 DiscoAll, DiscoSides []Box
32869                         }))(obj)).WallTop).deserialize(r)
32870                 }); err != nil {
32871                         if err == io.EOF {
32872                                 chk(io.EOF)
32873                         }
32874                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32875                 }
32876                 if err := pcall(func() {
32877                         ((*(*(struct {
32878                                 Type NodeBoxType
32879
32880                                 //mt:if %s.Type == MountedBox
32881                                 WallTop, WallBot, WallSides Box
32882
32883                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32884                                 Fixed []Box
32885
32886                                 //mt:if %s.Type == ConnectedBox
32887                                 ConnDirs, DiscoDirs  DirBoxes
32888                                 DiscoAll, DiscoSides []Box
32889                         }))(obj)).WallBot).deserialize(r)
32890                 }); err != nil {
32891                         if err == io.EOF {
32892                                 chk(io.EOF)
32893                         }
32894                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32895                 }
32896                 if err := pcall(func() {
32897                         ((*(*(struct {
32898                                 Type NodeBoxType
32899
32900                                 //mt:if %s.Type == MountedBox
32901                                 WallTop, WallBot, WallSides Box
32902
32903                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32904                                 Fixed []Box
32905
32906                                 //mt:if %s.Type == ConnectedBox
32907                                 ConnDirs, DiscoDirs  DirBoxes
32908                                 DiscoAll, DiscoSides []Box
32909                         }))(obj)).WallSides).deserialize(r)
32910                 }); err != nil {
32911                         if err == io.EOF {
32912                                 chk(io.EOF)
32913                         }
32914                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32915                 }
32916         }
32917         if t := (*(*(struct {
32918                 Type NodeBoxType
32919
32920                 //mt:if %s.Type == MountedBox
32921                 WallTop, WallBot, WallSides Box
32922
32923                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32924                 Fixed []Box
32925
32926                 //mt:if %s.Type == ConnectedBox
32927                 ConnDirs, DiscoDirs  DirBoxes
32928                 DiscoAll, DiscoSides []Box
32929         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32930                 var local383 uint16
32931                 {
32932                         p := &local383
32933                         *p = read16(r)
32934                 }
32935                 ((*(*(struct {
32936                         Type NodeBoxType
32937
32938                         //mt:if %s.Type == MountedBox
32939                         WallTop, WallBot, WallSides Box
32940
32941                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32942                         Fixed []Box
32943
32944                         //mt:if %s.Type == ConnectedBox
32945                         ConnDirs, DiscoDirs  DirBoxes
32946                         DiscoAll, DiscoSides []Box
32947                 }))(obj)).Fixed) = make([]Box, local383)
32948                 for local384 := range (*(*(struct {
32949                         Type NodeBoxType
32950
32951                         //mt:if %s.Type == MountedBox
32952                         WallTop, WallBot, WallSides Box
32953
32954                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32955                         Fixed []Box
32956
32957                         //mt:if %s.Type == ConnectedBox
32958                         ConnDirs, DiscoDirs  DirBoxes
32959                         DiscoAll, DiscoSides []Box
32960                 }))(obj)).Fixed {
32961                         if err := pcall(func() {
32962                                 (((*(*(struct {
32963                                         Type NodeBoxType
32964
32965                                         //mt:if %s.Type == MountedBox
32966                                         WallTop, WallBot, WallSides Box
32967
32968                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32969                                         Fixed []Box
32970
32971                                         //mt:if %s.Type == ConnectedBox
32972                                         ConnDirs, DiscoDirs  DirBoxes
32973                                         DiscoAll, DiscoSides []Box
32974                                 }))(obj)).Fixed)[local384]).deserialize(r)
32975                         }); err != nil {
32976                                 if err == io.EOF {
32977                                         chk(io.EOF)
32978                                 }
32979                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32980                         }
32981                 }
32982         }
32983         if (*(*(struct {
32984                 Type NodeBoxType
32985
32986                 //mt:if %s.Type == MountedBox
32987                 WallTop, WallBot, WallSides Box
32988
32989                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32990                 Fixed []Box
32991
32992                 //mt:if %s.Type == ConnectedBox
32993                 ConnDirs, DiscoDirs  DirBoxes
32994                 DiscoAll, DiscoSides []Box
32995         }))(obj)).Type == ConnectedBox {
32996                 if err := pcall(func() {
32997                         ((*(*(struct {
32998                                 Type NodeBoxType
32999
33000                                 //mt:if %s.Type == MountedBox
33001                                 WallTop, WallBot, WallSides Box
33002
33003                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33004                                 Fixed []Box
33005
33006                                 //mt:if %s.Type == ConnectedBox
33007                                 ConnDirs, DiscoDirs  DirBoxes
33008                                 DiscoAll, DiscoSides []Box
33009                         }))(obj)).ConnDirs).deserialize(r)
33010                 }); err != nil {
33011                         if err == io.EOF {
33012                                 chk(io.EOF)
33013                         }
33014                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33015                 }
33016                 if err := pcall(func() {
33017                         ((*(*(struct {
33018                                 Type NodeBoxType
33019
33020                                 //mt:if %s.Type == MountedBox
33021                                 WallTop, WallBot, WallSides Box
33022
33023                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33024                                 Fixed []Box
33025
33026                                 //mt:if %s.Type == ConnectedBox
33027                                 ConnDirs, DiscoDirs  DirBoxes
33028                                 DiscoAll, DiscoSides []Box
33029                         }))(obj)).DiscoDirs).deserialize(r)
33030                 }); err != nil {
33031                         if err == io.EOF {
33032                                 chk(io.EOF)
33033                         }
33034                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33035                 }
33036                 var local385 uint16
33037                 {
33038                         p := &local385
33039                         *p = read16(r)
33040                 }
33041                 ((*(*(struct {
33042                         Type NodeBoxType
33043
33044                         //mt:if %s.Type == MountedBox
33045                         WallTop, WallBot, WallSides Box
33046
33047                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33048                         Fixed []Box
33049
33050                         //mt:if %s.Type == ConnectedBox
33051                         ConnDirs, DiscoDirs  DirBoxes
33052                         DiscoAll, DiscoSides []Box
33053                 }))(obj)).DiscoAll) = make([]Box, local385)
33054                 for local386 := range (*(*(struct {
33055                         Type NodeBoxType
33056
33057                         //mt:if %s.Type == MountedBox
33058                         WallTop, WallBot, WallSides Box
33059
33060                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33061                         Fixed []Box
33062
33063                         //mt:if %s.Type == ConnectedBox
33064                         ConnDirs, DiscoDirs  DirBoxes
33065                         DiscoAll, DiscoSides []Box
33066                 }))(obj)).DiscoAll {
33067                         if err := pcall(func() {
33068                                 (((*(*(struct {
33069                                         Type NodeBoxType
33070
33071                                         //mt:if %s.Type == MountedBox
33072                                         WallTop, WallBot, WallSides Box
33073
33074                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33075                                         Fixed []Box
33076
33077                                         //mt:if %s.Type == ConnectedBox
33078                                         ConnDirs, DiscoDirs  DirBoxes
33079                                         DiscoAll, DiscoSides []Box
33080                                 }))(obj)).DiscoAll)[local386]).deserialize(r)
33081                         }); err != nil {
33082                                 if err == io.EOF {
33083                                         chk(io.EOF)
33084                                 }
33085                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33086                         }
33087                 }
33088                 var local387 uint16
33089                 {
33090                         p := &local387
33091                         *p = read16(r)
33092                 }
33093                 ((*(*(struct {
33094                         Type NodeBoxType
33095
33096                         //mt:if %s.Type == MountedBox
33097                         WallTop, WallBot, WallSides Box
33098
33099                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33100                         Fixed []Box
33101
33102                         //mt:if %s.Type == ConnectedBox
33103                         ConnDirs, DiscoDirs  DirBoxes
33104                         DiscoAll, DiscoSides []Box
33105                 }))(obj)).DiscoSides) = make([]Box, local387)
33106                 for local388 := range (*(*(struct {
33107                         Type NodeBoxType
33108
33109                         //mt:if %s.Type == MountedBox
33110                         WallTop, WallBot, WallSides Box
33111
33112                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33113                         Fixed []Box
33114
33115                         //mt:if %s.Type == ConnectedBox
33116                         ConnDirs, DiscoDirs  DirBoxes
33117                         DiscoAll, DiscoSides []Box
33118                 }))(obj)).DiscoSides {
33119                         if err := pcall(func() {
33120                                 (((*(*(struct {
33121                                         Type NodeBoxType
33122
33123                                         //mt:if %s.Type == MountedBox
33124                                         WallTop, WallBot, WallSides Box
33125
33126                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33127                                         Fixed []Box
33128
33129                                         //mt:if %s.Type == ConnectedBox
33130                                         ConnDirs, DiscoDirs  DirBoxes
33131                                         DiscoAll, DiscoSides []Box
33132                                 }))(obj)).DiscoSides)[local388]).deserialize(r)
33133                         }); err != nil {
33134                                 if err == io.EOF {
33135                                         chk(io.EOF)
33136                                 }
33137                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33138                         }
33139                 }
33140         }
33141 }
33142
33143 func (obj *SoundDef) serialize(w io.Writer) {
33144         if len(([]byte((*(*(struct {
33145                 Name              string
33146                 Gain, Pitch, Fade float32
33147         }))(obj)).Name))) > math.MaxUint16 {
33148                 chk(ErrTooLong)
33149         }
33150         {
33151                 x := uint16(len(([]byte((*(*(struct {
33152                         Name              string
33153                         Gain, Pitch, Fade float32
33154                 }))(obj)).Name))))
33155                 write16(w, uint16(x))
33156         }
33157         {
33158                 _, err := w.Write(([]byte((*(*(struct {
33159                         Name              string
33160                         Gain, Pitch, Fade float32
33161                 }))(obj)).Name))[:])
33162                 chk(err)
33163         }
33164         {
33165                 x := (*(*(struct {
33166                         Name              string
33167                         Gain, Pitch, Fade float32
33168                 }))(obj)).Gain
33169                 write32(w, math.Float32bits(x))
33170         }
33171         {
33172                 x := (*(*(struct {
33173                         Name              string
33174                         Gain, Pitch, Fade float32
33175                 }))(obj)).Pitch
33176                 write32(w, math.Float32bits(x))
33177         }
33178         {
33179                 x := (*(*(struct {
33180                         Name              string
33181                         Gain, Pitch, Fade float32
33182                 }))(obj)).Fade
33183                 write32(w, math.Float32bits(x))
33184         }
33185 }
33186
33187 func (obj *SoundDef) deserialize(r io.Reader) {
33188         var local389 []uint8
33189         var local390 uint16
33190         {
33191                 p := &local390
33192                 *p = read16(r)
33193         }
33194         (local389) = make([]uint8, local390)
33195         {
33196                 _, err := io.ReadFull(r, (local389)[:])
33197                 chk(err)
33198         }
33199         ((*(*(struct {
33200                 Name              string
33201                 Gain, Pitch, Fade float32
33202         }))(obj)).Name) = string(local389)
33203         {
33204                 p := &(*(*(struct {
33205                         Name              string
33206                         Gain, Pitch, Fade float32
33207                 }))(obj)).Gain
33208                 *p = math.Float32frombits(read32(r))
33209         }
33210         {
33211                 p := &(*(*(struct {
33212                         Name              string
33213                         Gain, Pitch, Fade float32
33214                 }))(obj)).Pitch
33215                 *p = math.Float32frombits(read32(r))
33216         }
33217         {
33218                 p := &(*(*(struct {
33219                         Name              string
33220                         Gain, Pitch, Fade float32
33221                 }))(obj)).Fade
33222                 *p = math.Float32frombits(read32(r))
33223         }
33224 }
33225
33226 func (obj *AlphaUse) serialize(w io.Writer) {
33227         {
33228                 x := *(*(uint8))(obj)
33229                 write8(w, uint8(x))
33230         }
33231 }
33232
33233 func (obj *AlphaUse) deserialize(r io.Reader) {
33234         {
33235                 p := &*(*(uint8))(obj)
33236                 *p = read8(r)
33237         }
33238 }
33239
33240 func (obj *Keys) serialize(w io.Writer) {
33241         {
33242                 x := *(*(uint32))(obj)
33243                 write32(w, uint32(x))
33244         }
33245 }
33246
33247 func (obj *Keys) deserialize(r io.Reader) {
33248         {
33249                 p := &*(*(uint32))(obj)
33250                 *p = read32(r)
33251         }
33252 }
33253
33254 func (obj *MapBlkFlags) serialize(w io.Writer) {
33255         {
33256                 x := *(*(uint8))(obj)
33257                 write8(w, uint8(x))
33258         }
33259 }
33260
33261 func (obj *MapBlkFlags) deserialize(r io.Reader) {
33262         {
33263                 p := &*(*(uint8))(obj)
33264                 *p = read8(r)
33265         }
33266 }
33267
33268 func (obj *LitFromBlks) serialize(w io.Writer) {
33269         {
33270                 x := *(*(uint16))(obj)
33271                 write16(w, uint16(x))
33272         }
33273 }
33274
33275 func (obj *LitFromBlks) deserialize(r io.Reader) {
33276         {
33277                 p := &*(*(uint16))(obj)
33278                 *p = read16(r)
33279         }
33280 }
33281
33282 func (obj *AOInitData) serialize(w io.Writer) {
33283         {
33284                 local391 := uint8(1)
33285                 {
33286                         x := local391
33287                         write8(w, uint8(x))
33288                 }
33289         }
33290         if len(([]byte((*(*(struct {
33291
33292                 // For players.
33293                 Name     string
33294                 IsPlayer bool
33295
33296                 ID AOID
33297
33298                 Pos
33299                 Rot [3]float32
33300
33301                 HP uint16
33302
33303                 // See (de)serialize.fmt.
33304                 Msgs []AOMsg
33305         }))(obj)).Name))) > math.MaxUint16 {
33306                 chk(ErrTooLong)
33307         }
33308         {
33309                 x := uint16(len(([]byte((*(*(struct {
33310
33311                         // For players.
33312                         Name     string
33313                         IsPlayer bool
33314
33315                         ID AOID
33316
33317                         Pos
33318                         Rot [3]float32
33319
33320                         HP uint16
33321
33322                         // See (de)serialize.fmt.
33323                         Msgs []AOMsg
33324                 }))(obj)).Name))))
33325                 write16(w, uint16(x))
33326         }
33327         {
33328                 _, err := w.Write(([]byte((*(*(struct {
33329
33330                         // For players.
33331                         Name     string
33332                         IsPlayer bool
33333
33334                         ID AOID
33335
33336                         Pos
33337                         Rot [3]float32
33338
33339                         HP uint16
33340
33341                         // See (de)serialize.fmt.
33342                         Msgs []AOMsg
33343                 }))(obj)).Name))[:])
33344                 chk(err)
33345         }
33346         {
33347                 x := (*(*(struct {
33348
33349                         // For players.
33350                         Name     string
33351                         IsPlayer bool
33352
33353                         ID AOID
33354
33355                         Pos
33356                         Rot [3]float32
33357
33358                         HP uint16
33359
33360                         // See (de)serialize.fmt.
33361                         Msgs []AOMsg
33362                 }))(obj)).IsPlayer
33363                 if x {
33364                         write8(w, 1)
33365                 } else {
33366                         write8(w, 0)
33367                 }
33368
33369         }
33370         if err := pcall(func() {
33371                 ((*(*(struct {
33372
33373                         // For players.
33374                         Name     string
33375                         IsPlayer bool
33376
33377                         ID AOID
33378
33379                         Pos
33380                         Rot [3]float32
33381
33382                         HP uint16
33383
33384                         // See (de)serialize.fmt.
33385                         Msgs []AOMsg
33386                 }))(obj)).ID).serialize(w)
33387         }); err != nil {
33388                 if err == io.EOF {
33389                         chk(io.EOF)
33390                 }
33391                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
33392         }
33393         if err := pcall(func() {
33394                 ((*(*(struct {
33395
33396                         // For players.
33397                         Name     string
33398                         IsPlayer bool
33399
33400                         ID AOID
33401
33402                         Pos
33403                         Rot [3]float32
33404
33405                         HP uint16
33406
33407                         // See (de)serialize.fmt.
33408                         Msgs []AOMsg
33409                 }))(obj)).Pos).serialize(w)
33410         }); err != nil {
33411                 if err == io.EOF {
33412                         chk(io.EOF)
33413                 }
33414                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
33415         }
33416         for local392 := range (*(*(struct {
33417
33418                 // For players.
33419                 Name     string
33420                 IsPlayer bool
33421
33422                 ID AOID
33423
33424                 Pos
33425                 Rot [3]float32
33426
33427                 HP uint16
33428
33429                 // See (de)serialize.fmt.
33430                 Msgs []AOMsg
33431         }))(obj)).Rot {
33432                 {
33433                         x := ((*(*(struct {
33434
33435                                 // For players.
33436                                 Name     string
33437                                 IsPlayer bool
33438
33439                                 ID AOID
33440
33441                                 Pos
33442                                 Rot [3]float32
33443
33444                                 HP uint16
33445
33446                                 // See (de)serialize.fmt.
33447                                 Msgs []AOMsg
33448                         }))(obj)).Rot)[local392]
33449                         write32(w, math.Float32bits(x))
33450                 }
33451         }
33452         {
33453                 x := (*(*(struct {
33454
33455                         // For players.
33456                         Name     string
33457                         IsPlayer bool
33458
33459                         ID AOID
33460
33461                         Pos
33462                         Rot [3]float32
33463
33464                         HP uint16
33465
33466                         // See (de)serialize.fmt.
33467                         Msgs []AOMsg
33468                 }))(obj)).HP
33469                 write16(w, uint16(x))
33470         }
33471         {
33472                 x := (*(*(struct {
33473
33474                         // For players.
33475                         Name     string
33476                         IsPlayer bool
33477
33478                         ID AOID
33479
33480                         Pos
33481                         Rot [3]float32
33482
33483                         HP uint16
33484
33485                         // See (de)serialize.fmt.
33486                         Msgs []AOMsg
33487                 }))(obj)).Msgs
33488                 { // For AOInitData.Msgs.
33489                         if len(x) > math.MaxUint8 {
33490                                 chk(ErrTooLong)
33491                         }
33492                         write8(w, uint8(len(x)))
33493                         for _, msg := range x {
33494                                 var b bytes.Buffer
33495                                 chk(writeAOMsg(&b, msg))
33496                                 if b.Len() > math.MaxUint32 {
33497                                         chk(ErrTooLong)
33498                                 }
33499                                 write32(w, uint32(b.Len()))
33500                                 _, err := b.WriteTo(w)
33501                                 chk(err)
33502                         }
33503                 }
33504
33505         }
33506 }
33507
33508 func (obj *AOInitData) deserialize(r io.Reader) {
33509         {
33510                 var local393 uint8
33511                 local394 := uint8(1)
33512                 {
33513                         p := &local393
33514                         *p = read8(r)
33515                 }
33516                 if local393 != local394 {
33517                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local393))
33518                 }
33519         }
33520         var local395 []uint8
33521         var local396 uint16
33522         {
33523                 p := &local396
33524                 *p = read16(r)
33525         }
33526         (local395) = make([]uint8, local396)
33527         {
33528                 _, err := io.ReadFull(r, (local395)[:])
33529                 chk(err)
33530         }
33531         ((*(*(struct {
33532
33533                 // For players.
33534                 Name     string
33535                 IsPlayer bool
33536
33537                 ID AOID
33538
33539                 Pos
33540                 Rot [3]float32
33541
33542                 HP uint16
33543
33544                 // See (de)serialize.fmt.
33545                 Msgs []AOMsg
33546         }))(obj)).Name) = string(local395)
33547         {
33548                 p := &(*(*(struct {
33549
33550                         // For players.
33551                         Name     string
33552                         IsPlayer bool
33553
33554                         ID AOID
33555
33556                         Pos
33557                         Rot [3]float32
33558
33559                         HP uint16
33560
33561                         // See (de)serialize.fmt.
33562                         Msgs []AOMsg
33563                 }))(obj)).IsPlayer
33564                 switch n := read8(r); n {
33565                 case 0:
33566                         *p = false
33567                 case 1:
33568                         *p = true
33569                 default:
33570                         chk(fmt.Errorf("invalid bool: %d", n))
33571                 }
33572
33573         }
33574         if err := pcall(func() {
33575                 ((*(*(struct {
33576
33577                         // For players.
33578                         Name     string
33579                         IsPlayer bool
33580
33581                         ID AOID
33582
33583                         Pos
33584                         Rot [3]float32
33585
33586                         HP uint16
33587
33588                         // See (de)serialize.fmt.
33589                         Msgs []AOMsg
33590                 }))(obj)).ID).deserialize(r)
33591         }); err != nil {
33592                 if err == io.EOF {
33593                         chk(io.EOF)
33594                 }
33595                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
33596         }
33597         if err := pcall(func() {
33598                 ((*(*(struct {
33599
33600                         // For players.
33601                         Name     string
33602                         IsPlayer bool
33603
33604                         ID AOID
33605
33606                         Pos
33607                         Rot [3]float32
33608
33609                         HP uint16
33610
33611                         // See (de)serialize.fmt.
33612                         Msgs []AOMsg
33613                 }))(obj)).Pos).deserialize(r)
33614         }); err != nil {
33615                 if err == io.EOF {
33616                         chk(io.EOF)
33617                 }
33618                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
33619         }
33620         for local397 := range (*(*(struct {
33621
33622                 // For players.
33623                 Name     string
33624                 IsPlayer bool
33625
33626                 ID AOID
33627
33628                 Pos
33629                 Rot [3]float32
33630
33631                 HP uint16
33632
33633                 // See (de)serialize.fmt.
33634                 Msgs []AOMsg
33635         }))(obj)).Rot {
33636                 {
33637                         p := &((*(*(struct {
33638
33639                                 // For players.
33640                                 Name     string
33641                                 IsPlayer bool
33642
33643                                 ID AOID
33644
33645                                 Pos
33646                                 Rot [3]float32
33647
33648                                 HP uint16
33649
33650                                 // See (de)serialize.fmt.
33651                                 Msgs []AOMsg
33652                         }))(obj)).Rot)[local397]
33653                         *p = math.Float32frombits(read32(r))
33654                 }
33655         }
33656         {
33657                 p := &(*(*(struct {
33658
33659                         // For players.
33660                         Name     string
33661                         IsPlayer bool
33662
33663                         ID AOID
33664
33665                         Pos
33666                         Rot [3]float32
33667
33668                         HP uint16
33669
33670                         // See (de)serialize.fmt.
33671                         Msgs []AOMsg
33672                 }))(obj)).HP
33673                 *p = read16(r)
33674         }
33675         {
33676                 p := &(*(*(struct {
33677
33678                         // For players.
33679                         Name     string
33680                         IsPlayer bool
33681
33682                         ID AOID
33683
33684                         Pos
33685                         Rot [3]float32
33686
33687                         HP uint16
33688
33689                         // See (de)serialize.fmt.
33690                         Msgs []AOMsg
33691                 }))(obj)).Msgs
33692                 { // For AOInitData.Msgs.
33693                         *p = make([]AOMsg, read8(r))
33694                         for i := range *p {
33695                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
33696                                 msg, err := readAOMsg(r)
33697                                 chk(err)
33698                                 (*p)[i] = msg
33699                                 if r.N > 0 {
33700                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
33701                                 }
33702                         }
33703                 }
33704
33705         }
33706 }
33707
33708 func (obj *ItemType) serialize(w io.Writer) {
33709         {
33710                 x := *(*(uint8))(obj)
33711                 write8(w, uint8(x))
33712         }
33713 }
33714
33715 func (obj *ItemType) deserialize(r io.Reader) {
33716         {
33717                 p := &*(*(uint8))(obj)
33718                 *p = read8(r)
33719         }
33720 }
33721
33722 func (obj *ToolCaps) serialize(w io.Writer) {
33723         if _ = (*(*(struct {
33724                 //mt:if _ = %s; false
33725                 NonNil bool
33726
33727                 AttackCooldown float32
33728                 MaxDropLvl     int16
33729
33730                 //mt:len32
33731                 GroupCaps []ToolGroupCap
33732
33733                 //mt:len32
33734                 DmgGroups []Group
33735
33736                 //mt:32tou16
33737                 PunchUses int32
33738         }))(obj)); false {
33739                 {
33740                         x := (*(*(struct {
33741                                 //mt:if _ = %s; false
33742                                 NonNil bool
33743
33744                                 AttackCooldown float32
33745                                 MaxDropLvl     int16
33746
33747                                 //mt:len32
33748                                 GroupCaps []ToolGroupCap
33749
33750                                 //mt:len32
33751                                 DmgGroups []Group
33752
33753                                 //mt:32tou16
33754                                 PunchUses int32
33755                         }))(obj)).NonNil
33756                         if x {
33757                                 write8(w, 1)
33758                         } else {
33759                                 write8(w, 0)
33760                         }
33761
33762                 }
33763         }
33764         {
33765                 ow := w
33766                 w := new(bytes.Buffer)
33767                 /*
33768                    if r.N > 0 { (*(*(struct {
33769                         //mt:if _ = %s; false
33770                         NonNil  bool
33771
33772                         AttackCooldown  float32
33773                         MaxDropLvl      int16
33774
33775                         //mt:len32
33776                         GroupCaps       []ToolGroupCap
33777
33778                         //mt:len32
33779                         DmgGroups       []Group
33780
33781                         //mt:32tou16
33782                         PunchUses       int32
33783                    }))(obj)).NonNil = true}; /**/{
33784                         if (*(*(struct {
33785                                 //mt:if _ = %s; false
33786                                 NonNil bool
33787
33788                                 AttackCooldown float32
33789                                 MaxDropLvl     int16
33790
33791                                 //mt:len32
33792                                 GroupCaps []ToolGroupCap
33793
33794                                 //mt:len32
33795                                 DmgGroups []Group
33796
33797                                 //mt:32tou16
33798                                 PunchUses int32
33799                         }))(obj)).NonNil {
33800                                 {
33801                                         local398 := uint8(5)
33802                                         {
33803                                                 x := local398
33804                                                 write8(w, uint8(x))
33805                                         }
33806                                 }
33807                                 {
33808                                         x := (*(*(struct {
33809                                                 //mt:if _ = %s; false
33810                                                 NonNil bool
33811
33812                                                 AttackCooldown float32
33813                                                 MaxDropLvl     int16
33814
33815                                                 //mt:len32
33816                                                 GroupCaps []ToolGroupCap
33817
33818                                                 //mt:len32
33819                                                 DmgGroups []Group
33820
33821                                                 //mt:32tou16
33822                                                 PunchUses int32
33823                                         }))(obj)).AttackCooldown
33824                                         write32(w, math.Float32bits(x))
33825                                 }
33826                                 {
33827                                         x := (*(*(struct {
33828                                                 //mt:if _ = %s; false
33829                                                 NonNil bool
33830
33831                                                 AttackCooldown float32
33832                                                 MaxDropLvl     int16
33833
33834                                                 //mt:len32
33835                                                 GroupCaps []ToolGroupCap
33836
33837                                                 //mt:len32
33838                                                 DmgGroups []Group
33839
33840                                                 //mt:32tou16
33841                                                 PunchUses int32
33842                                         }))(obj)).MaxDropLvl
33843                                         write16(w, uint16(x))
33844                                 }
33845                                 if len(((*(*(struct {
33846                                         //mt:if _ = %s; false
33847                                         NonNil bool
33848
33849                                         AttackCooldown float32
33850                                         MaxDropLvl     int16
33851
33852                                         //mt:len32
33853                                         GroupCaps []ToolGroupCap
33854
33855                                         //mt:len32
33856                                         DmgGroups []Group
33857
33858                                         //mt:32tou16
33859                                         PunchUses int32
33860                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
33861                                         chk(ErrTooLong)
33862                                 }
33863                                 {
33864                                         x := uint32(len(((*(*(struct {
33865                                                 //mt:if _ = %s; false
33866                                                 NonNil bool
33867
33868                                                 AttackCooldown float32
33869                                                 MaxDropLvl     int16
33870
33871                                                 //mt:len32
33872                                                 GroupCaps []ToolGroupCap
33873
33874                                                 //mt:len32
33875                                                 DmgGroups []Group
33876
33877                                                 //mt:32tou16
33878                                                 PunchUses int32
33879                                         }))(obj)).GroupCaps)))
33880                                         write32(w, uint32(x))
33881                                 }
33882                                 for local399 := range (*(*(struct {
33883                                         //mt:if _ = %s; false
33884                                         NonNil bool
33885
33886                                         AttackCooldown float32
33887                                         MaxDropLvl     int16
33888
33889                                         //mt:len32
33890                                         GroupCaps []ToolGroupCap
33891
33892                                         //mt:len32
33893                                         DmgGroups []Group
33894
33895                                         //mt:32tou16
33896                                         PunchUses int32
33897                                 }))(obj)).GroupCaps {
33898                                         if err := pcall(func() {
33899                                                 (((*(*(struct {
33900                                                         //mt:if _ = %s; false
33901                                                         NonNil bool
33902
33903                                                         AttackCooldown float32
33904                                                         MaxDropLvl     int16
33905
33906                                                         //mt:len32
33907                                                         GroupCaps []ToolGroupCap
33908
33909                                                         //mt:len32
33910                                                         DmgGroups []Group
33911
33912                                                         //mt:32tou16
33913                                                         PunchUses int32
33914                                                 }))(obj)).GroupCaps)[local399]).serialize(w)
33915                                         }); err != nil {
33916                                                 if err == io.EOF {
33917                                                         chk(io.EOF)
33918                                                 }
33919                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
33920                                         }
33921                                 }
33922                                 if len(((*(*(struct {
33923                                         //mt:if _ = %s; false
33924                                         NonNil bool
33925
33926                                         AttackCooldown float32
33927                                         MaxDropLvl     int16
33928
33929                                         //mt:len32
33930                                         GroupCaps []ToolGroupCap
33931
33932                                         //mt:len32
33933                                         DmgGroups []Group
33934
33935                                         //mt:32tou16
33936                                         PunchUses int32
33937                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
33938                                         chk(ErrTooLong)
33939                                 }
33940                                 {
33941                                         x := uint32(len(((*(*(struct {
33942                                                 //mt:if _ = %s; false
33943                                                 NonNil bool
33944
33945                                                 AttackCooldown float32
33946                                                 MaxDropLvl     int16
33947
33948                                                 //mt:len32
33949                                                 GroupCaps []ToolGroupCap
33950
33951                                                 //mt:len32
33952                                                 DmgGroups []Group
33953
33954                                                 //mt:32tou16
33955                                                 PunchUses int32
33956                                         }))(obj)).DmgGroups)))
33957                                         write32(w, uint32(x))
33958                                 }
33959                                 for local400 := range (*(*(struct {
33960                                         //mt:if _ = %s; false
33961                                         NonNil bool
33962
33963                                         AttackCooldown float32
33964                                         MaxDropLvl     int16
33965
33966                                         //mt:len32
33967                                         GroupCaps []ToolGroupCap
33968
33969                                         //mt:len32
33970                                         DmgGroups []Group
33971
33972                                         //mt:32tou16
33973                                         PunchUses int32
33974                                 }))(obj)).DmgGroups {
33975                                         if err := pcall(func() {
33976                                                 (((*(*(struct {
33977                                                         //mt:if _ = %s; false
33978                                                         NonNil bool
33979
33980                                                         AttackCooldown float32
33981                                                         MaxDropLvl     int16
33982
33983                                                         //mt:len32
33984                                                         GroupCaps []ToolGroupCap
33985
33986                                                         //mt:len32
33987                                                         DmgGroups []Group
33988
33989                                                         //mt:32tou16
33990                                                         PunchUses int32
33991                                                 }))(obj)).DmgGroups)[local400]).serialize(w)
33992                                         }); err != nil {
33993                                                 if err == io.EOF {
33994                                                         chk(io.EOF)
33995                                                 }
33996                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
33997                                         }
33998                                 }
33999                                 {
34000                                         x := uint16((*(*(struct {
34001                                                 //mt:if _ = %s; false
34002                                                 NonNil bool
34003
34004                                                 AttackCooldown float32
34005                                                 MaxDropLvl     int16
34006
34007                                                 //mt:len32
34008                                                 GroupCaps []ToolGroupCap
34009
34010                                                 //mt:len32
34011                                                 DmgGroups []Group
34012
34013                                                 //mt:32tou16
34014                                                 PunchUses int32
34015                                         }))(obj)).PunchUses)
34016                                         write16(w, uint16(x))
34017                                 }
34018                         }
34019                 }
34020                 {
34021                         buf := w
34022                         w := ow
34023                         if len((buf.Bytes())) > math.MaxUint16 {
34024                                 chk(ErrTooLong)
34025                         }
34026                         {
34027                                 x := uint16(len((buf.Bytes())))
34028                                 write16(w, uint16(x))
34029                         }
34030                         {
34031                                 _, err := w.Write((buf.Bytes())[:])
34032                                 chk(err)
34033                         }
34034                 }
34035         }
34036 }
34037
34038 func (obj *ToolCaps) deserialize(r io.Reader) {
34039         if _ = (*(*(struct {
34040                 //mt:if _ = %s; false
34041                 NonNil bool
34042
34043                 AttackCooldown float32
34044                 MaxDropLvl     int16
34045
34046                 //mt:len32
34047                 GroupCaps []ToolGroupCap
34048
34049                 //mt:len32
34050                 DmgGroups []Group
34051
34052                 //mt:32tou16
34053                 PunchUses int32
34054         }))(obj)); false {
34055                 {
34056                         p := &(*(*(struct {
34057                                 //mt:if _ = %s; false
34058                                 NonNil bool
34059
34060                                 AttackCooldown float32
34061                                 MaxDropLvl     int16
34062
34063                                 //mt:len32
34064                                 GroupCaps []ToolGroupCap
34065
34066                                 //mt:len32
34067                                 DmgGroups []Group
34068
34069                                 //mt:32tou16
34070                                 PunchUses int32
34071                         }))(obj)).NonNil
34072                         switch n := read8(r); n {
34073                         case 0:
34074                                 *p = false
34075                         case 1:
34076                                 *p = true
34077                         default:
34078                                 chk(fmt.Errorf("invalid bool: %d", n))
34079                         }
34080
34081                 }
34082         }
34083         {
34084                 var n uint16
34085                 {
34086                         p := &n
34087                         *p = read16(r)
34088                 }
34089                 r := &io.LimitedReader{R: r, N: int64(n)}
34090                 if r.N > 0 {
34091                         (*(*(struct {
34092                                 //mt:if _ = %s; false
34093                                 NonNil bool
34094
34095                                 AttackCooldown float32
34096                                 MaxDropLvl     int16
34097
34098                                 //mt:len32
34099                                 GroupCaps []ToolGroupCap
34100
34101                                 //mt:len32
34102                                 DmgGroups []Group
34103
34104                                 //mt:32tou16
34105                                 PunchUses int32
34106                         }))(obj)).NonNil = true
34107                 } /**/
34108                 {
34109                         if (*(*(struct {
34110                                 //mt:if _ = %s; false
34111                                 NonNil bool
34112
34113                                 AttackCooldown float32
34114                                 MaxDropLvl     int16
34115
34116                                 //mt:len32
34117                                 GroupCaps []ToolGroupCap
34118
34119                                 //mt:len32
34120                                 DmgGroups []Group
34121
34122                                 //mt:32tou16
34123                                 PunchUses int32
34124                         }))(obj)).NonNil {
34125                                 {
34126                                         var local401 uint8
34127                                         local402 := uint8(5)
34128                                         {
34129                                                 p := &local401
34130                                                 *p = read8(r)
34131                                         }
34132                                         if local401 != local402 {
34133                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local401))
34134                                         }
34135                                 }
34136                                 {
34137                                         p := &(*(*(struct {
34138                                                 //mt:if _ = %s; false
34139                                                 NonNil bool
34140
34141                                                 AttackCooldown float32
34142                                                 MaxDropLvl     int16
34143
34144                                                 //mt:len32
34145                                                 GroupCaps []ToolGroupCap
34146
34147                                                 //mt:len32
34148                                                 DmgGroups []Group
34149
34150                                                 //mt:32tou16
34151                                                 PunchUses int32
34152                                         }))(obj)).AttackCooldown
34153                                         *p = math.Float32frombits(read32(r))
34154                                 }
34155                                 {
34156                                         p := &(*(*(struct {
34157                                                 //mt:if _ = %s; false
34158                                                 NonNil bool
34159
34160                                                 AttackCooldown float32
34161                                                 MaxDropLvl     int16
34162
34163                                                 //mt:len32
34164                                                 GroupCaps []ToolGroupCap
34165
34166                                                 //mt:len32
34167                                                 DmgGroups []Group
34168
34169                                                 //mt:32tou16
34170                                                 PunchUses int32
34171                                         }))(obj)).MaxDropLvl
34172                                         *p = int16(read16(r))
34173                                 }
34174                                 var local403 uint32
34175                                 {
34176                                         p := &local403
34177                                         *p = read32(r)
34178                                 }
34179                                 ((*(*(struct {
34180                                         //mt:if _ = %s; false
34181                                         NonNil bool
34182
34183                                         AttackCooldown float32
34184                                         MaxDropLvl     int16
34185
34186                                         //mt:len32
34187                                         GroupCaps []ToolGroupCap
34188
34189                                         //mt:len32
34190                                         DmgGroups []Group
34191
34192                                         //mt:32tou16
34193                                         PunchUses int32
34194                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local403)
34195                                 for local404 := range (*(*(struct {
34196                                         //mt:if _ = %s; false
34197                                         NonNil bool
34198
34199                                         AttackCooldown float32
34200                                         MaxDropLvl     int16
34201
34202                                         //mt:len32
34203                                         GroupCaps []ToolGroupCap
34204
34205                                         //mt:len32
34206                                         DmgGroups []Group
34207
34208                                         //mt:32tou16
34209                                         PunchUses int32
34210                                 }))(obj)).GroupCaps {
34211                                         if err := pcall(func() {
34212                                                 (((*(*(struct {
34213                                                         //mt:if _ = %s; false
34214                                                         NonNil bool
34215
34216                                                         AttackCooldown float32
34217                                                         MaxDropLvl     int16
34218
34219                                                         //mt:len32
34220                                                         GroupCaps []ToolGroupCap
34221
34222                                                         //mt:len32
34223                                                         DmgGroups []Group
34224
34225                                                         //mt:32tou16
34226                                                         PunchUses int32
34227                                                 }))(obj)).GroupCaps)[local404]).deserialize(r)
34228                                         }); err != nil {
34229                                                 if err == io.EOF {
34230                                                         chk(io.EOF)
34231                                                 }
34232                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
34233                                         }
34234                                 }
34235                                 var local405 uint32
34236                                 {
34237                                         p := &local405
34238                                         *p = read32(r)
34239                                 }
34240                                 ((*(*(struct {
34241                                         //mt:if _ = %s; false
34242                                         NonNil bool
34243
34244                                         AttackCooldown float32
34245                                         MaxDropLvl     int16
34246
34247                                         //mt:len32
34248                                         GroupCaps []ToolGroupCap
34249
34250                                         //mt:len32
34251                                         DmgGroups []Group
34252
34253                                         //mt:32tou16
34254                                         PunchUses int32
34255                                 }))(obj)).DmgGroups) = make([]Group, local405)
34256                                 for local406 := range (*(*(struct {
34257                                         //mt:if _ = %s; false
34258                                         NonNil bool
34259
34260                                         AttackCooldown float32
34261                                         MaxDropLvl     int16
34262
34263                                         //mt:len32
34264                                         GroupCaps []ToolGroupCap
34265
34266                                         //mt:len32
34267                                         DmgGroups []Group
34268
34269                                         //mt:32tou16
34270                                         PunchUses int32
34271                                 }))(obj)).DmgGroups {
34272                                         if err := pcall(func() {
34273                                                 (((*(*(struct {
34274                                                         //mt:if _ = %s; false
34275                                                         NonNil bool
34276
34277                                                         AttackCooldown float32
34278                                                         MaxDropLvl     int16
34279
34280                                                         //mt:len32
34281                                                         GroupCaps []ToolGroupCap
34282
34283                                                         //mt:len32
34284                                                         DmgGroups []Group
34285
34286                                                         //mt:32tou16
34287                                                         PunchUses int32
34288                                                 }))(obj)).DmgGroups)[local406]).deserialize(r)
34289                                         }); err != nil {
34290                                                 if err == io.EOF {
34291                                                         chk(io.EOF)
34292                                                 }
34293                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
34294                                         }
34295                                 }
34296                                 var local407 uint16
34297                                 {
34298                                         p := &local407
34299                                         *p = read16(r)
34300                                 }
34301                                 (*(*(struct {
34302                                         //mt:if _ = %s; false
34303                                         NonNil bool
34304
34305                                         AttackCooldown float32
34306                                         MaxDropLvl     int16
34307
34308                                         //mt:len32
34309                                         GroupCaps []ToolGroupCap
34310
34311                                         //mt:len32
34312                                         DmgGroups []Group
34313
34314                                         //mt:32tou16
34315                                         PunchUses int32
34316                                 }))(obj)).PunchUses = int32(local407)
34317                         }
34318                 }
34319                 if r.N > 0 {
34320                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34321                 }
34322         }
34323 }
34324
34325 func (obj *AnimType) serialize(w io.Writer) {
34326         {
34327                 x := *(*(uint8))(obj)
34328                 write8(w, uint8(x))
34329         }
34330 }
34331
34332 func (obj *AnimType) deserialize(r io.Reader) {
34333         {
34334                 p := &*(*(uint8))(obj)
34335                 *p = read8(r)
34336         }
34337 }
34338
34339 func (obj *HUDType) serialize(w io.Writer) {
34340         {
34341                 x := *(*(uint8))(obj)
34342                 write8(w, uint8(x))
34343         }
34344 }
34345
34346 func (obj *HUDType) deserialize(r io.Reader) {
34347         {
34348                 p := &*(*(uint8))(obj)
34349                 *p = read8(r)
34350         }
34351 }
34352
34353 func (obj *Box) serialize(w io.Writer) {
34354         for local408 := range *(*([2]Vec))(obj) {
34355                 if err := pcall(func() {
34356                         ((*(*([2]Vec))(obj))[local408]).serialize(w)
34357                 }); err != nil {
34358                         if err == io.EOF {
34359                                 chk(io.EOF)
34360                         }
34361                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34362                 }
34363         }
34364 }
34365
34366 func (obj *Box) deserialize(r io.Reader) {
34367         for local409 := range *(*([2]Vec))(obj) {
34368                 if err := pcall(func() {
34369                         ((*(*([2]Vec))(obj))[local409]).deserialize(r)
34370                 }); err != nil {
34371                         if err == io.EOF {
34372                                 chk(io.EOF)
34373                         }
34374                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34375                 }
34376         }
34377 }
34378
34379 func (obj *TileFlags) serialize(w io.Writer) {
34380         {
34381                 x := *(*(uint16))(obj)
34382                 write16(w, uint16(x))
34383         }
34384 }
34385
34386 func (obj *TileFlags) deserialize(r io.Reader) {
34387         {
34388                 p := &*(*(uint16))(obj)
34389                 *p = read16(r)
34390         }
34391 }
34392
34393 func (obj *AlignType) serialize(w io.Writer) {
34394         {
34395                 x := *(*(uint8))(obj)
34396                 write8(w, uint8(x))
34397         }
34398 }
34399
34400 func (obj *AlignType) deserialize(r io.Reader) {
34401         {
34402                 p := &*(*(uint8))(obj)
34403                 *p = read8(r)
34404         }
34405 }
34406
34407 func (obj *NodeBoxType) serialize(w io.Writer) {
34408         {
34409                 x := *(*(uint8))(obj)
34410                 write8(w, uint8(x))
34411         }
34412 }
34413
34414 func (obj *NodeBoxType) deserialize(r io.Reader) {
34415         {
34416                 p := &*(*(uint8))(obj)
34417                 *p = read8(r)
34418         }
34419 }
34420
34421 func (obj *DirBoxes) serialize(w io.Writer) {
34422         if len(((*(*(struct {
34423                 Top, Bot                 []Box
34424                 Front, Left, Back, Right []Box
34425         }))(obj)).Top)) > math.MaxUint16 {
34426                 chk(ErrTooLong)
34427         }
34428         {
34429                 x := uint16(len(((*(*(struct {
34430                         Top, Bot                 []Box
34431                         Front, Left, Back, Right []Box
34432                 }))(obj)).Top)))
34433                 write16(w, uint16(x))
34434         }
34435         for local410 := range (*(*(struct {
34436                 Top, Bot                 []Box
34437                 Front, Left, Back, Right []Box
34438         }))(obj)).Top {
34439                 if err := pcall(func() {
34440                         (((*(*(struct {
34441                                 Top, Bot                 []Box
34442                                 Front, Left, Back, Right []Box
34443                         }))(obj)).Top)[local410]).serialize(w)
34444                 }); err != nil {
34445                         if err == io.EOF {
34446                                 chk(io.EOF)
34447                         }
34448                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34449                 }
34450         }
34451         if len(((*(*(struct {
34452                 Top, Bot                 []Box
34453                 Front, Left, Back, Right []Box
34454         }))(obj)).Bot)) > math.MaxUint16 {
34455                 chk(ErrTooLong)
34456         }
34457         {
34458                 x := uint16(len(((*(*(struct {
34459                         Top, Bot                 []Box
34460                         Front, Left, Back, Right []Box
34461                 }))(obj)).Bot)))
34462                 write16(w, uint16(x))
34463         }
34464         for local411 := range (*(*(struct {
34465                 Top, Bot                 []Box
34466                 Front, Left, Back, Right []Box
34467         }))(obj)).Bot {
34468                 if err := pcall(func() {
34469                         (((*(*(struct {
34470                                 Top, Bot                 []Box
34471                                 Front, Left, Back, Right []Box
34472                         }))(obj)).Bot)[local411]).serialize(w)
34473                 }); err != nil {
34474                         if err == io.EOF {
34475                                 chk(io.EOF)
34476                         }
34477                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34478                 }
34479         }
34480         if len(((*(*(struct {
34481                 Top, Bot                 []Box
34482                 Front, Left, Back, Right []Box
34483         }))(obj)).Front)) > math.MaxUint16 {
34484                 chk(ErrTooLong)
34485         }
34486         {
34487                 x := uint16(len(((*(*(struct {
34488                         Top, Bot                 []Box
34489                         Front, Left, Back, Right []Box
34490                 }))(obj)).Front)))
34491                 write16(w, uint16(x))
34492         }
34493         for local412 := range (*(*(struct {
34494                 Top, Bot                 []Box
34495                 Front, Left, Back, Right []Box
34496         }))(obj)).Front {
34497                 if err := pcall(func() {
34498                         (((*(*(struct {
34499                                 Top, Bot                 []Box
34500                                 Front, Left, Back, Right []Box
34501                         }))(obj)).Front)[local412]).serialize(w)
34502                 }); err != nil {
34503                         if err == io.EOF {
34504                                 chk(io.EOF)
34505                         }
34506                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34507                 }
34508         }
34509         if len(((*(*(struct {
34510                 Top, Bot                 []Box
34511                 Front, Left, Back, Right []Box
34512         }))(obj)).Left)) > math.MaxUint16 {
34513                 chk(ErrTooLong)
34514         }
34515         {
34516                 x := uint16(len(((*(*(struct {
34517                         Top, Bot                 []Box
34518                         Front, Left, Back, Right []Box
34519                 }))(obj)).Left)))
34520                 write16(w, uint16(x))
34521         }
34522         for local413 := range (*(*(struct {
34523                 Top, Bot                 []Box
34524                 Front, Left, Back, Right []Box
34525         }))(obj)).Left {
34526                 if err := pcall(func() {
34527                         (((*(*(struct {
34528                                 Top, Bot                 []Box
34529                                 Front, Left, Back, Right []Box
34530                         }))(obj)).Left)[local413]).serialize(w)
34531                 }); err != nil {
34532                         if err == io.EOF {
34533                                 chk(io.EOF)
34534                         }
34535                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34536                 }
34537         }
34538         if len(((*(*(struct {
34539                 Top, Bot                 []Box
34540                 Front, Left, Back, Right []Box
34541         }))(obj)).Back)) > math.MaxUint16 {
34542                 chk(ErrTooLong)
34543         }
34544         {
34545                 x := uint16(len(((*(*(struct {
34546                         Top, Bot                 []Box
34547                         Front, Left, Back, Right []Box
34548                 }))(obj)).Back)))
34549                 write16(w, uint16(x))
34550         }
34551         for local414 := range (*(*(struct {
34552                 Top, Bot                 []Box
34553                 Front, Left, Back, Right []Box
34554         }))(obj)).Back {
34555                 if err := pcall(func() {
34556                         (((*(*(struct {
34557                                 Top, Bot                 []Box
34558                                 Front, Left, Back, Right []Box
34559                         }))(obj)).Back)[local414]).serialize(w)
34560                 }); err != nil {
34561                         if err == io.EOF {
34562                                 chk(io.EOF)
34563                         }
34564                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34565                 }
34566         }
34567         if len(((*(*(struct {
34568                 Top, Bot                 []Box
34569                 Front, Left, Back, Right []Box
34570         }))(obj)).Right)) > math.MaxUint16 {
34571                 chk(ErrTooLong)
34572         }
34573         {
34574                 x := uint16(len(((*(*(struct {
34575                         Top, Bot                 []Box
34576                         Front, Left, Back, Right []Box
34577                 }))(obj)).Right)))
34578                 write16(w, uint16(x))
34579         }
34580         for local415 := range (*(*(struct {
34581                 Top, Bot                 []Box
34582                 Front, Left, Back, Right []Box
34583         }))(obj)).Right {
34584                 if err := pcall(func() {
34585                         (((*(*(struct {
34586                                 Top, Bot                 []Box
34587                                 Front, Left, Back, Right []Box
34588                         }))(obj)).Right)[local415]).serialize(w)
34589                 }); err != nil {
34590                         if err == io.EOF {
34591                                 chk(io.EOF)
34592                         }
34593                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34594                 }
34595         }
34596 }
34597
34598 func (obj *DirBoxes) deserialize(r io.Reader) {
34599         var local416 uint16
34600         {
34601                 p := &local416
34602                 *p = read16(r)
34603         }
34604         ((*(*(struct {
34605                 Top, Bot                 []Box
34606                 Front, Left, Back, Right []Box
34607         }))(obj)).Top) = make([]Box, local416)
34608         for local417 := range (*(*(struct {
34609                 Top, Bot                 []Box
34610                 Front, Left, Back, Right []Box
34611         }))(obj)).Top {
34612                 if err := pcall(func() {
34613                         (((*(*(struct {
34614                                 Top, Bot                 []Box
34615                                 Front, Left, Back, Right []Box
34616                         }))(obj)).Top)[local417]).deserialize(r)
34617                 }); err != nil {
34618                         if err == io.EOF {
34619                                 chk(io.EOF)
34620                         }
34621                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34622                 }
34623         }
34624         var local418 uint16
34625         {
34626                 p := &local418
34627                 *p = read16(r)
34628         }
34629         ((*(*(struct {
34630                 Top, Bot                 []Box
34631                 Front, Left, Back, Right []Box
34632         }))(obj)).Bot) = make([]Box, local418)
34633         for local419 := range (*(*(struct {
34634                 Top, Bot                 []Box
34635                 Front, Left, Back, Right []Box
34636         }))(obj)).Bot {
34637                 if err := pcall(func() {
34638                         (((*(*(struct {
34639                                 Top, Bot                 []Box
34640                                 Front, Left, Back, Right []Box
34641                         }))(obj)).Bot)[local419]).deserialize(r)
34642                 }); err != nil {
34643                         if err == io.EOF {
34644                                 chk(io.EOF)
34645                         }
34646                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34647                 }
34648         }
34649         var local420 uint16
34650         {
34651                 p := &local420
34652                 *p = read16(r)
34653         }
34654         ((*(*(struct {
34655                 Top, Bot                 []Box
34656                 Front, Left, Back, Right []Box
34657         }))(obj)).Front) = make([]Box, local420)
34658         for local421 := range (*(*(struct {
34659                 Top, Bot                 []Box
34660                 Front, Left, Back, Right []Box
34661         }))(obj)).Front {
34662                 if err := pcall(func() {
34663                         (((*(*(struct {
34664                                 Top, Bot                 []Box
34665                                 Front, Left, Back, Right []Box
34666                         }))(obj)).Front)[local421]).deserialize(r)
34667                 }); err != nil {
34668                         if err == io.EOF {
34669                                 chk(io.EOF)
34670                         }
34671                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34672                 }
34673         }
34674         var local422 uint16
34675         {
34676                 p := &local422
34677                 *p = read16(r)
34678         }
34679         ((*(*(struct {
34680                 Top, Bot                 []Box
34681                 Front, Left, Back, Right []Box
34682         }))(obj)).Left) = make([]Box, local422)
34683         for local423 := range (*(*(struct {
34684                 Top, Bot                 []Box
34685                 Front, Left, Back, Right []Box
34686         }))(obj)).Left {
34687                 if err := pcall(func() {
34688                         (((*(*(struct {
34689                                 Top, Bot                 []Box
34690                                 Front, Left, Back, Right []Box
34691                         }))(obj)).Left)[local423]).deserialize(r)
34692                 }); err != nil {
34693                         if err == io.EOF {
34694                                 chk(io.EOF)
34695                         }
34696                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34697                 }
34698         }
34699         var local424 uint16
34700         {
34701                 p := &local424
34702                 *p = read16(r)
34703         }
34704         ((*(*(struct {
34705                 Top, Bot                 []Box
34706                 Front, Left, Back, Right []Box
34707         }))(obj)).Back) = make([]Box, local424)
34708         for local425 := range (*(*(struct {
34709                 Top, Bot                 []Box
34710                 Front, Left, Back, Right []Box
34711         }))(obj)).Back {
34712                 if err := pcall(func() {
34713                         (((*(*(struct {
34714                                 Top, Bot                 []Box
34715                                 Front, Left, Back, Right []Box
34716                         }))(obj)).Back)[local425]).deserialize(r)
34717                 }); err != nil {
34718                         if err == io.EOF {
34719                                 chk(io.EOF)
34720                         }
34721                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34722                 }
34723         }
34724         var local426 uint16
34725         {
34726                 p := &local426
34727                 *p = read16(r)
34728         }
34729         ((*(*(struct {
34730                 Top, Bot                 []Box
34731                 Front, Left, Back, Right []Box
34732         }))(obj)).Right) = make([]Box, local426)
34733         for local427 := range (*(*(struct {
34734                 Top, Bot                 []Box
34735                 Front, Left, Back, Right []Box
34736         }))(obj)).Right {
34737                 if err := pcall(func() {
34738                         (((*(*(struct {
34739                                 Top, Bot                 []Box
34740                                 Front, Left, Back, Right []Box
34741                         }))(obj)).Right)[local427]).deserialize(r)
34742                 }); err != nil {
34743                         if err == io.EOF {
34744                                 chk(io.EOF)
34745                         }
34746                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34747                 }
34748         }
34749 }
34750
34751 func (obj *ToolGroupCap) serialize(w io.Writer) {
34752         if len(([]byte((*(*(struct {
34753                 Name string
34754
34755                 //mt:32to16
34756                 Uses int32
34757
34758                 MaxLvl int16
34759
34760                 //mt:len32
34761                 Times []DigTime
34762         }))(obj)).Name))) > math.MaxUint16 {
34763                 chk(ErrTooLong)
34764         }
34765         {
34766                 x := uint16(len(([]byte((*(*(struct {
34767                         Name string
34768
34769                         //mt:32to16
34770                         Uses int32
34771
34772                         MaxLvl int16
34773
34774                         //mt:len32
34775                         Times []DigTime
34776                 }))(obj)).Name))))
34777                 write16(w, uint16(x))
34778         }
34779         {
34780                 _, err := w.Write(([]byte((*(*(struct {
34781                         Name string
34782
34783                         //mt:32to16
34784                         Uses int32
34785
34786                         MaxLvl int16
34787
34788                         //mt:len32
34789                         Times []DigTime
34790                 }))(obj)).Name))[:])
34791                 chk(err)
34792         }
34793         {
34794                 x := int16((*(*(struct {
34795                         Name string
34796
34797                         //mt:32to16
34798                         Uses int32
34799
34800                         MaxLvl int16
34801
34802                         //mt:len32
34803                         Times []DigTime
34804                 }))(obj)).Uses)
34805                 write16(w, uint16(x))
34806         }
34807         {
34808                 x := (*(*(struct {
34809                         Name string
34810
34811                         //mt:32to16
34812                         Uses int32
34813
34814                         MaxLvl int16
34815
34816                         //mt:len32
34817                         Times []DigTime
34818                 }))(obj)).MaxLvl
34819                 write16(w, uint16(x))
34820         }
34821         if len(((*(*(struct {
34822                 Name string
34823
34824                 //mt:32to16
34825                 Uses int32
34826
34827                 MaxLvl int16
34828
34829                 //mt:len32
34830                 Times []DigTime
34831         }))(obj)).Times)) > math.MaxUint32 {
34832                 chk(ErrTooLong)
34833         }
34834         {
34835                 x := uint32(len(((*(*(struct {
34836                         Name string
34837
34838                         //mt:32to16
34839                         Uses int32
34840
34841                         MaxLvl int16
34842
34843                         //mt:len32
34844                         Times []DigTime
34845                 }))(obj)).Times)))
34846                 write32(w, uint32(x))
34847         }
34848         for local428 := range (*(*(struct {
34849                 Name string
34850
34851                 //mt:32to16
34852                 Uses int32
34853
34854                 MaxLvl int16
34855
34856                 //mt:len32
34857                 Times []DigTime
34858         }))(obj)).Times {
34859                 if err := pcall(func() {
34860                         (((*(*(struct {
34861                                 Name string
34862
34863                                 //mt:32to16
34864                                 Uses int32
34865
34866                                 MaxLvl int16
34867
34868                                 //mt:len32
34869                                 Times []DigTime
34870                         }))(obj)).Times)[local428]).serialize(w)
34871                 }); err != nil {
34872                         if err == io.EOF {
34873                                 chk(io.EOF)
34874                         }
34875                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34876                 }
34877         }
34878 }
34879
34880 func (obj *ToolGroupCap) deserialize(r io.Reader) {
34881         var local429 []uint8
34882         var local430 uint16
34883         {
34884                 p := &local430
34885                 *p = read16(r)
34886         }
34887         (local429) = make([]uint8, local430)
34888         {
34889                 _, err := io.ReadFull(r, (local429)[:])
34890                 chk(err)
34891         }
34892         ((*(*(struct {
34893                 Name string
34894
34895                 //mt:32to16
34896                 Uses int32
34897
34898                 MaxLvl int16
34899
34900                 //mt:len32
34901                 Times []DigTime
34902         }))(obj)).Name) = string(local429)
34903         var local431 int16
34904         {
34905                 p := &local431
34906                 *p = int16(read16(r))
34907         }
34908         (*(*(struct {
34909                 Name string
34910
34911                 //mt:32to16
34912                 Uses int32
34913
34914                 MaxLvl int16
34915
34916                 //mt:len32
34917                 Times []DigTime
34918         }))(obj)).Uses = int32(local431)
34919         {
34920                 p := &(*(*(struct {
34921                         Name string
34922
34923                         //mt:32to16
34924                         Uses int32
34925
34926                         MaxLvl int16
34927
34928                         //mt:len32
34929                         Times []DigTime
34930                 }))(obj)).MaxLvl
34931                 *p = int16(read16(r))
34932         }
34933         var local432 uint32
34934         {
34935                 p := &local432
34936                 *p = read32(r)
34937         }
34938         ((*(*(struct {
34939                 Name string
34940
34941                 //mt:32to16
34942                 Uses int32
34943
34944                 MaxLvl int16
34945
34946                 //mt:len32
34947                 Times []DigTime
34948         }))(obj)).Times) = make([]DigTime, local432)
34949         for local433 := range (*(*(struct {
34950                 Name string
34951
34952                 //mt:32to16
34953                 Uses int32
34954
34955                 MaxLvl int16
34956
34957                 //mt:len32
34958                 Times []DigTime
34959         }))(obj)).Times {
34960                 if err := pcall(func() {
34961                         (((*(*(struct {
34962                                 Name string
34963
34964                                 //mt:32to16
34965                                 Uses int32
34966
34967                                 MaxLvl int16
34968
34969                                 //mt:len32
34970                                 Times []DigTime
34971                         }))(obj)).Times)[local433]).deserialize(r)
34972                 }); err != nil {
34973                         if err == io.EOF {
34974                                 chk(io.EOF)
34975                         }
34976                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34977                 }
34978         }
34979 }
34980
34981 func (obj *DigTime) serialize(w io.Writer) {
34982         {
34983                 x := (*(*(struct {
34984                         Rating int16
34985                         Time   float32
34986                 }))(obj)).Rating
34987                 write16(w, uint16(x))
34988         }
34989         {
34990                 x := (*(*(struct {
34991                         Rating int16
34992                         Time   float32
34993                 }))(obj)).Time
34994                 write32(w, math.Float32bits(x))
34995         }
34996 }
34997
34998 func (obj *DigTime) deserialize(r io.Reader) {
34999         {
35000                 p := &(*(*(struct {
35001                         Rating int16
35002                         Time   float32
35003                 }))(obj)).Rating
35004                 *p = int16(read16(r))
35005         }
35006         {
35007                 p := &(*(*(struct {
35008                         Rating int16
35009                         Time   float32
35010                 }))(obj)).Time
35011                 *p = math.Float32frombits(read32(r))
35012         }
35013 }