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 := zstd.NewWriter(w)
22885                 for local285 := range (*(*(struct {
22886                         Flags   MapBlkFlags
22887                         LitFrom LitFromBlks
22888
22889                         //mt:zstd
22890                         Param0 [4096]Content
22891                         Param1 [4096]uint8
22892                         Param2 [4096]uint8
22893
22894                         NodeMetas map[uint16]*NodeMeta
22895                 }))(obj)).Param0 {
22896                         if err := pcall(func() {
22897                                 (((*(*(struct {
22898                                         Flags   MapBlkFlags
22899                                         LitFrom LitFromBlks
22900
22901                                         //mt:zstd
22902                                         Param0 [4096]Content
22903                                         Param1 [4096]uint8
22904                                         Param2 [4096]uint8
22905
22906                                         NodeMetas map[uint16]*NodeMeta
22907                                 }))(obj)).Param0)[local285]).serialize(w)
22908                         }); err != nil {
22909                                 if err == io.EOF {
22910                                         chk(io.EOF)
22911                                 }
22912                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
22913                         }
22914                 }
22915                 {
22916                         _, err := w.Write(((*(*(struct {
22917                                 Flags   MapBlkFlags
22918                                 LitFrom LitFromBlks
22919
22920                                 //mt:zstd
22921                                 Param0 [4096]Content
22922                                 Param1 [4096]uint8
22923                                 Param2 [4096]uint8
22924
22925                                 NodeMetas map[uint16]*NodeMeta
22926                         }))(obj)).Param1)[:])
22927                         chk(err)
22928                 }
22929                 {
22930                         _, err := w.Write(((*(*(struct {
22931                                 Flags   MapBlkFlags
22932                                 LitFrom LitFromBlks
22933
22934                                 //mt:zstd
22935                                 Param0 [4096]Content
22936                                 Param1 [4096]uint8
22937                                 Param2 [4096]uint8
22938
22939                                 NodeMetas map[uint16]*NodeMeta
22940                         }))(obj)).Param2)[:])
22941                         chk(err)
22942                 }
22943                 chk(w.Close())
22944         }
22945         {
22946                 x := (*(*(struct {
22947                         Flags   MapBlkFlags
22948                         LitFrom LitFromBlks
22949
22950                         //mt:zstd
22951                         Param0 [4096]Content
22952                         Param1 [4096]uint8
22953                         Param2 [4096]uint8
22954
22955                         NodeMetas map[uint16]*NodeMeta
22956                 }))(obj)).NodeMetas
22957                 {
22958                         w := zlib.NewWriter(w)
22959
22960                         if x == nil {
22961                                 write8(w, 0)
22962                         } else {
22963                                 write8(w, 2)
22964                                 // len(map[uint16]...) always < math.MaxUint16
22965                                 write16(w, uint16(len(x)))
22966                                 keys := make([]uint16, 0, len(x))
22967                                 for key := range x {
22968                                         keys = append(keys, key)
22969                                 }
22970                                 sort.Slice(keys, func(i, j int) bool {
22971                                         i2pos := func(i int) [3]int16 {
22972                                                 return Blkpos2Pos([3]int16{}, keys[i])
22973                                         }
22974
22975                                         p, q := i2pos(i), i2pos(j)
22976
22977                                         for i := range p {
22978                                                 switch {
22979                                                 case p[i] < q[i]:
22980                                                         return true
22981                                                 case p[i] > q[i]:
22982                                                         return false
22983                                                 }
22984                                         }
22985
22986                                         return false
22987                                 })
22988                                 for _, key := range keys {
22989                                         write16(w, key)
22990                                         chk(serialize(w, x[key]))
22991                                 }
22992                         }
22993
22994                         chk(w.Close())
22995                 }
22996
22997         }
22998         {
22999                 local286 := uint8(2) // version
23000                 {
23001                         x := local286
23002                         write8(w, uint8(x))
23003                 }
23004         }
23005 }
23006
23007 func (obj *MapBlk) deserialize(r io.Reader) {
23008         if err := pcall(func() {
23009                 ((*(*(struct {
23010                         Flags   MapBlkFlags
23011                         LitFrom LitFromBlks
23012
23013                         //mt:zstd
23014                         Param0 [4096]Content
23015                         Param1 [4096]uint8
23016                         Param2 [4096]uint8
23017
23018                         NodeMetas map[uint16]*NodeMeta
23019                 }))(obj)).Flags).deserialize(r)
23020         }); err != nil {
23021                 if err == io.EOF {
23022                         chk(io.EOF)
23023                 }
23024                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MapBlkFlags", err))
23025         }
23026         if err := pcall(func() {
23027                 ((*(*(struct {
23028                         Flags   MapBlkFlags
23029                         LitFrom LitFromBlks
23030
23031                         //mt:zstd
23032                         Param0 [4096]Content
23033                         Param1 [4096]uint8
23034                         Param2 [4096]uint8
23035
23036                         NodeMetas map[uint16]*NodeMeta
23037                 }))(obj)).LitFrom).deserialize(r)
23038         }); err != nil {
23039                 if err == io.EOF {
23040                         chk(io.EOF)
23041                 }
23042                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
23043         }
23044         {
23045                 var local287 uint8
23046                 local288 := uint8(2) // Size of param0 in bytes.
23047                 {
23048                         p := &local287
23049                         *p = read8(r)
23050                 }
23051                 if local287 != local288 {
23052                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local287))
23053                 }
23054         }
23055         {
23056                 var local289 uint8
23057                 local290 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23058                 {
23059                         p := &local289
23060                         *p = read8(r)
23061                 }
23062                 if local289 != local290 {
23063                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local289))
23064                 }
23065         }
23066         {
23067                 r, err := zstd.NewReader(byteReader{r})
23068                 chk(err)
23069                 for local291 := range (*(*(struct {
23070                         Flags   MapBlkFlags
23071                         LitFrom LitFromBlks
23072
23073                         //mt:zstd
23074                         Param0 [4096]Content
23075                         Param1 [4096]uint8
23076                         Param2 [4096]uint8
23077
23078                         NodeMetas map[uint16]*NodeMeta
23079                 }))(obj)).Param0 {
23080                         if err := pcall(func() {
23081                                 (((*(*(struct {
23082                                         Flags   MapBlkFlags
23083                                         LitFrom LitFromBlks
23084
23085                                         //mt:zstd
23086                                         Param0 [4096]Content
23087                                         Param1 [4096]uint8
23088                                         Param2 [4096]uint8
23089
23090                                         NodeMetas map[uint16]*NodeMeta
23091                                 }))(obj)).Param0)[local291]).deserialize(r)
23092                         }); err != nil {
23093                                 if err == io.EOF {
23094                                         chk(io.EOF)
23095                                 }
23096                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23097                         }
23098                 }
23099                 {
23100                         _, err := io.ReadFull(r, ((*(*(struct {
23101                                 Flags   MapBlkFlags
23102                                 LitFrom LitFromBlks
23103
23104                                 //mt:zstd
23105                                 Param0 [4096]Content
23106                                 Param1 [4096]uint8
23107                                 Param2 [4096]uint8
23108
23109                                 NodeMetas map[uint16]*NodeMeta
23110                         }))(obj)).Param1)[:])
23111                         chk(err)
23112                 }
23113                 {
23114                         _, err := io.ReadFull(r, ((*(*(struct {
23115                                 Flags   MapBlkFlags
23116                                 LitFrom LitFromBlks
23117
23118                                 //mt:zstd
23119                                 Param0 [4096]Content
23120                                 Param1 [4096]uint8
23121                                 Param2 [4096]uint8
23122
23123                                 NodeMetas map[uint16]*NodeMeta
23124                         }))(obj)).Param2)[:])
23125                         chk(err)
23126                 }
23127                 chk(r.Close())
23128         }
23129         {
23130                 p := &(*(*(struct {
23131                         Flags   MapBlkFlags
23132                         LitFrom LitFromBlks
23133
23134                         //mt:zstd
23135                         Param0 [4096]Content
23136                         Param1 [4096]uint8
23137                         Param2 [4096]uint8
23138
23139                         NodeMetas map[uint16]*NodeMeta
23140                 }))(obj)).NodeMetas
23141                 {
23142                         r, err := zlib.NewReader(byteReader{r})
23143                         chk(err)
23144
23145                         switch ver := read8(r); ver {
23146                         case 0:
23147                                 *p = nil
23148                         case 2:
23149                                 n := read16(r)
23150                                 *p = make(map[uint16]*NodeMeta, n)
23151                                 for ; n > 0; n-- {
23152                                         pos := read16(r)
23153                                         nm := new(NodeMeta)
23154                                         chk(deserialize(r, nm))
23155                                         (*p)[pos] = nm
23156                                 }
23157                         default:
23158                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
23159                         }
23160
23161                         chk(r.Close())
23162                 }
23163
23164         }
23165         {
23166                 var local292 uint8
23167                 local293 := uint8(2) // version
23168                 {
23169                         p := &local292
23170                         *p = read8(r)
23171                 }
23172                 if local292 != local293 {
23173                         chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local292))
23174                 }
23175         }
23176 }
23177
23178 func (obj *Node) serialize(w io.Writer) {
23179         if err := pcall(func() {
23180                 ((*(*(struct {
23181                         Param0         Content
23182                         Param1, Param2 uint8
23183                 }))(obj)).Param0).serialize(w)
23184         }); err != nil {
23185                 if err == io.EOF {
23186                         chk(io.EOF)
23187                 }
23188                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23189         }
23190         {
23191                 x := (*(*(struct {
23192                         Param0         Content
23193                         Param1, Param2 uint8
23194                 }))(obj)).Param1
23195                 write8(w, uint8(x))
23196         }
23197         {
23198                 x := (*(*(struct {
23199                         Param0         Content
23200                         Param1, Param2 uint8
23201                 }))(obj)).Param2
23202                 write8(w, uint8(x))
23203         }
23204 }
23205
23206 func (obj *Node) deserialize(r io.Reader) {
23207         if err := pcall(func() {
23208                 ((*(*(struct {
23209                         Param0         Content
23210                         Param1, Param2 uint8
23211                 }))(obj)).Param0).deserialize(r)
23212         }); err != nil {
23213                 if err == io.EOF {
23214                         chk(io.EOF)
23215                 }
23216                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Content", err))
23217         }
23218         {
23219                 p := &(*(*(struct {
23220                         Param0         Content
23221                         Param1, Param2 uint8
23222                 }))(obj)).Param1
23223                 *p = read8(r)
23224         }
23225         {
23226                 p := &(*(*(struct {
23227                         Param0         Content
23228                         Param1, Param2 uint8
23229                 }))(obj)).Param2
23230                 *p = read8(r)
23231         }
23232 }
23233
23234 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
23235         {
23236                 x := *(*(uint64))(obj)
23237                 write64(w, uint64(x))
23238
23239         }
23240 }
23241
23242 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
23243         {
23244                 p := &*(*(uint64))(obj)
23245                 *p = read64(r)
23246
23247         }
23248 }
23249
23250 func (obj *Vec) serialize(w io.Writer) {
23251         for local294 := range *(*([3]float32))(obj) {
23252                 {
23253                         x := (*(*([3]float32))(obj))[local294]
23254                         write32(w, math.Float32bits(x))
23255                 }
23256         }
23257 }
23258
23259 func (obj *Vec) deserialize(r io.Reader) {
23260         for local295 := range *(*([3]float32))(obj) {
23261                 {
23262                         p := &(*(*([3]float32))(obj))[local295]
23263                         *p = math.Float32frombits(read32(r))
23264                 }
23265         }
23266 }
23267
23268 func (obj *ChatMsgType) serialize(w io.Writer) {
23269         {
23270                 x := *(*(uint8))(obj)
23271                 write8(w, uint8(x))
23272         }
23273 }
23274
23275 func (obj *ChatMsgType) deserialize(r io.Reader) {
23276         {
23277                 p := &*(*(uint8))(obj)
23278                 *p = read8(r)
23279         }
23280 }
23281
23282 func (obj *AOID) serialize(w io.Writer) {
23283         {
23284                 x := *(*(uint16))(obj)
23285                 write16(w, uint16(x))
23286         }
23287 }
23288
23289 func (obj *AOID) deserialize(r io.Reader) {
23290         {
23291                 p := &*(*(uint16))(obj)
23292                 *p = read16(r)
23293         }
23294 }
23295
23296 func (obj *AOAdd) serialize(w io.Writer) {
23297         if err := pcall(func() {
23298                 ((*(*(struct {
23299                         ID AOID
23300                         //mt:const genericCAO
23301                         //mt:lenhdr 32
23302                         InitData AOInitData
23303                 }))(obj)).ID).serialize(w)
23304         }); err != nil {
23305                 if err == io.EOF {
23306                         chk(io.EOF)
23307                 }
23308                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23309         }
23310         {
23311                 local296 := genericCAO
23312                 if err := pcall(func() {
23313                         (local296).serialize(w)
23314                 }); err != nil {
23315                         if err == io.EOF {
23316                                 chk(io.EOF)
23317                         }
23318                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
23319                 }
23320         }
23321         {
23322                 ow := w
23323                 w := new(bytes.Buffer)
23324                 if err := pcall(func() {
23325                         ((*(*(struct {
23326                                 ID AOID
23327                                 //mt:const genericCAO
23328                                 //mt:lenhdr 32
23329                                 InitData AOInitData
23330                         }))(obj)).InitData).serialize(w)
23331                 }); err != nil {
23332                         if err == io.EOF {
23333                                 chk(io.EOF)
23334                         }
23335                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
23336                 }
23337                 {
23338                         buf := w
23339                         w := ow
23340                         if len((buf.Bytes())) > math.MaxUint32 {
23341                                 chk(ErrTooLong)
23342                         }
23343                         {
23344                                 x := uint32(len((buf.Bytes())))
23345                                 write32(w, uint32(x))
23346                         }
23347                         {
23348                                 _, err := w.Write((buf.Bytes())[:])
23349                                 chk(err)
23350                         }
23351                 }
23352         }
23353 }
23354
23355 func (obj *AOAdd) deserialize(r io.Reader) {
23356         if err := pcall(func() {
23357                 ((*(*(struct {
23358                         ID AOID
23359                         //mt:const genericCAO
23360                         //mt:lenhdr 32
23361                         InitData AOInitData
23362                 }))(obj)).ID).deserialize(r)
23363         }); err != nil {
23364                 if err == io.EOF {
23365                         chk(io.EOF)
23366                 }
23367                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23368         }
23369         {
23370                 var local297 aoType
23371                 local298 := genericCAO
23372                 if err := pcall(func() {
23373                         (local297).deserialize(r)
23374                 }); err != nil {
23375                         if err == io.EOF {
23376                                 chk(io.EOF)
23377                         }
23378                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
23379                 }
23380                 if local297 != local298 {
23381                         chk(fmt.Errorf("const %v: %v", "genericCAO", local297))
23382                 }
23383         }
23384         {
23385                 var n uint32
23386                 {
23387                         p := &n
23388                         *p = read32(r)
23389                 }
23390                 r := &io.LimitedReader{R: r, N: int64(n)}
23391                 if err := pcall(func() {
23392                         ((*(*(struct {
23393                                 ID AOID
23394                                 //mt:const genericCAO
23395                                 //mt:lenhdr 32
23396                                 InitData AOInitData
23397                         }))(obj)).InitData).deserialize(r)
23398                 }); err != nil {
23399                         if err == io.EOF {
23400                                 chk(io.EOF)
23401                         }
23402                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOInitData", err))
23403                 }
23404                 if r.N > 0 {
23405                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23406                 }
23407         }
23408 }
23409
23410 func (obj *IDAOMsg) serialize(w io.Writer) {
23411         if err := pcall(func() {
23412                 ((*(*(struct {
23413                         ID AOID
23414                         //mt:lenhdr 16
23415                         Msg AOMsg
23416                 }))(obj)).ID).serialize(w)
23417         }); err != nil {
23418                 if err == io.EOF {
23419                         chk(io.EOF)
23420                 }
23421                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23422         }
23423         {
23424                 ow := w
23425                 w := new(bytes.Buffer)
23426                 {
23427                         x := (*(*(struct {
23428                                 ID AOID
23429                                 //mt:lenhdr 16
23430                                 Msg AOMsg
23431                         }))(obj)).Msg
23432                         writeAOMsg(w, x)
23433
23434                 }
23435                 {
23436                         buf := w
23437                         w := ow
23438                         if len((buf.Bytes())) > math.MaxUint16 {
23439                                 chk(ErrTooLong)
23440                         }
23441                         {
23442                                 x := uint16(len((buf.Bytes())))
23443                                 write16(w, uint16(x))
23444                         }
23445                         {
23446                                 _, err := w.Write((buf.Bytes())[:])
23447                                 chk(err)
23448                         }
23449                 }
23450         }
23451 }
23452
23453 func (obj *IDAOMsg) deserialize(r io.Reader) {
23454         if err := pcall(func() {
23455                 ((*(*(struct {
23456                         ID AOID
23457                         //mt:lenhdr 16
23458                         Msg AOMsg
23459                 }))(obj)).ID).deserialize(r)
23460         }); err != nil {
23461                 if err == io.EOF {
23462                         chk(io.EOF)
23463                 }
23464                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
23465         }
23466         {
23467                 var n uint16
23468                 {
23469                         p := &n
23470                         *p = read16(r)
23471                 }
23472                 r := &io.LimitedReader{R: r, N: int64(n)}
23473                 {
23474                         p := &(*(*(struct {
23475                                 ID AOID
23476                                 //mt:lenhdr 16
23477                                 Msg AOMsg
23478                         }))(obj)).Msg
23479                         {
23480                                 var err error
23481                                 *p, err = readAOMsg(r)
23482                                 chk(err)
23483                         }
23484
23485                 }
23486                 if r.N > 0 {
23487                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23488                 }
23489         }
23490 }
23491
23492 func (obj *ItemDef) serialize(w io.Writer) {
23493         {
23494                 ow := w
23495                 w := new(bytes.Buffer)
23496                 {
23497                         local299 := uint8(6)
23498                         {
23499                                 x := local299
23500                                 write8(w, uint8(x))
23501                         }
23502                 }
23503                 if err := pcall(func() {
23504                         ((*(*(struct {
23505                                 Type ItemType
23506
23507                                 Name, Desc string
23508
23509                                 InvImg, WieldImg Texture
23510                                 WieldScale       [3]float32
23511
23512                                 StackMax uint16
23513
23514                                 Usable          bool
23515                                 CanPointLiquids bool
23516
23517                                 ToolCaps ToolCaps
23518
23519                                 Groups []Group
23520
23521                                 PlacePredict string
23522
23523                                 PlaceSnd, PlaceFailSnd SoundDef
23524
23525                                 PointRange float32
23526
23527                                 // Set index in Palette with "palette_index" item meta field,
23528                                 // this overrides Color.
23529                                 Palette Texture
23530                                 Color   color.NRGBA
23531
23532                                 // Texture overlays.
23533                                 InvOverlay, WieldOverlay Texture
23534
23535                                 ShortDesc string
23536                         }))(obj)).Type).serialize(w)
23537                 }); err != nil {
23538                         if err == io.EOF {
23539                                 chk(io.EOF)
23540                         }
23541                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
23542                 }
23543                 if len(([]byte((*(*(struct {
23544                         Type ItemType
23545
23546                         Name, Desc string
23547
23548                         InvImg, WieldImg Texture
23549                         WieldScale       [3]float32
23550
23551                         StackMax uint16
23552
23553                         Usable          bool
23554                         CanPointLiquids bool
23555
23556                         ToolCaps ToolCaps
23557
23558                         Groups []Group
23559
23560                         PlacePredict string
23561
23562                         PlaceSnd, PlaceFailSnd SoundDef
23563
23564                         PointRange float32
23565
23566                         // Set index in Palette with "palette_index" item meta field,
23567                         // this overrides Color.
23568                         Palette Texture
23569                         Color   color.NRGBA
23570
23571                         // Texture overlays.
23572                         InvOverlay, WieldOverlay Texture
23573
23574                         ShortDesc string
23575                 }))(obj)).Name))) > math.MaxUint16 {
23576                         chk(ErrTooLong)
23577                 }
23578                 {
23579                         x := uint16(len(([]byte((*(*(struct {
23580                                 Type ItemType
23581
23582                                 Name, Desc string
23583
23584                                 InvImg, WieldImg Texture
23585                                 WieldScale       [3]float32
23586
23587                                 StackMax uint16
23588
23589                                 Usable          bool
23590                                 CanPointLiquids bool
23591
23592                                 ToolCaps ToolCaps
23593
23594                                 Groups []Group
23595
23596                                 PlacePredict string
23597
23598                                 PlaceSnd, PlaceFailSnd SoundDef
23599
23600                                 PointRange float32
23601
23602                                 // Set index in Palette with "palette_index" item meta field,
23603                                 // this overrides Color.
23604                                 Palette Texture
23605                                 Color   color.NRGBA
23606
23607                                 // Texture overlays.
23608                                 InvOverlay, WieldOverlay Texture
23609
23610                                 ShortDesc string
23611                         }))(obj)).Name))))
23612                         write16(w, uint16(x))
23613                 }
23614                 {
23615                         _, err := w.Write(([]byte((*(*(struct {
23616                                 Type ItemType
23617
23618                                 Name, Desc string
23619
23620                                 InvImg, WieldImg Texture
23621                                 WieldScale       [3]float32
23622
23623                                 StackMax uint16
23624
23625                                 Usable          bool
23626                                 CanPointLiquids bool
23627
23628                                 ToolCaps ToolCaps
23629
23630                                 Groups []Group
23631
23632                                 PlacePredict string
23633
23634                                 PlaceSnd, PlaceFailSnd SoundDef
23635
23636                                 PointRange float32
23637
23638                                 // Set index in Palette with "palette_index" item meta field,
23639                                 // this overrides Color.
23640                                 Palette Texture
23641                                 Color   color.NRGBA
23642
23643                                 // Texture overlays.
23644                                 InvOverlay, WieldOverlay Texture
23645
23646                                 ShortDesc string
23647                         }))(obj)).Name))[:])
23648                         chk(err)
23649                 }
23650                 if len(([]byte((*(*(struct {
23651                         Type ItemType
23652
23653                         Name, Desc string
23654
23655                         InvImg, WieldImg Texture
23656                         WieldScale       [3]float32
23657
23658                         StackMax uint16
23659
23660                         Usable          bool
23661                         CanPointLiquids bool
23662
23663                         ToolCaps ToolCaps
23664
23665                         Groups []Group
23666
23667                         PlacePredict string
23668
23669                         PlaceSnd, PlaceFailSnd SoundDef
23670
23671                         PointRange float32
23672
23673                         // Set index in Palette with "palette_index" item meta field,
23674                         // this overrides Color.
23675                         Palette Texture
23676                         Color   color.NRGBA
23677
23678                         // Texture overlays.
23679                         InvOverlay, WieldOverlay Texture
23680
23681                         ShortDesc string
23682                 }))(obj)).Desc))) > math.MaxUint16 {
23683                         chk(ErrTooLong)
23684                 }
23685                 {
23686                         x := uint16(len(([]byte((*(*(struct {
23687                                 Type ItemType
23688
23689                                 Name, Desc string
23690
23691                                 InvImg, WieldImg Texture
23692                                 WieldScale       [3]float32
23693
23694                                 StackMax uint16
23695
23696                                 Usable          bool
23697                                 CanPointLiquids bool
23698
23699                                 ToolCaps ToolCaps
23700
23701                                 Groups []Group
23702
23703                                 PlacePredict string
23704
23705                                 PlaceSnd, PlaceFailSnd SoundDef
23706
23707                                 PointRange float32
23708
23709                                 // Set index in Palette with "palette_index" item meta field,
23710                                 // this overrides Color.
23711                                 Palette Texture
23712                                 Color   color.NRGBA
23713
23714                                 // Texture overlays.
23715                                 InvOverlay, WieldOverlay Texture
23716
23717                                 ShortDesc string
23718                         }))(obj)).Desc))))
23719                         write16(w, uint16(x))
23720                 }
23721                 {
23722                         _, err := w.Write(([]byte((*(*(struct {
23723                                 Type ItemType
23724
23725                                 Name, Desc string
23726
23727                                 InvImg, WieldImg Texture
23728                                 WieldScale       [3]float32
23729
23730                                 StackMax uint16
23731
23732                                 Usable          bool
23733                                 CanPointLiquids bool
23734
23735                                 ToolCaps ToolCaps
23736
23737                                 Groups []Group
23738
23739                                 PlacePredict string
23740
23741                                 PlaceSnd, PlaceFailSnd SoundDef
23742
23743                                 PointRange float32
23744
23745                                 // Set index in Palette with "palette_index" item meta field,
23746                                 // this overrides Color.
23747                                 Palette Texture
23748                                 Color   color.NRGBA
23749
23750                                 // Texture overlays.
23751                                 InvOverlay, WieldOverlay Texture
23752
23753                                 ShortDesc string
23754                         }))(obj)).Desc))[:])
23755                         chk(err)
23756                 }
23757                 if err := pcall(func() {
23758                         ((*(*(struct {
23759                                 Type ItemType
23760
23761                                 Name, Desc string
23762
23763                                 InvImg, WieldImg Texture
23764                                 WieldScale       [3]float32
23765
23766                                 StackMax uint16
23767
23768                                 Usable          bool
23769                                 CanPointLiquids bool
23770
23771                                 ToolCaps ToolCaps
23772
23773                                 Groups []Group
23774
23775                                 PlacePredict string
23776
23777                                 PlaceSnd, PlaceFailSnd SoundDef
23778
23779                                 PointRange float32
23780
23781                                 // Set index in Palette with "palette_index" item meta field,
23782                                 // this overrides Color.
23783                                 Palette Texture
23784                                 Color   color.NRGBA
23785
23786                                 // Texture overlays.
23787                                 InvOverlay, WieldOverlay Texture
23788
23789                                 ShortDesc string
23790                         }))(obj)).InvImg).serialize(w)
23791                 }); err != nil {
23792                         if err == io.EOF {
23793                                 chk(io.EOF)
23794                         }
23795                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
23796                 }
23797                 if err := pcall(func() {
23798                         ((*(*(struct {
23799                                 Type ItemType
23800
23801                                 Name, Desc string
23802
23803                                 InvImg, WieldImg Texture
23804                                 WieldScale       [3]float32
23805
23806                                 StackMax uint16
23807
23808                                 Usable          bool
23809                                 CanPointLiquids bool
23810
23811                                 ToolCaps ToolCaps
23812
23813                                 Groups []Group
23814
23815                                 PlacePredict string
23816
23817                                 PlaceSnd, PlaceFailSnd SoundDef
23818
23819                                 PointRange float32
23820
23821                                 // Set index in Palette with "palette_index" item meta field,
23822                                 // this overrides Color.
23823                                 Palette Texture
23824                                 Color   color.NRGBA
23825
23826                                 // Texture overlays.
23827                                 InvOverlay, WieldOverlay Texture
23828
23829                                 ShortDesc string
23830                         }))(obj)).WieldImg).serialize(w)
23831                 }); err != nil {
23832                         if err == io.EOF {
23833                                 chk(io.EOF)
23834                         }
23835                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
23836                 }
23837                 for local300 := range (*(*(struct {
23838                         Type ItemType
23839
23840                         Name, Desc string
23841
23842                         InvImg, WieldImg Texture
23843                         WieldScale       [3]float32
23844
23845                         StackMax uint16
23846
23847                         Usable          bool
23848                         CanPointLiquids bool
23849
23850                         ToolCaps ToolCaps
23851
23852                         Groups []Group
23853
23854                         PlacePredict string
23855
23856                         PlaceSnd, PlaceFailSnd SoundDef
23857
23858                         PointRange float32
23859
23860                         // Set index in Palette with "palette_index" item meta field,
23861                         // this overrides Color.
23862                         Palette Texture
23863                         Color   color.NRGBA
23864
23865                         // Texture overlays.
23866                         InvOverlay, WieldOverlay Texture
23867
23868                         ShortDesc string
23869                 }))(obj)).WieldScale {
23870                         {
23871                                 x := ((*(*(struct {
23872                                         Type ItemType
23873
23874                                         Name, Desc string
23875
23876                                         InvImg, WieldImg Texture
23877                                         WieldScale       [3]float32
23878
23879                                         StackMax uint16
23880
23881                                         Usable          bool
23882                                         CanPointLiquids bool
23883
23884                                         ToolCaps ToolCaps
23885
23886                                         Groups []Group
23887
23888                                         PlacePredict string
23889
23890                                         PlaceSnd, PlaceFailSnd SoundDef
23891
23892                                         PointRange float32
23893
23894                                         // Set index in Palette with "palette_index" item meta field,
23895                                         // this overrides Color.
23896                                         Palette Texture
23897                                         Color   color.NRGBA
23898
23899                                         // Texture overlays.
23900                                         InvOverlay, WieldOverlay Texture
23901
23902                                         ShortDesc string
23903                                 }))(obj)).WieldScale)[local300]
23904                                 write32(w, math.Float32bits(x))
23905                         }
23906                 }
23907                 {
23908                         x := (*(*(struct {
23909                                 Type ItemType
23910
23911                                 Name, Desc string
23912
23913                                 InvImg, WieldImg Texture
23914                                 WieldScale       [3]float32
23915
23916                                 StackMax uint16
23917
23918                                 Usable          bool
23919                                 CanPointLiquids bool
23920
23921                                 ToolCaps ToolCaps
23922
23923                                 Groups []Group
23924
23925                                 PlacePredict string
23926
23927                                 PlaceSnd, PlaceFailSnd SoundDef
23928
23929                                 PointRange float32
23930
23931                                 // Set index in Palette with "palette_index" item meta field,
23932                                 // this overrides Color.
23933                                 Palette Texture
23934                                 Color   color.NRGBA
23935
23936                                 // Texture overlays.
23937                                 InvOverlay, WieldOverlay Texture
23938
23939                                 ShortDesc string
23940                         }))(obj)).StackMax
23941                         write16(w, uint16(x))
23942                 }
23943                 {
23944                         x := (*(*(struct {
23945                                 Type ItemType
23946
23947                                 Name, Desc string
23948
23949                                 InvImg, WieldImg Texture
23950                                 WieldScale       [3]float32
23951
23952                                 StackMax uint16
23953
23954                                 Usable          bool
23955                                 CanPointLiquids bool
23956
23957                                 ToolCaps ToolCaps
23958
23959                                 Groups []Group
23960
23961                                 PlacePredict string
23962
23963                                 PlaceSnd, PlaceFailSnd SoundDef
23964
23965                                 PointRange float32
23966
23967                                 // Set index in Palette with "palette_index" item meta field,
23968                                 // this overrides Color.
23969                                 Palette Texture
23970                                 Color   color.NRGBA
23971
23972                                 // Texture overlays.
23973                                 InvOverlay, WieldOverlay Texture
23974
23975                                 ShortDesc string
23976                         }))(obj)).Usable
23977                         if x {
23978                                 write8(w, 1)
23979                         } else {
23980                                 write8(w, 0)
23981                         }
23982
23983                 }
23984                 {
23985                         x := (*(*(struct {
23986                                 Type ItemType
23987
23988                                 Name, Desc string
23989
23990                                 InvImg, WieldImg Texture
23991                                 WieldScale       [3]float32
23992
23993                                 StackMax uint16
23994
23995                                 Usable          bool
23996                                 CanPointLiquids bool
23997
23998                                 ToolCaps ToolCaps
23999
24000                                 Groups []Group
24001
24002                                 PlacePredict string
24003
24004                                 PlaceSnd, PlaceFailSnd SoundDef
24005
24006                                 PointRange float32
24007
24008                                 // Set index in Palette with "palette_index" item meta field,
24009                                 // this overrides Color.
24010                                 Palette Texture
24011                                 Color   color.NRGBA
24012
24013                                 // Texture overlays.
24014                                 InvOverlay, WieldOverlay Texture
24015
24016                                 ShortDesc string
24017                         }))(obj)).CanPointLiquids
24018                         if x {
24019                                 write8(w, 1)
24020                         } else {
24021                                 write8(w, 0)
24022                         }
24023
24024                 }
24025                 if err := pcall(func() {
24026                         ((*(*(struct {
24027                                 Type ItemType
24028
24029                                 Name, Desc string
24030
24031                                 InvImg, WieldImg Texture
24032                                 WieldScale       [3]float32
24033
24034                                 StackMax uint16
24035
24036                                 Usable          bool
24037                                 CanPointLiquids bool
24038
24039                                 ToolCaps ToolCaps
24040
24041                                 Groups []Group
24042
24043                                 PlacePredict string
24044
24045                                 PlaceSnd, PlaceFailSnd SoundDef
24046
24047                                 PointRange float32
24048
24049                                 // Set index in Palette with "palette_index" item meta field,
24050                                 // this overrides Color.
24051                                 Palette Texture
24052                                 Color   color.NRGBA
24053
24054                                 // Texture overlays.
24055                                 InvOverlay, WieldOverlay Texture
24056
24057                                 ShortDesc string
24058                         }))(obj)).ToolCaps).serialize(w)
24059                 }); err != nil {
24060                         if err == io.EOF {
24061                                 chk(io.EOF)
24062                         }
24063                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
24064                 }
24065                 if len(((*(*(struct {
24066                         Type ItemType
24067
24068                         Name, Desc string
24069
24070                         InvImg, WieldImg Texture
24071                         WieldScale       [3]float32
24072
24073                         StackMax uint16
24074
24075                         Usable          bool
24076                         CanPointLiquids bool
24077
24078                         ToolCaps ToolCaps
24079
24080                         Groups []Group
24081
24082                         PlacePredict string
24083
24084                         PlaceSnd, PlaceFailSnd SoundDef
24085
24086                         PointRange float32
24087
24088                         // Set index in Palette with "palette_index" item meta field,
24089                         // this overrides Color.
24090                         Palette Texture
24091                         Color   color.NRGBA
24092
24093                         // Texture overlays.
24094                         InvOverlay, WieldOverlay Texture
24095
24096                         ShortDesc string
24097                 }))(obj)).Groups)) > math.MaxUint16 {
24098                         chk(ErrTooLong)
24099                 }
24100                 {
24101                         x := uint16(len(((*(*(struct {
24102                                 Type ItemType
24103
24104                                 Name, Desc string
24105
24106                                 InvImg, WieldImg Texture
24107                                 WieldScale       [3]float32
24108
24109                                 StackMax uint16
24110
24111                                 Usable          bool
24112                                 CanPointLiquids bool
24113
24114                                 ToolCaps ToolCaps
24115
24116                                 Groups []Group
24117
24118                                 PlacePredict string
24119
24120                                 PlaceSnd, PlaceFailSnd SoundDef
24121
24122                                 PointRange float32
24123
24124                                 // Set index in Palette with "palette_index" item meta field,
24125                                 // this overrides Color.
24126                                 Palette Texture
24127                                 Color   color.NRGBA
24128
24129                                 // Texture overlays.
24130                                 InvOverlay, WieldOverlay Texture
24131
24132                                 ShortDesc string
24133                         }))(obj)).Groups)))
24134                         write16(w, uint16(x))
24135                 }
24136                 for local301 := range (*(*(struct {
24137                         Type ItemType
24138
24139                         Name, Desc string
24140
24141                         InvImg, WieldImg Texture
24142                         WieldScale       [3]float32
24143
24144                         StackMax uint16
24145
24146                         Usable          bool
24147                         CanPointLiquids bool
24148
24149                         ToolCaps ToolCaps
24150
24151                         Groups []Group
24152
24153                         PlacePredict string
24154
24155                         PlaceSnd, PlaceFailSnd SoundDef
24156
24157                         PointRange float32
24158
24159                         // Set index in Palette with "palette_index" item meta field,
24160                         // this overrides Color.
24161                         Palette Texture
24162                         Color   color.NRGBA
24163
24164                         // Texture overlays.
24165                         InvOverlay, WieldOverlay Texture
24166
24167                         ShortDesc string
24168                 }))(obj)).Groups {
24169                         if err := pcall(func() {
24170                                 (((*(*(struct {
24171                                         Type ItemType
24172
24173                                         Name, Desc string
24174
24175                                         InvImg, WieldImg Texture
24176                                         WieldScale       [3]float32
24177
24178                                         StackMax uint16
24179
24180                                         Usable          bool
24181                                         CanPointLiquids bool
24182
24183                                         ToolCaps ToolCaps
24184
24185                                         Groups []Group
24186
24187                                         PlacePredict string
24188
24189                                         PlaceSnd, PlaceFailSnd SoundDef
24190
24191                                         PointRange float32
24192
24193                                         // Set index in Palette with "palette_index" item meta field,
24194                                         // this overrides Color.
24195                                         Palette Texture
24196                                         Color   color.NRGBA
24197
24198                                         // Texture overlays.
24199                                         InvOverlay, WieldOverlay Texture
24200
24201                                         ShortDesc string
24202                                 }))(obj)).Groups)[local301]).serialize(w)
24203                         }); err != nil {
24204                                 if err == io.EOF {
24205                                         chk(io.EOF)
24206                                 }
24207                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
24208                         }
24209                 }
24210                 if len(([]byte((*(*(struct {
24211                         Type ItemType
24212
24213                         Name, Desc string
24214
24215                         InvImg, WieldImg Texture
24216                         WieldScale       [3]float32
24217
24218                         StackMax uint16
24219
24220                         Usable          bool
24221                         CanPointLiquids bool
24222
24223                         ToolCaps ToolCaps
24224
24225                         Groups []Group
24226
24227                         PlacePredict string
24228
24229                         PlaceSnd, PlaceFailSnd SoundDef
24230
24231                         PointRange float32
24232
24233                         // Set index in Palette with "palette_index" item meta field,
24234                         // this overrides Color.
24235                         Palette Texture
24236                         Color   color.NRGBA
24237
24238                         // Texture overlays.
24239                         InvOverlay, WieldOverlay Texture
24240
24241                         ShortDesc string
24242                 }))(obj)).PlacePredict))) > math.MaxUint16 {
24243                         chk(ErrTooLong)
24244                 }
24245                 {
24246                         x := uint16(len(([]byte((*(*(struct {
24247                                 Type ItemType
24248
24249                                 Name, Desc string
24250
24251                                 InvImg, WieldImg Texture
24252                                 WieldScale       [3]float32
24253
24254                                 StackMax uint16
24255
24256                                 Usable          bool
24257                                 CanPointLiquids bool
24258
24259                                 ToolCaps ToolCaps
24260
24261                                 Groups []Group
24262
24263                                 PlacePredict string
24264
24265                                 PlaceSnd, PlaceFailSnd SoundDef
24266
24267                                 PointRange float32
24268
24269                                 // Set index in Palette with "palette_index" item meta field,
24270                                 // this overrides Color.
24271                                 Palette Texture
24272                                 Color   color.NRGBA
24273
24274                                 // Texture overlays.
24275                                 InvOverlay, WieldOverlay Texture
24276
24277                                 ShortDesc string
24278                         }))(obj)).PlacePredict))))
24279                         write16(w, uint16(x))
24280                 }
24281                 {
24282                         _, err := w.Write(([]byte((*(*(struct {
24283                                 Type ItemType
24284
24285                                 Name, Desc string
24286
24287                                 InvImg, WieldImg Texture
24288                                 WieldScale       [3]float32
24289
24290                                 StackMax uint16
24291
24292                                 Usable          bool
24293                                 CanPointLiquids bool
24294
24295                                 ToolCaps ToolCaps
24296
24297                                 Groups []Group
24298
24299                                 PlacePredict string
24300
24301                                 PlaceSnd, PlaceFailSnd SoundDef
24302
24303                                 PointRange float32
24304
24305                                 // Set index in Palette with "palette_index" item meta field,
24306                                 // this overrides Color.
24307                                 Palette Texture
24308                                 Color   color.NRGBA
24309
24310                                 // Texture overlays.
24311                                 InvOverlay, WieldOverlay Texture
24312
24313                                 ShortDesc string
24314                         }))(obj)).PlacePredict))[:])
24315                         chk(err)
24316                 }
24317                 if err := pcall(func() {
24318                         ((*(*(struct {
24319                                 Type ItemType
24320
24321                                 Name, Desc string
24322
24323                                 InvImg, WieldImg Texture
24324                                 WieldScale       [3]float32
24325
24326                                 StackMax uint16
24327
24328                                 Usable          bool
24329                                 CanPointLiquids bool
24330
24331                                 ToolCaps ToolCaps
24332
24333                                 Groups []Group
24334
24335                                 PlacePredict string
24336
24337                                 PlaceSnd, PlaceFailSnd SoundDef
24338
24339                                 PointRange float32
24340
24341                                 // Set index in Palette with "palette_index" item meta field,
24342                                 // this overrides Color.
24343                                 Palette Texture
24344                                 Color   color.NRGBA
24345
24346                                 // Texture overlays.
24347                                 InvOverlay, WieldOverlay Texture
24348
24349                                 ShortDesc string
24350                         }))(obj)).PlaceSnd).serialize(w)
24351                 }); err != nil {
24352                         if err == io.EOF {
24353                                 chk(io.EOF)
24354                         }
24355                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
24356                 }
24357                 if err := pcall(func() {
24358                         ((*(*(struct {
24359                                 Type ItemType
24360
24361                                 Name, Desc string
24362
24363                                 InvImg, WieldImg Texture
24364                                 WieldScale       [3]float32
24365
24366                                 StackMax uint16
24367
24368                                 Usable          bool
24369                                 CanPointLiquids bool
24370
24371                                 ToolCaps ToolCaps
24372
24373                                 Groups []Group
24374
24375                                 PlacePredict string
24376
24377                                 PlaceSnd, PlaceFailSnd SoundDef
24378
24379                                 PointRange float32
24380
24381                                 // Set index in Palette with "palette_index" item meta field,
24382                                 // this overrides Color.
24383                                 Palette Texture
24384                                 Color   color.NRGBA
24385
24386                                 // Texture overlays.
24387                                 InvOverlay, WieldOverlay Texture
24388
24389                                 ShortDesc string
24390                         }))(obj)).PlaceFailSnd).serialize(w)
24391                 }); err != nil {
24392                         if err == io.EOF {
24393                                 chk(io.EOF)
24394                         }
24395                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
24396                 }
24397                 {
24398                         x := (*(*(struct {
24399                                 Type ItemType
24400
24401                                 Name, Desc string
24402
24403                                 InvImg, WieldImg Texture
24404                                 WieldScale       [3]float32
24405
24406                                 StackMax uint16
24407
24408                                 Usable          bool
24409                                 CanPointLiquids bool
24410
24411                                 ToolCaps ToolCaps
24412
24413                                 Groups []Group
24414
24415                                 PlacePredict string
24416
24417                                 PlaceSnd, PlaceFailSnd SoundDef
24418
24419                                 PointRange float32
24420
24421                                 // Set index in Palette with "palette_index" item meta field,
24422                                 // this overrides Color.
24423                                 Palette Texture
24424                                 Color   color.NRGBA
24425
24426                                 // Texture overlays.
24427                                 InvOverlay, WieldOverlay Texture
24428
24429                                 ShortDesc string
24430                         }))(obj)).PointRange
24431                         write32(w, math.Float32bits(x))
24432                 }
24433                 if err := pcall(func() {
24434                         ((*(*(struct {
24435                                 Type ItemType
24436
24437                                 Name, Desc string
24438
24439                                 InvImg, WieldImg Texture
24440                                 WieldScale       [3]float32
24441
24442                                 StackMax uint16
24443
24444                                 Usable          bool
24445                                 CanPointLiquids bool
24446
24447                                 ToolCaps ToolCaps
24448
24449                                 Groups []Group
24450
24451                                 PlacePredict string
24452
24453                                 PlaceSnd, PlaceFailSnd SoundDef
24454
24455                                 PointRange float32
24456
24457                                 // Set index in Palette with "palette_index" item meta field,
24458                                 // this overrides Color.
24459                                 Palette Texture
24460                                 Color   color.NRGBA
24461
24462                                 // Texture overlays.
24463                                 InvOverlay, WieldOverlay Texture
24464
24465                                 ShortDesc string
24466                         }))(obj)).Palette).serialize(w)
24467                 }); err != nil {
24468                         if err == io.EOF {
24469                                 chk(io.EOF)
24470                         }
24471                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24472                 }
24473                 {
24474                         x := (*(*(struct {
24475                                 Type ItemType
24476
24477                                 Name, Desc string
24478
24479                                 InvImg, WieldImg Texture
24480                                 WieldScale       [3]float32
24481
24482                                 StackMax uint16
24483
24484                                 Usable          bool
24485                                 CanPointLiquids bool
24486
24487                                 ToolCaps ToolCaps
24488
24489                                 Groups []Group
24490
24491                                 PlacePredict string
24492
24493                                 PlaceSnd, PlaceFailSnd SoundDef
24494
24495                                 PointRange float32
24496
24497                                 // Set index in Palette with "palette_index" item meta field,
24498                                 // this overrides Color.
24499                                 Palette Texture
24500                                 Color   color.NRGBA
24501
24502                                 // Texture overlays.
24503                                 InvOverlay, WieldOverlay Texture
24504
24505                                 ShortDesc string
24506                         }))(obj)).Color
24507                         w.Write([]byte{x.A, x.R, x.G, x.B})
24508
24509                 }
24510                 if err := pcall(func() {
24511                         ((*(*(struct {
24512                                 Type ItemType
24513
24514                                 Name, Desc string
24515
24516                                 InvImg, WieldImg Texture
24517                                 WieldScale       [3]float32
24518
24519                                 StackMax uint16
24520
24521                                 Usable          bool
24522                                 CanPointLiquids bool
24523
24524                                 ToolCaps ToolCaps
24525
24526                                 Groups []Group
24527
24528                                 PlacePredict string
24529
24530                                 PlaceSnd, PlaceFailSnd SoundDef
24531
24532                                 PointRange float32
24533
24534                                 // Set index in Palette with "palette_index" item meta field,
24535                                 // this overrides Color.
24536                                 Palette Texture
24537                                 Color   color.NRGBA
24538
24539                                 // Texture overlays.
24540                                 InvOverlay, WieldOverlay Texture
24541
24542                                 ShortDesc string
24543                         }))(obj)).InvOverlay).serialize(w)
24544                 }); err != nil {
24545                         if err == io.EOF {
24546                                 chk(io.EOF)
24547                         }
24548                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24549                 }
24550                 if err := pcall(func() {
24551                         ((*(*(struct {
24552                                 Type ItemType
24553
24554                                 Name, Desc string
24555
24556                                 InvImg, WieldImg Texture
24557                                 WieldScale       [3]float32
24558
24559                                 StackMax uint16
24560
24561                                 Usable          bool
24562                                 CanPointLiquids bool
24563
24564                                 ToolCaps ToolCaps
24565
24566                                 Groups []Group
24567
24568                                 PlacePredict string
24569
24570                                 PlaceSnd, PlaceFailSnd SoundDef
24571
24572                                 PointRange float32
24573
24574                                 // Set index in Palette with "palette_index" item meta field,
24575                                 // this overrides Color.
24576                                 Palette Texture
24577                                 Color   color.NRGBA
24578
24579                                 // Texture overlays.
24580                                 InvOverlay, WieldOverlay Texture
24581
24582                                 ShortDesc string
24583                         }))(obj)).WieldOverlay).serialize(w)
24584                 }); err != nil {
24585                         if err == io.EOF {
24586                                 chk(io.EOF)
24587                         }
24588                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24589                 }
24590                 if len(([]byte((*(*(struct {
24591                         Type ItemType
24592
24593                         Name, Desc string
24594
24595                         InvImg, WieldImg Texture
24596                         WieldScale       [3]float32
24597
24598                         StackMax uint16
24599
24600                         Usable          bool
24601                         CanPointLiquids bool
24602
24603                         ToolCaps ToolCaps
24604
24605                         Groups []Group
24606
24607                         PlacePredict string
24608
24609                         PlaceSnd, PlaceFailSnd SoundDef
24610
24611                         PointRange float32
24612
24613                         // Set index in Palette with "palette_index" item meta field,
24614                         // this overrides Color.
24615                         Palette Texture
24616                         Color   color.NRGBA
24617
24618                         // Texture overlays.
24619                         InvOverlay, WieldOverlay Texture
24620
24621                         ShortDesc string
24622                 }))(obj)).ShortDesc))) > math.MaxUint16 {
24623                         chk(ErrTooLong)
24624                 }
24625                 {
24626                         x := uint16(len(([]byte((*(*(struct {
24627                                 Type ItemType
24628
24629                                 Name, Desc string
24630
24631                                 InvImg, WieldImg Texture
24632                                 WieldScale       [3]float32
24633
24634                                 StackMax uint16
24635
24636                                 Usable          bool
24637                                 CanPointLiquids bool
24638
24639                                 ToolCaps ToolCaps
24640
24641                                 Groups []Group
24642
24643                                 PlacePredict string
24644
24645                                 PlaceSnd, PlaceFailSnd SoundDef
24646
24647                                 PointRange float32
24648
24649                                 // Set index in Palette with "palette_index" item meta field,
24650                                 // this overrides Color.
24651                                 Palette Texture
24652                                 Color   color.NRGBA
24653
24654                                 // Texture overlays.
24655                                 InvOverlay, WieldOverlay Texture
24656
24657                                 ShortDesc string
24658                         }))(obj)).ShortDesc))))
24659                         write16(w, uint16(x))
24660                 }
24661                 {
24662                         _, err := w.Write(([]byte((*(*(struct {
24663                                 Type ItemType
24664
24665                                 Name, Desc string
24666
24667                                 InvImg, WieldImg Texture
24668                                 WieldScale       [3]float32
24669
24670                                 StackMax uint16
24671
24672                                 Usable          bool
24673                                 CanPointLiquids bool
24674
24675                                 ToolCaps ToolCaps
24676
24677                                 Groups []Group
24678
24679                                 PlacePredict string
24680
24681                                 PlaceSnd, PlaceFailSnd SoundDef
24682
24683                                 PointRange float32
24684
24685                                 // Set index in Palette with "palette_index" item meta field,
24686                                 // this overrides Color.
24687                                 Palette Texture
24688                                 Color   color.NRGBA
24689
24690                                 // Texture overlays.
24691                                 InvOverlay, WieldOverlay Texture
24692
24693                                 ShortDesc string
24694                         }))(obj)).ShortDesc))[:])
24695                         chk(err)
24696                 }
24697                 {
24698                         buf := w
24699                         w := ow
24700                         if len((buf.Bytes())) > math.MaxUint16 {
24701                                 chk(ErrTooLong)
24702                         }
24703                         {
24704                                 x := uint16(len((buf.Bytes())))
24705                                 write16(w, uint16(x))
24706                         }
24707                         {
24708                                 _, err := w.Write((buf.Bytes())[:])
24709                                 chk(err)
24710                         }
24711                 }
24712         }
24713 }
24714
24715 func (obj *ItemDef) deserialize(r io.Reader) {
24716         {
24717                 var n uint16
24718                 {
24719                         p := &n
24720                         *p = read16(r)
24721                 }
24722                 r := &io.LimitedReader{R: r, N: int64(n)}
24723                 {
24724                         var local302 uint8
24725                         local303 := uint8(6)
24726                         {
24727                                 p := &local302
24728                                 *p = read8(r)
24729                         }
24730                         if local302 != local303 {
24731                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local302))
24732                         }
24733                 }
24734                 if err := pcall(func() {
24735                         ((*(*(struct {
24736                                 Type ItemType
24737
24738                                 Name, Desc string
24739
24740                                 InvImg, WieldImg Texture
24741                                 WieldScale       [3]float32
24742
24743                                 StackMax uint16
24744
24745                                 Usable          bool
24746                                 CanPointLiquids bool
24747
24748                                 ToolCaps ToolCaps
24749
24750                                 Groups []Group
24751
24752                                 PlacePredict string
24753
24754                                 PlaceSnd, PlaceFailSnd SoundDef
24755
24756                                 PointRange float32
24757
24758                                 // Set index in Palette with "palette_index" item meta field,
24759                                 // this overrides Color.
24760                                 Palette Texture
24761                                 Color   color.NRGBA
24762
24763                                 // Texture overlays.
24764                                 InvOverlay, WieldOverlay Texture
24765
24766                                 ShortDesc string
24767                         }))(obj)).Type).deserialize(r)
24768                 }); err != nil {
24769                         if err == io.EOF {
24770                                 chk(io.EOF)
24771                         }
24772                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
24773                 }
24774                 var local304 []uint8
24775                 var local305 uint16
24776                 {
24777                         p := &local305
24778                         *p = read16(r)
24779                 }
24780                 (local304) = make([]uint8, local305)
24781                 {
24782                         _, err := io.ReadFull(r, (local304)[:])
24783                         chk(err)
24784                 }
24785                 ((*(*(struct {
24786                         Type ItemType
24787
24788                         Name, Desc string
24789
24790                         InvImg, WieldImg Texture
24791                         WieldScale       [3]float32
24792
24793                         StackMax uint16
24794
24795                         Usable          bool
24796                         CanPointLiquids bool
24797
24798                         ToolCaps ToolCaps
24799
24800                         Groups []Group
24801
24802                         PlacePredict string
24803
24804                         PlaceSnd, PlaceFailSnd SoundDef
24805
24806                         PointRange float32
24807
24808                         // Set index in Palette with "palette_index" item meta field,
24809                         // this overrides Color.
24810                         Palette Texture
24811                         Color   color.NRGBA
24812
24813                         // Texture overlays.
24814                         InvOverlay, WieldOverlay Texture
24815
24816                         ShortDesc string
24817                 }))(obj)).Name) = string(local304)
24818                 var local306 []uint8
24819                 var local307 uint16
24820                 {
24821                         p := &local307
24822                         *p = read16(r)
24823                 }
24824                 (local306) = make([]uint8, local307)
24825                 {
24826                         _, err := io.ReadFull(r, (local306)[:])
24827                         chk(err)
24828                 }
24829                 ((*(*(struct {
24830                         Type ItemType
24831
24832                         Name, Desc string
24833
24834                         InvImg, WieldImg Texture
24835                         WieldScale       [3]float32
24836
24837                         StackMax uint16
24838
24839                         Usable          bool
24840                         CanPointLiquids bool
24841
24842                         ToolCaps ToolCaps
24843
24844                         Groups []Group
24845
24846                         PlacePredict string
24847
24848                         PlaceSnd, PlaceFailSnd SoundDef
24849
24850                         PointRange float32
24851
24852                         // Set index in Palette with "palette_index" item meta field,
24853                         // this overrides Color.
24854                         Palette Texture
24855                         Color   color.NRGBA
24856
24857                         // Texture overlays.
24858                         InvOverlay, WieldOverlay Texture
24859
24860                         ShortDesc string
24861                 }))(obj)).Desc) = string(local306)
24862                 if err := pcall(func() {
24863                         ((*(*(struct {
24864                                 Type ItemType
24865
24866                                 Name, Desc string
24867
24868                                 InvImg, WieldImg Texture
24869                                 WieldScale       [3]float32
24870
24871                                 StackMax uint16
24872
24873                                 Usable          bool
24874                                 CanPointLiquids bool
24875
24876                                 ToolCaps ToolCaps
24877
24878                                 Groups []Group
24879
24880                                 PlacePredict string
24881
24882                                 PlaceSnd, PlaceFailSnd SoundDef
24883
24884                                 PointRange float32
24885
24886                                 // Set index in Palette with "palette_index" item meta field,
24887                                 // this overrides Color.
24888                                 Palette Texture
24889                                 Color   color.NRGBA
24890
24891                                 // Texture overlays.
24892                                 InvOverlay, WieldOverlay Texture
24893
24894                                 ShortDesc string
24895                         }))(obj)).InvImg).deserialize(r)
24896                 }); err != nil {
24897                         if err == io.EOF {
24898                                 chk(io.EOF)
24899                         }
24900                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24901                 }
24902                 if err := pcall(func() {
24903                         ((*(*(struct {
24904                                 Type ItemType
24905
24906                                 Name, Desc string
24907
24908                                 InvImg, WieldImg Texture
24909                                 WieldScale       [3]float32
24910
24911                                 StackMax uint16
24912
24913                                 Usable          bool
24914                                 CanPointLiquids bool
24915
24916                                 ToolCaps ToolCaps
24917
24918                                 Groups []Group
24919
24920                                 PlacePredict string
24921
24922                                 PlaceSnd, PlaceFailSnd SoundDef
24923
24924                                 PointRange float32
24925
24926                                 // Set index in Palette with "palette_index" item meta field,
24927                                 // this overrides Color.
24928                                 Palette Texture
24929                                 Color   color.NRGBA
24930
24931                                 // Texture overlays.
24932                                 InvOverlay, WieldOverlay Texture
24933
24934                                 ShortDesc string
24935                         }))(obj)).WieldImg).deserialize(r)
24936                 }); err != nil {
24937                         if err == io.EOF {
24938                                 chk(io.EOF)
24939                         }
24940                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
24941                 }
24942                 for local308 := range (*(*(struct {
24943                         Type ItemType
24944
24945                         Name, Desc string
24946
24947                         InvImg, WieldImg Texture
24948                         WieldScale       [3]float32
24949
24950                         StackMax uint16
24951
24952                         Usable          bool
24953                         CanPointLiquids bool
24954
24955                         ToolCaps ToolCaps
24956
24957                         Groups []Group
24958
24959                         PlacePredict string
24960
24961                         PlaceSnd, PlaceFailSnd SoundDef
24962
24963                         PointRange float32
24964
24965                         // Set index in Palette with "palette_index" item meta field,
24966                         // this overrides Color.
24967                         Palette Texture
24968                         Color   color.NRGBA
24969
24970                         // Texture overlays.
24971                         InvOverlay, WieldOverlay Texture
24972
24973                         ShortDesc string
24974                 }))(obj)).WieldScale {
24975                         {
24976                                 p := &((*(*(struct {
24977                                         Type ItemType
24978
24979                                         Name, Desc string
24980
24981                                         InvImg, WieldImg Texture
24982                                         WieldScale       [3]float32
24983
24984                                         StackMax uint16
24985
24986                                         Usable          bool
24987                                         CanPointLiquids bool
24988
24989                                         ToolCaps ToolCaps
24990
24991                                         Groups []Group
24992
24993                                         PlacePredict string
24994
24995                                         PlaceSnd, PlaceFailSnd SoundDef
24996
24997                                         PointRange float32
24998
24999                                         // Set index in Palette with "palette_index" item meta field,
25000                                         // this overrides Color.
25001                                         Palette Texture
25002                                         Color   color.NRGBA
25003
25004                                         // Texture overlays.
25005                                         InvOverlay, WieldOverlay Texture
25006
25007                                         ShortDesc string
25008                                 }))(obj)).WieldScale)[local308]
25009                                 *p = math.Float32frombits(read32(r))
25010                         }
25011                 }
25012                 {
25013                         p := &(*(*(struct {
25014                                 Type ItemType
25015
25016                                 Name, Desc string
25017
25018                                 InvImg, WieldImg Texture
25019                                 WieldScale       [3]float32
25020
25021                                 StackMax uint16
25022
25023                                 Usable          bool
25024                                 CanPointLiquids bool
25025
25026                                 ToolCaps ToolCaps
25027
25028                                 Groups []Group
25029
25030                                 PlacePredict string
25031
25032                                 PlaceSnd, PlaceFailSnd SoundDef
25033
25034                                 PointRange float32
25035
25036                                 // Set index in Palette with "palette_index" item meta field,
25037                                 // this overrides Color.
25038                                 Palette Texture
25039                                 Color   color.NRGBA
25040
25041                                 // Texture overlays.
25042                                 InvOverlay, WieldOverlay Texture
25043
25044                                 ShortDesc string
25045                         }))(obj)).StackMax
25046                         *p = read16(r)
25047                 }
25048                 {
25049                         p := &(*(*(struct {
25050                                 Type ItemType
25051
25052                                 Name, Desc string
25053
25054                                 InvImg, WieldImg Texture
25055                                 WieldScale       [3]float32
25056
25057                                 StackMax uint16
25058
25059                                 Usable          bool
25060                                 CanPointLiquids bool
25061
25062                                 ToolCaps ToolCaps
25063
25064                                 Groups []Group
25065
25066                                 PlacePredict string
25067
25068                                 PlaceSnd, PlaceFailSnd SoundDef
25069
25070                                 PointRange float32
25071
25072                                 // Set index in Palette with "palette_index" item meta field,
25073                                 // this overrides Color.
25074                                 Palette Texture
25075                                 Color   color.NRGBA
25076
25077                                 // Texture overlays.
25078                                 InvOverlay, WieldOverlay Texture
25079
25080                                 ShortDesc string
25081                         }))(obj)).Usable
25082                         switch n := read8(r); n {
25083                         case 0:
25084                                 *p = false
25085                         case 1:
25086                                 *p = true
25087                         default:
25088                                 chk(fmt.Errorf("invalid bool: %d", n))
25089                         }
25090
25091                 }
25092                 {
25093                         p := &(*(*(struct {
25094                                 Type ItemType
25095
25096                                 Name, Desc string
25097
25098                                 InvImg, WieldImg Texture
25099                                 WieldScale       [3]float32
25100
25101                                 StackMax uint16
25102
25103                                 Usable          bool
25104                                 CanPointLiquids bool
25105
25106                                 ToolCaps ToolCaps
25107
25108                                 Groups []Group
25109
25110                                 PlacePredict string
25111
25112                                 PlaceSnd, PlaceFailSnd SoundDef
25113
25114                                 PointRange float32
25115
25116                                 // Set index in Palette with "palette_index" item meta field,
25117                                 // this overrides Color.
25118                                 Palette Texture
25119                                 Color   color.NRGBA
25120
25121                                 // Texture overlays.
25122                                 InvOverlay, WieldOverlay Texture
25123
25124                                 ShortDesc string
25125                         }))(obj)).CanPointLiquids
25126                         switch n := read8(r); n {
25127                         case 0:
25128                                 *p = false
25129                         case 1:
25130                                 *p = true
25131                         default:
25132                                 chk(fmt.Errorf("invalid bool: %d", n))
25133                         }
25134
25135                 }
25136                 if err := pcall(func() {
25137                         ((*(*(struct {
25138                                 Type ItemType
25139
25140                                 Name, Desc string
25141
25142                                 InvImg, WieldImg Texture
25143                                 WieldScale       [3]float32
25144
25145                                 StackMax uint16
25146
25147                                 Usable          bool
25148                                 CanPointLiquids bool
25149
25150                                 ToolCaps ToolCaps
25151
25152                                 Groups []Group
25153
25154                                 PlacePredict string
25155
25156                                 PlaceSnd, PlaceFailSnd SoundDef
25157
25158                                 PointRange float32
25159
25160                                 // Set index in Palette with "palette_index" item meta field,
25161                                 // this overrides Color.
25162                                 Palette Texture
25163                                 Color   color.NRGBA
25164
25165                                 // Texture overlays.
25166                                 InvOverlay, WieldOverlay Texture
25167
25168                                 ShortDesc string
25169                         }))(obj)).ToolCaps).deserialize(r)
25170                 }); err != nil {
25171                         if err == io.EOF {
25172                                 chk(io.EOF)
25173                         }
25174                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
25175                 }
25176                 var local309 uint16
25177                 {
25178                         p := &local309
25179                         *p = read16(r)
25180                 }
25181                 ((*(*(struct {
25182                         Type ItemType
25183
25184                         Name, Desc string
25185
25186                         InvImg, WieldImg Texture
25187                         WieldScale       [3]float32
25188
25189                         StackMax uint16
25190
25191                         Usable          bool
25192                         CanPointLiquids bool
25193
25194                         ToolCaps ToolCaps
25195
25196                         Groups []Group
25197
25198                         PlacePredict string
25199
25200                         PlaceSnd, PlaceFailSnd SoundDef
25201
25202                         PointRange float32
25203
25204                         // Set index in Palette with "palette_index" item meta field,
25205                         // this overrides Color.
25206                         Palette Texture
25207                         Color   color.NRGBA
25208
25209                         // Texture overlays.
25210                         InvOverlay, WieldOverlay Texture
25211
25212                         ShortDesc string
25213                 }))(obj)).Groups) = make([]Group, local309)
25214                 for local310 := range (*(*(struct {
25215                         Type ItemType
25216
25217                         Name, Desc string
25218
25219                         InvImg, WieldImg Texture
25220                         WieldScale       [3]float32
25221
25222                         StackMax uint16
25223
25224                         Usable          bool
25225                         CanPointLiquids bool
25226
25227                         ToolCaps ToolCaps
25228
25229                         Groups []Group
25230
25231                         PlacePredict string
25232
25233                         PlaceSnd, PlaceFailSnd SoundDef
25234
25235                         PointRange float32
25236
25237                         // Set index in Palette with "palette_index" item meta field,
25238                         // this overrides Color.
25239                         Palette Texture
25240                         Color   color.NRGBA
25241
25242                         // Texture overlays.
25243                         InvOverlay, WieldOverlay Texture
25244
25245                         ShortDesc string
25246                 }))(obj)).Groups {
25247                         if err := pcall(func() {
25248                                 (((*(*(struct {
25249                                         Type ItemType
25250
25251                                         Name, Desc string
25252
25253                                         InvImg, WieldImg Texture
25254                                         WieldScale       [3]float32
25255
25256                                         StackMax uint16
25257
25258                                         Usable          bool
25259                                         CanPointLiquids bool
25260
25261                                         ToolCaps ToolCaps
25262
25263                                         Groups []Group
25264
25265                                         PlacePredict string
25266
25267                                         PlaceSnd, PlaceFailSnd SoundDef
25268
25269                                         PointRange float32
25270
25271                                         // Set index in Palette with "palette_index" item meta field,
25272                                         // this overrides Color.
25273                                         Palette Texture
25274                                         Color   color.NRGBA
25275
25276                                         // Texture overlays.
25277                                         InvOverlay, WieldOverlay Texture
25278
25279                                         ShortDesc string
25280                                 }))(obj)).Groups)[local310]).deserialize(r)
25281                         }); err != nil {
25282                                 if err == io.EOF {
25283                                         chk(io.EOF)
25284                                 }
25285                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
25286                         }
25287                 }
25288                 var local311 []uint8
25289                 var local312 uint16
25290                 {
25291                         p := &local312
25292                         *p = read16(r)
25293                 }
25294                 (local311) = make([]uint8, local312)
25295                 {
25296                         _, err := io.ReadFull(r, (local311)[:])
25297                         chk(err)
25298                 }
25299                 ((*(*(struct {
25300                         Type ItemType
25301
25302                         Name, Desc string
25303
25304                         InvImg, WieldImg Texture
25305                         WieldScale       [3]float32
25306
25307                         StackMax uint16
25308
25309                         Usable          bool
25310                         CanPointLiquids bool
25311
25312                         ToolCaps ToolCaps
25313
25314                         Groups []Group
25315
25316                         PlacePredict string
25317
25318                         PlaceSnd, PlaceFailSnd SoundDef
25319
25320                         PointRange float32
25321
25322                         // Set index in Palette with "palette_index" item meta field,
25323                         // this overrides Color.
25324                         Palette Texture
25325                         Color   color.NRGBA
25326
25327                         // Texture overlays.
25328                         InvOverlay, WieldOverlay Texture
25329
25330                         ShortDesc string
25331                 }))(obj)).PlacePredict) = string(local311)
25332                 if err := pcall(func() {
25333                         ((*(*(struct {
25334                                 Type ItemType
25335
25336                                 Name, Desc string
25337
25338                                 InvImg, WieldImg Texture
25339                                 WieldScale       [3]float32
25340
25341                                 StackMax uint16
25342
25343                                 Usable          bool
25344                                 CanPointLiquids bool
25345
25346                                 ToolCaps ToolCaps
25347
25348                                 Groups []Group
25349
25350                                 PlacePredict string
25351
25352                                 PlaceSnd, PlaceFailSnd SoundDef
25353
25354                                 PointRange float32
25355
25356                                 // Set index in Palette with "palette_index" item meta field,
25357                                 // this overrides Color.
25358                                 Palette Texture
25359                                 Color   color.NRGBA
25360
25361                                 // Texture overlays.
25362                                 InvOverlay, WieldOverlay Texture
25363
25364                                 ShortDesc string
25365                         }))(obj)).PlaceSnd).deserialize(r)
25366                 }); err != nil {
25367                         if err == io.EOF {
25368                                 chk(io.EOF)
25369                         }
25370                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25371                 }
25372                 if err := pcall(func() {
25373                         ((*(*(struct {
25374                                 Type ItemType
25375
25376                                 Name, Desc string
25377
25378                                 InvImg, WieldImg Texture
25379                                 WieldScale       [3]float32
25380
25381                                 StackMax uint16
25382
25383                                 Usable          bool
25384                                 CanPointLiquids bool
25385
25386                                 ToolCaps ToolCaps
25387
25388                                 Groups []Group
25389
25390                                 PlacePredict string
25391
25392                                 PlaceSnd, PlaceFailSnd SoundDef
25393
25394                                 PointRange float32
25395
25396                                 // Set index in Palette with "palette_index" item meta field,
25397                                 // this overrides Color.
25398                                 Palette Texture
25399                                 Color   color.NRGBA
25400
25401                                 // Texture overlays.
25402                                 InvOverlay, WieldOverlay Texture
25403
25404                                 ShortDesc string
25405                         }))(obj)).PlaceFailSnd).deserialize(r)
25406                 }); err != nil {
25407                         if err == io.EOF {
25408                                 chk(io.EOF)
25409                         }
25410                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundDef", err))
25411                 }
25412                 {
25413                         p := &(*(*(struct {
25414                                 Type ItemType
25415
25416                                 Name, Desc string
25417
25418                                 InvImg, WieldImg Texture
25419                                 WieldScale       [3]float32
25420
25421                                 StackMax uint16
25422
25423                                 Usable          bool
25424                                 CanPointLiquids bool
25425
25426                                 ToolCaps ToolCaps
25427
25428                                 Groups []Group
25429
25430                                 PlacePredict string
25431
25432                                 PlaceSnd, PlaceFailSnd SoundDef
25433
25434                                 PointRange float32
25435
25436                                 // Set index in Palette with "palette_index" item meta field,
25437                                 // this overrides Color.
25438                                 Palette Texture
25439                                 Color   color.NRGBA
25440
25441                                 // Texture overlays.
25442                                 InvOverlay, WieldOverlay Texture
25443
25444                                 ShortDesc string
25445                         }))(obj)).PointRange
25446                         *p = math.Float32frombits(read32(r))
25447                 }
25448                 if err := pcall(func() {
25449                         ((*(*(struct {
25450                                 Type ItemType
25451
25452                                 Name, Desc string
25453
25454                                 InvImg, WieldImg Texture
25455                                 WieldScale       [3]float32
25456
25457                                 StackMax uint16
25458
25459                                 Usable          bool
25460                                 CanPointLiquids bool
25461
25462                                 ToolCaps ToolCaps
25463
25464                                 Groups []Group
25465
25466                                 PlacePredict string
25467
25468                                 PlaceSnd, PlaceFailSnd SoundDef
25469
25470                                 PointRange float32
25471
25472                                 // Set index in Palette with "palette_index" item meta field,
25473                                 // this overrides Color.
25474                                 Palette Texture
25475                                 Color   color.NRGBA
25476
25477                                 // Texture overlays.
25478                                 InvOverlay, WieldOverlay Texture
25479
25480                                 ShortDesc string
25481                         }))(obj)).Palette).deserialize(r)
25482                 }); err != nil {
25483                         if err == io.EOF {
25484                                 chk(io.EOF)
25485                         }
25486                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25487                 }
25488                 {
25489                         p := &(*(*(struct {
25490                                 Type ItemType
25491
25492                                 Name, Desc string
25493
25494                                 InvImg, WieldImg Texture
25495                                 WieldScale       [3]float32
25496
25497                                 StackMax uint16
25498
25499                                 Usable          bool
25500                                 CanPointLiquids bool
25501
25502                                 ToolCaps ToolCaps
25503
25504                                 Groups []Group
25505
25506                                 PlacePredict string
25507
25508                                 PlaceSnd, PlaceFailSnd SoundDef
25509
25510                                 PointRange float32
25511
25512                                 // Set index in Palette with "palette_index" item meta field,
25513                                 // this overrides Color.
25514                                 Palette Texture
25515                                 Color   color.NRGBA
25516
25517                                 // Texture overlays.
25518                                 InvOverlay, WieldOverlay Texture
25519
25520                                 ShortDesc string
25521                         }))(obj)).Color
25522                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
25523
25524                 }
25525                 if err := pcall(func() {
25526                         ((*(*(struct {
25527                                 Type ItemType
25528
25529                                 Name, Desc string
25530
25531                                 InvImg, WieldImg Texture
25532                                 WieldScale       [3]float32
25533
25534                                 StackMax uint16
25535
25536                                 Usable          bool
25537                                 CanPointLiquids bool
25538
25539                                 ToolCaps ToolCaps
25540
25541                                 Groups []Group
25542
25543                                 PlacePredict string
25544
25545                                 PlaceSnd, PlaceFailSnd SoundDef
25546
25547                                 PointRange float32
25548
25549                                 // Set index in Palette with "palette_index" item meta field,
25550                                 // this overrides Color.
25551                                 Palette Texture
25552                                 Color   color.NRGBA
25553
25554                                 // Texture overlays.
25555                                 InvOverlay, WieldOverlay Texture
25556
25557                                 ShortDesc string
25558                         }))(obj)).InvOverlay).deserialize(r)
25559                 }); err != nil {
25560                         if err == io.EOF {
25561                                 chk(io.EOF)
25562                         }
25563                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25564                 }
25565                 if err := pcall(func() {
25566                         ((*(*(struct {
25567                                 Type ItemType
25568
25569                                 Name, Desc string
25570
25571                                 InvImg, WieldImg Texture
25572                                 WieldScale       [3]float32
25573
25574                                 StackMax uint16
25575
25576                                 Usable          bool
25577                                 CanPointLiquids bool
25578
25579                                 ToolCaps ToolCaps
25580
25581                                 Groups []Group
25582
25583                                 PlacePredict string
25584
25585                                 PlaceSnd, PlaceFailSnd SoundDef
25586
25587                                 PointRange float32
25588
25589                                 // Set index in Palette with "palette_index" item meta field,
25590                                 // this overrides Color.
25591                                 Palette Texture
25592                                 Color   color.NRGBA
25593
25594                                 // Texture overlays.
25595                                 InvOverlay, WieldOverlay Texture
25596
25597                                 ShortDesc string
25598                         }))(obj)).WieldOverlay).deserialize(r)
25599                 }); err != nil {
25600                         if err == io.EOF {
25601                                 chk(io.EOF)
25602                         }
25603                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
25604                 }
25605                 var local313 []uint8
25606                 var local314 uint16
25607                 {
25608                         p := &local314
25609                         *p = read16(r)
25610                 }
25611                 (local313) = make([]uint8, local314)
25612                 {
25613                         _, err := io.ReadFull(r, (local313)[:])
25614                         chk(err)
25615                 }
25616                 ((*(*(struct {
25617                         Type ItemType
25618
25619                         Name, Desc string
25620
25621                         InvImg, WieldImg Texture
25622                         WieldScale       [3]float32
25623
25624                         StackMax uint16
25625
25626                         Usable          bool
25627                         CanPointLiquids bool
25628
25629                         ToolCaps ToolCaps
25630
25631                         Groups []Group
25632
25633                         PlacePredict string
25634
25635                         PlaceSnd, PlaceFailSnd SoundDef
25636
25637                         PointRange float32
25638
25639                         // Set index in Palette with "palette_index" item meta field,
25640                         // this overrides Color.
25641                         Palette Texture
25642                         Color   color.NRGBA
25643
25644                         // Texture overlays.
25645                         InvOverlay, WieldOverlay Texture
25646
25647                         ShortDesc string
25648                 }))(obj)).ShortDesc) = string(local313)
25649                 if r.N > 0 {
25650                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
25651                 }
25652         }
25653 }
25654
25655 func (obj *SoundSrcType) serialize(w io.Writer) {
25656         {
25657                 x := *(*(uint8))(obj)
25658                 write8(w, uint8(x))
25659         }
25660 }
25661
25662 func (obj *SoundSrcType) deserialize(r io.Reader) {
25663         {
25664                 p := &*(*(uint8))(obj)
25665                 *p = read8(r)
25666         }
25667 }
25668
25669 func (obj *TileAnim) serialize(w io.Writer) {
25670         if err := pcall(func() {
25671                 ((*(*(struct {
25672                         Type AnimType
25673
25674                         //mt:if %s.Type == SpriteSheetAnim
25675                         AspectRatio [2]uint8
25676
25677                         //mt:if %s.Type == VerticalFrameAnim
25678                         NFrames [2]uint16
25679
25680                         //mt:if %s.Type != NoAnim
25681                         Duration float32 // in seconds
25682
25683                 }))(obj)).Type).serialize(w)
25684         }); err != nil {
25685                 if err == io.EOF {
25686                         chk(io.EOF)
25687                 }
25688                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
25689         }
25690         if !((*(*(struct {
25691                 Type AnimType
25692
25693                 //mt:if %s.Type == SpriteSheetAnim
25694                 AspectRatio [2]uint8
25695
25696                 //mt:if %s.Type == VerticalFrameAnim
25697                 NFrames [2]uint16
25698
25699                 //mt:if %s.Type != NoAnim
25700                 Duration float32 // in seconds
25701
25702         }))(obj)).Type < maxAnim) {
25703                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25704         }
25705         if (*(*(struct {
25706                 Type AnimType
25707
25708                 //mt:if %s.Type == SpriteSheetAnim
25709                 AspectRatio [2]uint8
25710
25711                 //mt:if %s.Type == VerticalFrameAnim
25712                 NFrames [2]uint16
25713
25714                 //mt:if %s.Type != NoAnim
25715                 Duration float32 // in seconds
25716
25717         }))(obj)).Type == SpriteSheetAnim {
25718                 {
25719                         _, err := w.Write(((*(*(struct {
25720                                 Type AnimType
25721
25722                                 //mt:if %s.Type == SpriteSheetAnim
25723                                 AspectRatio [2]uint8
25724
25725                                 //mt:if %s.Type == VerticalFrameAnim
25726                                 NFrames [2]uint16
25727
25728                                 //mt:if %s.Type != NoAnim
25729                                 Duration float32 // in seconds
25730
25731                         }))(obj)).AspectRatio)[:])
25732                         chk(err)
25733                 }
25734         }
25735         if (*(*(struct {
25736                 Type AnimType
25737
25738                 //mt:if %s.Type == SpriteSheetAnim
25739                 AspectRatio [2]uint8
25740
25741                 //mt:if %s.Type == VerticalFrameAnim
25742                 NFrames [2]uint16
25743
25744                 //mt:if %s.Type != NoAnim
25745                 Duration float32 // in seconds
25746
25747         }))(obj)).Type == VerticalFrameAnim {
25748                 for local315 := range (*(*(struct {
25749                         Type AnimType
25750
25751                         //mt:if %s.Type == SpriteSheetAnim
25752                         AspectRatio [2]uint8
25753
25754                         //mt:if %s.Type == VerticalFrameAnim
25755                         NFrames [2]uint16
25756
25757                         //mt:if %s.Type != NoAnim
25758                         Duration float32 // in seconds
25759
25760                 }))(obj)).NFrames {
25761                         {
25762                                 x := ((*(*(struct {
25763                                         Type AnimType
25764
25765                                         //mt:if %s.Type == SpriteSheetAnim
25766                                         AspectRatio [2]uint8
25767
25768                                         //mt:if %s.Type == VerticalFrameAnim
25769                                         NFrames [2]uint16
25770
25771                                         //mt:if %s.Type != NoAnim
25772                                         Duration float32 // in seconds
25773
25774                                 }))(obj)).NFrames)[local315]
25775                                 write16(w, uint16(x))
25776                         }
25777                 }
25778         }
25779         if (*(*(struct {
25780                 Type AnimType
25781
25782                 //mt:if %s.Type == SpriteSheetAnim
25783                 AspectRatio [2]uint8
25784
25785                 //mt:if %s.Type == VerticalFrameAnim
25786                 NFrames [2]uint16
25787
25788                 //mt:if %s.Type != NoAnim
25789                 Duration float32 // in seconds
25790
25791         }))(obj)).Type != NoAnim {
25792                 {
25793                         x := (*(*(struct {
25794                                 Type AnimType
25795
25796                                 //mt:if %s.Type == SpriteSheetAnim
25797                                 AspectRatio [2]uint8
25798
25799                                 //mt:if %s.Type == VerticalFrameAnim
25800                                 NFrames [2]uint16
25801
25802                                 //mt:if %s.Type != NoAnim
25803                                 Duration float32 // in seconds
25804
25805                         }))(obj)).Duration
25806                         write32(w, math.Float32bits(x))
25807                 }
25808         }
25809 }
25810
25811 func (obj *TileAnim) deserialize(r io.Reader) {
25812         if err := pcall(func() {
25813                 ((*(*(struct {
25814                         Type AnimType
25815
25816                         //mt:if %s.Type == SpriteSheetAnim
25817                         AspectRatio [2]uint8
25818
25819                         //mt:if %s.Type == VerticalFrameAnim
25820                         NFrames [2]uint16
25821
25822                         //mt:if %s.Type != NoAnim
25823                         Duration float32 // in seconds
25824
25825                 }))(obj)).Type).deserialize(r)
25826         }); err != nil {
25827                 if err == io.EOF {
25828                         chk(io.EOF)
25829                 }
25830                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AnimType", err))
25831         }
25832         if !((*(*(struct {
25833                 Type AnimType
25834
25835                 //mt:if %s.Type == SpriteSheetAnim
25836                 AspectRatio [2]uint8
25837
25838                 //mt:if %s.Type == VerticalFrameAnim
25839                 NFrames [2]uint16
25840
25841                 //mt:if %s.Type != NoAnim
25842                 Duration float32 // in seconds
25843
25844         }))(obj)).Type < maxAnim) {
25845                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25846         }
25847         if (*(*(struct {
25848                 Type AnimType
25849
25850                 //mt:if %s.Type == SpriteSheetAnim
25851                 AspectRatio [2]uint8
25852
25853                 //mt:if %s.Type == VerticalFrameAnim
25854                 NFrames [2]uint16
25855
25856                 //mt:if %s.Type != NoAnim
25857                 Duration float32 // in seconds
25858
25859         }))(obj)).Type == SpriteSheetAnim {
25860                 {
25861                         _, err := io.ReadFull(r, ((*(*(struct {
25862                                 Type AnimType
25863
25864                                 //mt:if %s.Type == SpriteSheetAnim
25865                                 AspectRatio [2]uint8
25866
25867                                 //mt:if %s.Type == VerticalFrameAnim
25868                                 NFrames [2]uint16
25869
25870                                 //mt:if %s.Type != NoAnim
25871                                 Duration float32 // in seconds
25872
25873                         }))(obj)).AspectRatio)[:])
25874                         chk(err)
25875                 }
25876         }
25877         if (*(*(struct {
25878                 Type AnimType
25879
25880                 //mt:if %s.Type == SpriteSheetAnim
25881                 AspectRatio [2]uint8
25882
25883                 //mt:if %s.Type == VerticalFrameAnim
25884                 NFrames [2]uint16
25885
25886                 //mt:if %s.Type != NoAnim
25887                 Duration float32 // in seconds
25888
25889         }))(obj)).Type == VerticalFrameAnim {
25890                 for local316 := range (*(*(struct {
25891                         Type AnimType
25892
25893                         //mt:if %s.Type == SpriteSheetAnim
25894                         AspectRatio [2]uint8
25895
25896                         //mt:if %s.Type == VerticalFrameAnim
25897                         NFrames [2]uint16
25898
25899                         //mt:if %s.Type != NoAnim
25900                         Duration float32 // in seconds
25901
25902                 }))(obj)).NFrames {
25903                         {
25904                                 p := &((*(*(struct {
25905                                         Type AnimType
25906
25907                                         //mt:if %s.Type == SpriteSheetAnim
25908                                         AspectRatio [2]uint8
25909
25910                                         //mt:if %s.Type == VerticalFrameAnim
25911                                         NFrames [2]uint16
25912
25913                                         //mt:if %s.Type != NoAnim
25914                                         Duration float32 // in seconds
25915
25916                                 }))(obj)).NFrames)[local316]
25917                                 *p = read16(r)
25918                         }
25919                 }
25920         }
25921         if (*(*(struct {
25922                 Type AnimType
25923
25924                 //mt:if %s.Type == SpriteSheetAnim
25925                 AspectRatio [2]uint8
25926
25927                 //mt:if %s.Type == VerticalFrameAnim
25928                 NFrames [2]uint16
25929
25930                 //mt:if %s.Type != NoAnim
25931                 Duration float32 // in seconds
25932
25933         }))(obj)).Type != NoAnim {
25934                 {
25935                         p := &(*(*(struct {
25936                                 Type AnimType
25937
25938                                 //mt:if %s.Type == SpriteSheetAnim
25939                                 AspectRatio [2]uint8
25940
25941                                 //mt:if %s.Type == VerticalFrameAnim
25942                                 NFrames [2]uint16
25943
25944                                 //mt:if %s.Type != NoAnim
25945                                 Duration float32 // in seconds
25946
25947                         }))(obj)).Duration
25948                         *p = math.Float32frombits(read32(r))
25949                 }
25950         }
25951 }
25952
25953 func (obj *Content) serialize(w io.Writer) {
25954         {
25955                 x := *(*(uint16))(obj)
25956                 write16(w, uint16(x))
25957         }
25958 }
25959
25960 func (obj *Content) deserialize(r io.Reader) {
25961         {
25962                 p := &*(*(uint16))(obj)
25963                 *p = read16(r)
25964         }
25965 }
25966
25967 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
25968         {
25969                 x := *(*(uint32))(obj)
25970                 write32(w, uint32(x))
25971         }
25972 }
25973
25974 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
25975         {
25976                 p := &*(*(uint32))(obj)
25977                 *p = read32(r)
25978         }
25979 }
25980
25981 func (obj *HUDID) serialize(w io.Writer) {
25982         {
25983                 x := *(*(uint32))(obj)
25984                 write32(w, uint32(x))
25985         }
25986 }
25987
25988 func (obj *HUDID) deserialize(r io.Reader) {
25989         {
25990                 p := &*(*(uint32))(obj)
25991                 *p = read32(r)
25992         }
25993 }
25994
25995 func (obj *HUD) serialize(w io.Writer) {
25996         if err := pcall(func() {
25997                 ((*(*(struct {
25998                         Type HUDType
25999
26000                         Pos      [2]float32
26001                         Name     string
26002                         Scale    [2]float32
26003                         Text     string
26004                         Number   uint32
26005                         Item     uint32
26006                         Dir      uint32
26007                         Align    [2]float32
26008                         Offset   [2]float32
26009                         WorldPos Pos
26010                         Size     [2]int32
26011                         ZIndex   int16
26012                         Text2    string
26013                 }))(obj)).Type).serialize(w)
26014         }); err != nil {
26015                 if err == io.EOF {
26016                         chk(io.EOF)
26017                 }
26018                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
26019         }
26020         for local317 := range (*(*(struct {
26021                 Type HUDType
26022
26023                 Pos      [2]float32
26024                 Name     string
26025                 Scale    [2]float32
26026                 Text     string
26027                 Number   uint32
26028                 Item     uint32
26029                 Dir      uint32
26030                 Align    [2]float32
26031                 Offset   [2]float32
26032                 WorldPos Pos
26033                 Size     [2]int32
26034                 ZIndex   int16
26035                 Text2    string
26036         }))(obj)).Pos {
26037                 {
26038                         x := ((*(*(struct {
26039                                 Type HUDType
26040
26041                                 Pos      [2]float32
26042                                 Name     string
26043                                 Scale    [2]float32
26044                                 Text     string
26045                                 Number   uint32
26046                                 Item     uint32
26047                                 Dir      uint32
26048                                 Align    [2]float32
26049                                 Offset   [2]float32
26050                                 WorldPos Pos
26051                                 Size     [2]int32
26052                                 ZIndex   int16
26053                                 Text2    string
26054                         }))(obj)).Pos)[local317]
26055                         write32(w, math.Float32bits(x))
26056                 }
26057         }
26058         if len(([]byte((*(*(struct {
26059                 Type HUDType
26060
26061                 Pos      [2]float32
26062                 Name     string
26063                 Scale    [2]float32
26064                 Text     string
26065                 Number   uint32
26066                 Item     uint32
26067                 Dir      uint32
26068                 Align    [2]float32
26069                 Offset   [2]float32
26070                 WorldPos Pos
26071                 Size     [2]int32
26072                 ZIndex   int16
26073                 Text2    string
26074         }))(obj)).Name))) > math.MaxUint16 {
26075                 chk(ErrTooLong)
26076         }
26077         {
26078                 x := uint16(len(([]byte((*(*(struct {
26079                         Type HUDType
26080
26081                         Pos      [2]float32
26082                         Name     string
26083                         Scale    [2]float32
26084                         Text     string
26085                         Number   uint32
26086                         Item     uint32
26087                         Dir      uint32
26088                         Align    [2]float32
26089                         Offset   [2]float32
26090                         WorldPos Pos
26091                         Size     [2]int32
26092                         ZIndex   int16
26093                         Text2    string
26094                 }))(obj)).Name))))
26095                 write16(w, uint16(x))
26096         }
26097         {
26098                 _, err := w.Write(([]byte((*(*(struct {
26099                         Type HUDType
26100
26101                         Pos      [2]float32
26102                         Name     string
26103                         Scale    [2]float32
26104                         Text     string
26105                         Number   uint32
26106                         Item     uint32
26107                         Dir      uint32
26108                         Align    [2]float32
26109                         Offset   [2]float32
26110                         WorldPos Pos
26111                         Size     [2]int32
26112                         ZIndex   int16
26113                         Text2    string
26114                 }))(obj)).Name))[:])
26115                 chk(err)
26116         }
26117         for local318 := range (*(*(struct {
26118                 Type HUDType
26119
26120                 Pos      [2]float32
26121                 Name     string
26122                 Scale    [2]float32
26123                 Text     string
26124                 Number   uint32
26125                 Item     uint32
26126                 Dir      uint32
26127                 Align    [2]float32
26128                 Offset   [2]float32
26129                 WorldPos Pos
26130                 Size     [2]int32
26131                 ZIndex   int16
26132                 Text2    string
26133         }))(obj)).Scale {
26134                 {
26135                         x := ((*(*(struct {
26136                                 Type HUDType
26137
26138                                 Pos      [2]float32
26139                                 Name     string
26140                                 Scale    [2]float32
26141                                 Text     string
26142                                 Number   uint32
26143                                 Item     uint32
26144                                 Dir      uint32
26145                                 Align    [2]float32
26146                                 Offset   [2]float32
26147                                 WorldPos Pos
26148                                 Size     [2]int32
26149                                 ZIndex   int16
26150                                 Text2    string
26151                         }))(obj)).Scale)[local318]
26152                         write32(w, math.Float32bits(x))
26153                 }
26154         }
26155         if len(([]byte((*(*(struct {
26156                 Type HUDType
26157
26158                 Pos      [2]float32
26159                 Name     string
26160                 Scale    [2]float32
26161                 Text     string
26162                 Number   uint32
26163                 Item     uint32
26164                 Dir      uint32
26165                 Align    [2]float32
26166                 Offset   [2]float32
26167                 WorldPos Pos
26168                 Size     [2]int32
26169                 ZIndex   int16
26170                 Text2    string
26171         }))(obj)).Text))) > math.MaxUint16 {
26172                 chk(ErrTooLong)
26173         }
26174         {
26175                 x := uint16(len(([]byte((*(*(struct {
26176                         Type HUDType
26177
26178                         Pos      [2]float32
26179                         Name     string
26180                         Scale    [2]float32
26181                         Text     string
26182                         Number   uint32
26183                         Item     uint32
26184                         Dir      uint32
26185                         Align    [2]float32
26186                         Offset   [2]float32
26187                         WorldPos Pos
26188                         Size     [2]int32
26189                         ZIndex   int16
26190                         Text2    string
26191                 }))(obj)).Text))))
26192                 write16(w, uint16(x))
26193         }
26194         {
26195                 _, err := w.Write(([]byte((*(*(struct {
26196                         Type HUDType
26197
26198                         Pos      [2]float32
26199                         Name     string
26200                         Scale    [2]float32
26201                         Text     string
26202                         Number   uint32
26203                         Item     uint32
26204                         Dir      uint32
26205                         Align    [2]float32
26206                         Offset   [2]float32
26207                         WorldPos Pos
26208                         Size     [2]int32
26209                         ZIndex   int16
26210                         Text2    string
26211                 }))(obj)).Text))[:])
26212                 chk(err)
26213         }
26214         {
26215                 x := (*(*(struct {
26216                         Type HUDType
26217
26218                         Pos      [2]float32
26219                         Name     string
26220                         Scale    [2]float32
26221                         Text     string
26222                         Number   uint32
26223                         Item     uint32
26224                         Dir      uint32
26225                         Align    [2]float32
26226                         Offset   [2]float32
26227                         WorldPos Pos
26228                         Size     [2]int32
26229                         ZIndex   int16
26230                         Text2    string
26231                 }))(obj)).Number
26232                 write32(w, uint32(x))
26233         }
26234         {
26235                 x := (*(*(struct {
26236                         Type HUDType
26237
26238                         Pos      [2]float32
26239                         Name     string
26240                         Scale    [2]float32
26241                         Text     string
26242                         Number   uint32
26243                         Item     uint32
26244                         Dir      uint32
26245                         Align    [2]float32
26246                         Offset   [2]float32
26247                         WorldPos Pos
26248                         Size     [2]int32
26249                         ZIndex   int16
26250                         Text2    string
26251                 }))(obj)).Item
26252                 write32(w, uint32(x))
26253         }
26254         {
26255                 x := (*(*(struct {
26256                         Type HUDType
26257
26258                         Pos      [2]float32
26259                         Name     string
26260                         Scale    [2]float32
26261                         Text     string
26262                         Number   uint32
26263                         Item     uint32
26264                         Dir      uint32
26265                         Align    [2]float32
26266                         Offset   [2]float32
26267                         WorldPos Pos
26268                         Size     [2]int32
26269                         ZIndex   int16
26270                         Text2    string
26271                 }))(obj)).Dir
26272                 write32(w, uint32(x))
26273         }
26274         for local319 := range (*(*(struct {
26275                 Type HUDType
26276
26277                 Pos      [2]float32
26278                 Name     string
26279                 Scale    [2]float32
26280                 Text     string
26281                 Number   uint32
26282                 Item     uint32
26283                 Dir      uint32
26284                 Align    [2]float32
26285                 Offset   [2]float32
26286                 WorldPos Pos
26287                 Size     [2]int32
26288                 ZIndex   int16
26289                 Text2    string
26290         }))(obj)).Align {
26291                 {
26292                         x := ((*(*(struct {
26293                                 Type HUDType
26294
26295                                 Pos      [2]float32
26296                                 Name     string
26297                                 Scale    [2]float32
26298                                 Text     string
26299                                 Number   uint32
26300                                 Item     uint32
26301                                 Dir      uint32
26302                                 Align    [2]float32
26303                                 Offset   [2]float32
26304                                 WorldPos Pos
26305                                 Size     [2]int32
26306                                 ZIndex   int16
26307                                 Text2    string
26308                         }))(obj)).Align)[local319]
26309                         write32(w, math.Float32bits(x))
26310                 }
26311         }
26312         for local320 := range (*(*(struct {
26313                 Type HUDType
26314
26315                 Pos      [2]float32
26316                 Name     string
26317                 Scale    [2]float32
26318                 Text     string
26319                 Number   uint32
26320                 Item     uint32
26321                 Dir      uint32
26322                 Align    [2]float32
26323                 Offset   [2]float32
26324                 WorldPos Pos
26325                 Size     [2]int32
26326                 ZIndex   int16
26327                 Text2    string
26328         }))(obj)).Offset {
26329                 {
26330                         x := ((*(*(struct {
26331                                 Type HUDType
26332
26333                                 Pos      [2]float32
26334                                 Name     string
26335                                 Scale    [2]float32
26336                                 Text     string
26337                                 Number   uint32
26338                                 Item     uint32
26339                                 Dir      uint32
26340                                 Align    [2]float32
26341                                 Offset   [2]float32
26342                                 WorldPos Pos
26343                                 Size     [2]int32
26344                                 ZIndex   int16
26345                                 Text2    string
26346                         }))(obj)).Offset)[local320]
26347                         write32(w, math.Float32bits(x))
26348                 }
26349         }
26350         if err := pcall(func() {
26351                 ((*(*(struct {
26352                         Type HUDType
26353
26354                         Pos      [2]float32
26355                         Name     string
26356                         Scale    [2]float32
26357                         Text     string
26358                         Number   uint32
26359                         Item     uint32
26360                         Dir      uint32
26361                         Align    [2]float32
26362                         Offset   [2]float32
26363                         WorldPos Pos
26364                         Size     [2]int32
26365                         ZIndex   int16
26366                         Text2    string
26367                 }))(obj)).WorldPos).serialize(w)
26368         }); err != nil {
26369                 if err == io.EOF {
26370                         chk(io.EOF)
26371                 }
26372                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
26373         }
26374         for local321 := range (*(*(struct {
26375                 Type HUDType
26376
26377                 Pos      [2]float32
26378                 Name     string
26379                 Scale    [2]float32
26380                 Text     string
26381                 Number   uint32
26382                 Item     uint32
26383                 Dir      uint32
26384                 Align    [2]float32
26385                 Offset   [2]float32
26386                 WorldPos Pos
26387                 Size     [2]int32
26388                 ZIndex   int16
26389                 Text2    string
26390         }))(obj)).Size {
26391                 {
26392                         x := ((*(*(struct {
26393                                 Type HUDType
26394
26395                                 Pos      [2]float32
26396                                 Name     string
26397                                 Scale    [2]float32
26398                                 Text     string
26399                                 Number   uint32
26400                                 Item     uint32
26401                                 Dir      uint32
26402                                 Align    [2]float32
26403                                 Offset   [2]float32
26404                                 WorldPos Pos
26405                                 Size     [2]int32
26406                                 ZIndex   int16
26407                                 Text2    string
26408                         }))(obj)).Size)[local321]
26409                         write32(w, uint32(x))
26410                 }
26411         }
26412         {
26413                 x := (*(*(struct {
26414                         Type HUDType
26415
26416                         Pos      [2]float32
26417                         Name     string
26418                         Scale    [2]float32
26419                         Text     string
26420                         Number   uint32
26421                         Item     uint32
26422                         Dir      uint32
26423                         Align    [2]float32
26424                         Offset   [2]float32
26425                         WorldPos Pos
26426                         Size     [2]int32
26427                         ZIndex   int16
26428                         Text2    string
26429                 }))(obj)).ZIndex
26430                 write16(w, uint16(x))
26431         }
26432         if len(([]byte((*(*(struct {
26433                 Type HUDType
26434
26435                 Pos      [2]float32
26436                 Name     string
26437                 Scale    [2]float32
26438                 Text     string
26439                 Number   uint32
26440                 Item     uint32
26441                 Dir      uint32
26442                 Align    [2]float32
26443                 Offset   [2]float32
26444                 WorldPos Pos
26445                 Size     [2]int32
26446                 ZIndex   int16
26447                 Text2    string
26448         }))(obj)).Text2))) > math.MaxUint16 {
26449                 chk(ErrTooLong)
26450         }
26451         {
26452                 x := uint16(len(([]byte((*(*(struct {
26453                         Type HUDType
26454
26455                         Pos      [2]float32
26456                         Name     string
26457                         Scale    [2]float32
26458                         Text     string
26459                         Number   uint32
26460                         Item     uint32
26461                         Dir      uint32
26462                         Align    [2]float32
26463                         Offset   [2]float32
26464                         WorldPos Pos
26465                         Size     [2]int32
26466                         ZIndex   int16
26467                         Text2    string
26468                 }))(obj)).Text2))))
26469                 write16(w, uint16(x))
26470         }
26471         {
26472                 _, err := w.Write(([]byte((*(*(struct {
26473                         Type HUDType
26474
26475                         Pos      [2]float32
26476                         Name     string
26477                         Scale    [2]float32
26478                         Text     string
26479                         Number   uint32
26480                         Item     uint32
26481                         Dir      uint32
26482                         Align    [2]float32
26483                         Offset   [2]float32
26484                         WorldPos Pos
26485                         Size     [2]int32
26486                         ZIndex   int16
26487                         Text2    string
26488                 }))(obj)).Text2))[:])
26489                 chk(err)
26490         }
26491 }
26492
26493 func (obj *HUD) deserialize(r io.Reader) {
26494         if err := pcall(func() {
26495                 ((*(*(struct {
26496                         Type HUDType
26497
26498                         Pos      [2]float32
26499                         Name     string
26500                         Scale    [2]float32
26501                         Text     string
26502                         Number   uint32
26503                         Item     uint32
26504                         Dir      uint32
26505                         Align    [2]float32
26506                         Offset   [2]float32
26507                         WorldPos Pos
26508                         Size     [2]int32
26509                         ZIndex   int16
26510                         Text2    string
26511                 }))(obj)).Type).deserialize(r)
26512         }); err != nil {
26513                 if err == io.EOF {
26514                         chk(io.EOF)
26515                 }
26516                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
26517         }
26518         for local322 := range (*(*(struct {
26519                 Type HUDType
26520
26521                 Pos      [2]float32
26522                 Name     string
26523                 Scale    [2]float32
26524                 Text     string
26525                 Number   uint32
26526                 Item     uint32
26527                 Dir      uint32
26528                 Align    [2]float32
26529                 Offset   [2]float32
26530                 WorldPos Pos
26531                 Size     [2]int32
26532                 ZIndex   int16
26533                 Text2    string
26534         }))(obj)).Pos {
26535                 {
26536                         p := &((*(*(struct {
26537                                 Type HUDType
26538
26539                                 Pos      [2]float32
26540                                 Name     string
26541                                 Scale    [2]float32
26542                                 Text     string
26543                                 Number   uint32
26544                                 Item     uint32
26545                                 Dir      uint32
26546                                 Align    [2]float32
26547                                 Offset   [2]float32
26548                                 WorldPos Pos
26549                                 Size     [2]int32
26550                                 ZIndex   int16
26551                                 Text2    string
26552                         }))(obj)).Pos)[local322]
26553                         *p = math.Float32frombits(read32(r))
26554                 }
26555         }
26556         var local323 []uint8
26557         var local324 uint16
26558         {
26559                 p := &local324
26560                 *p = read16(r)
26561         }
26562         (local323) = make([]uint8, local324)
26563         {
26564                 _, err := io.ReadFull(r, (local323)[:])
26565                 chk(err)
26566         }
26567         ((*(*(struct {
26568                 Type HUDType
26569
26570                 Pos      [2]float32
26571                 Name     string
26572                 Scale    [2]float32
26573                 Text     string
26574                 Number   uint32
26575                 Item     uint32
26576                 Dir      uint32
26577                 Align    [2]float32
26578                 Offset   [2]float32
26579                 WorldPos Pos
26580                 Size     [2]int32
26581                 ZIndex   int16
26582                 Text2    string
26583         }))(obj)).Name) = string(local323)
26584         for local325 := range (*(*(struct {
26585                 Type HUDType
26586
26587                 Pos      [2]float32
26588                 Name     string
26589                 Scale    [2]float32
26590                 Text     string
26591                 Number   uint32
26592                 Item     uint32
26593                 Dir      uint32
26594                 Align    [2]float32
26595                 Offset   [2]float32
26596                 WorldPos Pos
26597                 Size     [2]int32
26598                 ZIndex   int16
26599                 Text2    string
26600         }))(obj)).Scale {
26601                 {
26602                         p := &((*(*(struct {
26603                                 Type HUDType
26604
26605                                 Pos      [2]float32
26606                                 Name     string
26607                                 Scale    [2]float32
26608                                 Text     string
26609                                 Number   uint32
26610                                 Item     uint32
26611                                 Dir      uint32
26612                                 Align    [2]float32
26613                                 Offset   [2]float32
26614                                 WorldPos Pos
26615                                 Size     [2]int32
26616                                 ZIndex   int16
26617                                 Text2    string
26618                         }))(obj)).Scale)[local325]
26619                         *p = math.Float32frombits(read32(r))
26620                 }
26621         }
26622         var local326 []uint8
26623         var local327 uint16
26624         {
26625                 p := &local327
26626                 *p = read16(r)
26627         }
26628         (local326) = make([]uint8, local327)
26629         {
26630                 _, err := io.ReadFull(r, (local326)[:])
26631                 chk(err)
26632         }
26633         ((*(*(struct {
26634                 Type HUDType
26635
26636                 Pos      [2]float32
26637                 Name     string
26638                 Scale    [2]float32
26639                 Text     string
26640                 Number   uint32
26641                 Item     uint32
26642                 Dir      uint32
26643                 Align    [2]float32
26644                 Offset   [2]float32
26645                 WorldPos Pos
26646                 Size     [2]int32
26647                 ZIndex   int16
26648                 Text2    string
26649         }))(obj)).Text) = string(local326)
26650         {
26651                 p := &(*(*(struct {
26652                         Type HUDType
26653
26654                         Pos      [2]float32
26655                         Name     string
26656                         Scale    [2]float32
26657                         Text     string
26658                         Number   uint32
26659                         Item     uint32
26660                         Dir      uint32
26661                         Align    [2]float32
26662                         Offset   [2]float32
26663                         WorldPos Pos
26664                         Size     [2]int32
26665                         ZIndex   int16
26666                         Text2    string
26667                 }))(obj)).Number
26668                 *p = read32(r)
26669         }
26670         {
26671                 p := &(*(*(struct {
26672                         Type HUDType
26673
26674                         Pos      [2]float32
26675                         Name     string
26676                         Scale    [2]float32
26677                         Text     string
26678                         Number   uint32
26679                         Item     uint32
26680                         Dir      uint32
26681                         Align    [2]float32
26682                         Offset   [2]float32
26683                         WorldPos Pos
26684                         Size     [2]int32
26685                         ZIndex   int16
26686                         Text2    string
26687                 }))(obj)).Item
26688                 *p = read32(r)
26689         }
26690         {
26691                 p := &(*(*(struct {
26692                         Type HUDType
26693
26694                         Pos      [2]float32
26695                         Name     string
26696                         Scale    [2]float32
26697                         Text     string
26698                         Number   uint32
26699                         Item     uint32
26700                         Dir      uint32
26701                         Align    [2]float32
26702                         Offset   [2]float32
26703                         WorldPos Pos
26704                         Size     [2]int32
26705                         ZIndex   int16
26706                         Text2    string
26707                 }))(obj)).Dir
26708                 *p = read32(r)
26709         }
26710         for local328 := range (*(*(struct {
26711                 Type HUDType
26712
26713                 Pos      [2]float32
26714                 Name     string
26715                 Scale    [2]float32
26716                 Text     string
26717                 Number   uint32
26718                 Item     uint32
26719                 Dir      uint32
26720                 Align    [2]float32
26721                 Offset   [2]float32
26722                 WorldPos Pos
26723                 Size     [2]int32
26724                 ZIndex   int16
26725                 Text2    string
26726         }))(obj)).Align {
26727                 {
26728                         p := &((*(*(struct {
26729                                 Type HUDType
26730
26731                                 Pos      [2]float32
26732                                 Name     string
26733                                 Scale    [2]float32
26734                                 Text     string
26735                                 Number   uint32
26736                                 Item     uint32
26737                                 Dir      uint32
26738                                 Align    [2]float32
26739                                 Offset   [2]float32
26740                                 WorldPos Pos
26741                                 Size     [2]int32
26742                                 ZIndex   int16
26743                                 Text2    string
26744                         }))(obj)).Align)[local328]
26745                         *p = math.Float32frombits(read32(r))
26746                 }
26747         }
26748         for local329 := range (*(*(struct {
26749                 Type HUDType
26750
26751                 Pos      [2]float32
26752                 Name     string
26753                 Scale    [2]float32
26754                 Text     string
26755                 Number   uint32
26756                 Item     uint32
26757                 Dir      uint32
26758                 Align    [2]float32
26759                 Offset   [2]float32
26760                 WorldPos Pos
26761                 Size     [2]int32
26762                 ZIndex   int16
26763                 Text2    string
26764         }))(obj)).Offset {
26765                 {
26766                         p := &((*(*(struct {
26767                                 Type HUDType
26768
26769                                 Pos      [2]float32
26770                                 Name     string
26771                                 Scale    [2]float32
26772                                 Text     string
26773                                 Number   uint32
26774                                 Item     uint32
26775                                 Dir      uint32
26776                                 Align    [2]float32
26777                                 Offset   [2]float32
26778                                 WorldPos Pos
26779                                 Size     [2]int32
26780                                 ZIndex   int16
26781                                 Text2    string
26782                         }))(obj)).Offset)[local329]
26783                         *p = math.Float32frombits(read32(r))
26784                 }
26785         }
26786         if err := pcall(func() {
26787                 ((*(*(struct {
26788                         Type HUDType
26789
26790                         Pos      [2]float32
26791                         Name     string
26792                         Scale    [2]float32
26793                         Text     string
26794                         Number   uint32
26795                         Item     uint32
26796                         Dir      uint32
26797                         Align    [2]float32
26798                         Offset   [2]float32
26799                         WorldPos Pos
26800                         Size     [2]int32
26801                         ZIndex   int16
26802                         Text2    string
26803                 }))(obj)).WorldPos).deserialize(r)
26804         }); err != nil {
26805                 if err == io.EOF {
26806                         chk(io.EOF)
26807                 }
26808                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
26809         }
26810         for local330 := range (*(*(struct {
26811                 Type HUDType
26812
26813                 Pos      [2]float32
26814                 Name     string
26815                 Scale    [2]float32
26816                 Text     string
26817                 Number   uint32
26818                 Item     uint32
26819                 Dir      uint32
26820                 Align    [2]float32
26821                 Offset   [2]float32
26822                 WorldPos Pos
26823                 Size     [2]int32
26824                 ZIndex   int16
26825                 Text2    string
26826         }))(obj)).Size {
26827                 {
26828                         p := &((*(*(struct {
26829                                 Type HUDType
26830
26831                                 Pos      [2]float32
26832                                 Name     string
26833                                 Scale    [2]float32
26834                                 Text     string
26835                                 Number   uint32
26836                                 Item     uint32
26837                                 Dir      uint32
26838                                 Align    [2]float32
26839                                 Offset   [2]float32
26840                                 WorldPos Pos
26841                                 Size     [2]int32
26842                                 ZIndex   int16
26843                                 Text2    string
26844                         }))(obj)).Size)[local330]
26845                         *p = int32(read32(r))
26846                 }
26847         }
26848         {
26849                 p := &(*(*(struct {
26850                         Type HUDType
26851
26852                         Pos      [2]float32
26853                         Name     string
26854                         Scale    [2]float32
26855                         Text     string
26856                         Number   uint32
26857                         Item     uint32
26858                         Dir      uint32
26859                         Align    [2]float32
26860                         Offset   [2]float32
26861                         WorldPos Pos
26862                         Size     [2]int32
26863                         ZIndex   int16
26864                         Text2    string
26865                 }))(obj)).ZIndex
26866                 *p = int16(read16(r))
26867         }
26868         var local331 []uint8
26869         var local332 uint16
26870         {
26871                 p := &local332
26872                 *p = read16(r)
26873         }
26874         (local331) = make([]uint8, local332)
26875         {
26876                 _, err := io.ReadFull(r, (local331)[:])
26877                 chk(err)
26878         }
26879         ((*(*(struct {
26880                 Type HUDType
26881
26882                 Pos      [2]float32
26883                 Name     string
26884                 Scale    [2]float32
26885                 Text     string
26886                 Number   uint32
26887                 Item     uint32
26888                 Dir      uint32
26889                 Align    [2]float32
26890                 Offset   [2]float32
26891                 WorldPos Pos
26892                 Size     [2]int32
26893                 ZIndex   int16
26894                 Text2    string
26895         }))(obj)).Text2) = string(local331)
26896 }
26897
26898 func (obj *HUDField) serialize(w io.Writer) {
26899         {
26900                 x := *(*(uint8))(obj)
26901                 write8(w, uint8(x))
26902         }
26903 }
26904
26905 func (obj *HUDField) deserialize(r io.Reader) {
26906         {
26907                 p := &*(*(uint8))(obj)
26908                 *p = read8(r)
26909         }
26910 }
26911
26912 func (obj *HUDFlags) serialize(w io.Writer) {
26913         {
26914                 x := *(*(uint32))(obj)
26915                 write32(w, uint32(x))
26916         }
26917 }
26918
26919 func (obj *HUDFlags) deserialize(r io.Reader) {
26920         {
26921                 p := &*(*(uint32))(obj)
26922                 *p = read32(r)
26923         }
26924 }
26925
26926 func (obj *HotbarParam) serialize(w io.Writer) {
26927         {
26928                 x := *(*(uint16))(obj)
26929                 write16(w, uint16(x))
26930         }
26931 }
26932
26933 func (obj *HotbarParam) deserialize(r io.Reader) {
26934         {
26935                 p := &*(*(uint16))(obj)
26936                 *p = read16(r)
26937         }
26938 }
26939
26940 func (obj *Texture) serialize(w io.Writer) {
26941         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
26942                 chk(ErrTooLong)
26943         }
26944         {
26945                 x := uint16(len(([]byte(*(*(string))(obj)))))
26946                 write16(w, uint16(x))
26947         }
26948         {
26949                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
26950                 chk(err)
26951         }
26952 }
26953
26954 func (obj *Texture) deserialize(r io.Reader) {
26955         var local333 []uint8
26956         var local334 uint16
26957         {
26958                 p := &local334
26959                 *p = read16(r)
26960         }
26961         (local333) = make([]uint8, local334)
26962         {
26963                 _, err := io.ReadFull(r, (local333)[:])
26964                 chk(err)
26965         }
26966         (*(*(string))(obj)) = string(local333)
26967 }
26968
26969 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
26970         {
26971                 x := *(*(uint8))(obj)
26972                 write8(w, uint8(x))
26973         }
26974 }
26975
26976 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
26977         {
26978                 p := &*(*(uint8))(obj)
26979                 *p = read8(r)
26980         }
26981 }
26982
26983 func (obj *ModChanSig) serialize(w io.Writer) {
26984         {
26985                 x := *(*(uint8))(obj)
26986                 write8(w, uint8(x))
26987         }
26988 }
26989
26990 func (obj *ModChanSig) deserialize(r io.Reader) {
26991         {
26992                 p := &*(*(uint8))(obj)
26993                 *p = read8(r)
26994         }
26995 }
26996
26997 func (obj *AOProps) serialize(w io.Writer) {
26998         {
26999                 local335 := uint8(4)
27000                 {
27001                         x := local335
27002                         write8(w, uint8(x))
27003                 }
27004         }
27005         {
27006                 x := (*(*(struct {
27007                         MaxHP            uint16 // Player only.
27008                         CollideWithNodes bool
27009                         Weight           float32 // deprecated
27010                         ColBox, SelBox   Box
27011                         Pointable        bool
27012                         Visual           string
27013                         VisualSize       [3]float32
27014                         Textures         []Texture
27015                         SpriteSheetSize  [2]int16 // in sprites.
27016                         SpritePos        [2]int16 // in sprite sheet.
27017                         Visible          bool
27018                         MakeFootstepSnds bool
27019                         RotateSpeed      float32 // in radians per second.
27020                         Mesh             string
27021                         Colors           []color.NRGBA
27022                         CollideWithAOs   bool
27023                         StepHeight       float32
27024                         FaceRotateDir    bool
27025                         FaceRotateDirOff float32 // in degrees.
27026                         BackfaceCull     bool
27027                         Nametag          string
27028                         NametagColor     color.NRGBA
27029                         FaceRotateSpeed  float32 // in degrees per second.
27030                         Infotext         string
27031                         Itemstring       string
27032                         Glow             int8
27033                         MaxBreath        uint16  // Player only.
27034                         EyeHeight        float32 // Player only.
27035                         ZoomFOV          float32 // in degrees. Player only.
27036                         UseTextureAlpha  bool
27037                         DmgTextureMod    Texture // suffix
27038                         Shaded           bool
27039                         ShowOnMinimap    bool
27040                         NametagBG        color.NRGBA
27041                 }))(obj)).MaxHP
27042                 write16(w, uint16(x))
27043         }
27044         {
27045                 x := (*(*(struct {
27046                         MaxHP            uint16 // Player only.
27047                         CollideWithNodes bool
27048                         Weight           float32 // deprecated
27049                         ColBox, SelBox   Box
27050                         Pointable        bool
27051                         Visual           string
27052                         VisualSize       [3]float32
27053                         Textures         []Texture
27054                         SpriteSheetSize  [2]int16 // in sprites.
27055                         SpritePos        [2]int16 // in sprite sheet.
27056                         Visible          bool
27057                         MakeFootstepSnds bool
27058                         RotateSpeed      float32 // in radians per second.
27059                         Mesh             string
27060                         Colors           []color.NRGBA
27061                         CollideWithAOs   bool
27062                         StepHeight       float32
27063                         FaceRotateDir    bool
27064                         FaceRotateDirOff float32 // in degrees.
27065                         BackfaceCull     bool
27066                         Nametag          string
27067                         NametagColor     color.NRGBA
27068                         FaceRotateSpeed  float32 // in degrees per second.
27069                         Infotext         string
27070                         Itemstring       string
27071                         Glow             int8
27072                         MaxBreath        uint16  // Player only.
27073                         EyeHeight        float32 // Player only.
27074                         ZoomFOV          float32 // in degrees. Player only.
27075                         UseTextureAlpha  bool
27076                         DmgTextureMod    Texture // suffix
27077                         Shaded           bool
27078                         ShowOnMinimap    bool
27079                         NametagBG        color.NRGBA
27080                 }))(obj)).CollideWithNodes
27081                 if x {
27082                         write8(w, 1)
27083                 } else {
27084                         write8(w, 0)
27085                 }
27086
27087         }
27088         {
27089                 x := (*(*(struct {
27090                         MaxHP            uint16 // Player only.
27091                         CollideWithNodes bool
27092                         Weight           float32 // deprecated
27093                         ColBox, SelBox   Box
27094                         Pointable        bool
27095                         Visual           string
27096                         VisualSize       [3]float32
27097                         Textures         []Texture
27098                         SpriteSheetSize  [2]int16 // in sprites.
27099                         SpritePos        [2]int16 // in sprite sheet.
27100                         Visible          bool
27101                         MakeFootstepSnds bool
27102                         RotateSpeed      float32 // in radians per second.
27103                         Mesh             string
27104                         Colors           []color.NRGBA
27105                         CollideWithAOs   bool
27106                         StepHeight       float32
27107                         FaceRotateDir    bool
27108                         FaceRotateDirOff float32 // in degrees.
27109                         BackfaceCull     bool
27110                         Nametag          string
27111                         NametagColor     color.NRGBA
27112                         FaceRotateSpeed  float32 // in degrees per second.
27113                         Infotext         string
27114                         Itemstring       string
27115                         Glow             int8
27116                         MaxBreath        uint16  // Player only.
27117                         EyeHeight        float32 // Player only.
27118                         ZoomFOV          float32 // in degrees. Player only.
27119                         UseTextureAlpha  bool
27120                         DmgTextureMod    Texture // suffix
27121                         Shaded           bool
27122                         ShowOnMinimap    bool
27123                         NametagBG        color.NRGBA
27124                 }))(obj)).Weight
27125                 write32(w, math.Float32bits(x))
27126         }
27127         if err := pcall(func() {
27128                 ((*(*(struct {
27129                         MaxHP            uint16 // Player only.
27130                         CollideWithNodes bool
27131                         Weight           float32 // deprecated
27132                         ColBox, SelBox   Box
27133                         Pointable        bool
27134                         Visual           string
27135                         VisualSize       [3]float32
27136                         Textures         []Texture
27137                         SpriteSheetSize  [2]int16 // in sprites.
27138                         SpritePos        [2]int16 // in sprite sheet.
27139                         Visible          bool
27140                         MakeFootstepSnds bool
27141                         RotateSpeed      float32 // in radians per second.
27142                         Mesh             string
27143                         Colors           []color.NRGBA
27144                         CollideWithAOs   bool
27145                         StepHeight       float32
27146                         FaceRotateDir    bool
27147                         FaceRotateDirOff float32 // in degrees.
27148                         BackfaceCull     bool
27149                         Nametag          string
27150                         NametagColor     color.NRGBA
27151                         FaceRotateSpeed  float32 // in degrees per second.
27152                         Infotext         string
27153                         Itemstring       string
27154                         Glow             int8
27155                         MaxBreath        uint16  // Player only.
27156                         EyeHeight        float32 // Player only.
27157                         ZoomFOV          float32 // in degrees. Player only.
27158                         UseTextureAlpha  bool
27159                         DmgTextureMod    Texture // suffix
27160                         Shaded           bool
27161                         ShowOnMinimap    bool
27162                         NametagBG        color.NRGBA
27163                 }))(obj)).ColBox).serialize(w)
27164         }); err != nil {
27165                 if err == io.EOF {
27166                         chk(io.EOF)
27167                 }
27168                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27169         }
27170         if err := pcall(func() {
27171                 ((*(*(struct {
27172                         MaxHP            uint16 // Player only.
27173                         CollideWithNodes bool
27174                         Weight           float32 // deprecated
27175                         ColBox, SelBox   Box
27176                         Pointable        bool
27177                         Visual           string
27178                         VisualSize       [3]float32
27179                         Textures         []Texture
27180                         SpriteSheetSize  [2]int16 // in sprites.
27181                         SpritePos        [2]int16 // in sprite sheet.
27182                         Visible          bool
27183                         MakeFootstepSnds bool
27184                         RotateSpeed      float32 // in radians per second.
27185                         Mesh             string
27186                         Colors           []color.NRGBA
27187                         CollideWithAOs   bool
27188                         StepHeight       float32
27189                         FaceRotateDir    bool
27190                         FaceRotateDirOff float32 // in degrees.
27191                         BackfaceCull     bool
27192                         Nametag          string
27193                         NametagColor     color.NRGBA
27194                         FaceRotateSpeed  float32 // in degrees per second.
27195                         Infotext         string
27196                         Itemstring       string
27197                         Glow             int8
27198                         MaxBreath        uint16  // Player only.
27199                         EyeHeight        float32 // Player only.
27200                         ZoomFOV          float32 // in degrees. Player only.
27201                         UseTextureAlpha  bool
27202                         DmgTextureMod    Texture // suffix
27203                         Shaded           bool
27204                         ShowOnMinimap    bool
27205                         NametagBG        color.NRGBA
27206                 }))(obj)).SelBox).serialize(w)
27207         }); err != nil {
27208                 if err == io.EOF {
27209                         chk(io.EOF)
27210                 }
27211                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
27212         }
27213         {
27214                 x := (*(*(struct {
27215                         MaxHP            uint16 // Player only.
27216                         CollideWithNodes bool
27217                         Weight           float32 // deprecated
27218                         ColBox, SelBox   Box
27219                         Pointable        bool
27220                         Visual           string
27221                         VisualSize       [3]float32
27222                         Textures         []Texture
27223                         SpriteSheetSize  [2]int16 // in sprites.
27224                         SpritePos        [2]int16 // in sprite sheet.
27225                         Visible          bool
27226                         MakeFootstepSnds bool
27227                         RotateSpeed      float32 // in radians per second.
27228                         Mesh             string
27229                         Colors           []color.NRGBA
27230                         CollideWithAOs   bool
27231                         StepHeight       float32
27232                         FaceRotateDir    bool
27233                         FaceRotateDirOff float32 // in degrees.
27234                         BackfaceCull     bool
27235                         Nametag          string
27236                         NametagColor     color.NRGBA
27237                         FaceRotateSpeed  float32 // in degrees per second.
27238                         Infotext         string
27239                         Itemstring       string
27240                         Glow             int8
27241                         MaxBreath        uint16  // Player only.
27242                         EyeHeight        float32 // Player only.
27243                         ZoomFOV          float32 // in degrees. Player only.
27244                         UseTextureAlpha  bool
27245                         DmgTextureMod    Texture // suffix
27246                         Shaded           bool
27247                         ShowOnMinimap    bool
27248                         NametagBG        color.NRGBA
27249                 }))(obj)).Pointable
27250                 if x {
27251                         write8(w, 1)
27252                 } else {
27253                         write8(w, 0)
27254                 }
27255
27256         }
27257         if len(([]byte((*(*(struct {
27258                 MaxHP            uint16 // Player only.
27259                 CollideWithNodes bool
27260                 Weight           float32 // deprecated
27261                 ColBox, SelBox   Box
27262                 Pointable        bool
27263                 Visual           string
27264                 VisualSize       [3]float32
27265                 Textures         []Texture
27266                 SpriteSheetSize  [2]int16 // in sprites.
27267                 SpritePos        [2]int16 // in sprite sheet.
27268                 Visible          bool
27269                 MakeFootstepSnds bool
27270                 RotateSpeed      float32 // in radians per second.
27271                 Mesh             string
27272                 Colors           []color.NRGBA
27273                 CollideWithAOs   bool
27274                 StepHeight       float32
27275                 FaceRotateDir    bool
27276                 FaceRotateDirOff float32 // in degrees.
27277                 BackfaceCull     bool
27278                 Nametag          string
27279                 NametagColor     color.NRGBA
27280                 FaceRotateSpeed  float32 // in degrees per second.
27281                 Infotext         string
27282                 Itemstring       string
27283                 Glow             int8
27284                 MaxBreath        uint16  // Player only.
27285                 EyeHeight        float32 // Player only.
27286                 ZoomFOV          float32 // in degrees. Player only.
27287                 UseTextureAlpha  bool
27288                 DmgTextureMod    Texture // suffix
27289                 Shaded           bool
27290                 ShowOnMinimap    bool
27291                 NametagBG        color.NRGBA
27292         }))(obj)).Visual))) > math.MaxUint16 {
27293                 chk(ErrTooLong)
27294         }
27295         {
27296                 x := uint16(len(([]byte((*(*(struct {
27297                         MaxHP            uint16 // Player only.
27298                         CollideWithNodes bool
27299                         Weight           float32 // deprecated
27300                         ColBox, SelBox   Box
27301                         Pointable        bool
27302                         Visual           string
27303                         VisualSize       [3]float32
27304                         Textures         []Texture
27305                         SpriteSheetSize  [2]int16 // in sprites.
27306                         SpritePos        [2]int16 // in sprite sheet.
27307                         Visible          bool
27308                         MakeFootstepSnds bool
27309                         RotateSpeed      float32 // in radians per second.
27310                         Mesh             string
27311                         Colors           []color.NRGBA
27312                         CollideWithAOs   bool
27313                         StepHeight       float32
27314                         FaceRotateDir    bool
27315                         FaceRotateDirOff float32 // in degrees.
27316                         BackfaceCull     bool
27317                         Nametag          string
27318                         NametagColor     color.NRGBA
27319                         FaceRotateSpeed  float32 // in degrees per second.
27320                         Infotext         string
27321                         Itemstring       string
27322                         Glow             int8
27323                         MaxBreath        uint16  // Player only.
27324                         EyeHeight        float32 // Player only.
27325                         ZoomFOV          float32 // in degrees. Player only.
27326                         UseTextureAlpha  bool
27327                         DmgTextureMod    Texture // suffix
27328                         Shaded           bool
27329                         ShowOnMinimap    bool
27330                         NametagBG        color.NRGBA
27331                 }))(obj)).Visual))))
27332                 write16(w, uint16(x))
27333         }
27334         {
27335                 _, err := w.Write(([]byte((*(*(struct {
27336                         MaxHP            uint16 // Player only.
27337                         CollideWithNodes bool
27338                         Weight           float32 // deprecated
27339                         ColBox, SelBox   Box
27340                         Pointable        bool
27341                         Visual           string
27342                         VisualSize       [3]float32
27343                         Textures         []Texture
27344                         SpriteSheetSize  [2]int16 // in sprites.
27345                         SpritePos        [2]int16 // in sprite sheet.
27346                         Visible          bool
27347                         MakeFootstepSnds bool
27348                         RotateSpeed      float32 // in radians per second.
27349                         Mesh             string
27350                         Colors           []color.NRGBA
27351                         CollideWithAOs   bool
27352                         StepHeight       float32
27353                         FaceRotateDir    bool
27354                         FaceRotateDirOff float32 // in degrees.
27355                         BackfaceCull     bool
27356                         Nametag          string
27357                         NametagColor     color.NRGBA
27358                         FaceRotateSpeed  float32 // in degrees per second.
27359                         Infotext         string
27360                         Itemstring       string
27361                         Glow             int8
27362                         MaxBreath        uint16  // Player only.
27363                         EyeHeight        float32 // Player only.
27364                         ZoomFOV          float32 // in degrees. Player only.
27365                         UseTextureAlpha  bool
27366                         DmgTextureMod    Texture // suffix
27367                         Shaded           bool
27368                         ShowOnMinimap    bool
27369                         NametagBG        color.NRGBA
27370                 }))(obj)).Visual))[:])
27371                 chk(err)
27372         }
27373         for local336 := range (*(*(struct {
27374                 MaxHP            uint16 // Player only.
27375                 CollideWithNodes bool
27376                 Weight           float32 // deprecated
27377                 ColBox, SelBox   Box
27378                 Pointable        bool
27379                 Visual           string
27380                 VisualSize       [3]float32
27381                 Textures         []Texture
27382                 SpriteSheetSize  [2]int16 // in sprites.
27383                 SpritePos        [2]int16 // in sprite sheet.
27384                 Visible          bool
27385                 MakeFootstepSnds bool
27386                 RotateSpeed      float32 // in radians per second.
27387                 Mesh             string
27388                 Colors           []color.NRGBA
27389                 CollideWithAOs   bool
27390                 StepHeight       float32
27391                 FaceRotateDir    bool
27392                 FaceRotateDirOff float32 // in degrees.
27393                 BackfaceCull     bool
27394                 Nametag          string
27395                 NametagColor     color.NRGBA
27396                 FaceRotateSpeed  float32 // in degrees per second.
27397                 Infotext         string
27398                 Itemstring       string
27399                 Glow             int8
27400                 MaxBreath        uint16  // Player only.
27401                 EyeHeight        float32 // Player only.
27402                 ZoomFOV          float32 // in degrees. Player only.
27403                 UseTextureAlpha  bool
27404                 DmgTextureMod    Texture // suffix
27405                 Shaded           bool
27406                 ShowOnMinimap    bool
27407                 NametagBG        color.NRGBA
27408         }))(obj)).VisualSize {
27409                 {
27410                         x := ((*(*(struct {
27411                                 MaxHP            uint16 // Player only.
27412                                 CollideWithNodes bool
27413                                 Weight           float32 // deprecated
27414                                 ColBox, SelBox   Box
27415                                 Pointable        bool
27416                                 Visual           string
27417                                 VisualSize       [3]float32
27418                                 Textures         []Texture
27419                                 SpriteSheetSize  [2]int16 // in sprites.
27420                                 SpritePos        [2]int16 // in sprite sheet.
27421                                 Visible          bool
27422                                 MakeFootstepSnds bool
27423                                 RotateSpeed      float32 // in radians per second.
27424                                 Mesh             string
27425                                 Colors           []color.NRGBA
27426                                 CollideWithAOs   bool
27427                                 StepHeight       float32
27428                                 FaceRotateDir    bool
27429                                 FaceRotateDirOff float32 // in degrees.
27430                                 BackfaceCull     bool
27431                                 Nametag          string
27432                                 NametagColor     color.NRGBA
27433                                 FaceRotateSpeed  float32 // in degrees per second.
27434                                 Infotext         string
27435                                 Itemstring       string
27436                                 Glow             int8
27437                                 MaxBreath        uint16  // Player only.
27438                                 EyeHeight        float32 // Player only.
27439                                 ZoomFOV          float32 // in degrees. Player only.
27440                                 UseTextureAlpha  bool
27441                                 DmgTextureMod    Texture // suffix
27442                                 Shaded           bool
27443                                 ShowOnMinimap    bool
27444                                 NametagBG        color.NRGBA
27445                         }))(obj)).VisualSize)[local336]
27446                         write32(w, math.Float32bits(x))
27447                 }
27448         }
27449         if len(((*(*(struct {
27450                 MaxHP            uint16 // Player only.
27451                 CollideWithNodes bool
27452                 Weight           float32 // deprecated
27453                 ColBox, SelBox   Box
27454                 Pointable        bool
27455                 Visual           string
27456                 VisualSize       [3]float32
27457                 Textures         []Texture
27458                 SpriteSheetSize  [2]int16 // in sprites.
27459                 SpritePos        [2]int16 // in sprite sheet.
27460                 Visible          bool
27461                 MakeFootstepSnds bool
27462                 RotateSpeed      float32 // in radians per second.
27463                 Mesh             string
27464                 Colors           []color.NRGBA
27465                 CollideWithAOs   bool
27466                 StepHeight       float32
27467                 FaceRotateDir    bool
27468                 FaceRotateDirOff float32 // in degrees.
27469                 BackfaceCull     bool
27470                 Nametag          string
27471                 NametagColor     color.NRGBA
27472                 FaceRotateSpeed  float32 // in degrees per second.
27473                 Infotext         string
27474                 Itemstring       string
27475                 Glow             int8
27476                 MaxBreath        uint16  // Player only.
27477                 EyeHeight        float32 // Player only.
27478                 ZoomFOV          float32 // in degrees. Player only.
27479                 UseTextureAlpha  bool
27480                 DmgTextureMod    Texture // suffix
27481                 Shaded           bool
27482                 ShowOnMinimap    bool
27483                 NametagBG        color.NRGBA
27484         }))(obj)).Textures)) > math.MaxUint16 {
27485                 chk(ErrTooLong)
27486         }
27487         {
27488                 x := uint16(len(((*(*(struct {
27489                         MaxHP            uint16 // Player only.
27490                         CollideWithNodes bool
27491                         Weight           float32 // deprecated
27492                         ColBox, SelBox   Box
27493                         Pointable        bool
27494                         Visual           string
27495                         VisualSize       [3]float32
27496                         Textures         []Texture
27497                         SpriteSheetSize  [2]int16 // in sprites.
27498                         SpritePos        [2]int16 // in sprite sheet.
27499                         Visible          bool
27500                         MakeFootstepSnds bool
27501                         RotateSpeed      float32 // in radians per second.
27502                         Mesh             string
27503                         Colors           []color.NRGBA
27504                         CollideWithAOs   bool
27505                         StepHeight       float32
27506                         FaceRotateDir    bool
27507                         FaceRotateDirOff float32 // in degrees.
27508                         BackfaceCull     bool
27509                         Nametag          string
27510                         NametagColor     color.NRGBA
27511                         FaceRotateSpeed  float32 // in degrees per second.
27512                         Infotext         string
27513                         Itemstring       string
27514                         Glow             int8
27515                         MaxBreath        uint16  // Player only.
27516                         EyeHeight        float32 // Player only.
27517                         ZoomFOV          float32 // in degrees. Player only.
27518                         UseTextureAlpha  bool
27519                         DmgTextureMod    Texture // suffix
27520                         Shaded           bool
27521                         ShowOnMinimap    bool
27522                         NametagBG        color.NRGBA
27523                 }))(obj)).Textures)))
27524                 write16(w, uint16(x))
27525         }
27526         for local337 := range (*(*(struct {
27527                 MaxHP            uint16 // Player only.
27528                 CollideWithNodes bool
27529                 Weight           float32 // deprecated
27530                 ColBox, SelBox   Box
27531                 Pointable        bool
27532                 Visual           string
27533                 VisualSize       [3]float32
27534                 Textures         []Texture
27535                 SpriteSheetSize  [2]int16 // in sprites.
27536                 SpritePos        [2]int16 // in sprite sheet.
27537                 Visible          bool
27538                 MakeFootstepSnds bool
27539                 RotateSpeed      float32 // in radians per second.
27540                 Mesh             string
27541                 Colors           []color.NRGBA
27542                 CollideWithAOs   bool
27543                 StepHeight       float32
27544                 FaceRotateDir    bool
27545                 FaceRotateDirOff float32 // in degrees.
27546                 BackfaceCull     bool
27547                 Nametag          string
27548                 NametagColor     color.NRGBA
27549                 FaceRotateSpeed  float32 // in degrees per second.
27550                 Infotext         string
27551                 Itemstring       string
27552                 Glow             int8
27553                 MaxBreath        uint16  // Player only.
27554                 EyeHeight        float32 // Player only.
27555                 ZoomFOV          float32 // in degrees. Player only.
27556                 UseTextureAlpha  bool
27557                 DmgTextureMod    Texture // suffix
27558                 Shaded           bool
27559                 ShowOnMinimap    bool
27560                 NametagBG        color.NRGBA
27561         }))(obj)).Textures {
27562                 if err := pcall(func() {
27563                         (((*(*(struct {
27564                                 MaxHP            uint16 // Player only.
27565                                 CollideWithNodes bool
27566                                 Weight           float32 // deprecated
27567                                 ColBox, SelBox   Box
27568                                 Pointable        bool
27569                                 Visual           string
27570                                 VisualSize       [3]float32
27571                                 Textures         []Texture
27572                                 SpriteSheetSize  [2]int16 // in sprites.
27573                                 SpritePos        [2]int16 // in sprite sheet.
27574                                 Visible          bool
27575                                 MakeFootstepSnds bool
27576                                 RotateSpeed      float32 // in radians per second.
27577                                 Mesh             string
27578                                 Colors           []color.NRGBA
27579                                 CollideWithAOs   bool
27580                                 StepHeight       float32
27581                                 FaceRotateDir    bool
27582                                 FaceRotateDirOff float32 // in degrees.
27583                                 BackfaceCull     bool
27584                                 Nametag          string
27585                                 NametagColor     color.NRGBA
27586                                 FaceRotateSpeed  float32 // in degrees per second.
27587                                 Infotext         string
27588                                 Itemstring       string
27589                                 Glow             int8
27590                                 MaxBreath        uint16  // Player only.
27591                                 EyeHeight        float32 // Player only.
27592                                 ZoomFOV          float32 // in degrees. Player only.
27593                                 UseTextureAlpha  bool
27594                                 DmgTextureMod    Texture // suffix
27595                                 Shaded           bool
27596                                 ShowOnMinimap    bool
27597                                 NametagBG        color.NRGBA
27598                         }))(obj)).Textures)[local337]).serialize(w)
27599                 }); err != nil {
27600                         if err == io.EOF {
27601                                 chk(io.EOF)
27602                         }
27603                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
27604                 }
27605         }
27606         for local338 := range (*(*(struct {
27607                 MaxHP            uint16 // Player only.
27608                 CollideWithNodes bool
27609                 Weight           float32 // deprecated
27610                 ColBox, SelBox   Box
27611                 Pointable        bool
27612                 Visual           string
27613                 VisualSize       [3]float32
27614                 Textures         []Texture
27615                 SpriteSheetSize  [2]int16 // in sprites.
27616                 SpritePos        [2]int16 // in sprite sheet.
27617                 Visible          bool
27618                 MakeFootstepSnds bool
27619                 RotateSpeed      float32 // in radians per second.
27620                 Mesh             string
27621                 Colors           []color.NRGBA
27622                 CollideWithAOs   bool
27623                 StepHeight       float32
27624                 FaceRotateDir    bool
27625                 FaceRotateDirOff float32 // in degrees.
27626                 BackfaceCull     bool
27627                 Nametag          string
27628                 NametagColor     color.NRGBA
27629                 FaceRotateSpeed  float32 // in degrees per second.
27630                 Infotext         string
27631                 Itemstring       string
27632                 Glow             int8
27633                 MaxBreath        uint16  // Player only.
27634                 EyeHeight        float32 // Player only.
27635                 ZoomFOV          float32 // in degrees. Player only.
27636                 UseTextureAlpha  bool
27637                 DmgTextureMod    Texture // suffix
27638                 Shaded           bool
27639                 ShowOnMinimap    bool
27640                 NametagBG        color.NRGBA
27641         }))(obj)).SpriteSheetSize {
27642                 {
27643                         x := ((*(*(struct {
27644                                 MaxHP            uint16 // Player only.
27645                                 CollideWithNodes bool
27646                                 Weight           float32 // deprecated
27647                                 ColBox, SelBox   Box
27648                                 Pointable        bool
27649                                 Visual           string
27650                                 VisualSize       [3]float32
27651                                 Textures         []Texture
27652                                 SpriteSheetSize  [2]int16 // in sprites.
27653                                 SpritePos        [2]int16 // in sprite sheet.
27654                                 Visible          bool
27655                                 MakeFootstepSnds bool
27656                                 RotateSpeed      float32 // in radians per second.
27657                                 Mesh             string
27658                                 Colors           []color.NRGBA
27659                                 CollideWithAOs   bool
27660                                 StepHeight       float32
27661                                 FaceRotateDir    bool
27662                                 FaceRotateDirOff float32 // in degrees.
27663                                 BackfaceCull     bool
27664                                 Nametag          string
27665                                 NametagColor     color.NRGBA
27666                                 FaceRotateSpeed  float32 // in degrees per second.
27667                                 Infotext         string
27668                                 Itemstring       string
27669                                 Glow             int8
27670                                 MaxBreath        uint16  // Player only.
27671                                 EyeHeight        float32 // Player only.
27672                                 ZoomFOV          float32 // in degrees. Player only.
27673                                 UseTextureAlpha  bool
27674                                 DmgTextureMod    Texture // suffix
27675                                 Shaded           bool
27676                                 ShowOnMinimap    bool
27677                                 NametagBG        color.NRGBA
27678                         }))(obj)).SpriteSheetSize)[local338]
27679                         write16(w, uint16(x))
27680                 }
27681         }
27682         for local339 := range (*(*(struct {
27683                 MaxHP            uint16 // Player only.
27684                 CollideWithNodes bool
27685                 Weight           float32 // deprecated
27686                 ColBox, SelBox   Box
27687                 Pointable        bool
27688                 Visual           string
27689                 VisualSize       [3]float32
27690                 Textures         []Texture
27691                 SpriteSheetSize  [2]int16 // in sprites.
27692                 SpritePos        [2]int16 // in sprite sheet.
27693                 Visible          bool
27694                 MakeFootstepSnds bool
27695                 RotateSpeed      float32 // in radians per second.
27696                 Mesh             string
27697                 Colors           []color.NRGBA
27698                 CollideWithAOs   bool
27699                 StepHeight       float32
27700                 FaceRotateDir    bool
27701                 FaceRotateDirOff float32 // in degrees.
27702                 BackfaceCull     bool
27703                 Nametag          string
27704                 NametagColor     color.NRGBA
27705                 FaceRotateSpeed  float32 // in degrees per second.
27706                 Infotext         string
27707                 Itemstring       string
27708                 Glow             int8
27709                 MaxBreath        uint16  // Player only.
27710                 EyeHeight        float32 // Player only.
27711                 ZoomFOV          float32 // in degrees. Player only.
27712                 UseTextureAlpha  bool
27713                 DmgTextureMod    Texture // suffix
27714                 Shaded           bool
27715                 ShowOnMinimap    bool
27716                 NametagBG        color.NRGBA
27717         }))(obj)).SpritePos {
27718                 {
27719                         x := ((*(*(struct {
27720                                 MaxHP            uint16 // Player only.
27721                                 CollideWithNodes bool
27722                                 Weight           float32 // deprecated
27723                                 ColBox, SelBox   Box
27724                                 Pointable        bool
27725                                 Visual           string
27726                                 VisualSize       [3]float32
27727                                 Textures         []Texture
27728                                 SpriteSheetSize  [2]int16 // in sprites.
27729                                 SpritePos        [2]int16 // in sprite sheet.
27730                                 Visible          bool
27731                                 MakeFootstepSnds bool
27732                                 RotateSpeed      float32 // in radians per second.
27733                                 Mesh             string
27734                                 Colors           []color.NRGBA
27735                                 CollideWithAOs   bool
27736                                 StepHeight       float32
27737                                 FaceRotateDir    bool
27738                                 FaceRotateDirOff float32 // in degrees.
27739                                 BackfaceCull     bool
27740                                 Nametag          string
27741                                 NametagColor     color.NRGBA
27742                                 FaceRotateSpeed  float32 // in degrees per second.
27743                                 Infotext         string
27744                                 Itemstring       string
27745                                 Glow             int8
27746                                 MaxBreath        uint16  // Player only.
27747                                 EyeHeight        float32 // Player only.
27748                                 ZoomFOV          float32 // in degrees. Player only.
27749                                 UseTextureAlpha  bool
27750                                 DmgTextureMod    Texture // suffix
27751                                 Shaded           bool
27752                                 ShowOnMinimap    bool
27753                                 NametagBG        color.NRGBA
27754                         }))(obj)).SpritePos)[local339]
27755                         write16(w, uint16(x))
27756                 }
27757         }
27758         {
27759                 x := (*(*(struct {
27760                         MaxHP            uint16 // Player only.
27761                         CollideWithNodes bool
27762                         Weight           float32 // deprecated
27763                         ColBox, SelBox   Box
27764                         Pointable        bool
27765                         Visual           string
27766                         VisualSize       [3]float32
27767                         Textures         []Texture
27768                         SpriteSheetSize  [2]int16 // in sprites.
27769                         SpritePos        [2]int16 // in sprite sheet.
27770                         Visible          bool
27771                         MakeFootstepSnds bool
27772                         RotateSpeed      float32 // in radians per second.
27773                         Mesh             string
27774                         Colors           []color.NRGBA
27775                         CollideWithAOs   bool
27776                         StepHeight       float32
27777                         FaceRotateDir    bool
27778                         FaceRotateDirOff float32 // in degrees.
27779                         BackfaceCull     bool
27780                         Nametag          string
27781                         NametagColor     color.NRGBA
27782                         FaceRotateSpeed  float32 // in degrees per second.
27783                         Infotext         string
27784                         Itemstring       string
27785                         Glow             int8
27786                         MaxBreath        uint16  // Player only.
27787                         EyeHeight        float32 // Player only.
27788                         ZoomFOV          float32 // in degrees. Player only.
27789                         UseTextureAlpha  bool
27790                         DmgTextureMod    Texture // suffix
27791                         Shaded           bool
27792                         ShowOnMinimap    bool
27793                         NametagBG        color.NRGBA
27794                 }))(obj)).Visible
27795                 if x {
27796                         write8(w, 1)
27797                 } else {
27798                         write8(w, 0)
27799                 }
27800
27801         }
27802         {
27803                 x := (*(*(struct {
27804                         MaxHP            uint16 // Player only.
27805                         CollideWithNodes bool
27806                         Weight           float32 // deprecated
27807                         ColBox, SelBox   Box
27808                         Pointable        bool
27809                         Visual           string
27810                         VisualSize       [3]float32
27811                         Textures         []Texture
27812                         SpriteSheetSize  [2]int16 // in sprites.
27813                         SpritePos        [2]int16 // in sprite sheet.
27814                         Visible          bool
27815                         MakeFootstepSnds bool
27816                         RotateSpeed      float32 // in radians per second.
27817                         Mesh             string
27818                         Colors           []color.NRGBA
27819                         CollideWithAOs   bool
27820                         StepHeight       float32
27821                         FaceRotateDir    bool
27822                         FaceRotateDirOff float32 // in degrees.
27823                         BackfaceCull     bool
27824                         Nametag          string
27825                         NametagColor     color.NRGBA
27826                         FaceRotateSpeed  float32 // in degrees per second.
27827                         Infotext         string
27828                         Itemstring       string
27829                         Glow             int8
27830                         MaxBreath        uint16  // Player only.
27831                         EyeHeight        float32 // Player only.
27832                         ZoomFOV          float32 // in degrees. Player only.
27833                         UseTextureAlpha  bool
27834                         DmgTextureMod    Texture // suffix
27835                         Shaded           bool
27836                         ShowOnMinimap    bool
27837                         NametagBG        color.NRGBA
27838                 }))(obj)).MakeFootstepSnds
27839                 if x {
27840                         write8(w, 1)
27841                 } else {
27842                         write8(w, 0)
27843                 }
27844
27845         }
27846         {
27847                 x := (*(*(struct {
27848                         MaxHP            uint16 // Player only.
27849                         CollideWithNodes bool
27850                         Weight           float32 // deprecated
27851                         ColBox, SelBox   Box
27852                         Pointable        bool
27853                         Visual           string
27854                         VisualSize       [3]float32
27855                         Textures         []Texture
27856                         SpriteSheetSize  [2]int16 // in sprites.
27857                         SpritePos        [2]int16 // in sprite sheet.
27858                         Visible          bool
27859                         MakeFootstepSnds bool
27860                         RotateSpeed      float32 // in radians per second.
27861                         Mesh             string
27862                         Colors           []color.NRGBA
27863                         CollideWithAOs   bool
27864                         StepHeight       float32
27865                         FaceRotateDir    bool
27866                         FaceRotateDirOff float32 // in degrees.
27867                         BackfaceCull     bool
27868                         Nametag          string
27869                         NametagColor     color.NRGBA
27870                         FaceRotateSpeed  float32 // in degrees per second.
27871                         Infotext         string
27872                         Itemstring       string
27873                         Glow             int8
27874                         MaxBreath        uint16  // Player only.
27875                         EyeHeight        float32 // Player only.
27876                         ZoomFOV          float32 // in degrees. Player only.
27877                         UseTextureAlpha  bool
27878                         DmgTextureMod    Texture // suffix
27879                         Shaded           bool
27880                         ShowOnMinimap    bool
27881                         NametagBG        color.NRGBA
27882                 }))(obj)).RotateSpeed
27883                 write32(w, math.Float32bits(x))
27884         }
27885         if len(([]byte((*(*(struct {
27886                 MaxHP            uint16 // Player only.
27887                 CollideWithNodes bool
27888                 Weight           float32 // deprecated
27889                 ColBox, SelBox   Box
27890                 Pointable        bool
27891                 Visual           string
27892                 VisualSize       [3]float32
27893                 Textures         []Texture
27894                 SpriteSheetSize  [2]int16 // in sprites.
27895                 SpritePos        [2]int16 // in sprite sheet.
27896                 Visible          bool
27897                 MakeFootstepSnds bool
27898                 RotateSpeed      float32 // in radians per second.
27899                 Mesh             string
27900                 Colors           []color.NRGBA
27901                 CollideWithAOs   bool
27902                 StepHeight       float32
27903                 FaceRotateDir    bool
27904                 FaceRotateDirOff float32 // in degrees.
27905                 BackfaceCull     bool
27906                 Nametag          string
27907                 NametagColor     color.NRGBA
27908                 FaceRotateSpeed  float32 // in degrees per second.
27909                 Infotext         string
27910                 Itemstring       string
27911                 Glow             int8
27912                 MaxBreath        uint16  // Player only.
27913                 EyeHeight        float32 // Player only.
27914                 ZoomFOV          float32 // in degrees. Player only.
27915                 UseTextureAlpha  bool
27916                 DmgTextureMod    Texture // suffix
27917                 Shaded           bool
27918                 ShowOnMinimap    bool
27919                 NametagBG        color.NRGBA
27920         }))(obj)).Mesh))) > math.MaxUint16 {
27921                 chk(ErrTooLong)
27922         }
27923         {
27924                 x := uint16(len(([]byte((*(*(struct {
27925                         MaxHP            uint16 // Player only.
27926                         CollideWithNodes bool
27927                         Weight           float32 // deprecated
27928                         ColBox, SelBox   Box
27929                         Pointable        bool
27930                         Visual           string
27931                         VisualSize       [3]float32
27932                         Textures         []Texture
27933                         SpriteSheetSize  [2]int16 // in sprites.
27934                         SpritePos        [2]int16 // in sprite sheet.
27935                         Visible          bool
27936                         MakeFootstepSnds bool
27937                         RotateSpeed      float32 // in radians per second.
27938                         Mesh             string
27939                         Colors           []color.NRGBA
27940                         CollideWithAOs   bool
27941                         StepHeight       float32
27942                         FaceRotateDir    bool
27943                         FaceRotateDirOff float32 // in degrees.
27944                         BackfaceCull     bool
27945                         Nametag          string
27946                         NametagColor     color.NRGBA
27947                         FaceRotateSpeed  float32 // in degrees per second.
27948                         Infotext         string
27949                         Itemstring       string
27950                         Glow             int8
27951                         MaxBreath        uint16  // Player only.
27952                         EyeHeight        float32 // Player only.
27953                         ZoomFOV          float32 // in degrees. Player only.
27954                         UseTextureAlpha  bool
27955                         DmgTextureMod    Texture // suffix
27956                         Shaded           bool
27957                         ShowOnMinimap    bool
27958                         NametagBG        color.NRGBA
27959                 }))(obj)).Mesh))))
27960                 write16(w, uint16(x))
27961         }
27962         {
27963                 _, err := w.Write(([]byte((*(*(struct {
27964                         MaxHP            uint16 // Player only.
27965                         CollideWithNodes bool
27966                         Weight           float32 // deprecated
27967                         ColBox, SelBox   Box
27968                         Pointable        bool
27969                         Visual           string
27970                         VisualSize       [3]float32
27971                         Textures         []Texture
27972                         SpriteSheetSize  [2]int16 // in sprites.
27973                         SpritePos        [2]int16 // in sprite sheet.
27974                         Visible          bool
27975                         MakeFootstepSnds bool
27976                         RotateSpeed      float32 // in radians per second.
27977                         Mesh             string
27978                         Colors           []color.NRGBA
27979                         CollideWithAOs   bool
27980                         StepHeight       float32
27981                         FaceRotateDir    bool
27982                         FaceRotateDirOff float32 // in degrees.
27983                         BackfaceCull     bool
27984                         Nametag          string
27985                         NametagColor     color.NRGBA
27986                         FaceRotateSpeed  float32 // in degrees per second.
27987                         Infotext         string
27988                         Itemstring       string
27989                         Glow             int8
27990                         MaxBreath        uint16  // Player only.
27991                         EyeHeight        float32 // Player only.
27992                         ZoomFOV          float32 // in degrees. Player only.
27993                         UseTextureAlpha  bool
27994                         DmgTextureMod    Texture // suffix
27995                         Shaded           bool
27996                         ShowOnMinimap    bool
27997                         NametagBG        color.NRGBA
27998                 }))(obj)).Mesh))[:])
27999                 chk(err)
28000         }
28001         if len(((*(*(struct {
28002                 MaxHP            uint16 // Player only.
28003                 CollideWithNodes bool
28004                 Weight           float32 // deprecated
28005                 ColBox, SelBox   Box
28006                 Pointable        bool
28007                 Visual           string
28008                 VisualSize       [3]float32
28009                 Textures         []Texture
28010                 SpriteSheetSize  [2]int16 // in sprites.
28011                 SpritePos        [2]int16 // in sprite sheet.
28012                 Visible          bool
28013                 MakeFootstepSnds bool
28014                 RotateSpeed      float32 // in radians per second.
28015                 Mesh             string
28016                 Colors           []color.NRGBA
28017                 CollideWithAOs   bool
28018                 StepHeight       float32
28019                 FaceRotateDir    bool
28020                 FaceRotateDirOff float32 // in degrees.
28021                 BackfaceCull     bool
28022                 Nametag          string
28023                 NametagColor     color.NRGBA
28024                 FaceRotateSpeed  float32 // in degrees per second.
28025                 Infotext         string
28026                 Itemstring       string
28027                 Glow             int8
28028                 MaxBreath        uint16  // Player only.
28029                 EyeHeight        float32 // Player only.
28030                 ZoomFOV          float32 // in degrees. Player only.
28031                 UseTextureAlpha  bool
28032                 DmgTextureMod    Texture // suffix
28033                 Shaded           bool
28034                 ShowOnMinimap    bool
28035                 NametagBG        color.NRGBA
28036         }))(obj)).Colors)) > math.MaxUint16 {
28037                 chk(ErrTooLong)
28038         }
28039         {
28040                 x := uint16(len(((*(*(struct {
28041                         MaxHP            uint16 // Player only.
28042                         CollideWithNodes bool
28043                         Weight           float32 // deprecated
28044                         ColBox, SelBox   Box
28045                         Pointable        bool
28046                         Visual           string
28047                         VisualSize       [3]float32
28048                         Textures         []Texture
28049                         SpriteSheetSize  [2]int16 // in sprites.
28050                         SpritePos        [2]int16 // in sprite sheet.
28051                         Visible          bool
28052                         MakeFootstepSnds bool
28053                         RotateSpeed      float32 // in radians per second.
28054                         Mesh             string
28055                         Colors           []color.NRGBA
28056                         CollideWithAOs   bool
28057                         StepHeight       float32
28058                         FaceRotateDir    bool
28059                         FaceRotateDirOff float32 // in degrees.
28060                         BackfaceCull     bool
28061                         Nametag          string
28062                         NametagColor     color.NRGBA
28063                         FaceRotateSpeed  float32 // in degrees per second.
28064                         Infotext         string
28065                         Itemstring       string
28066                         Glow             int8
28067                         MaxBreath        uint16  // Player only.
28068                         EyeHeight        float32 // Player only.
28069                         ZoomFOV          float32 // in degrees. Player only.
28070                         UseTextureAlpha  bool
28071                         DmgTextureMod    Texture // suffix
28072                         Shaded           bool
28073                         ShowOnMinimap    bool
28074                         NametagBG        color.NRGBA
28075                 }))(obj)).Colors)))
28076                 write16(w, uint16(x))
28077         }
28078         for local340 := range (*(*(struct {
28079                 MaxHP            uint16 // Player only.
28080                 CollideWithNodes bool
28081                 Weight           float32 // deprecated
28082                 ColBox, SelBox   Box
28083                 Pointable        bool
28084                 Visual           string
28085                 VisualSize       [3]float32
28086                 Textures         []Texture
28087                 SpriteSheetSize  [2]int16 // in sprites.
28088                 SpritePos        [2]int16 // in sprite sheet.
28089                 Visible          bool
28090                 MakeFootstepSnds bool
28091                 RotateSpeed      float32 // in radians per second.
28092                 Mesh             string
28093                 Colors           []color.NRGBA
28094                 CollideWithAOs   bool
28095                 StepHeight       float32
28096                 FaceRotateDir    bool
28097                 FaceRotateDirOff float32 // in degrees.
28098                 BackfaceCull     bool
28099                 Nametag          string
28100                 NametagColor     color.NRGBA
28101                 FaceRotateSpeed  float32 // in degrees per second.
28102                 Infotext         string
28103                 Itemstring       string
28104                 Glow             int8
28105                 MaxBreath        uint16  // Player only.
28106                 EyeHeight        float32 // Player only.
28107                 ZoomFOV          float32 // in degrees. Player only.
28108                 UseTextureAlpha  bool
28109                 DmgTextureMod    Texture // suffix
28110                 Shaded           bool
28111                 ShowOnMinimap    bool
28112                 NametagBG        color.NRGBA
28113         }))(obj)).Colors {
28114                 {
28115                         x := ((*(*(struct {
28116                                 MaxHP            uint16 // Player only.
28117                                 CollideWithNodes bool
28118                                 Weight           float32 // deprecated
28119                                 ColBox, SelBox   Box
28120                                 Pointable        bool
28121                                 Visual           string
28122                                 VisualSize       [3]float32
28123                                 Textures         []Texture
28124                                 SpriteSheetSize  [2]int16 // in sprites.
28125                                 SpritePos        [2]int16 // in sprite sheet.
28126                                 Visible          bool
28127                                 MakeFootstepSnds bool
28128                                 RotateSpeed      float32 // in radians per second.
28129                                 Mesh             string
28130                                 Colors           []color.NRGBA
28131                                 CollideWithAOs   bool
28132                                 StepHeight       float32
28133                                 FaceRotateDir    bool
28134                                 FaceRotateDirOff float32 // in degrees.
28135                                 BackfaceCull     bool
28136                                 Nametag          string
28137                                 NametagColor     color.NRGBA
28138                                 FaceRotateSpeed  float32 // in degrees per second.
28139                                 Infotext         string
28140                                 Itemstring       string
28141                                 Glow             int8
28142                                 MaxBreath        uint16  // Player only.
28143                                 EyeHeight        float32 // Player only.
28144                                 ZoomFOV          float32 // in degrees. Player only.
28145                                 UseTextureAlpha  bool
28146                                 DmgTextureMod    Texture // suffix
28147                                 Shaded           bool
28148                                 ShowOnMinimap    bool
28149                                 NametagBG        color.NRGBA
28150                         }))(obj)).Colors)[local340]
28151                         w.Write([]byte{x.A, x.R, x.G, x.B})
28152
28153                 }
28154         }
28155         {
28156                 x := (*(*(struct {
28157                         MaxHP            uint16 // Player only.
28158                         CollideWithNodes bool
28159                         Weight           float32 // deprecated
28160                         ColBox, SelBox   Box
28161                         Pointable        bool
28162                         Visual           string
28163                         VisualSize       [3]float32
28164                         Textures         []Texture
28165                         SpriteSheetSize  [2]int16 // in sprites.
28166                         SpritePos        [2]int16 // in sprite sheet.
28167                         Visible          bool
28168                         MakeFootstepSnds bool
28169                         RotateSpeed      float32 // in radians per second.
28170                         Mesh             string
28171                         Colors           []color.NRGBA
28172                         CollideWithAOs   bool
28173                         StepHeight       float32
28174                         FaceRotateDir    bool
28175                         FaceRotateDirOff float32 // in degrees.
28176                         BackfaceCull     bool
28177                         Nametag          string
28178                         NametagColor     color.NRGBA
28179                         FaceRotateSpeed  float32 // in degrees per second.
28180                         Infotext         string
28181                         Itemstring       string
28182                         Glow             int8
28183                         MaxBreath        uint16  // Player only.
28184                         EyeHeight        float32 // Player only.
28185                         ZoomFOV          float32 // in degrees. Player only.
28186                         UseTextureAlpha  bool
28187                         DmgTextureMod    Texture // suffix
28188                         Shaded           bool
28189                         ShowOnMinimap    bool
28190                         NametagBG        color.NRGBA
28191                 }))(obj)).CollideWithAOs
28192                 if x {
28193                         write8(w, 1)
28194                 } else {
28195                         write8(w, 0)
28196                 }
28197
28198         }
28199         {
28200                 x := (*(*(struct {
28201                         MaxHP            uint16 // Player only.
28202                         CollideWithNodes bool
28203                         Weight           float32 // deprecated
28204                         ColBox, SelBox   Box
28205                         Pointable        bool
28206                         Visual           string
28207                         VisualSize       [3]float32
28208                         Textures         []Texture
28209                         SpriteSheetSize  [2]int16 // in sprites.
28210                         SpritePos        [2]int16 // in sprite sheet.
28211                         Visible          bool
28212                         MakeFootstepSnds bool
28213                         RotateSpeed      float32 // in radians per second.
28214                         Mesh             string
28215                         Colors           []color.NRGBA
28216                         CollideWithAOs   bool
28217                         StepHeight       float32
28218                         FaceRotateDir    bool
28219                         FaceRotateDirOff float32 // in degrees.
28220                         BackfaceCull     bool
28221                         Nametag          string
28222                         NametagColor     color.NRGBA
28223                         FaceRotateSpeed  float32 // in degrees per second.
28224                         Infotext         string
28225                         Itemstring       string
28226                         Glow             int8
28227                         MaxBreath        uint16  // Player only.
28228                         EyeHeight        float32 // Player only.
28229                         ZoomFOV          float32 // in degrees. Player only.
28230                         UseTextureAlpha  bool
28231                         DmgTextureMod    Texture // suffix
28232                         Shaded           bool
28233                         ShowOnMinimap    bool
28234                         NametagBG        color.NRGBA
28235                 }))(obj)).StepHeight
28236                 write32(w, math.Float32bits(x))
28237         }
28238         {
28239                 x := (*(*(struct {
28240                         MaxHP            uint16 // Player only.
28241                         CollideWithNodes bool
28242                         Weight           float32 // deprecated
28243                         ColBox, SelBox   Box
28244                         Pointable        bool
28245                         Visual           string
28246                         VisualSize       [3]float32
28247                         Textures         []Texture
28248                         SpriteSheetSize  [2]int16 // in sprites.
28249                         SpritePos        [2]int16 // in sprite sheet.
28250                         Visible          bool
28251                         MakeFootstepSnds bool
28252                         RotateSpeed      float32 // in radians per second.
28253                         Mesh             string
28254                         Colors           []color.NRGBA
28255                         CollideWithAOs   bool
28256                         StepHeight       float32
28257                         FaceRotateDir    bool
28258                         FaceRotateDirOff float32 // in degrees.
28259                         BackfaceCull     bool
28260                         Nametag          string
28261                         NametagColor     color.NRGBA
28262                         FaceRotateSpeed  float32 // in degrees per second.
28263                         Infotext         string
28264                         Itemstring       string
28265                         Glow             int8
28266                         MaxBreath        uint16  // Player only.
28267                         EyeHeight        float32 // Player only.
28268                         ZoomFOV          float32 // in degrees. Player only.
28269                         UseTextureAlpha  bool
28270                         DmgTextureMod    Texture // suffix
28271                         Shaded           bool
28272                         ShowOnMinimap    bool
28273                         NametagBG        color.NRGBA
28274                 }))(obj)).FaceRotateDir
28275                 if x {
28276                         write8(w, 1)
28277                 } else {
28278                         write8(w, 0)
28279                 }
28280
28281         }
28282         {
28283                 x := (*(*(struct {
28284                         MaxHP            uint16 // Player only.
28285                         CollideWithNodes bool
28286                         Weight           float32 // deprecated
28287                         ColBox, SelBox   Box
28288                         Pointable        bool
28289                         Visual           string
28290                         VisualSize       [3]float32
28291                         Textures         []Texture
28292                         SpriteSheetSize  [2]int16 // in sprites.
28293                         SpritePos        [2]int16 // in sprite sheet.
28294                         Visible          bool
28295                         MakeFootstepSnds bool
28296                         RotateSpeed      float32 // in radians per second.
28297                         Mesh             string
28298                         Colors           []color.NRGBA
28299                         CollideWithAOs   bool
28300                         StepHeight       float32
28301                         FaceRotateDir    bool
28302                         FaceRotateDirOff float32 // in degrees.
28303                         BackfaceCull     bool
28304                         Nametag          string
28305                         NametagColor     color.NRGBA
28306                         FaceRotateSpeed  float32 // in degrees per second.
28307                         Infotext         string
28308                         Itemstring       string
28309                         Glow             int8
28310                         MaxBreath        uint16  // Player only.
28311                         EyeHeight        float32 // Player only.
28312                         ZoomFOV          float32 // in degrees. Player only.
28313                         UseTextureAlpha  bool
28314                         DmgTextureMod    Texture // suffix
28315                         Shaded           bool
28316                         ShowOnMinimap    bool
28317                         NametagBG        color.NRGBA
28318                 }))(obj)).FaceRotateDirOff
28319                 write32(w, math.Float32bits(x))
28320         }
28321         {
28322                 x := (*(*(struct {
28323                         MaxHP            uint16 // Player only.
28324                         CollideWithNodes bool
28325                         Weight           float32 // deprecated
28326                         ColBox, SelBox   Box
28327                         Pointable        bool
28328                         Visual           string
28329                         VisualSize       [3]float32
28330                         Textures         []Texture
28331                         SpriteSheetSize  [2]int16 // in sprites.
28332                         SpritePos        [2]int16 // in sprite sheet.
28333                         Visible          bool
28334                         MakeFootstepSnds bool
28335                         RotateSpeed      float32 // in radians per second.
28336                         Mesh             string
28337                         Colors           []color.NRGBA
28338                         CollideWithAOs   bool
28339                         StepHeight       float32
28340                         FaceRotateDir    bool
28341                         FaceRotateDirOff float32 // in degrees.
28342                         BackfaceCull     bool
28343                         Nametag          string
28344                         NametagColor     color.NRGBA
28345                         FaceRotateSpeed  float32 // in degrees per second.
28346                         Infotext         string
28347                         Itemstring       string
28348                         Glow             int8
28349                         MaxBreath        uint16  // Player only.
28350                         EyeHeight        float32 // Player only.
28351                         ZoomFOV          float32 // in degrees. Player only.
28352                         UseTextureAlpha  bool
28353                         DmgTextureMod    Texture // suffix
28354                         Shaded           bool
28355                         ShowOnMinimap    bool
28356                         NametagBG        color.NRGBA
28357                 }))(obj)).BackfaceCull
28358                 if x {
28359                         write8(w, 1)
28360                 } else {
28361                         write8(w, 0)
28362                 }
28363
28364         }
28365         if len(([]byte((*(*(struct {
28366                 MaxHP            uint16 // Player only.
28367                 CollideWithNodes bool
28368                 Weight           float32 // deprecated
28369                 ColBox, SelBox   Box
28370                 Pointable        bool
28371                 Visual           string
28372                 VisualSize       [3]float32
28373                 Textures         []Texture
28374                 SpriteSheetSize  [2]int16 // in sprites.
28375                 SpritePos        [2]int16 // in sprite sheet.
28376                 Visible          bool
28377                 MakeFootstepSnds bool
28378                 RotateSpeed      float32 // in radians per second.
28379                 Mesh             string
28380                 Colors           []color.NRGBA
28381                 CollideWithAOs   bool
28382                 StepHeight       float32
28383                 FaceRotateDir    bool
28384                 FaceRotateDirOff float32 // in degrees.
28385                 BackfaceCull     bool
28386                 Nametag          string
28387                 NametagColor     color.NRGBA
28388                 FaceRotateSpeed  float32 // in degrees per second.
28389                 Infotext         string
28390                 Itemstring       string
28391                 Glow             int8
28392                 MaxBreath        uint16  // Player only.
28393                 EyeHeight        float32 // Player only.
28394                 ZoomFOV          float32 // in degrees. Player only.
28395                 UseTextureAlpha  bool
28396                 DmgTextureMod    Texture // suffix
28397                 Shaded           bool
28398                 ShowOnMinimap    bool
28399                 NametagBG        color.NRGBA
28400         }))(obj)).Nametag))) > math.MaxUint16 {
28401                 chk(ErrTooLong)
28402         }
28403         {
28404                 x := uint16(len(([]byte((*(*(struct {
28405                         MaxHP            uint16 // Player only.
28406                         CollideWithNodes bool
28407                         Weight           float32 // deprecated
28408                         ColBox, SelBox   Box
28409                         Pointable        bool
28410                         Visual           string
28411                         VisualSize       [3]float32
28412                         Textures         []Texture
28413                         SpriteSheetSize  [2]int16 // in sprites.
28414                         SpritePos        [2]int16 // in sprite sheet.
28415                         Visible          bool
28416                         MakeFootstepSnds bool
28417                         RotateSpeed      float32 // in radians per second.
28418                         Mesh             string
28419                         Colors           []color.NRGBA
28420                         CollideWithAOs   bool
28421                         StepHeight       float32
28422                         FaceRotateDir    bool
28423                         FaceRotateDirOff float32 // in degrees.
28424                         BackfaceCull     bool
28425                         Nametag          string
28426                         NametagColor     color.NRGBA
28427                         FaceRotateSpeed  float32 // in degrees per second.
28428                         Infotext         string
28429                         Itemstring       string
28430                         Glow             int8
28431                         MaxBreath        uint16  // Player only.
28432                         EyeHeight        float32 // Player only.
28433                         ZoomFOV          float32 // in degrees. Player only.
28434                         UseTextureAlpha  bool
28435                         DmgTextureMod    Texture // suffix
28436                         Shaded           bool
28437                         ShowOnMinimap    bool
28438                         NametagBG        color.NRGBA
28439                 }))(obj)).Nametag))))
28440                 write16(w, uint16(x))
28441         }
28442         {
28443                 _, err := w.Write(([]byte((*(*(struct {
28444                         MaxHP            uint16 // Player only.
28445                         CollideWithNodes bool
28446                         Weight           float32 // deprecated
28447                         ColBox, SelBox   Box
28448                         Pointable        bool
28449                         Visual           string
28450                         VisualSize       [3]float32
28451                         Textures         []Texture
28452                         SpriteSheetSize  [2]int16 // in sprites.
28453                         SpritePos        [2]int16 // in sprite sheet.
28454                         Visible          bool
28455                         MakeFootstepSnds bool
28456                         RotateSpeed      float32 // in radians per second.
28457                         Mesh             string
28458                         Colors           []color.NRGBA
28459                         CollideWithAOs   bool
28460                         StepHeight       float32
28461                         FaceRotateDir    bool
28462                         FaceRotateDirOff float32 // in degrees.
28463                         BackfaceCull     bool
28464                         Nametag          string
28465                         NametagColor     color.NRGBA
28466                         FaceRotateSpeed  float32 // in degrees per second.
28467                         Infotext         string
28468                         Itemstring       string
28469                         Glow             int8
28470                         MaxBreath        uint16  // Player only.
28471                         EyeHeight        float32 // Player only.
28472                         ZoomFOV          float32 // in degrees. Player only.
28473                         UseTextureAlpha  bool
28474                         DmgTextureMod    Texture // suffix
28475                         Shaded           bool
28476                         ShowOnMinimap    bool
28477                         NametagBG        color.NRGBA
28478                 }))(obj)).Nametag))[:])
28479                 chk(err)
28480         }
28481         {
28482                 x := (*(*(struct {
28483                         MaxHP            uint16 // Player only.
28484                         CollideWithNodes bool
28485                         Weight           float32 // deprecated
28486                         ColBox, SelBox   Box
28487                         Pointable        bool
28488                         Visual           string
28489                         VisualSize       [3]float32
28490                         Textures         []Texture
28491                         SpriteSheetSize  [2]int16 // in sprites.
28492                         SpritePos        [2]int16 // in sprite sheet.
28493                         Visible          bool
28494                         MakeFootstepSnds bool
28495                         RotateSpeed      float32 // in radians per second.
28496                         Mesh             string
28497                         Colors           []color.NRGBA
28498                         CollideWithAOs   bool
28499                         StepHeight       float32
28500                         FaceRotateDir    bool
28501                         FaceRotateDirOff float32 // in degrees.
28502                         BackfaceCull     bool
28503                         Nametag          string
28504                         NametagColor     color.NRGBA
28505                         FaceRotateSpeed  float32 // in degrees per second.
28506                         Infotext         string
28507                         Itemstring       string
28508                         Glow             int8
28509                         MaxBreath        uint16  // Player only.
28510                         EyeHeight        float32 // Player only.
28511                         ZoomFOV          float32 // in degrees. Player only.
28512                         UseTextureAlpha  bool
28513                         DmgTextureMod    Texture // suffix
28514                         Shaded           bool
28515                         ShowOnMinimap    bool
28516                         NametagBG        color.NRGBA
28517                 }))(obj)).NametagColor
28518                 w.Write([]byte{x.A, x.R, x.G, x.B})
28519
28520         }
28521         {
28522                 x := (*(*(struct {
28523                         MaxHP            uint16 // Player only.
28524                         CollideWithNodes bool
28525                         Weight           float32 // deprecated
28526                         ColBox, SelBox   Box
28527                         Pointable        bool
28528                         Visual           string
28529                         VisualSize       [3]float32
28530                         Textures         []Texture
28531                         SpriteSheetSize  [2]int16 // in sprites.
28532                         SpritePos        [2]int16 // in sprite sheet.
28533                         Visible          bool
28534                         MakeFootstepSnds bool
28535                         RotateSpeed      float32 // in radians per second.
28536                         Mesh             string
28537                         Colors           []color.NRGBA
28538                         CollideWithAOs   bool
28539                         StepHeight       float32
28540                         FaceRotateDir    bool
28541                         FaceRotateDirOff float32 // in degrees.
28542                         BackfaceCull     bool
28543                         Nametag          string
28544                         NametagColor     color.NRGBA
28545                         FaceRotateSpeed  float32 // in degrees per second.
28546                         Infotext         string
28547                         Itemstring       string
28548                         Glow             int8
28549                         MaxBreath        uint16  // Player only.
28550                         EyeHeight        float32 // Player only.
28551                         ZoomFOV          float32 // in degrees. Player only.
28552                         UseTextureAlpha  bool
28553                         DmgTextureMod    Texture // suffix
28554                         Shaded           bool
28555                         ShowOnMinimap    bool
28556                         NametagBG        color.NRGBA
28557                 }))(obj)).FaceRotateSpeed
28558                 write32(w, math.Float32bits(x))
28559         }
28560         if len(([]byte((*(*(struct {
28561                 MaxHP            uint16 // Player only.
28562                 CollideWithNodes bool
28563                 Weight           float32 // deprecated
28564                 ColBox, SelBox   Box
28565                 Pointable        bool
28566                 Visual           string
28567                 VisualSize       [3]float32
28568                 Textures         []Texture
28569                 SpriteSheetSize  [2]int16 // in sprites.
28570                 SpritePos        [2]int16 // in sprite sheet.
28571                 Visible          bool
28572                 MakeFootstepSnds bool
28573                 RotateSpeed      float32 // in radians per second.
28574                 Mesh             string
28575                 Colors           []color.NRGBA
28576                 CollideWithAOs   bool
28577                 StepHeight       float32
28578                 FaceRotateDir    bool
28579                 FaceRotateDirOff float32 // in degrees.
28580                 BackfaceCull     bool
28581                 Nametag          string
28582                 NametagColor     color.NRGBA
28583                 FaceRotateSpeed  float32 // in degrees per second.
28584                 Infotext         string
28585                 Itemstring       string
28586                 Glow             int8
28587                 MaxBreath        uint16  // Player only.
28588                 EyeHeight        float32 // Player only.
28589                 ZoomFOV          float32 // in degrees. Player only.
28590                 UseTextureAlpha  bool
28591                 DmgTextureMod    Texture // suffix
28592                 Shaded           bool
28593                 ShowOnMinimap    bool
28594                 NametagBG        color.NRGBA
28595         }))(obj)).Infotext))) > math.MaxUint16 {
28596                 chk(ErrTooLong)
28597         }
28598         {
28599                 x := uint16(len(([]byte((*(*(struct {
28600                         MaxHP            uint16 // Player only.
28601                         CollideWithNodes bool
28602                         Weight           float32 // deprecated
28603                         ColBox, SelBox   Box
28604                         Pointable        bool
28605                         Visual           string
28606                         VisualSize       [3]float32
28607                         Textures         []Texture
28608                         SpriteSheetSize  [2]int16 // in sprites.
28609                         SpritePos        [2]int16 // in sprite sheet.
28610                         Visible          bool
28611                         MakeFootstepSnds bool
28612                         RotateSpeed      float32 // in radians per second.
28613                         Mesh             string
28614                         Colors           []color.NRGBA
28615                         CollideWithAOs   bool
28616                         StepHeight       float32
28617                         FaceRotateDir    bool
28618                         FaceRotateDirOff float32 // in degrees.
28619                         BackfaceCull     bool
28620                         Nametag          string
28621                         NametagColor     color.NRGBA
28622                         FaceRotateSpeed  float32 // in degrees per second.
28623                         Infotext         string
28624                         Itemstring       string
28625                         Glow             int8
28626                         MaxBreath        uint16  // Player only.
28627                         EyeHeight        float32 // Player only.
28628                         ZoomFOV          float32 // in degrees. Player only.
28629                         UseTextureAlpha  bool
28630                         DmgTextureMod    Texture // suffix
28631                         Shaded           bool
28632                         ShowOnMinimap    bool
28633                         NametagBG        color.NRGBA
28634                 }))(obj)).Infotext))))
28635                 write16(w, uint16(x))
28636         }
28637         {
28638                 _, err := w.Write(([]byte((*(*(struct {
28639                         MaxHP            uint16 // Player only.
28640                         CollideWithNodes bool
28641                         Weight           float32 // deprecated
28642                         ColBox, SelBox   Box
28643                         Pointable        bool
28644                         Visual           string
28645                         VisualSize       [3]float32
28646                         Textures         []Texture
28647                         SpriteSheetSize  [2]int16 // in sprites.
28648                         SpritePos        [2]int16 // in sprite sheet.
28649                         Visible          bool
28650                         MakeFootstepSnds bool
28651                         RotateSpeed      float32 // in radians per second.
28652                         Mesh             string
28653                         Colors           []color.NRGBA
28654                         CollideWithAOs   bool
28655                         StepHeight       float32
28656                         FaceRotateDir    bool
28657                         FaceRotateDirOff float32 // in degrees.
28658                         BackfaceCull     bool
28659                         Nametag          string
28660                         NametagColor     color.NRGBA
28661                         FaceRotateSpeed  float32 // in degrees per second.
28662                         Infotext         string
28663                         Itemstring       string
28664                         Glow             int8
28665                         MaxBreath        uint16  // Player only.
28666                         EyeHeight        float32 // Player only.
28667                         ZoomFOV          float32 // in degrees. Player only.
28668                         UseTextureAlpha  bool
28669                         DmgTextureMod    Texture // suffix
28670                         Shaded           bool
28671                         ShowOnMinimap    bool
28672                         NametagBG        color.NRGBA
28673                 }))(obj)).Infotext))[:])
28674                 chk(err)
28675         }
28676         if len(([]byte((*(*(struct {
28677                 MaxHP            uint16 // Player only.
28678                 CollideWithNodes bool
28679                 Weight           float32 // deprecated
28680                 ColBox, SelBox   Box
28681                 Pointable        bool
28682                 Visual           string
28683                 VisualSize       [3]float32
28684                 Textures         []Texture
28685                 SpriteSheetSize  [2]int16 // in sprites.
28686                 SpritePos        [2]int16 // in sprite sheet.
28687                 Visible          bool
28688                 MakeFootstepSnds bool
28689                 RotateSpeed      float32 // in radians per second.
28690                 Mesh             string
28691                 Colors           []color.NRGBA
28692                 CollideWithAOs   bool
28693                 StepHeight       float32
28694                 FaceRotateDir    bool
28695                 FaceRotateDirOff float32 // in degrees.
28696                 BackfaceCull     bool
28697                 Nametag          string
28698                 NametagColor     color.NRGBA
28699                 FaceRotateSpeed  float32 // in degrees per second.
28700                 Infotext         string
28701                 Itemstring       string
28702                 Glow             int8
28703                 MaxBreath        uint16  // Player only.
28704                 EyeHeight        float32 // Player only.
28705                 ZoomFOV          float32 // in degrees. Player only.
28706                 UseTextureAlpha  bool
28707                 DmgTextureMod    Texture // suffix
28708                 Shaded           bool
28709                 ShowOnMinimap    bool
28710                 NametagBG        color.NRGBA
28711         }))(obj)).Itemstring))) > math.MaxUint16 {
28712                 chk(ErrTooLong)
28713         }
28714         {
28715                 x := uint16(len(([]byte((*(*(struct {
28716                         MaxHP            uint16 // Player only.
28717                         CollideWithNodes bool
28718                         Weight           float32 // deprecated
28719                         ColBox, SelBox   Box
28720                         Pointable        bool
28721                         Visual           string
28722                         VisualSize       [3]float32
28723                         Textures         []Texture
28724                         SpriteSheetSize  [2]int16 // in sprites.
28725                         SpritePos        [2]int16 // in sprite sheet.
28726                         Visible          bool
28727                         MakeFootstepSnds bool
28728                         RotateSpeed      float32 // in radians per second.
28729                         Mesh             string
28730                         Colors           []color.NRGBA
28731                         CollideWithAOs   bool
28732                         StepHeight       float32
28733                         FaceRotateDir    bool
28734                         FaceRotateDirOff float32 // in degrees.
28735                         BackfaceCull     bool
28736                         Nametag          string
28737                         NametagColor     color.NRGBA
28738                         FaceRotateSpeed  float32 // in degrees per second.
28739                         Infotext         string
28740                         Itemstring       string
28741                         Glow             int8
28742                         MaxBreath        uint16  // Player only.
28743                         EyeHeight        float32 // Player only.
28744                         ZoomFOV          float32 // in degrees. Player only.
28745                         UseTextureAlpha  bool
28746                         DmgTextureMod    Texture // suffix
28747                         Shaded           bool
28748                         ShowOnMinimap    bool
28749                         NametagBG        color.NRGBA
28750                 }))(obj)).Itemstring))))
28751                 write16(w, uint16(x))
28752         }
28753         {
28754                 _, err := w.Write(([]byte((*(*(struct {
28755                         MaxHP            uint16 // Player only.
28756                         CollideWithNodes bool
28757                         Weight           float32 // deprecated
28758                         ColBox, SelBox   Box
28759                         Pointable        bool
28760                         Visual           string
28761                         VisualSize       [3]float32
28762                         Textures         []Texture
28763                         SpriteSheetSize  [2]int16 // in sprites.
28764                         SpritePos        [2]int16 // in sprite sheet.
28765                         Visible          bool
28766                         MakeFootstepSnds bool
28767                         RotateSpeed      float32 // in radians per second.
28768                         Mesh             string
28769                         Colors           []color.NRGBA
28770                         CollideWithAOs   bool
28771                         StepHeight       float32
28772                         FaceRotateDir    bool
28773                         FaceRotateDirOff float32 // in degrees.
28774                         BackfaceCull     bool
28775                         Nametag          string
28776                         NametagColor     color.NRGBA
28777                         FaceRotateSpeed  float32 // in degrees per second.
28778                         Infotext         string
28779                         Itemstring       string
28780                         Glow             int8
28781                         MaxBreath        uint16  // Player only.
28782                         EyeHeight        float32 // Player only.
28783                         ZoomFOV          float32 // in degrees. Player only.
28784                         UseTextureAlpha  bool
28785                         DmgTextureMod    Texture // suffix
28786                         Shaded           bool
28787                         ShowOnMinimap    bool
28788                         NametagBG        color.NRGBA
28789                 }))(obj)).Itemstring))[:])
28790                 chk(err)
28791         }
28792         {
28793                 x := (*(*(struct {
28794                         MaxHP            uint16 // Player only.
28795                         CollideWithNodes bool
28796                         Weight           float32 // deprecated
28797                         ColBox, SelBox   Box
28798                         Pointable        bool
28799                         Visual           string
28800                         VisualSize       [3]float32
28801                         Textures         []Texture
28802                         SpriteSheetSize  [2]int16 // in sprites.
28803                         SpritePos        [2]int16 // in sprite sheet.
28804                         Visible          bool
28805                         MakeFootstepSnds bool
28806                         RotateSpeed      float32 // in radians per second.
28807                         Mesh             string
28808                         Colors           []color.NRGBA
28809                         CollideWithAOs   bool
28810                         StepHeight       float32
28811                         FaceRotateDir    bool
28812                         FaceRotateDirOff float32 // in degrees.
28813                         BackfaceCull     bool
28814                         Nametag          string
28815                         NametagColor     color.NRGBA
28816                         FaceRotateSpeed  float32 // in degrees per second.
28817                         Infotext         string
28818                         Itemstring       string
28819                         Glow             int8
28820                         MaxBreath        uint16  // Player only.
28821                         EyeHeight        float32 // Player only.
28822                         ZoomFOV          float32 // in degrees. Player only.
28823                         UseTextureAlpha  bool
28824                         DmgTextureMod    Texture // suffix
28825                         Shaded           bool
28826                         ShowOnMinimap    bool
28827                         NametagBG        color.NRGBA
28828                 }))(obj)).Glow
28829                 write8(w, uint8(x))
28830         }
28831         {
28832                 x := (*(*(struct {
28833                         MaxHP            uint16 // Player only.
28834                         CollideWithNodes bool
28835                         Weight           float32 // deprecated
28836                         ColBox, SelBox   Box
28837                         Pointable        bool
28838                         Visual           string
28839                         VisualSize       [3]float32
28840                         Textures         []Texture
28841                         SpriteSheetSize  [2]int16 // in sprites.
28842                         SpritePos        [2]int16 // in sprite sheet.
28843                         Visible          bool
28844                         MakeFootstepSnds bool
28845                         RotateSpeed      float32 // in radians per second.
28846                         Mesh             string
28847                         Colors           []color.NRGBA
28848                         CollideWithAOs   bool
28849                         StepHeight       float32
28850                         FaceRotateDir    bool
28851                         FaceRotateDirOff float32 // in degrees.
28852                         BackfaceCull     bool
28853                         Nametag          string
28854                         NametagColor     color.NRGBA
28855                         FaceRotateSpeed  float32 // in degrees per second.
28856                         Infotext         string
28857                         Itemstring       string
28858                         Glow             int8
28859                         MaxBreath        uint16  // Player only.
28860                         EyeHeight        float32 // Player only.
28861                         ZoomFOV          float32 // in degrees. Player only.
28862                         UseTextureAlpha  bool
28863                         DmgTextureMod    Texture // suffix
28864                         Shaded           bool
28865                         ShowOnMinimap    bool
28866                         NametagBG        color.NRGBA
28867                 }))(obj)).MaxBreath
28868                 write16(w, uint16(x))
28869         }
28870         {
28871                 x := (*(*(struct {
28872                         MaxHP            uint16 // Player only.
28873                         CollideWithNodes bool
28874                         Weight           float32 // deprecated
28875                         ColBox, SelBox   Box
28876                         Pointable        bool
28877                         Visual           string
28878                         VisualSize       [3]float32
28879                         Textures         []Texture
28880                         SpriteSheetSize  [2]int16 // in sprites.
28881                         SpritePos        [2]int16 // in sprite sheet.
28882                         Visible          bool
28883                         MakeFootstepSnds bool
28884                         RotateSpeed      float32 // in radians per second.
28885                         Mesh             string
28886                         Colors           []color.NRGBA
28887                         CollideWithAOs   bool
28888                         StepHeight       float32
28889                         FaceRotateDir    bool
28890                         FaceRotateDirOff float32 // in degrees.
28891                         BackfaceCull     bool
28892                         Nametag          string
28893                         NametagColor     color.NRGBA
28894                         FaceRotateSpeed  float32 // in degrees per second.
28895                         Infotext         string
28896                         Itemstring       string
28897                         Glow             int8
28898                         MaxBreath        uint16  // Player only.
28899                         EyeHeight        float32 // Player only.
28900                         ZoomFOV          float32 // in degrees. Player only.
28901                         UseTextureAlpha  bool
28902                         DmgTextureMod    Texture // suffix
28903                         Shaded           bool
28904                         ShowOnMinimap    bool
28905                         NametagBG        color.NRGBA
28906                 }))(obj)).EyeHeight
28907                 write32(w, math.Float32bits(x))
28908         }
28909         {
28910                 x := (*(*(struct {
28911                         MaxHP            uint16 // Player only.
28912                         CollideWithNodes bool
28913                         Weight           float32 // deprecated
28914                         ColBox, SelBox   Box
28915                         Pointable        bool
28916                         Visual           string
28917                         VisualSize       [3]float32
28918                         Textures         []Texture
28919                         SpriteSheetSize  [2]int16 // in sprites.
28920                         SpritePos        [2]int16 // in sprite sheet.
28921                         Visible          bool
28922                         MakeFootstepSnds bool
28923                         RotateSpeed      float32 // in radians per second.
28924                         Mesh             string
28925                         Colors           []color.NRGBA
28926                         CollideWithAOs   bool
28927                         StepHeight       float32
28928                         FaceRotateDir    bool
28929                         FaceRotateDirOff float32 // in degrees.
28930                         BackfaceCull     bool
28931                         Nametag          string
28932                         NametagColor     color.NRGBA
28933                         FaceRotateSpeed  float32 // in degrees per second.
28934                         Infotext         string
28935                         Itemstring       string
28936                         Glow             int8
28937                         MaxBreath        uint16  // Player only.
28938                         EyeHeight        float32 // Player only.
28939                         ZoomFOV          float32 // in degrees. Player only.
28940                         UseTextureAlpha  bool
28941                         DmgTextureMod    Texture // suffix
28942                         Shaded           bool
28943                         ShowOnMinimap    bool
28944                         NametagBG        color.NRGBA
28945                 }))(obj)).ZoomFOV
28946                 write32(w, math.Float32bits(x))
28947         }
28948         {
28949                 x := (*(*(struct {
28950                         MaxHP            uint16 // Player only.
28951                         CollideWithNodes bool
28952                         Weight           float32 // deprecated
28953                         ColBox, SelBox   Box
28954                         Pointable        bool
28955                         Visual           string
28956                         VisualSize       [3]float32
28957                         Textures         []Texture
28958                         SpriteSheetSize  [2]int16 // in sprites.
28959                         SpritePos        [2]int16 // in sprite sheet.
28960                         Visible          bool
28961                         MakeFootstepSnds bool
28962                         RotateSpeed      float32 // in radians per second.
28963                         Mesh             string
28964                         Colors           []color.NRGBA
28965                         CollideWithAOs   bool
28966                         StepHeight       float32
28967                         FaceRotateDir    bool
28968                         FaceRotateDirOff float32 // in degrees.
28969                         BackfaceCull     bool
28970                         Nametag          string
28971                         NametagColor     color.NRGBA
28972                         FaceRotateSpeed  float32 // in degrees per second.
28973                         Infotext         string
28974                         Itemstring       string
28975                         Glow             int8
28976                         MaxBreath        uint16  // Player only.
28977                         EyeHeight        float32 // Player only.
28978                         ZoomFOV          float32 // in degrees. Player only.
28979                         UseTextureAlpha  bool
28980                         DmgTextureMod    Texture // suffix
28981                         Shaded           bool
28982                         ShowOnMinimap    bool
28983                         NametagBG        color.NRGBA
28984                 }))(obj)).UseTextureAlpha
28985                 if x {
28986                         write8(w, 1)
28987                 } else {
28988                         write8(w, 0)
28989                 }
28990
28991         }
28992         if err := pcall(func() {
28993                 ((*(*(struct {
28994                         MaxHP            uint16 // Player only.
28995                         CollideWithNodes bool
28996                         Weight           float32 // deprecated
28997                         ColBox, SelBox   Box
28998                         Pointable        bool
28999                         Visual           string
29000                         VisualSize       [3]float32
29001                         Textures         []Texture
29002                         SpriteSheetSize  [2]int16 // in sprites.
29003                         SpritePos        [2]int16 // in sprite sheet.
29004                         Visible          bool
29005                         MakeFootstepSnds bool
29006                         RotateSpeed      float32 // in radians per second.
29007                         Mesh             string
29008                         Colors           []color.NRGBA
29009                         CollideWithAOs   bool
29010                         StepHeight       float32
29011                         FaceRotateDir    bool
29012                         FaceRotateDirOff float32 // in degrees.
29013                         BackfaceCull     bool
29014                         Nametag          string
29015                         NametagColor     color.NRGBA
29016                         FaceRotateSpeed  float32 // in degrees per second.
29017                         Infotext         string
29018                         Itemstring       string
29019                         Glow             int8
29020                         MaxBreath        uint16  // Player only.
29021                         EyeHeight        float32 // Player only.
29022                         ZoomFOV          float32 // in degrees. Player only.
29023                         UseTextureAlpha  bool
29024                         DmgTextureMod    Texture // suffix
29025                         Shaded           bool
29026                         ShowOnMinimap    bool
29027                         NametagBG        color.NRGBA
29028                 }))(obj)).DmgTextureMod).serialize(w)
29029         }); err != nil {
29030                 if err == io.EOF {
29031                         chk(io.EOF)
29032                 }
29033                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
29034         }
29035         {
29036                 x := (*(*(struct {
29037                         MaxHP            uint16 // Player only.
29038                         CollideWithNodes bool
29039                         Weight           float32 // deprecated
29040                         ColBox, SelBox   Box
29041                         Pointable        bool
29042                         Visual           string
29043                         VisualSize       [3]float32
29044                         Textures         []Texture
29045                         SpriteSheetSize  [2]int16 // in sprites.
29046                         SpritePos        [2]int16 // in sprite sheet.
29047                         Visible          bool
29048                         MakeFootstepSnds bool
29049                         RotateSpeed      float32 // in radians per second.
29050                         Mesh             string
29051                         Colors           []color.NRGBA
29052                         CollideWithAOs   bool
29053                         StepHeight       float32
29054                         FaceRotateDir    bool
29055                         FaceRotateDirOff float32 // in degrees.
29056                         BackfaceCull     bool
29057                         Nametag          string
29058                         NametagColor     color.NRGBA
29059                         FaceRotateSpeed  float32 // in degrees per second.
29060                         Infotext         string
29061                         Itemstring       string
29062                         Glow             int8
29063                         MaxBreath        uint16  // Player only.
29064                         EyeHeight        float32 // Player only.
29065                         ZoomFOV          float32 // in degrees. Player only.
29066                         UseTextureAlpha  bool
29067                         DmgTextureMod    Texture // suffix
29068                         Shaded           bool
29069                         ShowOnMinimap    bool
29070                         NametagBG        color.NRGBA
29071                 }))(obj)).Shaded
29072                 if x {
29073                         write8(w, 1)
29074                 } else {
29075                         write8(w, 0)
29076                 }
29077
29078         }
29079         {
29080                 x := (*(*(struct {
29081                         MaxHP            uint16 // Player only.
29082                         CollideWithNodes bool
29083                         Weight           float32 // deprecated
29084                         ColBox, SelBox   Box
29085                         Pointable        bool
29086                         Visual           string
29087                         VisualSize       [3]float32
29088                         Textures         []Texture
29089                         SpriteSheetSize  [2]int16 // in sprites.
29090                         SpritePos        [2]int16 // in sprite sheet.
29091                         Visible          bool
29092                         MakeFootstepSnds bool
29093                         RotateSpeed      float32 // in radians per second.
29094                         Mesh             string
29095                         Colors           []color.NRGBA
29096                         CollideWithAOs   bool
29097                         StepHeight       float32
29098                         FaceRotateDir    bool
29099                         FaceRotateDirOff float32 // in degrees.
29100                         BackfaceCull     bool
29101                         Nametag          string
29102                         NametagColor     color.NRGBA
29103                         FaceRotateSpeed  float32 // in degrees per second.
29104                         Infotext         string
29105                         Itemstring       string
29106                         Glow             int8
29107                         MaxBreath        uint16  // Player only.
29108                         EyeHeight        float32 // Player only.
29109                         ZoomFOV          float32 // in degrees. Player only.
29110                         UseTextureAlpha  bool
29111                         DmgTextureMod    Texture // suffix
29112                         Shaded           bool
29113                         ShowOnMinimap    bool
29114                         NametagBG        color.NRGBA
29115                 }))(obj)).ShowOnMinimap
29116                 if x {
29117                         write8(w, 1)
29118                 } else {
29119                         write8(w, 0)
29120                 }
29121
29122         }
29123         {
29124                 x := (*(*(struct {
29125                         MaxHP            uint16 // Player only.
29126                         CollideWithNodes bool
29127                         Weight           float32 // deprecated
29128                         ColBox, SelBox   Box
29129                         Pointable        bool
29130                         Visual           string
29131                         VisualSize       [3]float32
29132                         Textures         []Texture
29133                         SpriteSheetSize  [2]int16 // in sprites.
29134                         SpritePos        [2]int16 // in sprite sheet.
29135                         Visible          bool
29136                         MakeFootstepSnds bool
29137                         RotateSpeed      float32 // in radians per second.
29138                         Mesh             string
29139                         Colors           []color.NRGBA
29140                         CollideWithAOs   bool
29141                         StepHeight       float32
29142                         FaceRotateDir    bool
29143                         FaceRotateDirOff float32 // in degrees.
29144                         BackfaceCull     bool
29145                         Nametag          string
29146                         NametagColor     color.NRGBA
29147                         FaceRotateSpeed  float32 // in degrees per second.
29148                         Infotext         string
29149                         Itemstring       string
29150                         Glow             int8
29151                         MaxBreath        uint16  // Player only.
29152                         EyeHeight        float32 // Player only.
29153                         ZoomFOV          float32 // in degrees. Player only.
29154                         UseTextureAlpha  bool
29155                         DmgTextureMod    Texture // suffix
29156                         Shaded           bool
29157                         ShowOnMinimap    bool
29158                         NametagBG        color.NRGBA
29159                 }))(obj)).NametagBG
29160                 w.Write([]byte{x.A, x.R, x.G, x.B})
29161
29162         }
29163 }
29164
29165 func (obj *AOProps) deserialize(r io.Reader) {
29166         {
29167                 var local341 uint8
29168                 local342 := uint8(4)
29169                 {
29170                         p := &local341
29171                         *p = read8(r)
29172                 }
29173                 if local341 != local342 {
29174                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local341))
29175                 }
29176         }
29177         {
29178                 p := &(*(*(struct {
29179                         MaxHP            uint16 // Player only.
29180                         CollideWithNodes bool
29181                         Weight           float32 // deprecated
29182                         ColBox, SelBox   Box
29183                         Pointable        bool
29184                         Visual           string
29185                         VisualSize       [3]float32
29186                         Textures         []Texture
29187                         SpriteSheetSize  [2]int16 // in sprites.
29188                         SpritePos        [2]int16 // in sprite sheet.
29189                         Visible          bool
29190                         MakeFootstepSnds bool
29191                         RotateSpeed      float32 // in radians per second.
29192                         Mesh             string
29193                         Colors           []color.NRGBA
29194                         CollideWithAOs   bool
29195                         StepHeight       float32
29196                         FaceRotateDir    bool
29197                         FaceRotateDirOff float32 // in degrees.
29198                         BackfaceCull     bool
29199                         Nametag          string
29200                         NametagColor     color.NRGBA
29201                         FaceRotateSpeed  float32 // in degrees per second.
29202                         Infotext         string
29203                         Itemstring       string
29204                         Glow             int8
29205                         MaxBreath        uint16  // Player only.
29206                         EyeHeight        float32 // Player only.
29207                         ZoomFOV          float32 // in degrees. Player only.
29208                         UseTextureAlpha  bool
29209                         DmgTextureMod    Texture // suffix
29210                         Shaded           bool
29211                         ShowOnMinimap    bool
29212                         NametagBG        color.NRGBA
29213                 }))(obj)).MaxHP
29214                 *p = read16(r)
29215         }
29216         {
29217                 p := &(*(*(struct {
29218                         MaxHP            uint16 // Player only.
29219                         CollideWithNodes bool
29220                         Weight           float32 // deprecated
29221                         ColBox, SelBox   Box
29222                         Pointable        bool
29223                         Visual           string
29224                         VisualSize       [3]float32
29225                         Textures         []Texture
29226                         SpriteSheetSize  [2]int16 // in sprites.
29227                         SpritePos        [2]int16 // in sprite sheet.
29228                         Visible          bool
29229                         MakeFootstepSnds bool
29230                         RotateSpeed      float32 // in radians per second.
29231                         Mesh             string
29232                         Colors           []color.NRGBA
29233                         CollideWithAOs   bool
29234                         StepHeight       float32
29235                         FaceRotateDir    bool
29236                         FaceRotateDirOff float32 // in degrees.
29237                         BackfaceCull     bool
29238                         Nametag          string
29239                         NametagColor     color.NRGBA
29240                         FaceRotateSpeed  float32 // in degrees per second.
29241                         Infotext         string
29242                         Itemstring       string
29243                         Glow             int8
29244                         MaxBreath        uint16  // Player only.
29245                         EyeHeight        float32 // Player only.
29246                         ZoomFOV          float32 // in degrees. Player only.
29247                         UseTextureAlpha  bool
29248                         DmgTextureMod    Texture // suffix
29249                         Shaded           bool
29250                         ShowOnMinimap    bool
29251                         NametagBG        color.NRGBA
29252                 }))(obj)).CollideWithNodes
29253                 switch n := read8(r); n {
29254                 case 0:
29255                         *p = false
29256                 case 1:
29257                         *p = true
29258                 default:
29259                         chk(fmt.Errorf("invalid bool: %d", n))
29260                 }
29261
29262         }
29263         {
29264                 p := &(*(*(struct {
29265                         MaxHP            uint16 // Player only.
29266                         CollideWithNodes bool
29267                         Weight           float32 // deprecated
29268                         ColBox, SelBox   Box
29269                         Pointable        bool
29270                         Visual           string
29271                         VisualSize       [3]float32
29272                         Textures         []Texture
29273                         SpriteSheetSize  [2]int16 // in sprites.
29274                         SpritePos        [2]int16 // in sprite sheet.
29275                         Visible          bool
29276                         MakeFootstepSnds bool
29277                         RotateSpeed      float32 // in radians per second.
29278                         Mesh             string
29279                         Colors           []color.NRGBA
29280                         CollideWithAOs   bool
29281                         StepHeight       float32
29282                         FaceRotateDir    bool
29283                         FaceRotateDirOff float32 // in degrees.
29284                         BackfaceCull     bool
29285                         Nametag          string
29286                         NametagColor     color.NRGBA
29287                         FaceRotateSpeed  float32 // in degrees per second.
29288                         Infotext         string
29289                         Itemstring       string
29290                         Glow             int8
29291                         MaxBreath        uint16  // Player only.
29292                         EyeHeight        float32 // Player only.
29293                         ZoomFOV          float32 // in degrees. Player only.
29294                         UseTextureAlpha  bool
29295                         DmgTextureMod    Texture // suffix
29296                         Shaded           bool
29297                         ShowOnMinimap    bool
29298                         NametagBG        color.NRGBA
29299                 }))(obj)).Weight
29300                 *p = math.Float32frombits(read32(r))
29301         }
29302         if err := pcall(func() {
29303                 ((*(*(struct {
29304                         MaxHP            uint16 // Player only.
29305                         CollideWithNodes bool
29306                         Weight           float32 // deprecated
29307                         ColBox, SelBox   Box
29308                         Pointable        bool
29309                         Visual           string
29310                         VisualSize       [3]float32
29311                         Textures         []Texture
29312                         SpriteSheetSize  [2]int16 // in sprites.
29313                         SpritePos        [2]int16 // in sprite sheet.
29314                         Visible          bool
29315                         MakeFootstepSnds bool
29316                         RotateSpeed      float32 // in radians per second.
29317                         Mesh             string
29318                         Colors           []color.NRGBA
29319                         CollideWithAOs   bool
29320                         StepHeight       float32
29321                         FaceRotateDir    bool
29322                         FaceRotateDirOff float32 // in degrees.
29323                         BackfaceCull     bool
29324                         Nametag          string
29325                         NametagColor     color.NRGBA
29326                         FaceRotateSpeed  float32 // in degrees per second.
29327                         Infotext         string
29328                         Itemstring       string
29329                         Glow             int8
29330                         MaxBreath        uint16  // Player only.
29331                         EyeHeight        float32 // Player only.
29332                         ZoomFOV          float32 // in degrees. Player only.
29333                         UseTextureAlpha  bool
29334                         DmgTextureMod    Texture // suffix
29335                         Shaded           bool
29336                         ShowOnMinimap    bool
29337                         NametagBG        color.NRGBA
29338                 }))(obj)).ColBox).deserialize(r)
29339         }); err != nil {
29340                 if err == io.EOF {
29341                         chk(io.EOF)
29342                 }
29343                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29344         }
29345         if err := pcall(func() {
29346                 ((*(*(struct {
29347                         MaxHP            uint16 // Player only.
29348                         CollideWithNodes bool
29349                         Weight           float32 // deprecated
29350                         ColBox, SelBox   Box
29351                         Pointable        bool
29352                         Visual           string
29353                         VisualSize       [3]float32
29354                         Textures         []Texture
29355                         SpriteSheetSize  [2]int16 // in sprites.
29356                         SpritePos        [2]int16 // in sprite sheet.
29357                         Visible          bool
29358                         MakeFootstepSnds bool
29359                         RotateSpeed      float32 // in radians per second.
29360                         Mesh             string
29361                         Colors           []color.NRGBA
29362                         CollideWithAOs   bool
29363                         StepHeight       float32
29364                         FaceRotateDir    bool
29365                         FaceRotateDirOff float32 // in degrees.
29366                         BackfaceCull     bool
29367                         Nametag          string
29368                         NametagColor     color.NRGBA
29369                         FaceRotateSpeed  float32 // in degrees per second.
29370                         Infotext         string
29371                         Itemstring       string
29372                         Glow             int8
29373                         MaxBreath        uint16  // Player only.
29374                         EyeHeight        float32 // Player only.
29375                         ZoomFOV          float32 // in degrees. Player only.
29376                         UseTextureAlpha  bool
29377                         DmgTextureMod    Texture // suffix
29378                         Shaded           bool
29379                         ShowOnMinimap    bool
29380                         NametagBG        color.NRGBA
29381                 }))(obj)).SelBox).deserialize(r)
29382         }); err != nil {
29383                 if err == io.EOF {
29384                         chk(io.EOF)
29385                 }
29386                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
29387         }
29388         {
29389                 p := &(*(*(struct {
29390                         MaxHP            uint16 // Player only.
29391                         CollideWithNodes bool
29392                         Weight           float32 // deprecated
29393                         ColBox, SelBox   Box
29394                         Pointable        bool
29395                         Visual           string
29396                         VisualSize       [3]float32
29397                         Textures         []Texture
29398                         SpriteSheetSize  [2]int16 // in sprites.
29399                         SpritePos        [2]int16 // in sprite sheet.
29400                         Visible          bool
29401                         MakeFootstepSnds bool
29402                         RotateSpeed      float32 // in radians per second.
29403                         Mesh             string
29404                         Colors           []color.NRGBA
29405                         CollideWithAOs   bool
29406                         StepHeight       float32
29407                         FaceRotateDir    bool
29408                         FaceRotateDirOff float32 // in degrees.
29409                         BackfaceCull     bool
29410                         Nametag          string
29411                         NametagColor     color.NRGBA
29412                         FaceRotateSpeed  float32 // in degrees per second.
29413                         Infotext         string
29414                         Itemstring       string
29415                         Glow             int8
29416                         MaxBreath        uint16  // Player only.
29417                         EyeHeight        float32 // Player only.
29418                         ZoomFOV          float32 // in degrees. Player only.
29419                         UseTextureAlpha  bool
29420                         DmgTextureMod    Texture // suffix
29421                         Shaded           bool
29422                         ShowOnMinimap    bool
29423                         NametagBG        color.NRGBA
29424                 }))(obj)).Pointable
29425                 switch n := read8(r); n {
29426                 case 0:
29427                         *p = false
29428                 case 1:
29429                         *p = true
29430                 default:
29431                         chk(fmt.Errorf("invalid bool: %d", n))
29432                 }
29433
29434         }
29435         var local343 []uint8
29436         var local344 uint16
29437         {
29438                 p := &local344
29439                 *p = read16(r)
29440         }
29441         (local343) = make([]uint8, local344)
29442         {
29443                 _, err := io.ReadFull(r, (local343)[:])
29444                 chk(err)
29445         }
29446         ((*(*(struct {
29447                 MaxHP            uint16 // Player only.
29448                 CollideWithNodes bool
29449                 Weight           float32 // deprecated
29450                 ColBox, SelBox   Box
29451                 Pointable        bool
29452                 Visual           string
29453                 VisualSize       [3]float32
29454                 Textures         []Texture
29455                 SpriteSheetSize  [2]int16 // in sprites.
29456                 SpritePos        [2]int16 // in sprite sheet.
29457                 Visible          bool
29458                 MakeFootstepSnds bool
29459                 RotateSpeed      float32 // in radians per second.
29460                 Mesh             string
29461                 Colors           []color.NRGBA
29462                 CollideWithAOs   bool
29463                 StepHeight       float32
29464                 FaceRotateDir    bool
29465                 FaceRotateDirOff float32 // in degrees.
29466                 BackfaceCull     bool
29467                 Nametag          string
29468                 NametagColor     color.NRGBA
29469                 FaceRotateSpeed  float32 // in degrees per second.
29470                 Infotext         string
29471                 Itemstring       string
29472                 Glow             int8
29473                 MaxBreath        uint16  // Player only.
29474                 EyeHeight        float32 // Player only.
29475                 ZoomFOV          float32 // in degrees. Player only.
29476                 UseTextureAlpha  bool
29477                 DmgTextureMod    Texture // suffix
29478                 Shaded           bool
29479                 ShowOnMinimap    bool
29480                 NametagBG        color.NRGBA
29481         }))(obj)).Visual) = string(local343)
29482         for local345 := range (*(*(struct {
29483                 MaxHP            uint16 // Player only.
29484                 CollideWithNodes bool
29485                 Weight           float32 // deprecated
29486                 ColBox, SelBox   Box
29487                 Pointable        bool
29488                 Visual           string
29489                 VisualSize       [3]float32
29490                 Textures         []Texture
29491                 SpriteSheetSize  [2]int16 // in sprites.
29492                 SpritePos        [2]int16 // in sprite sheet.
29493                 Visible          bool
29494                 MakeFootstepSnds bool
29495                 RotateSpeed      float32 // in radians per second.
29496                 Mesh             string
29497                 Colors           []color.NRGBA
29498                 CollideWithAOs   bool
29499                 StepHeight       float32
29500                 FaceRotateDir    bool
29501                 FaceRotateDirOff float32 // in degrees.
29502                 BackfaceCull     bool
29503                 Nametag          string
29504                 NametagColor     color.NRGBA
29505                 FaceRotateSpeed  float32 // in degrees per second.
29506                 Infotext         string
29507                 Itemstring       string
29508                 Glow             int8
29509                 MaxBreath        uint16  // Player only.
29510                 EyeHeight        float32 // Player only.
29511                 ZoomFOV          float32 // in degrees. Player only.
29512                 UseTextureAlpha  bool
29513                 DmgTextureMod    Texture // suffix
29514                 Shaded           bool
29515                 ShowOnMinimap    bool
29516                 NametagBG        color.NRGBA
29517         }))(obj)).VisualSize {
29518                 {
29519                         p := &((*(*(struct {
29520                                 MaxHP            uint16 // Player only.
29521                                 CollideWithNodes bool
29522                                 Weight           float32 // deprecated
29523                                 ColBox, SelBox   Box
29524                                 Pointable        bool
29525                                 Visual           string
29526                                 VisualSize       [3]float32
29527                                 Textures         []Texture
29528                                 SpriteSheetSize  [2]int16 // in sprites.
29529                                 SpritePos        [2]int16 // in sprite sheet.
29530                                 Visible          bool
29531                                 MakeFootstepSnds bool
29532                                 RotateSpeed      float32 // in radians per second.
29533                                 Mesh             string
29534                                 Colors           []color.NRGBA
29535                                 CollideWithAOs   bool
29536                                 StepHeight       float32
29537                                 FaceRotateDir    bool
29538                                 FaceRotateDirOff float32 // in degrees.
29539                                 BackfaceCull     bool
29540                                 Nametag          string
29541                                 NametagColor     color.NRGBA
29542                                 FaceRotateSpeed  float32 // in degrees per second.
29543                                 Infotext         string
29544                                 Itemstring       string
29545                                 Glow             int8
29546                                 MaxBreath        uint16  // Player only.
29547                                 EyeHeight        float32 // Player only.
29548                                 ZoomFOV          float32 // in degrees. Player only.
29549                                 UseTextureAlpha  bool
29550                                 DmgTextureMod    Texture // suffix
29551                                 Shaded           bool
29552                                 ShowOnMinimap    bool
29553                                 NametagBG        color.NRGBA
29554                         }))(obj)).VisualSize)[local345]
29555                         *p = math.Float32frombits(read32(r))
29556                 }
29557         }
29558         var local346 uint16
29559         {
29560                 p := &local346
29561                 *p = read16(r)
29562         }
29563         ((*(*(struct {
29564                 MaxHP            uint16 // Player only.
29565                 CollideWithNodes bool
29566                 Weight           float32 // deprecated
29567                 ColBox, SelBox   Box
29568                 Pointable        bool
29569                 Visual           string
29570                 VisualSize       [3]float32
29571                 Textures         []Texture
29572                 SpriteSheetSize  [2]int16 // in sprites.
29573                 SpritePos        [2]int16 // in sprite sheet.
29574                 Visible          bool
29575                 MakeFootstepSnds bool
29576                 RotateSpeed      float32 // in radians per second.
29577                 Mesh             string
29578                 Colors           []color.NRGBA
29579                 CollideWithAOs   bool
29580                 StepHeight       float32
29581                 FaceRotateDir    bool
29582                 FaceRotateDirOff float32 // in degrees.
29583                 BackfaceCull     bool
29584                 Nametag          string
29585                 NametagColor     color.NRGBA
29586                 FaceRotateSpeed  float32 // in degrees per second.
29587                 Infotext         string
29588                 Itemstring       string
29589                 Glow             int8
29590                 MaxBreath        uint16  // Player only.
29591                 EyeHeight        float32 // Player only.
29592                 ZoomFOV          float32 // in degrees. Player only.
29593                 UseTextureAlpha  bool
29594                 DmgTextureMod    Texture // suffix
29595                 Shaded           bool
29596                 ShowOnMinimap    bool
29597                 NametagBG        color.NRGBA
29598         }))(obj)).Textures) = make([]Texture, local346)
29599         for local347 := range (*(*(struct {
29600                 MaxHP            uint16 // Player only.
29601                 CollideWithNodes bool
29602                 Weight           float32 // deprecated
29603                 ColBox, SelBox   Box
29604                 Pointable        bool
29605                 Visual           string
29606                 VisualSize       [3]float32
29607                 Textures         []Texture
29608                 SpriteSheetSize  [2]int16 // in sprites.
29609                 SpritePos        [2]int16 // in sprite sheet.
29610                 Visible          bool
29611                 MakeFootstepSnds bool
29612                 RotateSpeed      float32 // in radians per second.
29613                 Mesh             string
29614                 Colors           []color.NRGBA
29615                 CollideWithAOs   bool
29616                 StepHeight       float32
29617                 FaceRotateDir    bool
29618                 FaceRotateDirOff float32 // in degrees.
29619                 BackfaceCull     bool
29620                 Nametag          string
29621                 NametagColor     color.NRGBA
29622                 FaceRotateSpeed  float32 // in degrees per second.
29623                 Infotext         string
29624                 Itemstring       string
29625                 Glow             int8
29626                 MaxBreath        uint16  // Player only.
29627                 EyeHeight        float32 // Player only.
29628                 ZoomFOV          float32 // in degrees. Player only.
29629                 UseTextureAlpha  bool
29630                 DmgTextureMod    Texture // suffix
29631                 Shaded           bool
29632                 ShowOnMinimap    bool
29633                 NametagBG        color.NRGBA
29634         }))(obj)).Textures {
29635                 if err := pcall(func() {
29636                         (((*(*(struct {
29637                                 MaxHP            uint16 // Player only.
29638                                 CollideWithNodes bool
29639                                 Weight           float32 // deprecated
29640                                 ColBox, SelBox   Box
29641                                 Pointable        bool
29642                                 Visual           string
29643                                 VisualSize       [3]float32
29644                                 Textures         []Texture
29645                                 SpriteSheetSize  [2]int16 // in sprites.
29646                                 SpritePos        [2]int16 // in sprite sheet.
29647                                 Visible          bool
29648                                 MakeFootstepSnds bool
29649                                 RotateSpeed      float32 // in radians per second.
29650                                 Mesh             string
29651                                 Colors           []color.NRGBA
29652                                 CollideWithAOs   bool
29653                                 StepHeight       float32
29654                                 FaceRotateDir    bool
29655                                 FaceRotateDirOff float32 // in degrees.
29656                                 BackfaceCull     bool
29657                                 Nametag          string
29658                                 NametagColor     color.NRGBA
29659                                 FaceRotateSpeed  float32 // in degrees per second.
29660                                 Infotext         string
29661                                 Itemstring       string
29662                                 Glow             int8
29663                                 MaxBreath        uint16  // Player only.
29664                                 EyeHeight        float32 // Player only.
29665                                 ZoomFOV          float32 // in degrees. Player only.
29666                                 UseTextureAlpha  bool
29667                                 DmgTextureMod    Texture // suffix
29668                                 Shaded           bool
29669                                 ShowOnMinimap    bool
29670                                 NametagBG        color.NRGBA
29671                         }))(obj)).Textures)[local347]).deserialize(r)
29672                 }); err != nil {
29673                         if err == io.EOF {
29674                                 chk(io.EOF)
29675                         }
29676                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
29677                 }
29678         }
29679         for local348 := range (*(*(struct {
29680                 MaxHP            uint16 // Player only.
29681                 CollideWithNodes bool
29682                 Weight           float32 // deprecated
29683                 ColBox, SelBox   Box
29684                 Pointable        bool
29685                 Visual           string
29686                 VisualSize       [3]float32
29687                 Textures         []Texture
29688                 SpriteSheetSize  [2]int16 // in sprites.
29689                 SpritePos        [2]int16 // in sprite sheet.
29690                 Visible          bool
29691                 MakeFootstepSnds bool
29692                 RotateSpeed      float32 // in radians per second.
29693                 Mesh             string
29694                 Colors           []color.NRGBA
29695                 CollideWithAOs   bool
29696                 StepHeight       float32
29697                 FaceRotateDir    bool
29698                 FaceRotateDirOff float32 // in degrees.
29699                 BackfaceCull     bool
29700                 Nametag          string
29701                 NametagColor     color.NRGBA
29702                 FaceRotateSpeed  float32 // in degrees per second.
29703                 Infotext         string
29704                 Itemstring       string
29705                 Glow             int8
29706                 MaxBreath        uint16  // Player only.
29707                 EyeHeight        float32 // Player only.
29708                 ZoomFOV          float32 // in degrees. Player only.
29709                 UseTextureAlpha  bool
29710                 DmgTextureMod    Texture // suffix
29711                 Shaded           bool
29712                 ShowOnMinimap    bool
29713                 NametagBG        color.NRGBA
29714         }))(obj)).SpriteSheetSize {
29715                 {
29716                         p := &((*(*(struct {
29717                                 MaxHP            uint16 // Player only.
29718                                 CollideWithNodes bool
29719                                 Weight           float32 // deprecated
29720                                 ColBox, SelBox   Box
29721                                 Pointable        bool
29722                                 Visual           string
29723                                 VisualSize       [3]float32
29724                                 Textures         []Texture
29725                                 SpriteSheetSize  [2]int16 // in sprites.
29726                                 SpritePos        [2]int16 // in sprite sheet.
29727                                 Visible          bool
29728                                 MakeFootstepSnds bool
29729                                 RotateSpeed      float32 // in radians per second.
29730                                 Mesh             string
29731                                 Colors           []color.NRGBA
29732                                 CollideWithAOs   bool
29733                                 StepHeight       float32
29734                                 FaceRotateDir    bool
29735                                 FaceRotateDirOff float32 // in degrees.
29736                                 BackfaceCull     bool
29737                                 Nametag          string
29738                                 NametagColor     color.NRGBA
29739                                 FaceRotateSpeed  float32 // in degrees per second.
29740                                 Infotext         string
29741                                 Itemstring       string
29742                                 Glow             int8
29743                                 MaxBreath        uint16  // Player only.
29744                                 EyeHeight        float32 // Player only.
29745                                 ZoomFOV          float32 // in degrees. Player only.
29746                                 UseTextureAlpha  bool
29747                                 DmgTextureMod    Texture // suffix
29748                                 Shaded           bool
29749                                 ShowOnMinimap    bool
29750                                 NametagBG        color.NRGBA
29751                         }))(obj)).SpriteSheetSize)[local348]
29752                         *p = int16(read16(r))
29753                 }
29754         }
29755         for local349 := range (*(*(struct {
29756                 MaxHP            uint16 // Player only.
29757                 CollideWithNodes bool
29758                 Weight           float32 // deprecated
29759                 ColBox, SelBox   Box
29760                 Pointable        bool
29761                 Visual           string
29762                 VisualSize       [3]float32
29763                 Textures         []Texture
29764                 SpriteSheetSize  [2]int16 // in sprites.
29765                 SpritePos        [2]int16 // in sprite sheet.
29766                 Visible          bool
29767                 MakeFootstepSnds bool
29768                 RotateSpeed      float32 // in radians per second.
29769                 Mesh             string
29770                 Colors           []color.NRGBA
29771                 CollideWithAOs   bool
29772                 StepHeight       float32
29773                 FaceRotateDir    bool
29774                 FaceRotateDirOff float32 // in degrees.
29775                 BackfaceCull     bool
29776                 Nametag          string
29777                 NametagColor     color.NRGBA
29778                 FaceRotateSpeed  float32 // in degrees per second.
29779                 Infotext         string
29780                 Itemstring       string
29781                 Glow             int8
29782                 MaxBreath        uint16  // Player only.
29783                 EyeHeight        float32 // Player only.
29784                 ZoomFOV          float32 // in degrees. Player only.
29785                 UseTextureAlpha  bool
29786                 DmgTextureMod    Texture // suffix
29787                 Shaded           bool
29788                 ShowOnMinimap    bool
29789                 NametagBG        color.NRGBA
29790         }))(obj)).SpritePos {
29791                 {
29792                         p := &((*(*(struct {
29793                                 MaxHP            uint16 // Player only.
29794                                 CollideWithNodes bool
29795                                 Weight           float32 // deprecated
29796                                 ColBox, SelBox   Box
29797                                 Pointable        bool
29798                                 Visual           string
29799                                 VisualSize       [3]float32
29800                                 Textures         []Texture
29801                                 SpriteSheetSize  [2]int16 // in sprites.
29802                                 SpritePos        [2]int16 // in sprite sheet.
29803                                 Visible          bool
29804                                 MakeFootstepSnds bool
29805                                 RotateSpeed      float32 // in radians per second.
29806                                 Mesh             string
29807                                 Colors           []color.NRGBA
29808                                 CollideWithAOs   bool
29809                                 StepHeight       float32
29810                                 FaceRotateDir    bool
29811                                 FaceRotateDirOff float32 // in degrees.
29812                                 BackfaceCull     bool
29813                                 Nametag          string
29814                                 NametagColor     color.NRGBA
29815                                 FaceRotateSpeed  float32 // in degrees per second.
29816                                 Infotext         string
29817                                 Itemstring       string
29818                                 Glow             int8
29819                                 MaxBreath        uint16  // Player only.
29820                                 EyeHeight        float32 // Player only.
29821                                 ZoomFOV          float32 // in degrees. Player only.
29822                                 UseTextureAlpha  bool
29823                                 DmgTextureMod    Texture // suffix
29824                                 Shaded           bool
29825                                 ShowOnMinimap    bool
29826                                 NametagBG        color.NRGBA
29827                         }))(obj)).SpritePos)[local349]
29828                         *p = int16(read16(r))
29829                 }
29830         }
29831         {
29832                 p := &(*(*(struct {
29833                         MaxHP            uint16 // Player only.
29834                         CollideWithNodes bool
29835                         Weight           float32 // deprecated
29836                         ColBox, SelBox   Box
29837                         Pointable        bool
29838                         Visual           string
29839                         VisualSize       [3]float32
29840                         Textures         []Texture
29841                         SpriteSheetSize  [2]int16 // in sprites.
29842                         SpritePos        [2]int16 // in sprite sheet.
29843                         Visible          bool
29844                         MakeFootstepSnds bool
29845                         RotateSpeed      float32 // in radians per second.
29846                         Mesh             string
29847                         Colors           []color.NRGBA
29848                         CollideWithAOs   bool
29849                         StepHeight       float32
29850                         FaceRotateDir    bool
29851                         FaceRotateDirOff float32 // in degrees.
29852                         BackfaceCull     bool
29853                         Nametag          string
29854                         NametagColor     color.NRGBA
29855                         FaceRotateSpeed  float32 // in degrees per second.
29856                         Infotext         string
29857                         Itemstring       string
29858                         Glow             int8
29859                         MaxBreath        uint16  // Player only.
29860                         EyeHeight        float32 // Player only.
29861                         ZoomFOV          float32 // in degrees. Player only.
29862                         UseTextureAlpha  bool
29863                         DmgTextureMod    Texture // suffix
29864                         Shaded           bool
29865                         ShowOnMinimap    bool
29866                         NametagBG        color.NRGBA
29867                 }))(obj)).Visible
29868                 switch n := read8(r); n {
29869                 case 0:
29870                         *p = false
29871                 case 1:
29872                         *p = true
29873                 default:
29874                         chk(fmt.Errorf("invalid bool: %d", n))
29875                 }
29876
29877         }
29878         {
29879                 p := &(*(*(struct {
29880                         MaxHP            uint16 // Player only.
29881                         CollideWithNodes bool
29882                         Weight           float32 // deprecated
29883                         ColBox, SelBox   Box
29884                         Pointable        bool
29885                         Visual           string
29886                         VisualSize       [3]float32
29887                         Textures         []Texture
29888                         SpriteSheetSize  [2]int16 // in sprites.
29889                         SpritePos        [2]int16 // in sprite sheet.
29890                         Visible          bool
29891                         MakeFootstepSnds bool
29892                         RotateSpeed      float32 // in radians per second.
29893                         Mesh             string
29894                         Colors           []color.NRGBA
29895                         CollideWithAOs   bool
29896                         StepHeight       float32
29897                         FaceRotateDir    bool
29898                         FaceRotateDirOff float32 // in degrees.
29899                         BackfaceCull     bool
29900                         Nametag          string
29901                         NametagColor     color.NRGBA
29902                         FaceRotateSpeed  float32 // in degrees per second.
29903                         Infotext         string
29904                         Itemstring       string
29905                         Glow             int8
29906                         MaxBreath        uint16  // Player only.
29907                         EyeHeight        float32 // Player only.
29908                         ZoomFOV          float32 // in degrees. Player only.
29909                         UseTextureAlpha  bool
29910                         DmgTextureMod    Texture // suffix
29911                         Shaded           bool
29912                         ShowOnMinimap    bool
29913                         NametagBG        color.NRGBA
29914                 }))(obj)).MakeFootstepSnds
29915                 switch n := read8(r); n {
29916                 case 0:
29917                         *p = false
29918                 case 1:
29919                         *p = true
29920                 default:
29921                         chk(fmt.Errorf("invalid bool: %d", n))
29922                 }
29923
29924         }
29925         {
29926                 p := &(*(*(struct {
29927                         MaxHP            uint16 // Player only.
29928                         CollideWithNodes bool
29929                         Weight           float32 // deprecated
29930                         ColBox, SelBox   Box
29931                         Pointable        bool
29932                         Visual           string
29933                         VisualSize       [3]float32
29934                         Textures         []Texture
29935                         SpriteSheetSize  [2]int16 // in sprites.
29936                         SpritePos        [2]int16 // in sprite sheet.
29937                         Visible          bool
29938                         MakeFootstepSnds bool
29939                         RotateSpeed      float32 // in radians per second.
29940                         Mesh             string
29941                         Colors           []color.NRGBA
29942                         CollideWithAOs   bool
29943                         StepHeight       float32
29944                         FaceRotateDir    bool
29945                         FaceRotateDirOff float32 // in degrees.
29946                         BackfaceCull     bool
29947                         Nametag          string
29948                         NametagColor     color.NRGBA
29949                         FaceRotateSpeed  float32 // in degrees per second.
29950                         Infotext         string
29951                         Itemstring       string
29952                         Glow             int8
29953                         MaxBreath        uint16  // Player only.
29954                         EyeHeight        float32 // Player only.
29955                         ZoomFOV          float32 // in degrees. Player only.
29956                         UseTextureAlpha  bool
29957                         DmgTextureMod    Texture // suffix
29958                         Shaded           bool
29959                         ShowOnMinimap    bool
29960                         NametagBG        color.NRGBA
29961                 }))(obj)).RotateSpeed
29962                 *p = math.Float32frombits(read32(r))
29963         }
29964         var local350 []uint8
29965         var local351 uint16
29966         {
29967                 p := &local351
29968                 *p = read16(r)
29969         }
29970         (local350) = make([]uint8, local351)
29971         {
29972                 _, err := io.ReadFull(r, (local350)[:])
29973                 chk(err)
29974         }
29975         ((*(*(struct {
29976                 MaxHP            uint16 // Player only.
29977                 CollideWithNodes bool
29978                 Weight           float32 // deprecated
29979                 ColBox, SelBox   Box
29980                 Pointable        bool
29981                 Visual           string
29982                 VisualSize       [3]float32
29983                 Textures         []Texture
29984                 SpriteSheetSize  [2]int16 // in sprites.
29985                 SpritePos        [2]int16 // in sprite sheet.
29986                 Visible          bool
29987                 MakeFootstepSnds bool
29988                 RotateSpeed      float32 // in radians per second.
29989                 Mesh             string
29990                 Colors           []color.NRGBA
29991                 CollideWithAOs   bool
29992                 StepHeight       float32
29993                 FaceRotateDir    bool
29994                 FaceRotateDirOff float32 // in degrees.
29995                 BackfaceCull     bool
29996                 Nametag          string
29997                 NametagColor     color.NRGBA
29998                 FaceRotateSpeed  float32 // in degrees per second.
29999                 Infotext         string
30000                 Itemstring       string
30001                 Glow             int8
30002                 MaxBreath        uint16  // Player only.
30003                 EyeHeight        float32 // Player only.
30004                 ZoomFOV          float32 // in degrees. Player only.
30005                 UseTextureAlpha  bool
30006                 DmgTextureMod    Texture // suffix
30007                 Shaded           bool
30008                 ShowOnMinimap    bool
30009                 NametagBG        color.NRGBA
30010         }))(obj)).Mesh) = string(local350)
30011         var local352 uint16
30012         {
30013                 p := &local352
30014                 *p = read16(r)
30015         }
30016         ((*(*(struct {
30017                 MaxHP            uint16 // Player only.
30018                 CollideWithNodes bool
30019                 Weight           float32 // deprecated
30020                 ColBox, SelBox   Box
30021                 Pointable        bool
30022                 Visual           string
30023                 VisualSize       [3]float32
30024                 Textures         []Texture
30025                 SpriteSheetSize  [2]int16 // in sprites.
30026                 SpritePos        [2]int16 // in sprite sheet.
30027                 Visible          bool
30028                 MakeFootstepSnds bool
30029                 RotateSpeed      float32 // in radians per second.
30030                 Mesh             string
30031                 Colors           []color.NRGBA
30032                 CollideWithAOs   bool
30033                 StepHeight       float32
30034                 FaceRotateDir    bool
30035                 FaceRotateDirOff float32 // in degrees.
30036                 BackfaceCull     bool
30037                 Nametag          string
30038                 NametagColor     color.NRGBA
30039                 FaceRotateSpeed  float32 // in degrees per second.
30040                 Infotext         string
30041                 Itemstring       string
30042                 Glow             int8
30043                 MaxBreath        uint16  // Player only.
30044                 EyeHeight        float32 // Player only.
30045                 ZoomFOV          float32 // in degrees. Player only.
30046                 UseTextureAlpha  bool
30047                 DmgTextureMod    Texture // suffix
30048                 Shaded           bool
30049                 ShowOnMinimap    bool
30050                 NametagBG        color.NRGBA
30051         }))(obj)).Colors) = make([]color.NRGBA, local352)
30052         for local353 := range (*(*(struct {
30053                 MaxHP            uint16 // Player only.
30054                 CollideWithNodes bool
30055                 Weight           float32 // deprecated
30056                 ColBox, SelBox   Box
30057                 Pointable        bool
30058                 Visual           string
30059                 VisualSize       [3]float32
30060                 Textures         []Texture
30061                 SpriteSheetSize  [2]int16 // in sprites.
30062                 SpritePos        [2]int16 // in sprite sheet.
30063                 Visible          bool
30064                 MakeFootstepSnds bool
30065                 RotateSpeed      float32 // in radians per second.
30066                 Mesh             string
30067                 Colors           []color.NRGBA
30068                 CollideWithAOs   bool
30069                 StepHeight       float32
30070                 FaceRotateDir    bool
30071                 FaceRotateDirOff float32 // in degrees.
30072                 BackfaceCull     bool
30073                 Nametag          string
30074                 NametagColor     color.NRGBA
30075                 FaceRotateSpeed  float32 // in degrees per second.
30076                 Infotext         string
30077                 Itemstring       string
30078                 Glow             int8
30079                 MaxBreath        uint16  // Player only.
30080                 EyeHeight        float32 // Player only.
30081                 ZoomFOV          float32 // in degrees. Player only.
30082                 UseTextureAlpha  bool
30083                 DmgTextureMod    Texture // suffix
30084                 Shaded           bool
30085                 ShowOnMinimap    bool
30086                 NametagBG        color.NRGBA
30087         }))(obj)).Colors {
30088                 {
30089                         p := &((*(*(struct {
30090                                 MaxHP            uint16 // Player only.
30091                                 CollideWithNodes bool
30092                                 Weight           float32 // deprecated
30093                                 ColBox, SelBox   Box
30094                                 Pointable        bool
30095                                 Visual           string
30096                                 VisualSize       [3]float32
30097                                 Textures         []Texture
30098                                 SpriteSheetSize  [2]int16 // in sprites.
30099                                 SpritePos        [2]int16 // in sprite sheet.
30100                                 Visible          bool
30101                                 MakeFootstepSnds bool
30102                                 RotateSpeed      float32 // in radians per second.
30103                                 Mesh             string
30104                                 Colors           []color.NRGBA
30105                                 CollideWithAOs   bool
30106                                 StepHeight       float32
30107                                 FaceRotateDir    bool
30108                                 FaceRotateDirOff float32 // in degrees.
30109                                 BackfaceCull     bool
30110                                 Nametag          string
30111                                 NametagColor     color.NRGBA
30112                                 FaceRotateSpeed  float32 // in degrees per second.
30113                                 Infotext         string
30114                                 Itemstring       string
30115                                 Glow             int8
30116                                 MaxBreath        uint16  // Player only.
30117                                 EyeHeight        float32 // Player only.
30118                                 ZoomFOV          float32 // in degrees. Player only.
30119                                 UseTextureAlpha  bool
30120                                 DmgTextureMod    Texture // suffix
30121                                 Shaded           bool
30122                                 ShowOnMinimap    bool
30123                                 NametagBG        color.NRGBA
30124                         }))(obj)).Colors)[local353]
30125                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30126
30127                 }
30128         }
30129         {
30130                 p := &(*(*(struct {
30131                         MaxHP            uint16 // Player only.
30132                         CollideWithNodes bool
30133                         Weight           float32 // deprecated
30134                         ColBox, SelBox   Box
30135                         Pointable        bool
30136                         Visual           string
30137                         VisualSize       [3]float32
30138                         Textures         []Texture
30139                         SpriteSheetSize  [2]int16 // in sprites.
30140                         SpritePos        [2]int16 // in sprite sheet.
30141                         Visible          bool
30142                         MakeFootstepSnds bool
30143                         RotateSpeed      float32 // in radians per second.
30144                         Mesh             string
30145                         Colors           []color.NRGBA
30146                         CollideWithAOs   bool
30147                         StepHeight       float32
30148                         FaceRotateDir    bool
30149                         FaceRotateDirOff float32 // in degrees.
30150                         BackfaceCull     bool
30151                         Nametag          string
30152                         NametagColor     color.NRGBA
30153                         FaceRotateSpeed  float32 // in degrees per second.
30154                         Infotext         string
30155                         Itemstring       string
30156                         Glow             int8
30157                         MaxBreath        uint16  // Player only.
30158                         EyeHeight        float32 // Player only.
30159                         ZoomFOV          float32 // in degrees. Player only.
30160                         UseTextureAlpha  bool
30161                         DmgTextureMod    Texture // suffix
30162                         Shaded           bool
30163                         ShowOnMinimap    bool
30164                         NametagBG        color.NRGBA
30165                 }))(obj)).CollideWithAOs
30166                 switch n := read8(r); n {
30167                 case 0:
30168                         *p = false
30169                 case 1:
30170                         *p = true
30171                 default:
30172                         chk(fmt.Errorf("invalid bool: %d", n))
30173                 }
30174
30175         }
30176         {
30177                 p := &(*(*(struct {
30178                         MaxHP            uint16 // Player only.
30179                         CollideWithNodes bool
30180                         Weight           float32 // deprecated
30181                         ColBox, SelBox   Box
30182                         Pointable        bool
30183                         Visual           string
30184                         VisualSize       [3]float32
30185                         Textures         []Texture
30186                         SpriteSheetSize  [2]int16 // in sprites.
30187                         SpritePos        [2]int16 // in sprite sheet.
30188                         Visible          bool
30189                         MakeFootstepSnds bool
30190                         RotateSpeed      float32 // in radians per second.
30191                         Mesh             string
30192                         Colors           []color.NRGBA
30193                         CollideWithAOs   bool
30194                         StepHeight       float32
30195                         FaceRotateDir    bool
30196                         FaceRotateDirOff float32 // in degrees.
30197                         BackfaceCull     bool
30198                         Nametag          string
30199                         NametagColor     color.NRGBA
30200                         FaceRotateSpeed  float32 // in degrees per second.
30201                         Infotext         string
30202                         Itemstring       string
30203                         Glow             int8
30204                         MaxBreath        uint16  // Player only.
30205                         EyeHeight        float32 // Player only.
30206                         ZoomFOV          float32 // in degrees. Player only.
30207                         UseTextureAlpha  bool
30208                         DmgTextureMod    Texture // suffix
30209                         Shaded           bool
30210                         ShowOnMinimap    bool
30211                         NametagBG        color.NRGBA
30212                 }))(obj)).StepHeight
30213                 *p = math.Float32frombits(read32(r))
30214         }
30215         {
30216                 p := &(*(*(struct {
30217                         MaxHP            uint16 // Player only.
30218                         CollideWithNodes bool
30219                         Weight           float32 // deprecated
30220                         ColBox, SelBox   Box
30221                         Pointable        bool
30222                         Visual           string
30223                         VisualSize       [3]float32
30224                         Textures         []Texture
30225                         SpriteSheetSize  [2]int16 // in sprites.
30226                         SpritePos        [2]int16 // in sprite sheet.
30227                         Visible          bool
30228                         MakeFootstepSnds bool
30229                         RotateSpeed      float32 // in radians per second.
30230                         Mesh             string
30231                         Colors           []color.NRGBA
30232                         CollideWithAOs   bool
30233                         StepHeight       float32
30234                         FaceRotateDir    bool
30235                         FaceRotateDirOff float32 // in degrees.
30236                         BackfaceCull     bool
30237                         Nametag          string
30238                         NametagColor     color.NRGBA
30239                         FaceRotateSpeed  float32 // in degrees per second.
30240                         Infotext         string
30241                         Itemstring       string
30242                         Glow             int8
30243                         MaxBreath        uint16  // Player only.
30244                         EyeHeight        float32 // Player only.
30245                         ZoomFOV          float32 // in degrees. Player only.
30246                         UseTextureAlpha  bool
30247                         DmgTextureMod    Texture // suffix
30248                         Shaded           bool
30249                         ShowOnMinimap    bool
30250                         NametagBG        color.NRGBA
30251                 }))(obj)).FaceRotateDir
30252                 switch n := read8(r); n {
30253                 case 0:
30254                         *p = false
30255                 case 1:
30256                         *p = true
30257                 default:
30258                         chk(fmt.Errorf("invalid bool: %d", n))
30259                 }
30260
30261         }
30262         {
30263                 p := &(*(*(struct {
30264                         MaxHP            uint16 // Player only.
30265                         CollideWithNodes bool
30266                         Weight           float32 // deprecated
30267                         ColBox, SelBox   Box
30268                         Pointable        bool
30269                         Visual           string
30270                         VisualSize       [3]float32
30271                         Textures         []Texture
30272                         SpriteSheetSize  [2]int16 // in sprites.
30273                         SpritePos        [2]int16 // in sprite sheet.
30274                         Visible          bool
30275                         MakeFootstepSnds bool
30276                         RotateSpeed      float32 // in radians per second.
30277                         Mesh             string
30278                         Colors           []color.NRGBA
30279                         CollideWithAOs   bool
30280                         StepHeight       float32
30281                         FaceRotateDir    bool
30282                         FaceRotateDirOff float32 // in degrees.
30283                         BackfaceCull     bool
30284                         Nametag          string
30285                         NametagColor     color.NRGBA
30286                         FaceRotateSpeed  float32 // in degrees per second.
30287                         Infotext         string
30288                         Itemstring       string
30289                         Glow             int8
30290                         MaxBreath        uint16  // Player only.
30291                         EyeHeight        float32 // Player only.
30292                         ZoomFOV          float32 // in degrees. Player only.
30293                         UseTextureAlpha  bool
30294                         DmgTextureMod    Texture // suffix
30295                         Shaded           bool
30296                         ShowOnMinimap    bool
30297                         NametagBG        color.NRGBA
30298                 }))(obj)).FaceRotateDirOff
30299                 *p = math.Float32frombits(read32(r))
30300         }
30301         {
30302                 p := &(*(*(struct {
30303                         MaxHP            uint16 // Player only.
30304                         CollideWithNodes bool
30305                         Weight           float32 // deprecated
30306                         ColBox, SelBox   Box
30307                         Pointable        bool
30308                         Visual           string
30309                         VisualSize       [3]float32
30310                         Textures         []Texture
30311                         SpriteSheetSize  [2]int16 // in sprites.
30312                         SpritePos        [2]int16 // in sprite sheet.
30313                         Visible          bool
30314                         MakeFootstepSnds bool
30315                         RotateSpeed      float32 // in radians per second.
30316                         Mesh             string
30317                         Colors           []color.NRGBA
30318                         CollideWithAOs   bool
30319                         StepHeight       float32
30320                         FaceRotateDir    bool
30321                         FaceRotateDirOff float32 // in degrees.
30322                         BackfaceCull     bool
30323                         Nametag          string
30324                         NametagColor     color.NRGBA
30325                         FaceRotateSpeed  float32 // in degrees per second.
30326                         Infotext         string
30327                         Itemstring       string
30328                         Glow             int8
30329                         MaxBreath        uint16  // Player only.
30330                         EyeHeight        float32 // Player only.
30331                         ZoomFOV          float32 // in degrees. Player only.
30332                         UseTextureAlpha  bool
30333                         DmgTextureMod    Texture // suffix
30334                         Shaded           bool
30335                         ShowOnMinimap    bool
30336                         NametagBG        color.NRGBA
30337                 }))(obj)).BackfaceCull
30338                 switch n := read8(r); n {
30339                 case 0:
30340                         *p = false
30341                 case 1:
30342                         *p = true
30343                 default:
30344                         chk(fmt.Errorf("invalid bool: %d", n))
30345                 }
30346
30347         }
30348         var local354 []uint8
30349         var local355 uint16
30350         {
30351                 p := &local355
30352                 *p = read16(r)
30353         }
30354         (local354) = make([]uint8, local355)
30355         {
30356                 _, err := io.ReadFull(r, (local354)[:])
30357                 chk(err)
30358         }
30359         ((*(*(struct {
30360                 MaxHP            uint16 // Player only.
30361                 CollideWithNodes bool
30362                 Weight           float32 // deprecated
30363                 ColBox, SelBox   Box
30364                 Pointable        bool
30365                 Visual           string
30366                 VisualSize       [3]float32
30367                 Textures         []Texture
30368                 SpriteSheetSize  [2]int16 // in sprites.
30369                 SpritePos        [2]int16 // in sprite sheet.
30370                 Visible          bool
30371                 MakeFootstepSnds bool
30372                 RotateSpeed      float32 // in radians per second.
30373                 Mesh             string
30374                 Colors           []color.NRGBA
30375                 CollideWithAOs   bool
30376                 StepHeight       float32
30377                 FaceRotateDir    bool
30378                 FaceRotateDirOff float32 // in degrees.
30379                 BackfaceCull     bool
30380                 Nametag          string
30381                 NametagColor     color.NRGBA
30382                 FaceRotateSpeed  float32 // in degrees per second.
30383                 Infotext         string
30384                 Itemstring       string
30385                 Glow             int8
30386                 MaxBreath        uint16  // Player only.
30387                 EyeHeight        float32 // Player only.
30388                 ZoomFOV          float32 // in degrees. Player only.
30389                 UseTextureAlpha  bool
30390                 DmgTextureMod    Texture // suffix
30391                 Shaded           bool
30392                 ShowOnMinimap    bool
30393                 NametagBG        color.NRGBA
30394         }))(obj)).Nametag) = string(local354)
30395         {
30396                 p := &(*(*(struct {
30397                         MaxHP            uint16 // Player only.
30398                         CollideWithNodes bool
30399                         Weight           float32 // deprecated
30400                         ColBox, SelBox   Box
30401                         Pointable        bool
30402                         Visual           string
30403                         VisualSize       [3]float32
30404                         Textures         []Texture
30405                         SpriteSheetSize  [2]int16 // in sprites.
30406                         SpritePos        [2]int16 // in sprite sheet.
30407                         Visible          bool
30408                         MakeFootstepSnds bool
30409                         RotateSpeed      float32 // in radians per second.
30410                         Mesh             string
30411                         Colors           []color.NRGBA
30412                         CollideWithAOs   bool
30413                         StepHeight       float32
30414                         FaceRotateDir    bool
30415                         FaceRotateDirOff float32 // in degrees.
30416                         BackfaceCull     bool
30417                         Nametag          string
30418                         NametagColor     color.NRGBA
30419                         FaceRotateSpeed  float32 // in degrees per second.
30420                         Infotext         string
30421                         Itemstring       string
30422                         Glow             int8
30423                         MaxBreath        uint16  // Player only.
30424                         EyeHeight        float32 // Player only.
30425                         ZoomFOV          float32 // in degrees. Player only.
30426                         UseTextureAlpha  bool
30427                         DmgTextureMod    Texture // suffix
30428                         Shaded           bool
30429                         ShowOnMinimap    bool
30430                         NametagBG        color.NRGBA
30431                 }))(obj)).NametagColor
30432                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30433
30434         }
30435         {
30436                 p := &(*(*(struct {
30437                         MaxHP            uint16 // Player only.
30438                         CollideWithNodes bool
30439                         Weight           float32 // deprecated
30440                         ColBox, SelBox   Box
30441                         Pointable        bool
30442                         Visual           string
30443                         VisualSize       [3]float32
30444                         Textures         []Texture
30445                         SpriteSheetSize  [2]int16 // in sprites.
30446                         SpritePos        [2]int16 // in sprite sheet.
30447                         Visible          bool
30448                         MakeFootstepSnds bool
30449                         RotateSpeed      float32 // in radians per second.
30450                         Mesh             string
30451                         Colors           []color.NRGBA
30452                         CollideWithAOs   bool
30453                         StepHeight       float32
30454                         FaceRotateDir    bool
30455                         FaceRotateDirOff float32 // in degrees.
30456                         BackfaceCull     bool
30457                         Nametag          string
30458                         NametagColor     color.NRGBA
30459                         FaceRotateSpeed  float32 // in degrees per second.
30460                         Infotext         string
30461                         Itemstring       string
30462                         Glow             int8
30463                         MaxBreath        uint16  // Player only.
30464                         EyeHeight        float32 // Player only.
30465                         ZoomFOV          float32 // in degrees. Player only.
30466                         UseTextureAlpha  bool
30467                         DmgTextureMod    Texture // suffix
30468                         Shaded           bool
30469                         ShowOnMinimap    bool
30470                         NametagBG        color.NRGBA
30471                 }))(obj)).FaceRotateSpeed
30472                 *p = math.Float32frombits(read32(r))
30473         }
30474         var local356 []uint8
30475         var local357 uint16
30476         {
30477                 p := &local357
30478                 *p = read16(r)
30479         }
30480         (local356) = make([]uint8, local357)
30481         {
30482                 _, err := io.ReadFull(r, (local356)[:])
30483                 chk(err)
30484         }
30485         ((*(*(struct {
30486                 MaxHP            uint16 // Player only.
30487                 CollideWithNodes bool
30488                 Weight           float32 // deprecated
30489                 ColBox, SelBox   Box
30490                 Pointable        bool
30491                 Visual           string
30492                 VisualSize       [3]float32
30493                 Textures         []Texture
30494                 SpriteSheetSize  [2]int16 // in sprites.
30495                 SpritePos        [2]int16 // in sprite sheet.
30496                 Visible          bool
30497                 MakeFootstepSnds bool
30498                 RotateSpeed      float32 // in radians per second.
30499                 Mesh             string
30500                 Colors           []color.NRGBA
30501                 CollideWithAOs   bool
30502                 StepHeight       float32
30503                 FaceRotateDir    bool
30504                 FaceRotateDirOff float32 // in degrees.
30505                 BackfaceCull     bool
30506                 Nametag          string
30507                 NametagColor     color.NRGBA
30508                 FaceRotateSpeed  float32 // in degrees per second.
30509                 Infotext         string
30510                 Itemstring       string
30511                 Glow             int8
30512                 MaxBreath        uint16  // Player only.
30513                 EyeHeight        float32 // Player only.
30514                 ZoomFOV          float32 // in degrees. Player only.
30515                 UseTextureAlpha  bool
30516                 DmgTextureMod    Texture // suffix
30517                 Shaded           bool
30518                 ShowOnMinimap    bool
30519                 NametagBG        color.NRGBA
30520         }))(obj)).Infotext) = string(local356)
30521         var local358 []uint8
30522         var local359 uint16
30523         {
30524                 p := &local359
30525                 *p = read16(r)
30526         }
30527         (local358) = make([]uint8, local359)
30528         {
30529                 _, err := io.ReadFull(r, (local358)[:])
30530                 chk(err)
30531         }
30532         ((*(*(struct {
30533                 MaxHP            uint16 // Player only.
30534                 CollideWithNodes bool
30535                 Weight           float32 // deprecated
30536                 ColBox, SelBox   Box
30537                 Pointable        bool
30538                 Visual           string
30539                 VisualSize       [3]float32
30540                 Textures         []Texture
30541                 SpriteSheetSize  [2]int16 // in sprites.
30542                 SpritePos        [2]int16 // in sprite sheet.
30543                 Visible          bool
30544                 MakeFootstepSnds bool
30545                 RotateSpeed      float32 // in radians per second.
30546                 Mesh             string
30547                 Colors           []color.NRGBA
30548                 CollideWithAOs   bool
30549                 StepHeight       float32
30550                 FaceRotateDir    bool
30551                 FaceRotateDirOff float32 // in degrees.
30552                 BackfaceCull     bool
30553                 Nametag          string
30554                 NametagColor     color.NRGBA
30555                 FaceRotateSpeed  float32 // in degrees per second.
30556                 Infotext         string
30557                 Itemstring       string
30558                 Glow             int8
30559                 MaxBreath        uint16  // Player only.
30560                 EyeHeight        float32 // Player only.
30561                 ZoomFOV          float32 // in degrees. Player only.
30562                 UseTextureAlpha  bool
30563                 DmgTextureMod    Texture // suffix
30564                 Shaded           bool
30565                 ShowOnMinimap    bool
30566                 NametagBG        color.NRGBA
30567         }))(obj)).Itemstring) = string(local358)
30568         {
30569                 p := &(*(*(struct {
30570                         MaxHP            uint16 // Player only.
30571                         CollideWithNodes bool
30572                         Weight           float32 // deprecated
30573                         ColBox, SelBox   Box
30574                         Pointable        bool
30575                         Visual           string
30576                         VisualSize       [3]float32
30577                         Textures         []Texture
30578                         SpriteSheetSize  [2]int16 // in sprites.
30579                         SpritePos        [2]int16 // in sprite sheet.
30580                         Visible          bool
30581                         MakeFootstepSnds bool
30582                         RotateSpeed      float32 // in radians per second.
30583                         Mesh             string
30584                         Colors           []color.NRGBA
30585                         CollideWithAOs   bool
30586                         StepHeight       float32
30587                         FaceRotateDir    bool
30588                         FaceRotateDirOff float32 // in degrees.
30589                         BackfaceCull     bool
30590                         Nametag          string
30591                         NametagColor     color.NRGBA
30592                         FaceRotateSpeed  float32 // in degrees per second.
30593                         Infotext         string
30594                         Itemstring       string
30595                         Glow             int8
30596                         MaxBreath        uint16  // Player only.
30597                         EyeHeight        float32 // Player only.
30598                         ZoomFOV          float32 // in degrees. Player only.
30599                         UseTextureAlpha  bool
30600                         DmgTextureMod    Texture // suffix
30601                         Shaded           bool
30602                         ShowOnMinimap    bool
30603                         NametagBG        color.NRGBA
30604                 }))(obj)).Glow
30605                 *p = int8(read8(r))
30606         }
30607         {
30608                 p := &(*(*(struct {
30609                         MaxHP            uint16 // Player only.
30610                         CollideWithNodes bool
30611                         Weight           float32 // deprecated
30612                         ColBox, SelBox   Box
30613                         Pointable        bool
30614                         Visual           string
30615                         VisualSize       [3]float32
30616                         Textures         []Texture
30617                         SpriteSheetSize  [2]int16 // in sprites.
30618                         SpritePos        [2]int16 // in sprite sheet.
30619                         Visible          bool
30620                         MakeFootstepSnds bool
30621                         RotateSpeed      float32 // in radians per second.
30622                         Mesh             string
30623                         Colors           []color.NRGBA
30624                         CollideWithAOs   bool
30625                         StepHeight       float32
30626                         FaceRotateDir    bool
30627                         FaceRotateDirOff float32 // in degrees.
30628                         BackfaceCull     bool
30629                         Nametag          string
30630                         NametagColor     color.NRGBA
30631                         FaceRotateSpeed  float32 // in degrees per second.
30632                         Infotext         string
30633                         Itemstring       string
30634                         Glow             int8
30635                         MaxBreath        uint16  // Player only.
30636                         EyeHeight        float32 // Player only.
30637                         ZoomFOV          float32 // in degrees. Player only.
30638                         UseTextureAlpha  bool
30639                         DmgTextureMod    Texture // suffix
30640                         Shaded           bool
30641                         ShowOnMinimap    bool
30642                         NametagBG        color.NRGBA
30643                 }))(obj)).MaxBreath
30644                 *p = read16(r)
30645         }
30646         {
30647                 p := &(*(*(struct {
30648                         MaxHP            uint16 // Player only.
30649                         CollideWithNodes bool
30650                         Weight           float32 // deprecated
30651                         ColBox, SelBox   Box
30652                         Pointable        bool
30653                         Visual           string
30654                         VisualSize       [3]float32
30655                         Textures         []Texture
30656                         SpriteSheetSize  [2]int16 // in sprites.
30657                         SpritePos        [2]int16 // in sprite sheet.
30658                         Visible          bool
30659                         MakeFootstepSnds bool
30660                         RotateSpeed      float32 // in radians per second.
30661                         Mesh             string
30662                         Colors           []color.NRGBA
30663                         CollideWithAOs   bool
30664                         StepHeight       float32
30665                         FaceRotateDir    bool
30666                         FaceRotateDirOff float32 // in degrees.
30667                         BackfaceCull     bool
30668                         Nametag          string
30669                         NametagColor     color.NRGBA
30670                         FaceRotateSpeed  float32 // in degrees per second.
30671                         Infotext         string
30672                         Itemstring       string
30673                         Glow             int8
30674                         MaxBreath        uint16  // Player only.
30675                         EyeHeight        float32 // Player only.
30676                         ZoomFOV          float32 // in degrees. Player only.
30677                         UseTextureAlpha  bool
30678                         DmgTextureMod    Texture // suffix
30679                         Shaded           bool
30680                         ShowOnMinimap    bool
30681                         NametagBG        color.NRGBA
30682                 }))(obj)).EyeHeight
30683                 *p = math.Float32frombits(read32(r))
30684         }
30685         {
30686                 p := &(*(*(struct {
30687                         MaxHP            uint16 // Player only.
30688                         CollideWithNodes bool
30689                         Weight           float32 // deprecated
30690                         ColBox, SelBox   Box
30691                         Pointable        bool
30692                         Visual           string
30693                         VisualSize       [3]float32
30694                         Textures         []Texture
30695                         SpriteSheetSize  [2]int16 // in sprites.
30696                         SpritePos        [2]int16 // in sprite sheet.
30697                         Visible          bool
30698                         MakeFootstepSnds bool
30699                         RotateSpeed      float32 // in radians per second.
30700                         Mesh             string
30701                         Colors           []color.NRGBA
30702                         CollideWithAOs   bool
30703                         StepHeight       float32
30704                         FaceRotateDir    bool
30705                         FaceRotateDirOff float32 // in degrees.
30706                         BackfaceCull     bool
30707                         Nametag          string
30708                         NametagColor     color.NRGBA
30709                         FaceRotateSpeed  float32 // in degrees per second.
30710                         Infotext         string
30711                         Itemstring       string
30712                         Glow             int8
30713                         MaxBreath        uint16  // Player only.
30714                         EyeHeight        float32 // Player only.
30715                         ZoomFOV          float32 // in degrees. Player only.
30716                         UseTextureAlpha  bool
30717                         DmgTextureMod    Texture // suffix
30718                         Shaded           bool
30719                         ShowOnMinimap    bool
30720                         NametagBG        color.NRGBA
30721                 }))(obj)).ZoomFOV
30722                 *p = math.Float32frombits(read32(r))
30723         }
30724         {
30725                 p := &(*(*(struct {
30726                         MaxHP            uint16 // Player only.
30727                         CollideWithNodes bool
30728                         Weight           float32 // deprecated
30729                         ColBox, SelBox   Box
30730                         Pointable        bool
30731                         Visual           string
30732                         VisualSize       [3]float32
30733                         Textures         []Texture
30734                         SpriteSheetSize  [2]int16 // in sprites.
30735                         SpritePos        [2]int16 // in sprite sheet.
30736                         Visible          bool
30737                         MakeFootstepSnds bool
30738                         RotateSpeed      float32 // in radians per second.
30739                         Mesh             string
30740                         Colors           []color.NRGBA
30741                         CollideWithAOs   bool
30742                         StepHeight       float32
30743                         FaceRotateDir    bool
30744                         FaceRotateDirOff float32 // in degrees.
30745                         BackfaceCull     bool
30746                         Nametag          string
30747                         NametagColor     color.NRGBA
30748                         FaceRotateSpeed  float32 // in degrees per second.
30749                         Infotext         string
30750                         Itemstring       string
30751                         Glow             int8
30752                         MaxBreath        uint16  // Player only.
30753                         EyeHeight        float32 // Player only.
30754                         ZoomFOV          float32 // in degrees. Player only.
30755                         UseTextureAlpha  bool
30756                         DmgTextureMod    Texture // suffix
30757                         Shaded           bool
30758                         ShowOnMinimap    bool
30759                         NametagBG        color.NRGBA
30760                 }))(obj)).UseTextureAlpha
30761                 switch n := read8(r); n {
30762                 case 0:
30763                         *p = false
30764                 case 1:
30765                         *p = true
30766                 default:
30767                         chk(fmt.Errorf("invalid bool: %d", n))
30768                 }
30769
30770         }
30771         if err := pcall(func() {
30772                 ((*(*(struct {
30773                         MaxHP            uint16 // Player only.
30774                         CollideWithNodes bool
30775                         Weight           float32 // deprecated
30776                         ColBox, SelBox   Box
30777                         Pointable        bool
30778                         Visual           string
30779                         VisualSize       [3]float32
30780                         Textures         []Texture
30781                         SpriteSheetSize  [2]int16 // in sprites.
30782                         SpritePos        [2]int16 // in sprite sheet.
30783                         Visible          bool
30784                         MakeFootstepSnds bool
30785                         RotateSpeed      float32 // in radians per second.
30786                         Mesh             string
30787                         Colors           []color.NRGBA
30788                         CollideWithAOs   bool
30789                         StepHeight       float32
30790                         FaceRotateDir    bool
30791                         FaceRotateDirOff float32 // in degrees.
30792                         BackfaceCull     bool
30793                         Nametag          string
30794                         NametagColor     color.NRGBA
30795                         FaceRotateSpeed  float32 // in degrees per second.
30796                         Infotext         string
30797                         Itemstring       string
30798                         Glow             int8
30799                         MaxBreath        uint16  // Player only.
30800                         EyeHeight        float32 // Player only.
30801                         ZoomFOV          float32 // in degrees. Player only.
30802                         UseTextureAlpha  bool
30803                         DmgTextureMod    Texture // suffix
30804                         Shaded           bool
30805                         ShowOnMinimap    bool
30806                         NametagBG        color.NRGBA
30807                 }))(obj)).DmgTextureMod).deserialize(r)
30808         }); err != nil {
30809                 if err == io.EOF {
30810                         chk(io.EOF)
30811                 }
30812                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
30813         }
30814         {
30815                 p := &(*(*(struct {
30816                         MaxHP            uint16 // Player only.
30817                         CollideWithNodes bool
30818                         Weight           float32 // deprecated
30819                         ColBox, SelBox   Box
30820                         Pointable        bool
30821                         Visual           string
30822                         VisualSize       [3]float32
30823                         Textures         []Texture
30824                         SpriteSheetSize  [2]int16 // in sprites.
30825                         SpritePos        [2]int16 // in sprite sheet.
30826                         Visible          bool
30827                         MakeFootstepSnds bool
30828                         RotateSpeed      float32 // in radians per second.
30829                         Mesh             string
30830                         Colors           []color.NRGBA
30831                         CollideWithAOs   bool
30832                         StepHeight       float32
30833                         FaceRotateDir    bool
30834                         FaceRotateDirOff float32 // in degrees.
30835                         BackfaceCull     bool
30836                         Nametag          string
30837                         NametagColor     color.NRGBA
30838                         FaceRotateSpeed  float32 // in degrees per second.
30839                         Infotext         string
30840                         Itemstring       string
30841                         Glow             int8
30842                         MaxBreath        uint16  // Player only.
30843                         EyeHeight        float32 // Player only.
30844                         ZoomFOV          float32 // in degrees. Player only.
30845                         UseTextureAlpha  bool
30846                         DmgTextureMod    Texture // suffix
30847                         Shaded           bool
30848                         ShowOnMinimap    bool
30849                         NametagBG        color.NRGBA
30850                 }))(obj)).Shaded
30851                 switch n := read8(r); n {
30852                 case 0:
30853                         *p = false
30854                 case 1:
30855                         *p = true
30856                 default:
30857                         chk(fmt.Errorf("invalid bool: %d", n))
30858                 }
30859
30860         }
30861         {
30862                 p := &(*(*(struct {
30863                         MaxHP            uint16 // Player only.
30864                         CollideWithNodes bool
30865                         Weight           float32 // deprecated
30866                         ColBox, SelBox   Box
30867                         Pointable        bool
30868                         Visual           string
30869                         VisualSize       [3]float32
30870                         Textures         []Texture
30871                         SpriteSheetSize  [2]int16 // in sprites.
30872                         SpritePos        [2]int16 // in sprite sheet.
30873                         Visible          bool
30874                         MakeFootstepSnds bool
30875                         RotateSpeed      float32 // in radians per second.
30876                         Mesh             string
30877                         Colors           []color.NRGBA
30878                         CollideWithAOs   bool
30879                         StepHeight       float32
30880                         FaceRotateDir    bool
30881                         FaceRotateDirOff float32 // in degrees.
30882                         BackfaceCull     bool
30883                         Nametag          string
30884                         NametagColor     color.NRGBA
30885                         FaceRotateSpeed  float32 // in degrees per second.
30886                         Infotext         string
30887                         Itemstring       string
30888                         Glow             int8
30889                         MaxBreath        uint16  // Player only.
30890                         EyeHeight        float32 // Player only.
30891                         ZoomFOV          float32 // in degrees. Player only.
30892                         UseTextureAlpha  bool
30893                         DmgTextureMod    Texture // suffix
30894                         Shaded           bool
30895                         ShowOnMinimap    bool
30896                         NametagBG        color.NRGBA
30897                 }))(obj)).ShowOnMinimap
30898                 switch n := read8(r); n {
30899                 case 0:
30900                         *p = false
30901                 case 1:
30902                         *p = true
30903                 default:
30904                         chk(fmt.Errorf("invalid bool: %d", n))
30905                 }
30906
30907         }
30908         {
30909                 p := &(*(*(struct {
30910                         MaxHP            uint16 // Player only.
30911                         CollideWithNodes bool
30912                         Weight           float32 // deprecated
30913                         ColBox, SelBox   Box
30914                         Pointable        bool
30915                         Visual           string
30916                         VisualSize       [3]float32
30917                         Textures         []Texture
30918                         SpriteSheetSize  [2]int16 // in sprites.
30919                         SpritePos        [2]int16 // in sprite sheet.
30920                         Visible          bool
30921                         MakeFootstepSnds bool
30922                         RotateSpeed      float32 // in radians per second.
30923                         Mesh             string
30924                         Colors           []color.NRGBA
30925                         CollideWithAOs   bool
30926                         StepHeight       float32
30927                         FaceRotateDir    bool
30928                         FaceRotateDirOff float32 // in degrees.
30929                         BackfaceCull     bool
30930                         Nametag          string
30931                         NametagColor     color.NRGBA
30932                         FaceRotateSpeed  float32 // in degrees per second.
30933                         Infotext         string
30934                         Itemstring       string
30935                         Glow             int8
30936                         MaxBreath        uint16  // Player only.
30937                         EyeHeight        float32 // Player only.
30938                         ZoomFOV          float32 // in degrees. Player only.
30939                         UseTextureAlpha  bool
30940                         DmgTextureMod    Texture // suffix
30941                         Shaded           bool
30942                         ShowOnMinimap    bool
30943                         NametagBG        color.NRGBA
30944                 }))(obj)).NametagBG
30945                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30946
30947         }
30948 }
30949
30950 func (obj *AOPos) serialize(w io.Writer) {
30951         if err := pcall(func() {
30952                 ((*(*(struct {
30953                         Pos
30954                         Vel, Acc Vec
30955                         Rot      [3]float32
30956
30957                         Interpolate    bool
30958                         End            bool
30959                         UpdateInterval float32
30960                 }))(obj)).Pos).serialize(w)
30961         }); err != nil {
30962                 if err == io.EOF {
30963                         chk(io.EOF)
30964                 }
30965                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
30966         }
30967         if err := pcall(func() {
30968                 ((*(*(struct {
30969                         Pos
30970                         Vel, Acc Vec
30971                         Rot      [3]float32
30972
30973                         Interpolate    bool
30974                         End            bool
30975                         UpdateInterval float32
30976                 }))(obj)).Vel).serialize(w)
30977         }); err != nil {
30978                 if err == io.EOF {
30979                         chk(io.EOF)
30980                 }
30981                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30982         }
30983         if err := pcall(func() {
30984                 ((*(*(struct {
30985                         Pos
30986                         Vel, Acc Vec
30987                         Rot      [3]float32
30988
30989                         Interpolate    bool
30990                         End            bool
30991                         UpdateInterval float32
30992                 }))(obj)).Acc).serialize(w)
30993         }); err != nil {
30994                 if err == io.EOF {
30995                         chk(io.EOF)
30996                 }
30997                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
30998         }
30999         for local360 := range (*(*(struct {
31000                 Pos
31001                 Vel, Acc Vec
31002                 Rot      [3]float32
31003
31004                 Interpolate    bool
31005                 End            bool
31006                 UpdateInterval float32
31007         }))(obj)).Rot {
31008                 {
31009                         x := ((*(*(struct {
31010                                 Pos
31011                                 Vel, Acc Vec
31012                                 Rot      [3]float32
31013
31014                                 Interpolate    bool
31015                                 End            bool
31016                                 UpdateInterval float32
31017                         }))(obj)).Rot)[local360]
31018                         write32(w, math.Float32bits(x))
31019                 }
31020         }
31021         {
31022                 x := (*(*(struct {
31023                         Pos
31024                         Vel, Acc Vec
31025                         Rot      [3]float32
31026
31027                         Interpolate    bool
31028                         End            bool
31029                         UpdateInterval float32
31030                 }))(obj)).Interpolate
31031                 if x {
31032                         write8(w, 1)
31033                 } else {
31034                         write8(w, 0)
31035                 }
31036
31037         }
31038         {
31039                 x := (*(*(struct {
31040                         Pos
31041                         Vel, Acc Vec
31042                         Rot      [3]float32
31043
31044                         Interpolate    bool
31045                         End            bool
31046                         UpdateInterval float32
31047                 }))(obj)).End
31048                 if x {
31049                         write8(w, 1)
31050                 } else {
31051                         write8(w, 0)
31052                 }
31053
31054         }
31055         {
31056                 x := (*(*(struct {
31057                         Pos
31058                         Vel, Acc Vec
31059                         Rot      [3]float32
31060
31061                         Interpolate    bool
31062                         End            bool
31063                         UpdateInterval float32
31064                 }))(obj)).UpdateInterval
31065                 write32(w, math.Float32bits(x))
31066         }
31067 }
31068
31069 func (obj *AOPos) deserialize(r io.Reader) {
31070         if err := pcall(func() {
31071                 ((*(*(struct {
31072                         Pos
31073                         Vel, Acc Vec
31074                         Rot      [3]float32
31075
31076                         Interpolate    bool
31077                         End            bool
31078                         UpdateInterval float32
31079                 }))(obj)).Pos).deserialize(r)
31080         }); err != nil {
31081                 if err == io.EOF {
31082                         chk(io.EOF)
31083                 }
31084                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
31085         }
31086         if err := pcall(func() {
31087                 ((*(*(struct {
31088                         Pos
31089                         Vel, Acc Vec
31090                         Rot      [3]float32
31091
31092                         Interpolate    bool
31093                         End            bool
31094                         UpdateInterval float32
31095                 }))(obj)).Vel).deserialize(r)
31096         }); err != nil {
31097                 if err == io.EOF {
31098                         chk(io.EOF)
31099                 }
31100                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31101         }
31102         if err := pcall(func() {
31103                 ((*(*(struct {
31104                         Pos
31105                         Vel, Acc Vec
31106                         Rot      [3]float32
31107
31108                         Interpolate    bool
31109                         End            bool
31110                         UpdateInterval float32
31111                 }))(obj)).Acc).deserialize(r)
31112         }); err != nil {
31113                 if err == io.EOF {
31114                         chk(io.EOF)
31115                 }
31116                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31117         }
31118         for local361 := range (*(*(struct {
31119                 Pos
31120                 Vel, Acc Vec
31121                 Rot      [3]float32
31122
31123                 Interpolate    bool
31124                 End            bool
31125                 UpdateInterval float32
31126         }))(obj)).Rot {
31127                 {
31128                         p := &((*(*(struct {
31129                                 Pos
31130                                 Vel, Acc Vec
31131                                 Rot      [3]float32
31132
31133                                 Interpolate    bool
31134                                 End            bool
31135                                 UpdateInterval float32
31136                         }))(obj)).Rot)[local361]
31137                         *p = math.Float32frombits(read32(r))
31138                 }
31139         }
31140         {
31141                 p := &(*(*(struct {
31142                         Pos
31143                         Vel, Acc Vec
31144                         Rot      [3]float32
31145
31146                         Interpolate    bool
31147                         End            bool
31148                         UpdateInterval float32
31149                 }))(obj)).Interpolate
31150                 switch n := read8(r); n {
31151                 case 0:
31152                         *p = false
31153                 case 1:
31154                         *p = true
31155                 default:
31156                         chk(fmt.Errorf("invalid bool: %d", n))
31157                 }
31158
31159         }
31160         {
31161                 p := &(*(*(struct {
31162                         Pos
31163                         Vel, Acc Vec
31164                         Rot      [3]float32
31165
31166                         Interpolate    bool
31167                         End            bool
31168                         UpdateInterval float32
31169                 }))(obj)).End
31170                 switch n := read8(r); n {
31171                 case 0:
31172                         *p = false
31173                 case 1:
31174                         *p = true
31175                 default:
31176                         chk(fmt.Errorf("invalid bool: %d", n))
31177                 }
31178
31179         }
31180         {
31181                 p := &(*(*(struct {
31182                         Pos
31183                         Vel, Acc Vec
31184                         Rot      [3]float32
31185
31186                         Interpolate    bool
31187                         End            bool
31188                         UpdateInterval float32
31189                 }))(obj)).UpdateInterval
31190                 *p = math.Float32frombits(read32(r))
31191         }
31192 }
31193
31194 func (obj *AOSprite) serialize(w io.Writer) {
31195         for local362 := range (*(*(struct {
31196                 Frame0          [2]int16
31197                 Frames          uint16
31198                 FrameDuration   float32
31199                 ViewAngleFrames bool
31200         }))(obj)).Frame0 {
31201                 {
31202                         x := ((*(*(struct {
31203                                 Frame0          [2]int16
31204                                 Frames          uint16
31205                                 FrameDuration   float32
31206                                 ViewAngleFrames bool
31207                         }))(obj)).Frame0)[local362]
31208                         write16(w, uint16(x))
31209                 }
31210         }
31211         {
31212                 x := (*(*(struct {
31213                         Frame0          [2]int16
31214                         Frames          uint16
31215                         FrameDuration   float32
31216                         ViewAngleFrames bool
31217                 }))(obj)).Frames
31218                 write16(w, uint16(x))
31219         }
31220         {
31221                 x := (*(*(struct {
31222                         Frame0          [2]int16
31223                         Frames          uint16
31224                         FrameDuration   float32
31225                         ViewAngleFrames bool
31226                 }))(obj)).FrameDuration
31227                 write32(w, math.Float32bits(x))
31228         }
31229         {
31230                 x := (*(*(struct {
31231                         Frame0          [2]int16
31232                         Frames          uint16
31233                         FrameDuration   float32
31234                         ViewAngleFrames bool
31235                 }))(obj)).ViewAngleFrames
31236                 if x {
31237                         write8(w, 1)
31238                 } else {
31239                         write8(w, 0)
31240                 }
31241
31242         }
31243 }
31244
31245 func (obj *AOSprite) deserialize(r io.Reader) {
31246         for local363 := range (*(*(struct {
31247                 Frame0          [2]int16
31248                 Frames          uint16
31249                 FrameDuration   float32
31250                 ViewAngleFrames bool
31251         }))(obj)).Frame0 {
31252                 {
31253                         p := &((*(*(struct {
31254                                 Frame0          [2]int16
31255                                 Frames          uint16
31256                                 FrameDuration   float32
31257                                 ViewAngleFrames bool
31258                         }))(obj)).Frame0)[local363]
31259                         *p = int16(read16(r))
31260                 }
31261         }
31262         {
31263                 p := &(*(*(struct {
31264                         Frame0          [2]int16
31265                         Frames          uint16
31266                         FrameDuration   float32
31267                         ViewAngleFrames bool
31268                 }))(obj)).Frames
31269                 *p = read16(r)
31270         }
31271         {
31272                 p := &(*(*(struct {
31273                         Frame0          [2]int16
31274                         Frames          uint16
31275                         FrameDuration   float32
31276                         ViewAngleFrames bool
31277                 }))(obj)).FrameDuration
31278                 *p = math.Float32frombits(read32(r))
31279         }
31280         {
31281                 p := &(*(*(struct {
31282                         Frame0          [2]int16
31283                         Frames          uint16
31284                         FrameDuration   float32
31285                         ViewAngleFrames bool
31286                 }))(obj)).ViewAngleFrames
31287                 switch n := read8(r); n {
31288                 case 0:
31289                         *p = false
31290                 case 1:
31291                         *p = true
31292                 default:
31293                         chk(fmt.Errorf("invalid bool: %d", n))
31294                 }
31295
31296         }
31297 }
31298
31299 func (obj *Group) serialize(w io.Writer) {
31300         if len(([]byte((*(*(struct {
31301                 Name   string
31302                 Rating int16
31303         }))(obj)).Name))) > math.MaxUint16 {
31304                 chk(ErrTooLong)
31305         }
31306         {
31307                 x := uint16(len(([]byte((*(*(struct {
31308                         Name   string
31309                         Rating int16
31310                 }))(obj)).Name))))
31311                 write16(w, uint16(x))
31312         }
31313         {
31314                 _, err := w.Write(([]byte((*(*(struct {
31315                         Name   string
31316                         Rating int16
31317                 }))(obj)).Name))[:])
31318                 chk(err)
31319         }
31320         {
31321                 x := (*(*(struct {
31322                         Name   string
31323                         Rating int16
31324                 }))(obj)).Rating
31325                 write16(w, uint16(x))
31326         }
31327 }
31328
31329 func (obj *Group) deserialize(r io.Reader) {
31330         var local364 []uint8
31331         var local365 uint16
31332         {
31333                 p := &local365
31334                 *p = read16(r)
31335         }
31336         (local364) = make([]uint8, local365)
31337         {
31338                 _, err := io.ReadFull(r, (local364)[:])
31339                 chk(err)
31340         }
31341         ((*(*(struct {
31342                 Name   string
31343                 Rating int16
31344         }))(obj)).Name) = string(local364)
31345         {
31346                 p := &(*(*(struct {
31347                         Name   string
31348                         Rating int16
31349                 }))(obj)).Rating
31350                 *p = int16(read16(r))
31351         }
31352 }
31353
31354 func (obj *AOAnim) serialize(w io.Writer) {
31355         for local366 := range (*(*(struct {
31356                 Frames [2]int32
31357                 Speed  float32
31358                 Blend  float32
31359                 NoLoop bool
31360         }))(obj)).Frames {
31361                 {
31362                         x := ((*(*(struct {
31363                                 Frames [2]int32
31364                                 Speed  float32
31365                                 Blend  float32
31366                                 NoLoop bool
31367                         }))(obj)).Frames)[local366]
31368                         write32(w, uint32(x))
31369                 }
31370         }
31371         {
31372                 x := (*(*(struct {
31373                         Frames [2]int32
31374                         Speed  float32
31375                         Blend  float32
31376                         NoLoop bool
31377                 }))(obj)).Speed
31378                 write32(w, math.Float32bits(x))
31379         }
31380         {
31381                 x := (*(*(struct {
31382                         Frames [2]int32
31383                         Speed  float32
31384                         Blend  float32
31385                         NoLoop bool
31386                 }))(obj)).Blend
31387                 write32(w, math.Float32bits(x))
31388         }
31389         {
31390                 x := (*(*(struct {
31391                         Frames [2]int32
31392                         Speed  float32
31393                         Blend  float32
31394                         NoLoop bool
31395                 }))(obj)).NoLoop
31396                 if x {
31397                         write8(w, 1)
31398                 } else {
31399                         write8(w, 0)
31400                 }
31401
31402         }
31403 }
31404
31405 func (obj *AOAnim) deserialize(r io.Reader) {
31406         for local367 := range (*(*(struct {
31407                 Frames [2]int32
31408                 Speed  float32
31409                 Blend  float32
31410                 NoLoop bool
31411         }))(obj)).Frames {
31412                 {
31413                         p := &((*(*(struct {
31414                                 Frames [2]int32
31415                                 Speed  float32
31416                                 Blend  float32
31417                                 NoLoop bool
31418                         }))(obj)).Frames)[local367]
31419                         *p = int32(read32(r))
31420                 }
31421         }
31422         {
31423                 p := &(*(*(struct {
31424                         Frames [2]int32
31425                         Speed  float32
31426                         Blend  float32
31427                         NoLoop bool
31428                 }))(obj)).Speed
31429                 *p = math.Float32frombits(read32(r))
31430         }
31431         {
31432                 p := &(*(*(struct {
31433                         Frames [2]int32
31434                         Speed  float32
31435                         Blend  float32
31436                         NoLoop bool
31437                 }))(obj)).Blend
31438                 *p = math.Float32frombits(read32(r))
31439         }
31440         {
31441                 p := &(*(*(struct {
31442                         Frames [2]int32
31443                         Speed  float32
31444                         Blend  float32
31445                         NoLoop bool
31446                 }))(obj)).NoLoop
31447                 switch n := read8(r); n {
31448                 case 0:
31449                         *p = false
31450                 case 1:
31451                         *p = true
31452                 default:
31453                         chk(fmt.Errorf("invalid bool: %d", n))
31454                 }
31455
31456         }
31457 }
31458
31459 func (obj *AOBonePos) serialize(w io.Writer) {
31460         if err := pcall(func() {
31461                 ((*(*(struct {
31462                         Pos Vec
31463                         Rot [3]float32
31464                 }))(obj)).Pos).serialize(w)
31465         }); err != nil {
31466                 if err == io.EOF {
31467                         chk(io.EOF)
31468                 }
31469                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31470         }
31471         for local368 := range (*(*(struct {
31472                 Pos Vec
31473                 Rot [3]float32
31474         }))(obj)).Rot {
31475                 {
31476                         x := ((*(*(struct {
31477                                 Pos Vec
31478                                 Rot [3]float32
31479                         }))(obj)).Rot)[local368]
31480                         write32(w, math.Float32bits(x))
31481                 }
31482         }
31483 }
31484
31485 func (obj *AOBonePos) deserialize(r io.Reader) {
31486         if err := pcall(func() {
31487                 ((*(*(struct {
31488                         Pos Vec
31489                         Rot [3]float32
31490                 }))(obj)).Pos).deserialize(r)
31491         }); err != nil {
31492                 if err == io.EOF {
31493                         chk(io.EOF)
31494                 }
31495                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31496         }
31497         for local369 := range (*(*(struct {
31498                 Pos Vec
31499                 Rot [3]float32
31500         }))(obj)).Rot {
31501                 {
31502                         p := &((*(*(struct {
31503                                 Pos Vec
31504                                 Rot [3]float32
31505                         }))(obj)).Rot)[local369]
31506                         *p = math.Float32frombits(read32(r))
31507                 }
31508         }
31509 }
31510
31511 func (obj *AOAttach) serialize(w io.Writer) {
31512         if err := pcall(func() {
31513                 ((*(*(struct {
31514                         ParentID     AOID
31515                         Bone         string
31516                         Pos          Vec
31517                         Rot          [3]float32
31518                         ForceVisible bool
31519                 }))(obj)).ParentID).serialize(w)
31520         }); err != nil {
31521                 if err == io.EOF {
31522                         chk(io.EOF)
31523                 }
31524                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
31525         }
31526         if len(([]byte((*(*(struct {
31527                 ParentID     AOID
31528                 Bone         string
31529                 Pos          Vec
31530                 Rot          [3]float32
31531                 ForceVisible bool
31532         }))(obj)).Bone))) > math.MaxUint16 {
31533                 chk(ErrTooLong)
31534         }
31535         {
31536                 x := uint16(len(([]byte((*(*(struct {
31537                         ParentID     AOID
31538                         Bone         string
31539                         Pos          Vec
31540                         Rot          [3]float32
31541                         ForceVisible bool
31542                 }))(obj)).Bone))))
31543                 write16(w, uint16(x))
31544         }
31545         {
31546                 _, err := w.Write(([]byte((*(*(struct {
31547                         ParentID     AOID
31548                         Bone         string
31549                         Pos          Vec
31550                         Rot          [3]float32
31551                         ForceVisible bool
31552                 }))(obj)).Bone))[:])
31553                 chk(err)
31554         }
31555         if err := pcall(func() {
31556                 ((*(*(struct {
31557                         ParentID     AOID
31558                         Bone         string
31559                         Pos          Vec
31560                         Rot          [3]float32
31561                         ForceVisible bool
31562                 }))(obj)).Pos).serialize(w)
31563         }); err != nil {
31564                 if err == io.EOF {
31565                         chk(io.EOF)
31566                 }
31567                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31568         }
31569         for local370 := range (*(*(struct {
31570                 ParentID     AOID
31571                 Bone         string
31572                 Pos          Vec
31573                 Rot          [3]float32
31574                 ForceVisible bool
31575         }))(obj)).Rot {
31576                 {
31577                         x := ((*(*(struct {
31578                                 ParentID     AOID
31579                                 Bone         string
31580                                 Pos          Vec
31581                                 Rot          [3]float32
31582                                 ForceVisible bool
31583                         }))(obj)).Rot)[local370]
31584                         write32(w, math.Float32bits(x))
31585                 }
31586         }
31587         {
31588                 x := (*(*(struct {
31589                         ParentID     AOID
31590                         Bone         string
31591                         Pos          Vec
31592                         Rot          [3]float32
31593                         ForceVisible bool
31594                 }))(obj)).ForceVisible
31595                 if x {
31596                         write8(w, 1)
31597                 } else {
31598                         write8(w, 0)
31599                 }
31600
31601         }
31602 }
31603
31604 func (obj *AOAttach) deserialize(r io.Reader) {
31605         if err := pcall(func() {
31606                 ((*(*(struct {
31607                         ParentID     AOID
31608                         Bone         string
31609                         Pos          Vec
31610                         Rot          [3]float32
31611                         ForceVisible bool
31612                 }))(obj)).ParentID).deserialize(r)
31613         }); err != nil {
31614                 if err == io.EOF {
31615                         chk(io.EOF)
31616                 }
31617                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
31618         }
31619         var local371 []uint8
31620         var local372 uint16
31621         {
31622                 p := &local372
31623                 *p = read16(r)
31624         }
31625         (local371) = make([]uint8, local372)
31626         {
31627                 _, err := io.ReadFull(r, (local371)[:])
31628                 chk(err)
31629         }
31630         ((*(*(struct {
31631                 ParentID     AOID
31632                 Bone         string
31633                 Pos          Vec
31634                 Rot          [3]float32
31635                 ForceVisible bool
31636         }))(obj)).Bone) = string(local371)
31637         if err := pcall(func() {
31638                 ((*(*(struct {
31639                         ParentID     AOID
31640                         Bone         string
31641                         Pos          Vec
31642                         Rot          [3]float32
31643                         ForceVisible bool
31644                 }))(obj)).Pos).deserialize(r)
31645         }); err != nil {
31646                 if err == io.EOF {
31647                         chk(io.EOF)
31648                 }
31649                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
31650         }
31651         for local373 := range (*(*(struct {
31652                 ParentID     AOID
31653                 Bone         string
31654                 Pos          Vec
31655                 Rot          [3]float32
31656                 ForceVisible bool
31657         }))(obj)).Rot {
31658                 {
31659                         p := &((*(*(struct {
31660                                 ParentID     AOID
31661                                 Bone         string
31662                                 Pos          Vec
31663                                 Rot          [3]float32
31664                                 ForceVisible bool
31665                         }))(obj)).Rot)[local373]
31666                         *p = math.Float32frombits(read32(r))
31667                 }
31668         }
31669         {
31670                 p := &(*(*(struct {
31671                         ParentID     AOID
31672                         Bone         string
31673                         Pos          Vec
31674                         Rot          [3]float32
31675                         ForceVisible bool
31676                 }))(obj)).ForceVisible
31677                 switch n := read8(r); n {
31678                 case 0:
31679                         *p = false
31680                 case 1:
31681                         *p = true
31682                 default:
31683                         chk(fmt.Errorf("invalid bool: %d", n))
31684                 }
31685
31686         }
31687 }
31688
31689 func (obj *AOPhysOverride) serialize(w io.Writer) {
31690         {
31691                 x := (*(*(struct {
31692                         Walk, Jump, Gravity float32
31693
31694                         // Player only.
31695                         NoSneak, NoSneakGlitch, OldSneak bool
31696                 }))(obj)).Walk
31697                 write32(w, math.Float32bits(x))
31698         }
31699         {
31700                 x := (*(*(struct {
31701                         Walk, Jump, Gravity float32
31702
31703                         // Player only.
31704                         NoSneak, NoSneakGlitch, OldSneak bool
31705                 }))(obj)).Jump
31706                 write32(w, math.Float32bits(x))
31707         }
31708         {
31709                 x := (*(*(struct {
31710                         Walk, Jump, Gravity float32
31711
31712                         // Player only.
31713                         NoSneak, NoSneakGlitch, OldSneak bool
31714                 }))(obj)).Gravity
31715                 write32(w, math.Float32bits(x))
31716         }
31717         {
31718                 x := (*(*(struct {
31719                         Walk, Jump, Gravity float32
31720
31721                         // Player only.
31722                         NoSneak, NoSneakGlitch, OldSneak bool
31723                 }))(obj)).NoSneak
31724                 if x {
31725                         write8(w, 1)
31726                 } else {
31727                         write8(w, 0)
31728                 }
31729
31730         }
31731         {
31732                 x := (*(*(struct {
31733                         Walk, Jump, Gravity float32
31734
31735                         // Player only.
31736                         NoSneak, NoSneakGlitch, OldSneak bool
31737                 }))(obj)).NoSneakGlitch
31738                 if x {
31739                         write8(w, 1)
31740                 } else {
31741                         write8(w, 0)
31742                 }
31743
31744         }
31745         {
31746                 x := (*(*(struct {
31747                         Walk, Jump, Gravity float32
31748
31749                         // Player only.
31750                         NoSneak, NoSneakGlitch, OldSneak bool
31751                 }))(obj)).OldSneak
31752                 if x {
31753                         write8(w, 1)
31754                 } else {
31755                         write8(w, 0)
31756                 }
31757
31758         }
31759 }
31760
31761 func (obj *AOPhysOverride) deserialize(r io.Reader) {
31762         {
31763                 p := &(*(*(struct {
31764                         Walk, Jump, Gravity float32
31765
31766                         // Player only.
31767                         NoSneak, NoSneakGlitch, OldSneak bool
31768                 }))(obj)).Walk
31769                 *p = math.Float32frombits(read32(r))
31770         }
31771         {
31772                 p := &(*(*(struct {
31773                         Walk, Jump, Gravity float32
31774
31775                         // Player only.
31776                         NoSneak, NoSneakGlitch, OldSneak bool
31777                 }))(obj)).Jump
31778                 *p = math.Float32frombits(read32(r))
31779         }
31780         {
31781                 p := &(*(*(struct {
31782                         Walk, Jump, Gravity float32
31783
31784                         // Player only.
31785                         NoSneak, NoSneakGlitch, OldSneak bool
31786                 }))(obj)).Gravity
31787                 *p = math.Float32frombits(read32(r))
31788         }
31789         {
31790                 p := &(*(*(struct {
31791                         Walk, Jump, Gravity float32
31792
31793                         // Player only.
31794                         NoSneak, NoSneakGlitch, OldSneak bool
31795                 }))(obj)).NoSneak
31796                 switch n := read8(r); n {
31797                 case 0:
31798                         *p = false
31799                 case 1:
31800                         *p = true
31801                 default:
31802                         chk(fmt.Errorf("invalid bool: %d", n))
31803                 }
31804
31805         }
31806         {
31807                 p := &(*(*(struct {
31808                         Walk, Jump, Gravity float32
31809
31810                         // Player only.
31811                         NoSneak, NoSneakGlitch, OldSneak bool
31812                 }))(obj)).NoSneakGlitch
31813                 switch n := read8(r); n {
31814                 case 0:
31815                         *p = false
31816                 case 1:
31817                         *p = true
31818                 default:
31819                         chk(fmt.Errorf("invalid bool: %d", n))
31820                 }
31821
31822         }
31823         {
31824                 p := &(*(*(struct {
31825                         Walk, Jump, Gravity float32
31826
31827                         // Player only.
31828                         NoSneak, NoSneakGlitch, OldSneak bool
31829                 }))(obj)).OldSneak
31830                 switch n := read8(r); n {
31831                 case 0:
31832                         *p = false
31833                 case 1:
31834                         *p = true
31835                 default:
31836                         chk(fmt.Errorf("invalid bool: %d", n))
31837                 }
31838
31839         }
31840 }
31841
31842 func (obj *aoType) serialize(w io.Writer) {
31843         {
31844                 x := *(*(uint8))(obj)
31845                 write8(w, uint8(x))
31846         }
31847 }
31848
31849 func (obj *aoType) deserialize(r io.Reader) {
31850         {
31851                 p := &*(*(uint8))(obj)
31852                 *p = read8(r)
31853         }
31854 }
31855
31856 func (obj *NodeMetaField) serialize(w io.Writer) {
31857         if err := pcall(func() {
31858                 ((*(*(struct {
31859                         Field
31860                         Private bool
31861                 }))(obj)).Field).serialize(w)
31862         }); err != nil {
31863                 if err == io.EOF {
31864                         chk(io.EOF)
31865                 }
31866                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
31867         }
31868         {
31869                 x := (*(*(struct {
31870                         Field
31871                         Private bool
31872                 }))(obj)).Private
31873                 if x {
31874                         write8(w, 1)
31875                 } else {
31876                         write8(w, 0)
31877                 }
31878
31879         }
31880 }
31881
31882 func (obj *NodeMetaField) deserialize(r io.Reader) {
31883         if err := pcall(func() {
31884                 ((*(*(struct {
31885                         Field
31886                         Private bool
31887                 }))(obj)).Field).deserialize(r)
31888         }); err != nil {
31889                 if err == io.EOF {
31890                         chk(io.EOF)
31891                 }
31892                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Field", err))
31893         }
31894         {
31895                 p := &(*(*(struct {
31896                         Field
31897                         Private bool
31898                 }))(obj)).Private
31899                 switch n := read8(r); n {
31900                 case 0:
31901                         *p = false
31902                 case 1:
31903                         *p = true
31904                 default:
31905                         chk(fmt.Errorf("invalid bool: %d", n))
31906                 }
31907
31908         }
31909 }
31910
31911 func (obj *MinimapType) serialize(w io.Writer) {
31912         {
31913                 x := *(*(uint16))(obj)
31914                 write16(w, uint16(x))
31915         }
31916 }
31917
31918 func (obj *MinimapType) deserialize(r io.Reader) {
31919         {
31920                 p := &*(*(uint16))(obj)
31921                 *p = read16(r)
31922         }
31923 }
31924
31925 func (obj *Param1Type) serialize(w io.Writer) {
31926         {
31927                 x := *(*(uint8))(obj)
31928                 write8(w, uint8(x))
31929         }
31930 }
31931
31932 func (obj *Param1Type) deserialize(r io.Reader) {
31933         {
31934                 p := &*(*(uint8))(obj)
31935                 *p = read8(r)
31936         }
31937 }
31938
31939 func (obj *Param2Type) serialize(w io.Writer) {
31940         {
31941                 x := *(*(uint8))(obj)
31942                 write8(w, uint8(x))
31943         }
31944 }
31945
31946 func (obj *Param2Type) deserialize(r io.Reader) {
31947         {
31948                 p := &*(*(uint8))(obj)
31949                 *p = read8(r)
31950         }
31951 }
31952
31953 func (obj *DrawType) serialize(w io.Writer) {
31954         {
31955                 x := *(*(uint8))(obj)
31956                 write8(w, uint8(x))
31957         }
31958 }
31959
31960 func (obj *DrawType) deserialize(r io.Reader) {
31961         {
31962                 p := &*(*(uint8))(obj)
31963                 *p = read8(r)
31964         }
31965 }
31966
31967 func (obj *TileDef) serialize(w io.Writer) {
31968         {
31969                 local374 := uint8(6)
31970                 {
31971                         x := local374
31972                         write8(w, uint8(x))
31973                 }
31974         }
31975         if err := pcall(func() {
31976                 ((*(*(struct {
31977                         Texture
31978                         Anim  TileAnim
31979                         Flags TileFlags
31980
31981                         //mt:if %s.Flags&TileColor != 0
31982                         R, G, B uint8
31983
31984                         //mt:if %s.Flags&TileScale != 0
31985                         Scale uint8
31986
31987                         //mt:if %s.Flags&TileAlign != 0
31988                         Align AlignType
31989                 }))(obj)).Texture).serialize(w)
31990         }); err != nil {
31991                 if err == io.EOF {
31992                         chk(io.EOF)
31993                 }
31994                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
31995         }
31996         if err := pcall(func() {
31997                 ((*(*(struct {
31998                         Texture
31999                         Anim  TileAnim
32000                         Flags TileFlags
32001
32002                         //mt:if %s.Flags&TileColor != 0
32003                         R, G, B uint8
32004
32005                         //mt:if %s.Flags&TileScale != 0
32006                         Scale uint8
32007
32008                         //mt:if %s.Flags&TileAlign != 0
32009                         Align AlignType
32010                 }))(obj)).Anim).serialize(w)
32011         }); err != nil {
32012                 if err == io.EOF {
32013                         chk(io.EOF)
32014                 }
32015                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32016         }
32017         if err := pcall(func() {
32018                 ((*(*(struct {
32019                         Texture
32020                         Anim  TileAnim
32021                         Flags TileFlags
32022
32023                         //mt:if %s.Flags&TileColor != 0
32024                         R, G, B uint8
32025
32026                         //mt:if %s.Flags&TileScale != 0
32027                         Scale uint8
32028
32029                         //mt:if %s.Flags&TileAlign != 0
32030                         Align AlignType
32031                 }))(obj)).Flags).serialize(w)
32032         }); err != nil {
32033                 if err == io.EOF {
32034                         chk(io.EOF)
32035                 }
32036                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32037         }
32038         if (*(*(struct {
32039                 Texture
32040                 Anim  TileAnim
32041                 Flags TileFlags
32042
32043                 //mt:if %s.Flags&TileColor != 0
32044                 R, G, B uint8
32045
32046                 //mt:if %s.Flags&TileScale != 0
32047                 Scale uint8
32048
32049                 //mt:if %s.Flags&TileAlign != 0
32050                 Align AlignType
32051         }))(obj)).Flags&TileColor != 0 {
32052                 {
32053                         x := (*(*(struct {
32054                                 Texture
32055                                 Anim  TileAnim
32056                                 Flags TileFlags
32057
32058                                 //mt:if %s.Flags&TileColor != 0
32059                                 R, G, B uint8
32060
32061                                 //mt:if %s.Flags&TileScale != 0
32062                                 Scale uint8
32063
32064                                 //mt:if %s.Flags&TileAlign != 0
32065                                 Align AlignType
32066                         }))(obj)).R
32067                         write8(w, uint8(x))
32068                 }
32069                 {
32070                         x := (*(*(struct {
32071                                 Texture
32072                                 Anim  TileAnim
32073                                 Flags TileFlags
32074
32075                                 //mt:if %s.Flags&TileColor != 0
32076                                 R, G, B uint8
32077
32078                                 //mt:if %s.Flags&TileScale != 0
32079                                 Scale uint8
32080
32081                                 //mt:if %s.Flags&TileAlign != 0
32082                                 Align AlignType
32083                         }))(obj)).G
32084                         write8(w, uint8(x))
32085                 }
32086                 {
32087                         x := (*(*(struct {
32088                                 Texture
32089                                 Anim  TileAnim
32090                                 Flags TileFlags
32091
32092                                 //mt:if %s.Flags&TileColor != 0
32093                                 R, G, B uint8
32094
32095                                 //mt:if %s.Flags&TileScale != 0
32096                                 Scale uint8
32097
32098                                 //mt:if %s.Flags&TileAlign != 0
32099                                 Align AlignType
32100                         }))(obj)).B
32101                         write8(w, uint8(x))
32102                 }
32103         }
32104         if (*(*(struct {
32105                 Texture
32106                 Anim  TileAnim
32107                 Flags TileFlags
32108
32109                 //mt:if %s.Flags&TileColor != 0
32110                 R, G, B uint8
32111
32112                 //mt:if %s.Flags&TileScale != 0
32113                 Scale uint8
32114
32115                 //mt:if %s.Flags&TileAlign != 0
32116                 Align AlignType
32117         }))(obj)).Flags&TileScale != 0 {
32118                 {
32119                         x := (*(*(struct {
32120                                 Texture
32121                                 Anim  TileAnim
32122                                 Flags TileFlags
32123
32124                                 //mt:if %s.Flags&TileColor != 0
32125                                 R, G, B uint8
32126
32127                                 //mt:if %s.Flags&TileScale != 0
32128                                 Scale uint8
32129
32130                                 //mt:if %s.Flags&TileAlign != 0
32131                                 Align AlignType
32132                         }))(obj)).Scale
32133                         write8(w, uint8(x))
32134                 }
32135         }
32136         if (*(*(struct {
32137                 Texture
32138                 Anim  TileAnim
32139                 Flags TileFlags
32140
32141                 //mt:if %s.Flags&TileColor != 0
32142                 R, G, B uint8
32143
32144                 //mt:if %s.Flags&TileScale != 0
32145                 Scale uint8
32146
32147                 //mt:if %s.Flags&TileAlign != 0
32148                 Align AlignType
32149         }))(obj)).Flags&TileAlign != 0 {
32150                 if err := pcall(func() {
32151                         ((*(*(struct {
32152                                 Texture
32153                                 Anim  TileAnim
32154                                 Flags TileFlags
32155
32156                                 //mt:if %s.Flags&TileColor != 0
32157                                 R, G, B uint8
32158
32159                                 //mt:if %s.Flags&TileScale != 0
32160                                 Scale uint8
32161
32162                                 //mt:if %s.Flags&TileAlign != 0
32163                                 Align AlignType
32164                         }))(obj)).Align).serialize(w)
32165                 }); err != nil {
32166                         if err == io.EOF {
32167                                 chk(io.EOF)
32168                         }
32169                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32170                 }
32171         }
32172 }
32173
32174 func (obj *TileDef) deserialize(r io.Reader) {
32175         {
32176                 var local375 uint8
32177                 local376 := uint8(6)
32178                 {
32179                         p := &local375
32180                         *p = read8(r)
32181                 }
32182                 if local375 != local376 {
32183                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local375))
32184                 }
32185         }
32186         if err := pcall(func() {
32187                 ((*(*(struct {
32188                         Texture
32189                         Anim  TileAnim
32190                         Flags TileFlags
32191
32192                         //mt:if %s.Flags&TileColor != 0
32193                         R, G, B uint8
32194
32195                         //mt:if %s.Flags&TileScale != 0
32196                         Scale uint8
32197
32198                         //mt:if %s.Flags&TileAlign != 0
32199                         Align AlignType
32200                 }))(obj)).Texture).deserialize(r)
32201         }); err != nil {
32202                 if err == io.EOF {
32203                         chk(io.EOF)
32204                 }
32205                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
32206         }
32207         if err := pcall(func() {
32208                 ((*(*(struct {
32209                         Texture
32210                         Anim  TileAnim
32211                         Flags TileFlags
32212
32213                         //mt:if %s.Flags&TileColor != 0
32214                         R, G, B uint8
32215
32216                         //mt:if %s.Flags&TileScale != 0
32217                         Scale uint8
32218
32219                         //mt:if %s.Flags&TileAlign != 0
32220                         Align AlignType
32221                 }))(obj)).Anim).deserialize(r)
32222         }); err != nil {
32223                 if err == io.EOF {
32224                         chk(io.EOF)
32225                 }
32226                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileAnim", err))
32227         }
32228         if err := pcall(func() {
32229                 ((*(*(struct {
32230                         Texture
32231                         Anim  TileAnim
32232                         Flags TileFlags
32233
32234                         //mt:if %s.Flags&TileColor != 0
32235                         R, G, B uint8
32236
32237                         //mt:if %s.Flags&TileScale != 0
32238                         Scale uint8
32239
32240                         //mt:if %s.Flags&TileAlign != 0
32241                         Align AlignType
32242                 }))(obj)).Flags).deserialize(r)
32243         }); err != nil {
32244                 if err == io.EOF {
32245                         chk(io.EOF)
32246                 }
32247                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileFlags", err))
32248         }
32249         if (*(*(struct {
32250                 Texture
32251                 Anim  TileAnim
32252                 Flags TileFlags
32253
32254                 //mt:if %s.Flags&TileColor != 0
32255                 R, G, B uint8
32256
32257                 //mt:if %s.Flags&TileScale != 0
32258                 Scale uint8
32259
32260                 //mt:if %s.Flags&TileAlign != 0
32261                 Align AlignType
32262         }))(obj)).Flags&TileColor != 0 {
32263                 {
32264                         p := &(*(*(struct {
32265                                 Texture
32266                                 Anim  TileAnim
32267                                 Flags TileFlags
32268
32269                                 //mt:if %s.Flags&TileColor != 0
32270                                 R, G, B uint8
32271
32272                                 //mt:if %s.Flags&TileScale != 0
32273                                 Scale uint8
32274
32275                                 //mt:if %s.Flags&TileAlign != 0
32276                                 Align AlignType
32277                         }))(obj)).R
32278                         *p = read8(r)
32279                 }
32280                 {
32281                         p := &(*(*(struct {
32282                                 Texture
32283                                 Anim  TileAnim
32284                                 Flags TileFlags
32285
32286                                 //mt:if %s.Flags&TileColor != 0
32287                                 R, G, B uint8
32288
32289                                 //mt:if %s.Flags&TileScale != 0
32290                                 Scale uint8
32291
32292                                 //mt:if %s.Flags&TileAlign != 0
32293                                 Align AlignType
32294                         }))(obj)).G
32295                         *p = read8(r)
32296                 }
32297                 {
32298                         p := &(*(*(struct {
32299                                 Texture
32300                                 Anim  TileAnim
32301                                 Flags TileFlags
32302
32303                                 //mt:if %s.Flags&TileColor != 0
32304                                 R, G, B uint8
32305
32306                                 //mt:if %s.Flags&TileScale != 0
32307                                 Scale uint8
32308
32309                                 //mt:if %s.Flags&TileAlign != 0
32310                                 Align AlignType
32311                         }))(obj)).B
32312                         *p = read8(r)
32313                 }
32314         }
32315         if (*(*(struct {
32316                 Texture
32317                 Anim  TileAnim
32318                 Flags TileFlags
32319
32320                 //mt:if %s.Flags&TileColor != 0
32321                 R, G, B uint8
32322
32323                 //mt:if %s.Flags&TileScale != 0
32324                 Scale uint8
32325
32326                 //mt:if %s.Flags&TileAlign != 0
32327                 Align AlignType
32328         }))(obj)).Flags&TileScale != 0 {
32329                 {
32330                         p := &(*(*(struct {
32331                                 Texture
32332                                 Anim  TileAnim
32333                                 Flags TileFlags
32334
32335                                 //mt:if %s.Flags&TileColor != 0
32336                                 R, G, B uint8
32337
32338                                 //mt:if %s.Flags&TileScale != 0
32339                                 Scale uint8
32340
32341                                 //mt:if %s.Flags&TileAlign != 0
32342                                 Align AlignType
32343                         }))(obj)).Scale
32344                         *p = read8(r)
32345                 }
32346         }
32347         if (*(*(struct {
32348                 Texture
32349                 Anim  TileAnim
32350                 Flags TileFlags
32351
32352                 //mt:if %s.Flags&TileColor != 0
32353                 R, G, B uint8
32354
32355                 //mt:if %s.Flags&TileScale != 0
32356                 Scale uint8
32357
32358                 //mt:if %s.Flags&TileAlign != 0
32359                 Align AlignType
32360         }))(obj)).Flags&TileAlign != 0 {
32361                 if err := pcall(func() {
32362                         ((*(*(struct {
32363                                 Texture
32364                                 Anim  TileAnim
32365                                 Flags TileFlags
32366
32367                                 //mt:if %s.Flags&TileColor != 0
32368                                 R, G, B uint8
32369
32370                                 //mt:if %s.Flags&TileScale != 0
32371                                 Scale uint8
32372
32373                                 //mt:if %s.Flags&TileAlign != 0
32374                                 Align AlignType
32375                         }))(obj)).Align).deserialize(r)
32376                 }); err != nil {
32377                         if err == io.EOF {
32378                                 chk(io.EOF)
32379                         }
32380                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AlignType", err))
32381                 }
32382         }
32383 }
32384
32385 func (obj *WaveType) serialize(w io.Writer) {
32386         {
32387                 x := *(*(uint8))(obj)
32388                 write8(w, uint8(x))
32389         }
32390 }
32391
32392 func (obj *WaveType) deserialize(r io.Reader) {
32393         {
32394                 p := &*(*(uint8))(obj)
32395                 *p = read8(r)
32396         }
32397 }
32398
32399 func (obj *LiquidType) serialize(w io.Writer) {
32400         {
32401                 x := *(*(uint8))(obj)
32402                 write8(w, uint8(x))
32403         }
32404 }
32405
32406 func (obj *LiquidType) deserialize(r io.Reader) {
32407         {
32408                 p := &*(*(uint8))(obj)
32409                 *p = read8(r)
32410         }
32411 }
32412
32413 func (obj *NodeBox) serialize(w io.Writer) {
32414         {
32415                 local377 := uint8(6)
32416                 {
32417                         x := local377
32418                         write8(w, uint8(x))
32419                 }
32420         }
32421         if err := pcall(func() {
32422                 ((*(*(struct {
32423                         Type NodeBoxType
32424
32425                         //mt:if %s.Type == MountedBox
32426                         WallTop, WallBot, WallSides Box
32427
32428                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32429                         Fixed []Box
32430
32431                         //mt:if %s.Type == ConnectedBox
32432                         ConnDirs, DiscoDirs  DirBoxes
32433                         DiscoAll, DiscoSides []Box
32434                 }))(obj)).Type).serialize(w)
32435         }); err != nil {
32436                 if err == io.EOF {
32437                         chk(io.EOF)
32438                 }
32439                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
32440         }
32441         if !((*(*(struct {
32442                 Type NodeBoxType
32443
32444                 //mt:if %s.Type == MountedBox
32445                 WallTop, WallBot, WallSides Box
32446
32447                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32448                 Fixed []Box
32449
32450                 //mt:if %s.Type == ConnectedBox
32451                 ConnDirs, DiscoDirs  DirBoxes
32452                 DiscoAll, DiscoSides []Box
32453         }))(obj)).Type < maxBox) {
32454                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32455         }
32456         if (*(*(struct {
32457                 Type NodeBoxType
32458
32459                 //mt:if %s.Type == MountedBox
32460                 WallTop, WallBot, WallSides Box
32461
32462                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32463                 Fixed []Box
32464
32465                 //mt:if %s.Type == ConnectedBox
32466                 ConnDirs, DiscoDirs  DirBoxes
32467                 DiscoAll, DiscoSides []Box
32468         }))(obj)).Type == MountedBox {
32469                 if err := pcall(func() {
32470                         ((*(*(struct {
32471                                 Type NodeBoxType
32472
32473                                 //mt:if %s.Type == MountedBox
32474                                 WallTop, WallBot, WallSides Box
32475
32476                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32477                                 Fixed []Box
32478
32479                                 //mt:if %s.Type == ConnectedBox
32480                                 ConnDirs, DiscoDirs  DirBoxes
32481                                 DiscoAll, DiscoSides []Box
32482                         }))(obj)).WallTop).serialize(w)
32483                 }); err != nil {
32484                         if err == io.EOF {
32485                                 chk(io.EOF)
32486                         }
32487                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32488                 }
32489                 if err := pcall(func() {
32490                         ((*(*(struct {
32491                                 Type NodeBoxType
32492
32493                                 //mt:if %s.Type == MountedBox
32494                                 WallTop, WallBot, WallSides Box
32495
32496                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32497                                 Fixed []Box
32498
32499                                 //mt:if %s.Type == ConnectedBox
32500                                 ConnDirs, DiscoDirs  DirBoxes
32501                                 DiscoAll, DiscoSides []Box
32502                         }))(obj)).WallBot).serialize(w)
32503                 }); err != nil {
32504                         if err == io.EOF {
32505                                 chk(io.EOF)
32506                         }
32507                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32508                 }
32509                 if err := pcall(func() {
32510                         ((*(*(struct {
32511                                 Type NodeBoxType
32512
32513                                 //mt:if %s.Type == MountedBox
32514                                 WallTop, WallBot, WallSides Box
32515
32516                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32517                                 Fixed []Box
32518
32519                                 //mt:if %s.Type == ConnectedBox
32520                                 ConnDirs, DiscoDirs  DirBoxes
32521                                 DiscoAll, DiscoSides []Box
32522                         }))(obj)).WallSides).serialize(w)
32523                 }); err != nil {
32524                         if err == io.EOF {
32525                                 chk(io.EOF)
32526                         }
32527                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32528                 }
32529         }
32530         if t := (*(*(struct {
32531                 Type NodeBoxType
32532
32533                 //mt:if %s.Type == MountedBox
32534                 WallTop, WallBot, WallSides Box
32535
32536                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32537                 Fixed []Box
32538
32539                 //mt:if %s.Type == ConnectedBox
32540                 ConnDirs, DiscoDirs  DirBoxes
32541                 DiscoAll, DiscoSides []Box
32542         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32543                 if len(((*(*(struct {
32544                         Type NodeBoxType
32545
32546                         //mt:if %s.Type == MountedBox
32547                         WallTop, WallBot, WallSides Box
32548
32549                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32550                         Fixed []Box
32551
32552                         //mt:if %s.Type == ConnectedBox
32553                         ConnDirs, DiscoDirs  DirBoxes
32554                         DiscoAll, DiscoSides []Box
32555                 }))(obj)).Fixed)) > math.MaxUint16 {
32556                         chk(ErrTooLong)
32557                 }
32558                 {
32559                         x := uint16(len(((*(*(struct {
32560                                 Type NodeBoxType
32561
32562                                 //mt:if %s.Type == MountedBox
32563                                 WallTop, WallBot, WallSides Box
32564
32565                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32566                                 Fixed []Box
32567
32568                                 //mt:if %s.Type == ConnectedBox
32569                                 ConnDirs, DiscoDirs  DirBoxes
32570                                 DiscoAll, DiscoSides []Box
32571                         }))(obj)).Fixed)))
32572                         write16(w, uint16(x))
32573                 }
32574                 for local378 := range (*(*(struct {
32575                         Type NodeBoxType
32576
32577                         //mt:if %s.Type == MountedBox
32578                         WallTop, WallBot, WallSides Box
32579
32580                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32581                         Fixed []Box
32582
32583                         //mt:if %s.Type == ConnectedBox
32584                         ConnDirs, DiscoDirs  DirBoxes
32585                         DiscoAll, DiscoSides []Box
32586                 }))(obj)).Fixed {
32587                         if err := pcall(func() {
32588                                 (((*(*(struct {
32589                                         Type NodeBoxType
32590
32591                                         //mt:if %s.Type == MountedBox
32592                                         WallTop, WallBot, WallSides Box
32593
32594                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32595                                         Fixed []Box
32596
32597                                         //mt:if %s.Type == ConnectedBox
32598                                         ConnDirs, DiscoDirs  DirBoxes
32599                                         DiscoAll, DiscoSides []Box
32600                                 }))(obj)).Fixed)[local378]).serialize(w)
32601                         }); err != nil {
32602                                 if err == io.EOF {
32603                                         chk(io.EOF)
32604                                 }
32605                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32606                         }
32607                 }
32608         }
32609         if (*(*(struct {
32610                 Type NodeBoxType
32611
32612                 //mt:if %s.Type == MountedBox
32613                 WallTop, WallBot, WallSides Box
32614
32615                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32616                 Fixed []Box
32617
32618                 //mt:if %s.Type == ConnectedBox
32619                 ConnDirs, DiscoDirs  DirBoxes
32620                 DiscoAll, DiscoSides []Box
32621         }))(obj)).Type == ConnectedBox {
32622                 if err := pcall(func() {
32623                         ((*(*(struct {
32624                                 Type NodeBoxType
32625
32626                                 //mt:if %s.Type == MountedBox
32627                                 WallTop, WallBot, WallSides Box
32628
32629                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32630                                 Fixed []Box
32631
32632                                 //mt:if %s.Type == ConnectedBox
32633                                 ConnDirs, DiscoDirs  DirBoxes
32634                                 DiscoAll, DiscoSides []Box
32635                         }))(obj)).ConnDirs).serialize(w)
32636                 }); err != nil {
32637                         if err == io.EOF {
32638                                 chk(io.EOF)
32639                         }
32640                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32641                 }
32642                 if err := pcall(func() {
32643                         ((*(*(struct {
32644                                 Type NodeBoxType
32645
32646                                 //mt:if %s.Type == MountedBox
32647                                 WallTop, WallBot, WallSides Box
32648
32649                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32650                                 Fixed []Box
32651
32652                                 //mt:if %s.Type == ConnectedBox
32653                                 ConnDirs, DiscoDirs  DirBoxes
32654                                 DiscoAll, DiscoSides []Box
32655                         }))(obj)).DiscoDirs).serialize(w)
32656                 }); err != nil {
32657                         if err == io.EOF {
32658                                 chk(io.EOF)
32659                         }
32660                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
32661                 }
32662                 if len(((*(*(struct {
32663                         Type NodeBoxType
32664
32665                         //mt:if %s.Type == MountedBox
32666                         WallTop, WallBot, WallSides Box
32667
32668                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32669                         Fixed []Box
32670
32671                         //mt:if %s.Type == ConnectedBox
32672                         ConnDirs, DiscoDirs  DirBoxes
32673                         DiscoAll, DiscoSides []Box
32674                 }))(obj)).DiscoAll)) > math.MaxUint16 {
32675                         chk(ErrTooLong)
32676                 }
32677                 {
32678                         x := uint16(len(((*(*(struct {
32679                                 Type NodeBoxType
32680
32681                                 //mt:if %s.Type == MountedBox
32682                                 WallTop, WallBot, WallSides Box
32683
32684                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32685                                 Fixed []Box
32686
32687                                 //mt:if %s.Type == ConnectedBox
32688                                 ConnDirs, DiscoDirs  DirBoxes
32689                                 DiscoAll, DiscoSides []Box
32690                         }))(obj)).DiscoAll)))
32691                         write16(w, uint16(x))
32692                 }
32693                 for local379 := range (*(*(struct {
32694                         Type NodeBoxType
32695
32696                         //mt:if %s.Type == MountedBox
32697                         WallTop, WallBot, WallSides Box
32698
32699                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32700                         Fixed []Box
32701
32702                         //mt:if %s.Type == ConnectedBox
32703                         ConnDirs, DiscoDirs  DirBoxes
32704                         DiscoAll, DiscoSides []Box
32705                 }))(obj)).DiscoAll {
32706                         if err := pcall(func() {
32707                                 (((*(*(struct {
32708                                         Type NodeBoxType
32709
32710                                         //mt:if %s.Type == MountedBox
32711                                         WallTop, WallBot, WallSides Box
32712
32713                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32714                                         Fixed []Box
32715
32716                                         //mt:if %s.Type == ConnectedBox
32717                                         ConnDirs, DiscoDirs  DirBoxes
32718                                         DiscoAll, DiscoSides []Box
32719                                 }))(obj)).DiscoAll)[local379]).serialize(w)
32720                         }); err != nil {
32721                                 if err == io.EOF {
32722                                         chk(io.EOF)
32723                                 }
32724                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32725                         }
32726                 }
32727                 if len(((*(*(struct {
32728                         Type NodeBoxType
32729
32730                         //mt:if %s.Type == MountedBox
32731                         WallTop, WallBot, WallSides Box
32732
32733                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32734                         Fixed []Box
32735
32736                         //mt:if %s.Type == ConnectedBox
32737                         ConnDirs, DiscoDirs  DirBoxes
32738                         DiscoAll, DiscoSides []Box
32739                 }))(obj)).DiscoSides)) > math.MaxUint16 {
32740                         chk(ErrTooLong)
32741                 }
32742                 {
32743                         x := uint16(len(((*(*(struct {
32744                                 Type NodeBoxType
32745
32746                                 //mt:if %s.Type == MountedBox
32747                                 WallTop, WallBot, WallSides Box
32748
32749                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32750                                 Fixed []Box
32751
32752                                 //mt:if %s.Type == ConnectedBox
32753                                 ConnDirs, DiscoDirs  DirBoxes
32754                                 DiscoAll, DiscoSides []Box
32755                         }))(obj)).DiscoSides)))
32756                         write16(w, uint16(x))
32757                 }
32758                 for local380 := range (*(*(struct {
32759                         Type NodeBoxType
32760
32761                         //mt:if %s.Type == MountedBox
32762                         WallTop, WallBot, WallSides Box
32763
32764                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32765                         Fixed []Box
32766
32767                         //mt:if %s.Type == ConnectedBox
32768                         ConnDirs, DiscoDirs  DirBoxes
32769                         DiscoAll, DiscoSides []Box
32770                 }))(obj)).DiscoSides {
32771                         if err := pcall(func() {
32772                                 (((*(*(struct {
32773                                         Type NodeBoxType
32774
32775                                         //mt:if %s.Type == MountedBox
32776                                         WallTop, WallBot, WallSides Box
32777
32778                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32779                                         Fixed []Box
32780
32781                                         //mt:if %s.Type == ConnectedBox
32782                                         ConnDirs, DiscoDirs  DirBoxes
32783                                         DiscoAll, DiscoSides []Box
32784                                 }))(obj)).DiscoSides)[local380]).serialize(w)
32785                         }); err != nil {
32786                                 if err == io.EOF {
32787                                         chk(io.EOF)
32788                                 }
32789                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32790                         }
32791                 }
32792         }
32793 }
32794
32795 func (obj *NodeBox) deserialize(r io.Reader) {
32796         {
32797                 var local381 uint8
32798                 local382 := uint8(6)
32799                 {
32800                         p := &local381
32801                         *p = read8(r)
32802                 }
32803                 if local381 != local382 {
32804                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local381))
32805                 }
32806         }
32807         if err := pcall(func() {
32808                 ((*(*(struct {
32809                         Type NodeBoxType
32810
32811                         //mt:if %s.Type == MountedBox
32812                         WallTop, WallBot, WallSides Box
32813
32814                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32815                         Fixed []Box
32816
32817                         //mt:if %s.Type == ConnectedBox
32818                         ConnDirs, DiscoDirs  DirBoxes
32819                         DiscoAll, DiscoSides []Box
32820                 }))(obj)).Type).deserialize(r)
32821         }); err != nil {
32822                 if err == io.EOF {
32823                         chk(io.EOF)
32824                 }
32825                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.NodeBoxType", err))
32826         }
32827         if !((*(*(struct {
32828                 Type NodeBoxType
32829
32830                 //mt:if %s.Type == MountedBox
32831                 WallTop, WallBot, WallSides Box
32832
32833                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32834                 Fixed []Box
32835
32836                 //mt:if %s.Type == ConnectedBox
32837                 ConnDirs, DiscoDirs  DirBoxes
32838                 DiscoAll, DiscoSides []Box
32839         }))(obj)).Type < maxBox) {
32840                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32841         }
32842         if (*(*(struct {
32843                 Type NodeBoxType
32844
32845                 //mt:if %s.Type == MountedBox
32846                 WallTop, WallBot, WallSides Box
32847
32848                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32849                 Fixed []Box
32850
32851                 //mt:if %s.Type == ConnectedBox
32852                 ConnDirs, DiscoDirs  DirBoxes
32853                 DiscoAll, DiscoSides []Box
32854         }))(obj)).Type == MountedBox {
32855                 if err := pcall(func() {
32856                         ((*(*(struct {
32857                                 Type NodeBoxType
32858
32859                                 //mt:if %s.Type == MountedBox
32860                                 WallTop, WallBot, WallSides Box
32861
32862                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32863                                 Fixed []Box
32864
32865                                 //mt:if %s.Type == ConnectedBox
32866                                 ConnDirs, DiscoDirs  DirBoxes
32867                                 DiscoAll, DiscoSides []Box
32868                         }))(obj)).WallTop).deserialize(r)
32869                 }); err != nil {
32870                         if err == io.EOF {
32871                                 chk(io.EOF)
32872                         }
32873                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32874                 }
32875                 if err := pcall(func() {
32876                         ((*(*(struct {
32877                                 Type NodeBoxType
32878
32879                                 //mt:if %s.Type == MountedBox
32880                                 WallTop, WallBot, WallSides Box
32881
32882                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32883                                 Fixed []Box
32884
32885                                 //mt:if %s.Type == ConnectedBox
32886                                 ConnDirs, DiscoDirs  DirBoxes
32887                                 DiscoAll, DiscoSides []Box
32888                         }))(obj)).WallBot).deserialize(r)
32889                 }); err != nil {
32890                         if err == io.EOF {
32891                                 chk(io.EOF)
32892                         }
32893                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32894                 }
32895                 if err := pcall(func() {
32896                         ((*(*(struct {
32897                                 Type NodeBoxType
32898
32899                                 //mt:if %s.Type == MountedBox
32900                                 WallTop, WallBot, WallSides Box
32901
32902                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32903                                 Fixed []Box
32904
32905                                 //mt:if %s.Type == ConnectedBox
32906                                 ConnDirs, DiscoDirs  DirBoxes
32907                                 DiscoAll, DiscoSides []Box
32908                         }))(obj)).WallSides).deserialize(r)
32909                 }); err != nil {
32910                         if err == io.EOF {
32911                                 chk(io.EOF)
32912                         }
32913                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32914                 }
32915         }
32916         if t := (*(*(struct {
32917                 Type NodeBoxType
32918
32919                 //mt:if %s.Type == MountedBox
32920                 WallTop, WallBot, WallSides Box
32921
32922                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32923                 Fixed []Box
32924
32925                 //mt:if %s.Type == ConnectedBox
32926                 ConnDirs, DiscoDirs  DirBoxes
32927                 DiscoAll, DiscoSides []Box
32928         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32929                 var local383 uint16
32930                 {
32931                         p := &local383
32932                         *p = read16(r)
32933                 }
32934                 ((*(*(struct {
32935                         Type NodeBoxType
32936
32937                         //mt:if %s.Type == MountedBox
32938                         WallTop, WallBot, WallSides Box
32939
32940                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32941                         Fixed []Box
32942
32943                         //mt:if %s.Type == ConnectedBox
32944                         ConnDirs, DiscoDirs  DirBoxes
32945                         DiscoAll, DiscoSides []Box
32946                 }))(obj)).Fixed) = make([]Box, local383)
32947                 for local384 := range (*(*(struct {
32948                         Type NodeBoxType
32949
32950                         //mt:if %s.Type == MountedBox
32951                         WallTop, WallBot, WallSides Box
32952
32953                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32954                         Fixed []Box
32955
32956                         //mt:if %s.Type == ConnectedBox
32957                         ConnDirs, DiscoDirs  DirBoxes
32958                         DiscoAll, DiscoSides []Box
32959                 }))(obj)).Fixed {
32960                         if err := pcall(func() {
32961                                 (((*(*(struct {
32962                                         Type NodeBoxType
32963
32964                                         //mt:if %s.Type == MountedBox
32965                                         WallTop, WallBot, WallSides Box
32966
32967                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32968                                         Fixed []Box
32969
32970                                         //mt:if %s.Type == ConnectedBox
32971                                         ConnDirs, DiscoDirs  DirBoxes
32972                                         DiscoAll, DiscoSides []Box
32973                                 }))(obj)).Fixed)[local384]).deserialize(r)
32974                         }); err != nil {
32975                                 if err == io.EOF {
32976                                         chk(io.EOF)
32977                                 }
32978                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
32979                         }
32980                 }
32981         }
32982         if (*(*(struct {
32983                 Type NodeBoxType
32984
32985                 //mt:if %s.Type == MountedBox
32986                 WallTop, WallBot, WallSides Box
32987
32988                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32989                 Fixed []Box
32990
32991                 //mt:if %s.Type == ConnectedBox
32992                 ConnDirs, DiscoDirs  DirBoxes
32993                 DiscoAll, DiscoSides []Box
32994         }))(obj)).Type == ConnectedBox {
32995                 if err := pcall(func() {
32996                         ((*(*(struct {
32997                                 Type NodeBoxType
32998
32999                                 //mt:if %s.Type == MountedBox
33000                                 WallTop, WallBot, WallSides Box
33001
33002                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33003                                 Fixed []Box
33004
33005                                 //mt:if %s.Type == ConnectedBox
33006                                 ConnDirs, DiscoDirs  DirBoxes
33007                                 DiscoAll, DiscoSides []Box
33008                         }))(obj)).ConnDirs).deserialize(r)
33009                 }); err != nil {
33010                         if err == io.EOF {
33011                                 chk(io.EOF)
33012                         }
33013                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33014                 }
33015                 if err := pcall(func() {
33016                         ((*(*(struct {
33017                                 Type NodeBoxType
33018
33019                                 //mt:if %s.Type == MountedBox
33020                                 WallTop, WallBot, WallSides Box
33021
33022                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33023                                 Fixed []Box
33024
33025                                 //mt:if %s.Type == ConnectedBox
33026                                 ConnDirs, DiscoDirs  DirBoxes
33027                                 DiscoAll, DiscoSides []Box
33028                         }))(obj)).DiscoDirs).deserialize(r)
33029                 }); err != nil {
33030                         if err == io.EOF {
33031                                 chk(io.EOF)
33032                         }
33033                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
33034                 }
33035                 var local385 uint16
33036                 {
33037                         p := &local385
33038                         *p = read16(r)
33039                 }
33040                 ((*(*(struct {
33041                         Type NodeBoxType
33042
33043                         //mt:if %s.Type == MountedBox
33044                         WallTop, WallBot, WallSides Box
33045
33046                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33047                         Fixed []Box
33048
33049                         //mt:if %s.Type == ConnectedBox
33050                         ConnDirs, DiscoDirs  DirBoxes
33051                         DiscoAll, DiscoSides []Box
33052                 }))(obj)).DiscoAll) = make([]Box, local385)
33053                 for local386 := range (*(*(struct {
33054                         Type NodeBoxType
33055
33056                         //mt:if %s.Type == MountedBox
33057                         WallTop, WallBot, WallSides Box
33058
33059                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33060                         Fixed []Box
33061
33062                         //mt:if %s.Type == ConnectedBox
33063                         ConnDirs, DiscoDirs  DirBoxes
33064                         DiscoAll, DiscoSides []Box
33065                 }))(obj)).DiscoAll {
33066                         if err := pcall(func() {
33067                                 (((*(*(struct {
33068                                         Type NodeBoxType
33069
33070                                         //mt:if %s.Type == MountedBox
33071                                         WallTop, WallBot, WallSides Box
33072
33073                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33074                                         Fixed []Box
33075
33076                                         //mt:if %s.Type == ConnectedBox
33077                                         ConnDirs, DiscoDirs  DirBoxes
33078                                         DiscoAll, DiscoSides []Box
33079                                 }))(obj)).DiscoAll)[local386]).deserialize(r)
33080                         }); err != nil {
33081                                 if err == io.EOF {
33082                                         chk(io.EOF)
33083                                 }
33084                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33085                         }
33086                 }
33087                 var local387 uint16
33088                 {
33089                         p := &local387
33090                         *p = read16(r)
33091                 }
33092                 ((*(*(struct {
33093                         Type NodeBoxType
33094
33095                         //mt:if %s.Type == MountedBox
33096                         WallTop, WallBot, WallSides Box
33097
33098                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33099                         Fixed []Box
33100
33101                         //mt:if %s.Type == ConnectedBox
33102                         ConnDirs, DiscoDirs  DirBoxes
33103                         DiscoAll, DiscoSides []Box
33104                 }))(obj)).DiscoSides) = make([]Box, local387)
33105                 for local388 := range (*(*(struct {
33106                         Type NodeBoxType
33107
33108                         //mt:if %s.Type == MountedBox
33109                         WallTop, WallBot, WallSides Box
33110
33111                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33112                         Fixed []Box
33113
33114                         //mt:if %s.Type == ConnectedBox
33115                         ConnDirs, DiscoDirs  DirBoxes
33116                         DiscoAll, DiscoSides []Box
33117                 }))(obj)).DiscoSides {
33118                         if err := pcall(func() {
33119                                 (((*(*(struct {
33120                                         Type NodeBoxType
33121
33122                                         //mt:if %s.Type == MountedBox
33123                                         WallTop, WallBot, WallSides Box
33124
33125                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33126                                         Fixed []Box
33127
33128                                         //mt:if %s.Type == ConnectedBox
33129                                         ConnDirs, DiscoDirs  DirBoxes
33130                                         DiscoAll, DiscoSides []Box
33131                                 }))(obj)).DiscoSides)[local388]).deserialize(r)
33132                         }); err != nil {
33133                                 if err == io.EOF {
33134                                         chk(io.EOF)
33135                                 }
33136                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
33137                         }
33138                 }
33139         }
33140 }
33141
33142 func (obj *SoundDef) serialize(w io.Writer) {
33143         if len(([]byte((*(*(struct {
33144                 Name              string
33145                 Gain, Pitch, Fade float32
33146         }))(obj)).Name))) > math.MaxUint16 {
33147                 chk(ErrTooLong)
33148         }
33149         {
33150                 x := uint16(len(([]byte((*(*(struct {
33151                         Name              string
33152                         Gain, Pitch, Fade float32
33153                 }))(obj)).Name))))
33154                 write16(w, uint16(x))
33155         }
33156         {
33157                 _, err := w.Write(([]byte((*(*(struct {
33158                         Name              string
33159                         Gain, Pitch, Fade float32
33160                 }))(obj)).Name))[:])
33161                 chk(err)
33162         }
33163         {
33164                 x := (*(*(struct {
33165                         Name              string
33166                         Gain, Pitch, Fade float32
33167                 }))(obj)).Gain
33168                 write32(w, math.Float32bits(x))
33169         }
33170         {
33171                 x := (*(*(struct {
33172                         Name              string
33173                         Gain, Pitch, Fade float32
33174                 }))(obj)).Pitch
33175                 write32(w, math.Float32bits(x))
33176         }
33177         {
33178                 x := (*(*(struct {
33179                         Name              string
33180                         Gain, Pitch, Fade float32
33181                 }))(obj)).Fade
33182                 write32(w, math.Float32bits(x))
33183         }
33184 }
33185
33186 func (obj *SoundDef) deserialize(r io.Reader) {
33187         var local389 []uint8
33188         var local390 uint16
33189         {
33190                 p := &local390
33191                 *p = read16(r)
33192         }
33193         (local389) = make([]uint8, local390)
33194         {
33195                 _, err := io.ReadFull(r, (local389)[:])
33196                 chk(err)
33197         }
33198         ((*(*(struct {
33199                 Name              string
33200                 Gain, Pitch, Fade float32
33201         }))(obj)).Name) = string(local389)
33202         {
33203                 p := &(*(*(struct {
33204                         Name              string
33205                         Gain, Pitch, Fade float32
33206                 }))(obj)).Gain
33207                 *p = math.Float32frombits(read32(r))
33208         }
33209         {
33210                 p := &(*(*(struct {
33211                         Name              string
33212                         Gain, Pitch, Fade float32
33213                 }))(obj)).Pitch
33214                 *p = math.Float32frombits(read32(r))
33215         }
33216         {
33217                 p := &(*(*(struct {
33218                         Name              string
33219                         Gain, Pitch, Fade float32
33220                 }))(obj)).Fade
33221                 *p = math.Float32frombits(read32(r))
33222         }
33223 }
33224
33225 func (obj *AlphaUse) serialize(w io.Writer) {
33226         {
33227                 x := *(*(uint8))(obj)
33228                 write8(w, uint8(x))
33229         }
33230 }
33231
33232 func (obj *AlphaUse) deserialize(r io.Reader) {
33233         {
33234                 p := &*(*(uint8))(obj)
33235                 *p = read8(r)
33236         }
33237 }
33238
33239 func (obj *Keys) serialize(w io.Writer) {
33240         {
33241                 x := *(*(uint32))(obj)
33242                 write32(w, uint32(x))
33243         }
33244 }
33245
33246 func (obj *Keys) deserialize(r io.Reader) {
33247         {
33248                 p := &*(*(uint32))(obj)
33249                 *p = read32(r)
33250         }
33251 }
33252
33253 func (obj *MapBlkFlags) serialize(w io.Writer) {
33254         {
33255                 x := *(*(uint8))(obj)
33256                 write8(w, uint8(x))
33257         }
33258 }
33259
33260 func (obj *MapBlkFlags) deserialize(r io.Reader) {
33261         {
33262                 p := &*(*(uint8))(obj)
33263                 *p = read8(r)
33264         }
33265 }
33266
33267 func (obj *LitFromBlks) serialize(w io.Writer) {
33268         {
33269                 x := *(*(uint16))(obj)
33270                 write16(w, uint16(x))
33271         }
33272 }
33273
33274 func (obj *LitFromBlks) deserialize(r io.Reader) {
33275         {
33276                 p := &*(*(uint16))(obj)
33277                 *p = read16(r)
33278         }
33279 }
33280
33281 func (obj *AOInitData) serialize(w io.Writer) {
33282         {
33283                 local391 := uint8(1)
33284                 {
33285                         x := local391
33286                         write8(w, uint8(x))
33287                 }
33288         }
33289         if len(([]byte((*(*(struct {
33290
33291                 // For players.
33292                 Name     string
33293                 IsPlayer bool
33294
33295                 ID AOID
33296
33297                 Pos
33298                 Rot [3]float32
33299
33300                 HP uint16
33301
33302                 // See (de)serialize.fmt.
33303                 Msgs []AOMsg
33304         }))(obj)).Name))) > math.MaxUint16 {
33305                 chk(ErrTooLong)
33306         }
33307         {
33308                 x := uint16(len(([]byte((*(*(struct {
33309
33310                         // For players.
33311                         Name     string
33312                         IsPlayer bool
33313
33314                         ID AOID
33315
33316                         Pos
33317                         Rot [3]float32
33318
33319                         HP uint16
33320
33321                         // See (de)serialize.fmt.
33322                         Msgs []AOMsg
33323                 }))(obj)).Name))))
33324                 write16(w, uint16(x))
33325         }
33326         {
33327                 _, err := w.Write(([]byte((*(*(struct {
33328
33329                         // For players.
33330                         Name     string
33331                         IsPlayer bool
33332
33333                         ID AOID
33334
33335                         Pos
33336                         Rot [3]float32
33337
33338                         HP uint16
33339
33340                         // See (de)serialize.fmt.
33341                         Msgs []AOMsg
33342                 }))(obj)).Name))[:])
33343                 chk(err)
33344         }
33345         {
33346                 x := (*(*(struct {
33347
33348                         // For players.
33349                         Name     string
33350                         IsPlayer bool
33351
33352                         ID AOID
33353
33354                         Pos
33355                         Rot [3]float32
33356
33357                         HP uint16
33358
33359                         // See (de)serialize.fmt.
33360                         Msgs []AOMsg
33361                 }))(obj)).IsPlayer
33362                 if x {
33363                         write8(w, 1)
33364                 } else {
33365                         write8(w, 0)
33366                 }
33367
33368         }
33369         if err := pcall(func() {
33370                 ((*(*(struct {
33371
33372                         // For players.
33373                         Name     string
33374                         IsPlayer bool
33375
33376                         ID AOID
33377
33378                         Pos
33379                         Rot [3]float32
33380
33381                         HP uint16
33382
33383                         // See (de)serialize.fmt.
33384                         Msgs []AOMsg
33385                 }))(obj)).ID).serialize(w)
33386         }); err != nil {
33387                 if err == io.EOF {
33388                         chk(io.EOF)
33389                 }
33390                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
33391         }
33392         if err := pcall(func() {
33393                 ((*(*(struct {
33394
33395                         // For players.
33396                         Name     string
33397                         IsPlayer bool
33398
33399                         ID AOID
33400
33401                         Pos
33402                         Rot [3]float32
33403
33404                         HP uint16
33405
33406                         // See (de)serialize.fmt.
33407                         Msgs []AOMsg
33408                 }))(obj)).Pos).serialize(w)
33409         }); err != nil {
33410                 if err == io.EOF {
33411                         chk(io.EOF)
33412                 }
33413                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
33414         }
33415         for local392 := range (*(*(struct {
33416
33417                 // For players.
33418                 Name     string
33419                 IsPlayer bool
33420
33421                 ID AOID
33422
33423                 Pos
33424                 Rot [3]float32
33425
33426                 HP uint16
33427
33428                 // See (de)serialize.fmt.
33429                 Msgs []AOMsg
33430         }))(obj)).Rot {
33431                 {
33432                         x := ((*(*(struct {
33433
33434                                 // For players.
33435                                 Name     string
33436                                 IsPlayer bool
33437
33438                                 ID AOID
33439
33440                                 Pos
33441                                 Rot [3]float32
33442
33443                                 HP uint16
33444
33445                                 // See (de)serialize.fmt.
33446                                 Msgs []AOMsg
33447                         }))(obj)).Rot)[local392]
33448                         write32(w, math.Float32bits(x))
33449                 }
33450         }
33451         {
33452                 x := (*(*(struct {
33453
33454                         // For players.
33455                         Name     string
33456                         IsPlayer bool
33457
33458                         ID AOID
33459
33460                         Pos
33461                         Rot [3]float32
33462
33463                         HP uint16
33464
33465                         // See (de)serialize.fmt.
33466                         Msgs []AOMsg
33467                 }))(obj)).HP
33468                 write16(w, uint16(x))
33469         }
33470         {
33471                 x := (*(*(struct {
33472
33473                         // For players.
33474                         Name     string
33475                         IsPlayer bool
33476
33477                         ID AOID
33478
33479                         Pos
33480                         Rot [3]float32
33481
33482                         HP uint16
33483
33484                         // See (de)serialize.fmt.
33485                         Msgs []AOMsg
33486                 }))(obj)).Msgs
33487                 { // For AOInitData.Msgs.
33488                         if len(x) > math.MaxUint8 {
33489                                 chk(ErrTooLong)
33490                         }
33491                         write8(w, uint8(len(x)))
33492                         for _, msg := range x {
33493                                 var b bytes.Buffer
33494                                 chk(writeAOMsg(&b, msg))
33495                                 if b.Len() > math.MaxUint32 {
33496                                         chk(ErrTooLong)
33497                                 }
33498                                 write32(w, uint32(b.Len()))
33499                                 _, err := b.WriteTo(w)
33500                                 chk(err)
33501                         }
33502                 }
33503
33504         }
33505 }
33506
33507 func (obj *AOInitData) deserialize(r io.Reader) {
33508         {
33509                 var local393 uint8
33510                 local394 := uint8(1)
33511                 {
33512                         p := &local393
33513                         *p = read8(r)
33514                 }
33515                 if local393 != local394 {
33516                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local393))
33517                 }
33518         }
33519         var local395 []uint8
33520         var local396 uint16
33521         {
33522                 p := &local396
33523                 *p = read16(r)
33524         }
33525         (local395) = make([]uint8, local396)
33526         {
33527                 _, err := io.ReadFull(r, (local395)[:])
33528                 chk(err)
33529         }
33530         ((*(*(struct {
33531
33532                 // For players.
33533                 Name     string
33534                 IsPlayer bool
33535
33536                 ID AOID
33537
33538                 Pos
33539                 Rot [3]float32
33540
33541                 HP uint16
33542
33543                 // See (de)serialize.fmt.
33544                 Msgs []AOMsg
33545         }))(obj)).Name) = string(local395)
33546         {
33547                 p := &(*(*(struct {
33548
33549                         // For players.
33550                         Name     string
33551                         IsPlayer bool
33552
33553                         ID AOID
33554
33555                         Pos
33556                         Rot [3]float32
33557
33558                         HP uint16
33559
33560                         // See (de)serialize.fmt.
33561                         Msgs []AOMsg
33562                 }))(obj)).IsPlayer
33563                 switch n := read8(r); n {
33564                 case 0:
33565                         *p = false
33566                 case 1:
33567                         *p = true
33568                 default:
33569                         chk(fmt.Errorf("invalid bool: %d", n))
33570                 }
33571
33572         }
33573         if err := pcall(func() {
33574                 ((*(*(struct {
33575
33576                         // For players.
33577                         Name     string
33578                         IsPlayer bool
33579
33580                         ID AOID
33581
33582                         Pos
33583                         Rot [3]float32
33584
33585                         HP uint16
33586
33587                         // See (de)serialize.fmt.
33588                         Msgs []AOMsg
33589                 }))(obj)).ID).deserialize(r)
33590         }); err != nil {
33591                 if err == io.EOF {
33592                         chk(io.EOF)
33593                 }
33594                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
33595         }
33596         if err := pcall(func() {
33597                 ((*(*(struct {
33598
33599                         // For players.
33600                         Name     string
33601                         IsPlayer bool
33602
33603                         ID AOID
33604
33605                         Pos
33606                         Rot [3]float32
33607
33608                         HP uint16
33609
33610                         // See (de)serialize.fmt.
33611                         Msgs []AOMsg
33612                 }))(obj)).Pos).deserialize(r)
33613         }); err != nil {
33614                 if err == io.EOF {
33615                         chk(io.EOF)
33616                 }
33617                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
33618         }
33619         for local397 := range (*(*(struct {
33620
33621                 // For players.
33622                 Name     string
33623                 IsPlayer bool
33624
33625                 ID AOID
33626
33627                 Pos
33628                 Rot [3]float32
33629
33630                 HP uint16
33631
33632                 // See (de)serialize.fmt.
33633                 Msgs []AOMsg
33634         }))(obj)).Rot {
33635                 {
33636                         p := &((*(*(struct {
33637
33638                                 // For players.
33639                                 Name     string
33640                                 IsPlayer bool
33641
33642                                 ID AOID
33643
33644                                 Pos
33645                                 Rot [3]float32
33646
33647                                 HP uint16
33648
33649                                 // See (de)serialize.fmt.
33650                                 Msgs []AOMsg
33651                         }))(obj)).Rot)[local397]
33652                         *p = math.Float32frombits(read32(r))
33653                 }
33654         }
33655         {
33656                 p := &(*(*(struct {
33657
33658                         // For players.
33659                         Name     string
33660                         IsPlayer bool
33661
33662                         ID AOID
33663
33664                         Pos
33665                         Rot [3]float32
33666
33667                         HP uint16
33668
33669                         // See (de)serialize.fmt.
33670                         Msgs []AOMsg
33671                 }))(obj)).HP
33672                 *p = read16(r)
33673         }
33674         {
33675                 p := &(*(*(struct {
33676
33677                         // For players.
33678                         Name     string
33679                         IsPlayer bool
33680
33681                         ID AOID
33682
33683                         Pos
33684                         Rot [3]float32
33685
33686                         HP uint16
33687
33688                         // See (de)serialize.fmt.
33689                         Msgs []AOMsg
33690                 }))(obj)).Msgs
33691                 { // For AOInitData.Msgs.
33692                         *p = make([]AOMsg, read8(r))
33693                         for i := range *p {
33694                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
33695                                 msg, err := readAOMsg(r)
33696                                 chk(err)
33697                                 (*p)[i] = msg
33698                                 if r.N > 0 {
33699                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
33700                                 }
33701                         }
33702                 }
33703
33704         }
33705 }
33706
33707 func (obj *ItemType) serialize(w io.Writer) {
33708         {
33709                 x := *(*(uint8))(obj)
33710                 write8(w, uint8(x))
33711         }
33712 }
33713
33714 func (obj *ItemType) deserialize(r io.Reader) {
33715         {
33716                 p := &*(*(uint8))(obj)
33717                 *p = read8(r)
33718         }
33719 }
33720
33721 func (obj *ToolCaps) serialize(w io.Writer) {
33722         if _ = (*(*(struct {
33723                 //mt:if _ = %s; false
33724                 NonNil bool
33725
33726                 AttackCooldown float32
33727                 MaxDropLvl     int16
33728
33729                 //mt:len32
33730                 GroupCaps []ToolGroupCap
33731
33732                 //mt:len32
33733                 DmgGroups []Group
33734
33735                 //mt:32tou16
33736                 PunchUses int32
33737         }))(obj)); false {
33738                 {
33739                         x := (*(*(struct {
33740                                 //mt:if _ = %s; false
33741                                 NonNil bool
33742
33743                                 AttackCooldown float32
33744                                 MaxDropLvl     int16
33745
33746                                 //mt:len32
33747                                 GroupCaps []ToolGroupCap
33748
33749                                 //mt:len32
33750                                 DmgGroups []Group
33751
33752                                 //mt:32tou16
33753                                 PunchUses int32
33754                         }))(obj)).NonNil
33755                         if x {
33756                                 write8(w, 1)
33757                         } else {
33758                                 write8(w, 0)
33759                         }
33760
33761                 }
33762         }
33763         {
33764                 ow := w
33765                 w := new(bytes.Buffer)
33766                 /*
33767                    if r.N > 0 { (*(*(struct {
33768                         //mt:if _ = %s; false
33769                         NonNil  bool
33770
33771                         AttackCooldown  float32
33772                         MaxDropLvl      int16
33773
33774                         //mt:len32
33775                         GroupCaps       []ToolGroupCap
33776
33777                         //mt:len32
33778                         DmgGroups       []Group
33779
33780                         //mt:32tou16
33781                         PunchUses       int32
33782                    }))(obj)).NonNil = true}; /**/{
33783                         if (*(*(struct {
33784                                 //mt:if _ = %s; false
33785                                 NonNil bool
33786
33787                                 AttackCooldown float32
33788                                 MaxDropLvl     int16
33789
33790                                 //mt:len32
33791                                 GroupCaps []ToolGroupCap
33792
33793                                 //mt:len32
33794                                 DmgGroups []Group
33795
33796                                 //mt:32tou16
33797                                 PunchUses int32
33798                         }))(obj)).NonNil {
33799                                 {
33800                                         local398 := uint8(5)
33801                                         {
33802                                                 x := local398
33803                                                 write8(w, uint8(x))
33804                                         }
33805                                 }
33806                                 {
33807                                         x := (*(*(struct {
33808                                                 //mt:if _ = %s; false
33809                                                 NonNil bool
33810
33811                                                 AttackCooldown float32
33812                                                 MaxDropLvl     int16
33813
33814                                                 //mt:len32
33815                                                 GroupCaps []ToolGroupCap
33816
33817                                                 //mt:len32
33818                                                 DmgGroups []Group
33819
33820                                                 //mt:32tou16
33821                                                 PunchUses int32
33822                                         }))(obj)).AttackCooldown
33823                                         write32(w, math.Float32bits(x))
33824                                 }
33825                                 {
33826                                         x := (*(*(struct {
33827                                                 //mt:if _ = %s; false
33828                                                 NonNil bool
33829
33830                                                 AttackCooldown float32
33831                                                 MaxDropLvl     int16
33832
33833                                                 //mt:len32
33834                                                 GroupCaps []ToolGroupCap
33835
33836                                                 //mt:len32
33837                                                 DmgGroups []Group
33838
33839                                                 //mt:32tou16
33840                                                 PunchUses int32
33841                                         }))(obj)).MaxDropLvl
33842                                         write16(w, uint16(x))
33843                                 }
33844                                 if len(((*(*(struct {
33845                                         //mt:if _ = %s; false
33846                                         NonNil bool
33847
33848                                         AttackCooldown float32
33849                                         MaxDropLvl     int16
33850
33851                                         //mt:len32
33852                                         GroupCaps []ToolGroupCap
33853
33854                                         //mt:len32
33855                                         DmgGroups []Group
33856
33857                                         //mt:32tou16
33858                                         PunchUses int32
33859                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
33860                                         chk(ErrTooLong)
33861                                 }
33862                                 {
33863                                         x := uint32(len(((*(*(struct {
33864                                                 //mt:if _ = %s; false
33865                                                 NonNil bool
33866
33867                                                 AttackCooldown float32
33868                                                 MaxDropLvl     int16
33869
33870                                                 //mt:len32
33871                                                 GroupCaps []ToolGroupCap
33872
33873                                                 //mt:len32
33874                                                 DmgGroups []Group
33875
33876                                                 //mt:32tou16
33877                                                 PunchUses int32
33878                                         }))(obj)).GroupCaps)))
33879                                         write32(w, uint32(x))
33880                                 }
33881                                 for local399 := range (*(*(struct {
33882                                         //mt:if _ = %s; false
33883                                         NonNil bool
33884
33885                                         AttackCooldown float32
33886                                         MaxDropLvl     int16
33887
33888                                         //mt:len32
33889                                         GroupCaps []ToolGroupCap
33890
33891                                         //mt:len32
33892                                         DmgGroups []Group
33893
33894                                         //mt:32tou16
33895                                         PunchUses int32
33896                                 }))(obj)).GroupCaps {
33897                                         if err := pcall(func() {
33898                                                 (((*(*(struct {
33899                                                         //mt:if _ = %s; false
33900                                                         NonNil bool
33901
33902                                                         AttackCooldown float32
33903                                                         MaxDropLvl     int16
33904
33905                                                         //mt:len32
33906                                                         GroupCaps []ToolGroupCap
33907
33908                                                         //mt:len32
33909                                                         DmgGroups []Group
33910
33911                                                         //mt:32tou16
33912                                                         PunchUses int32
33913                                                 }))(obj)).GroupCaps)[local399]).serialize(w)
33914                                         }); err != nil {
33915                                                 if err == io.EOF {
33916                                                         chk(io.EOF)
33917                                                 }
33918                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
33919                                         }
33920                                 }
33921                                 if len(((*(*(struct {
33922                                         //mt:if _ = %s; false
33923                                         NonNil bool
33924
33925                                         AttackCooldown float32
33926                                         MaxDropLvl     int16
33927
33928                                         //mt:len32
33929                                         GroupCaps []ToolGroupCap
33930
33931                                         //mt:len32
33932                                         DmgGroups []Group
33933
33934                                         //mt:32tou16
33935                                         PunchUses int32
33936                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
33937                                         chk(ErrTooLong)
33938                                 }
33939                                 {
33940                                         x := uint32(len(((*(*(struct {
33941                                                 //mt:if _ = %s; false
33942                                                 NonNil bool
33943
33944                                                 AttackCooldown float32
33945                                                 MaxDropLvl     int16
33946
33947                                                 //mt:len32
33948                                                 GroupCaps []ToolGroupCap
33949
33950                                                 //mt:len32
33951                                                 DmgGroups []Group
33952
33953                                                 //mt:32tou16
33954                                                 PunchUses int32
33955                                         }))(obj)).DmgGroups)))
33956                                         write32(w, uint32(x))
33957                                 }
33958                                 for local400 := range (*(*(struct {
33959                                         //mt:if _ = %s; false
33960                                         NonNil bool
33961
33962                                         AttackCooldown float32
33963                                         MaxDropLvl     int16
33964
33965                                         //mt:len32
33966                                         GroupCaps []ToolGroupCap
33967
33968                                         //mt:len32
33969                                         DmgGroups []Group
33970
33971                                         //mt:32tou16
33972                                         PunchUses int32
33973                                 }))(obj)).DmgGroups {
33974                                         if err := pcall(func() {
33975                                                 (((*(*(struct {
33976                                                         //mt:if _ = %s; false
33977                                                         NonNil bool
33978
33979                                                         AttackCooldown float32
33980                                                         MaxDropLvl     int16
33981
33982                                                         //mt:len32
33983                                                         GroupCaps []ToolGroupCap
33984
33985                                                         //mt:len32
33986                                                         DmgGroups []Group
33987
33988                                                         //mt:32tou16
33989                                                         PunchUses int32
33990                                                 }))(obj)).DmgGroups)[local400]).serialize(w)
33991                                         }); err != nil {
33992                                                 if err == io.EOF {
33993                                                         chk(io.EOF)
33994                                                 }
33995                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
33996                                         }
33997                                 }
33998                                 {
33999                                         x := uint16((*(*(struct {
34000                                                 //mt:if _ = %s; false
34001                                                 NonNil bool
34002
34003                                                 AttackCooldown float32
34004                                                 MaxDropLvl     int16
34005
34006                                                 //mt:len32
34007                                                 GroupCaps []ToolGroupCap
34008
34009                                                 //mt:len32
34010                                                 DmgGroups []Group
34011
34012                                                 //mt:32tou16
34013                                                 PunchUses int32
34014                                         }))(obj)).PunchUses)
34015                                         write16(w, uint16(x))
34016                                 }
34017                         }
34018                 }
34019                 {
34020                         buf := w
34021                         w := ow
34022                         if len((buf.Bytes())) > math.MaxUint16 {
34023                                 chk(ErrTooLong)
34024                         }
34025                         {
34026                                 x := uint16(len((buf.Bytes())))
34027                                 write16(w, uint16(x))
34028                         }
34029                         {
34030                                 _, err := w.Write((buf.Bytes())[:])
34031                                 chk(err)
34032                         }
34033                 }
34034         }
34035 }
34036
34037 func (obj *ToolCaps) deserialize(r io.Reader) {
34038         if _ = (*(*(struct {
34039                 //mt:if _ = %s; false
34040                 NonNil bool
34041
34042                 AttackCooldown float32
34043                 MaxDropLvl     int16
34044
34045                 //mt:len32
34046                 GroupCaps []ToolGroupCap
34047
34048                 //mt:len32
34049                 DmgGroups []Group
34050
34051                 //mt:32tou16
34052                 PunchUses int32
34053         }))(obj)); false {
34054                 {
34055                         p := &(*(*(struct {
34056                                 //mt:if _ = %s; false
34057                                 NonNil bool
34058
34059                                 AttackCooldown float32
34060                                 MaxDropLvl     int16
34061
34062                                 //mt:len32
34063                                 GroupCaps []ToolGroupCap
34064
34065                                 //mt:len32
34066                                 DmgGroups []Group
34067
34068                                 //mt:32tou16
34069                                 PunchUses int32
34070                         }))(obj)).NonNil
34071                         switch n := read8(r); n {
34072                         case 0:
34073                                 *p = false
34074                         case 1:
34075                                 *p = true
34076                         default:
34077                                 chk(fmt.Errorf("invalid bool: %d", n))
34078                         }
34079
34080                 }
34081         }
34082         {
34083                 var n uint16
34084                 {
34085                         p := &n
34086                         *p = read16(r)
34087                 }
34088                 r := &io.LimitedReader{R: r, N: int64(n)}
34089                 if r.N > 0 {
34090                         (*(*(struct {
34091                                 //mt:if _ = %s; false
34092                                 NonNil bool
34093
34094                                 AttackCooldown float32
34095                                 MaxDropLvl     int16
34096
34097                                 //mt:len32
34098                                 GroupCaps []ToolGroupCap
34099
34100                                 //mt:len32
34101                                 DmgGroups []Group
34102
34103                                 //mt:32tou16
34104                                 PunchUses int32
34105                         }))(obj)).NonNil = true
34106                 } /**/
34107                 {
34108                         if (*(*(struct {
34109                                 //mt:if _ = %s; false
34110                                 NonNil bool
34111
34112                                 AttackCooldown float32
34113                                 MaxDropLvl     int16
34114
34115                                 //mt:len32
34116                                 GroupCaps []ToolGroupCap
34117
34118                                 //mt:len32
34119                                 DmgGroups []Group
34120
34121                                 //mt:32tou16
34122                                 PunchUses int32
34123                         }))(obj)).NonNil {
34124                                 {
34125                                         var local401 uint8
34126                                         local402 := uint8(5)
34127                                         {
34128                                                 p := &local401
34129                                                 *p = read8(r)
34130                                         }
34131                                         if local401 != local402 {
34132                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local401))
34133                                         }
34134                                 }
34135                                 {
34136                                         p := &(*(*(struct {
34137                                                 //mt:if _ = %s; false
34138                                                 NonNil bool
34139
34140                                                 AttackCooldown float32
34141                                                 MaxDropLvl     int16
34142
34143                                                 //mt:len32
34144                                                 GroupCaps []ToolGroupCap
34145
34146                                                 //mt:len32
34147                                                 DmgGroups []Group
34148
34149                                                 //mt:32tou16
34150                                                 PunchUses int32
34151                                         }))(obj)).AttackCooldown
34152                                         *p = math.Float32frombits(read32(r))
34153                                 }
34154                                 {
34155                                         p := &(*(*(struct {
34156                                                 //mt:if _ = %s; false
34157                                                 NonNil bool
34158
34159                                                 AttackCooldown float32
34160                                                 MaxDropLvl     int16
34161
34162                                                 //mt:len32
34163                                                 GroupCaps []ToolGroupCap
34164
34165                                                 //mt:len32
34166                                                 DmgGroups []Group
34167
34168                                                 //mt:32tou16
34169                                                 PunchUses int32
34170                                         }))(obj)).MaxDropLvl
34171                                         *p = int16(read16(r))
34172                                 }
34173                                 var local403 uint32
34174                                 {
34175                                         p := &local403
34176                                         *p = read32(r)
34177                                 }
34178                                 ((*(*(struct {
34179                                         //mt:if _ = %s; false
34180                                         NonNil bool
34181
34182                                         AttackCooldown float32
34183                                         MaxDropLvl     int16
34184
34185                                         //mt:len32
34186                                         GroupCaps []ToolGroupCap
34187
34188                                         //mt:len32
34189                                         DmgGroups []Group
34190
34191                                         //mt:32tou16
34192                                         PunchUses int32
34193                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local403)
34194                                 for local404 := range (*(*(struct {
34195                                         //mt:if _ = %s; false
34196                                         NonNil bool
34197
34198                                         AttackCooldown float32
34199                                         MaxDropLvl     int16
34200
34201                                         //mt:len32
34202                                         GroupCaps []ToolGroupCap
34203
34204                                         //mt:len32
34205                                         DmgGroups []Group
34206
34207                                         //mt:32tou16
34208                                         PunchUses int32
34209                                 }))(obj)).GroupCaps {
34210                                         if err := pcall(func() {
34211                                                 (((*(*(struct {
34212                                                         //mt:if _ = %s; false
34213                                                         NonNil bool
34214
34215                                                         AttackCooldown float32
34216                                                         MaxDropLvl     int16
34217
34218                                                         //mt:len32
34219                                                         GroupCaps []ToolGroupCap
34220
34221                                                         //mt:len32
34222                                                         DmgGroups []Group
34223
34224                                                         //mt:32tou16
34225                                                         PunchUses int32
34226                                                 }))(obj)).GroupCaps)[local404]).deserialize(r)
34227                                         }); err != nil {
34228                                                 if err == io.EOF {
34229                                                         chk(io.EOF)
34230                                                 }
34231                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
34232                                         }
34233                                 }
34234                                 var local405 uint32
34235                                 {
34236                                         p := &local405
34237                                         *p = read32(r)
34238                                 }
34239                                 ((*(*(struct {
34240                                         //mt:if _ = %s; false
34241                                         NonNil bool
34242
34243                                         AttackCooldown float32
34244                                         MaxDropLvl     int16
34245
34246                                         //mt:len32
34247                                         GroupCaps []ToolGroupCap
34248
34249                                         //mt:len32
34250                                         DmgGroups []Group
34251
34252                                         //mt:32tou16
34253                                         PunchUses int32
34254                                 }))(obj)).DmgGroups) = make([]Group, local405)
34255                                 for local406 := range (*(*(struct {
34256                                         //mt:if _ = %s; false
34257                                         NonNil bool
34258
34259                                         AttackCooldown float32
34260                                         MaxDropLvl     int16
34261
34262                                         //mt:len32
34263                                         GroupCaps []ToolGroupCap
34264
34265                                         //mt:len32
34266                                         DmgGroups []Group
34267
34268                                         //mt:32tou16
34269                                         PunchUses int32
34270                                 }))(obj)).DmgGroups {
34271                                         if err := pcall(func() {
34272                                                 (((*(*(struct {
34273                                                         //mt:if _ = %s; false
34274                                                         NonNil bool
34275
34276                                                         AttackCooldown float32
34277                                                         MaxDropLvl     int16
34278
34279                                                         //mt:len32
34280                                                         GroupCaps []ToolGroupCap
34281
34282                                                         //mt:len32
34283                                                         DmgGroups []Group
34284
34285                                                         //mt:32tou16
34286                                                         PunchUses int32
34287                                                 }))(obj)).DmgGroups)[local406]).deserialize(r)
34288                                         }); err != nil {
34289                                                 if err == io.EOF {
34290                                                         chk(io.EOF)
34291                                                 }
34292                                                 chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
34293                                         }
34294                                 }
34295                                 var local407 uint16
34296                                 {
34297                                         p := &local407
34298                                         *p = read16(r)
34299                                 }
34300                                 (*(*(struct {
34301                                         //mt:if _ = %s; false
34302                                         NonNil bool
34303
34304                                         AttackCooldown float32
34305                                         MaxDropLvl     int16
34306
34307                                         //mt:len32
34308                                         GroupCaps []ToolGroupCap
34309
34310                                         //mt:len32
34311                                         DmgGroups []Group
34312
34313                                         //mt:32tou16
34314                                         PunchUses int32
34315                                 }))(obj)).PunchUses = int32(local407)
34316                         }
34317                 }
34318                 if r.N > 0 {
34319                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34320                 }
34321         }
34322 }
34323
34324 func (obj *AnimType) serialize(w io.Writer) {
34325         {
34326                 x := *(*(uint8))(obj)
34327                 write8(w, uint8(x))
34328         }
34329 }
34330
34331 func (obj *AnimType) deserialize(r io.Reader) {
34332         {
34333                 p := &*(*(uint8))(obj)
34334                 *p = read8(r)
34335         }
34336 }
34337
34338 func (obj *HUDType) serialize(w io.Writer) {
34339         {
34340                 x := *(*(uint8))(obj)
34341                 write8(w, uint8(x))
34342         }
34343 }
34344
34345 func (obj *HUDType) deserialize(r io.Reader) {
34346         {
34347                 p := &*(*(uint8))(obj)
34348                 *p = read8(r)
34349         }
34350 }
34351
34352 func (obj *Box) serialize(w io.Writer) {
34353         for local408 := range *(*([2]Vec))(obj) {
34354                 if err := pcall(func() {
34355                         ((*(*([2]Vec))(obj))[local408]).serialize(w)
34356                 }); err != nil {
34357                         if err == io.EOF {
34358                                 chk(io.EOF)
34359                         }
34360                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34361                 }
34362         }
34363 }
34364
34365 func (obj *Box) deserialize(r io.Reader) {
34366         for local409 := range *(*([2]Vec))(obj) {
34367                 if err := pcall(func() {
34368                         ((*(*([2]Vec))(obj))[local409]).deserialize(r)
34369                 }); err != nil {
34370                         if err == io.EOF {
34371                                 chk(io.EOF)
34372                         }
34373                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
34374                 }
34375         }
34376 }
34377
34378 func (obj *TileFlags) serialize(w io.Writer) {
34379         {
34380                 x := *(*(uint16))(obj)
34381                 write16(w, uint16(x))
34382         }
34383 }
34384
34385 func (obj *TileFlags) deserialize(r io.Reader) {
34386         {
34387                 p := &*(*(uint16))(obj)
34388                 *p = read16(r)
34389         }
34390 }
34391
34392 func (obj *AlignType) serialize(w io.Writer) {
34393         {
34394                 x := *(*(uint8))(obj)
34395                 write8(w, uint8(x))
34396         }
34397 }
34398
34399 func (obj *AlignType) deserialize(r io.Reader) {
34400         {
34401                 p := &*(*(uint8))(obj)
34402                 *p = read8(r)
34403         }
34404 }
34405
34406 func (obj *NodeBoxType) serialize(w io.Writer) {
34407         {
34408                 x := *(*(uint8))(obj)
34409                 write8(w, uint8(x))
34410         }
34411 }
34412
34413 func (obj *NodeBoxType) deserialize(r io.Reader) {
34414         {
34415                 p := &*(*(uint8))(obj)
34416                 *p = read8(r)
34417         }
34418 }
34419
34420 func (obj *DirBoxes) serialize(w io.Writer) {
34421         if len(((*(*(struct {
34422                 Top, Bot                 []Box
34423                 Front, Left, Back, Right []Box
34424         }))(obj)).Top)) > math.MaxUint16 {
34425                 chk(ErrTooLong)
34426         }
34427         {
34428                 x := uint16(len(((*(*(struct {
34429                         Top, Bot                 []Box
34430                         Front, Left, Back, Right []Box
34431                 }))(obj)).Top)))
34432                 write16(w, uint16(x))
34433         }
34434         for local410 := range (*(*(struct {
34435                 Top, Bot                 []Box
34436                 Front, Left, Back, Right []Box
34437         }))(obj)).Top {
34438                 if err := pcall(func() {
34439                         (((*(*(struct {
34440                                 Top, Bot                 []Box
34441                                 Front, Left, Back, Right []Box
34442                         }))(obj)).Top)[local410]).serialize(w)
34443                 }); err != nil {
34444                         if err == io.EOF {
34445                                 chk(io.EOF)
34446                         }
34447                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34448                 }
34449         }
34450         if len(((*(*(struct {
34451                 Top, Bot                 []Box
34452                 Front, Left, Back, Right []Box
34453         }))(obj)).Bot)) > math.MaxUint16 {
34454                 chk(ErrTooLong)
34455         }
34456         {
34457                 x := uint16(len(((*(*(struct {
34458                         Top, Bot                 []Box
34459                         Front, Left, Back, Right []Box
34460                 }))(obj)).Bot)))
34461                 write16(w, uint16(x))
34462         }
34463         for local411 := range (*(*(struct {
34464                 Top, Bot                 []Box
34465                 Front, Left, Back, Right []Box
34466         }))(obj)).Bot {
34467                 if err := pcall(func() {
34468                         (((*(*(struct {
34469                                 Top, Bot                 []Box
34470                                 Front, Left, Back, Right []Box
34471                         }))(obj)).Bot)[local411]).serialize(w)
34472                 }); err != nil {
34473                         if err == io.EOF {
34474                                 chk(io.EOF)
34475                         }
34476                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34477                 }
34478         }
34479         if len(((*(*(struct {
34480                 Top, Bot                 []Box
34481                 Front, Left, Back, Right []Box
34482         }))(obj)).Front)) > math.MaxUint16 {
34483                 chk(ErrTooLong)
34484         }
34485         {
34486                 x := uint16(len(((*(*(struct {
34487                         Top, Bot                 []Box
34488                         Front, Left, Back, Right []Box
34489                 }))(obj)).Front)))
34490                 write16(w, uint16(x))
34491         }
34492         for local412 := range (*(*(struct {
34493                 Top, Bot                 []Box
34494                 Front, Left, Back, Right []Box
34495         }))(obj)).Front {
34496                 if err := pcall(func() {
34497                         (((*(*(struct {
34498                                 Top, Bot                 []Box
34499                                 Front, Left, Back, Right []Box
34500                         }))(obj)).Front)[local412]).serialize(w)
34501                 }); err != nil {
34502                         if err == io.EOF {
34503                                 chk(io.EOF)
34504                         }
34505                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34506                 }
34507         }
34508         if len(((*(*(struct {
34509                 Top, Bot                 []Box
34510                 Front, Left, Back, Right []Box
34511         }))(obj)).Left)) > math.MaxUint16 {
34512                 chk(ErrTooLong)
34513         }
34514         {
34515                 x := uint16(len(((*(*(struct {
34516                         Top, Bot                 []Box
34517                         Front, Left, Back, Right []Box
34518                 }))(obj)).Left)))
34519                 write16(w, uint16(x))
34520         }
34521         for local413 := range (*(*(struct {
34522                 Top, Bot                 []Box
34523                 Front, Left, Back, Right []Box
34524         }))(obj)).Left {
34525                 if err := pcall(func() {
34526                         (((*(*(struct {
34527                                 Top, Bot                 []Box
34528                                 Front, Left, Back, Right []Box
34529                         }))(obj)).Left)[local413]).serialize(w)
34530                 }); err != nil {
34531                         if err == io.EOF {
34532                                 chk(io.EOF)
34533                         }
34534                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34535                 }
34536         }
34537         if len(((*(*(struct {
34538                 Top, Bot                 []Box
34539                 Front, Left, Back, Right []Box
34540         }))(obj)).Back)) > math.MaxUint16 {
34541                 chk(ErrTooLong)
34542         }
34543         {
34544                 x := uint16(len(((*(*(struct {
34545                         Top, Bot                 []Box
34546                         Front, Left, Back, Right []Box
34547                 }))(obj)).Back)))
34548                 write16(w, uint16(x))
34549         }
34550         for local414 := range (*(*(struct {
34551                 Top, Bot                 []Box
34552                 Front, Left, Back, Right []Box
34553         }))(obj)).Back {
34554                 if err := pcall(func() {
34555                         (((*(*(struct {
34556                                 Top, Bot                 []Box
34557                                 Front, Left, Back, Right []Box
34558                         }))(obj)).Back)[local414]).serialize(w)
34559                 }); err != nil {
34560                         if err == io.EOF {
34561                                 chk(io.EOF)
34562                         }
34563                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34564                 }
34565         }
34566         if len(((*(*(struct {
34567                 Top, Bot                 []Box
34568                 Front, Left, Back, Right []Box
34569         }))(obj)).Right)) > math.MaxUint16 {
34570                 chk(ErrTooLong)
34571         }
34572         {
34573                 x := uint16(len(((*(*(struct {
34574                         Top, Bot                 []Box
34575                         Front, Left, Back, Right []Box
34576                 }))(obj)).Right)))
34577                 write16(w, uint16(x))
34578         }
34579         for local415 := range (*(*(struct {
34580                 Top, Bot                 []Box
34581                 Front, Left, Back, Right []Box
34582         }))(obj)).Right {
34583                 if err := pcall(func() {
34584                         (((*(*(struct {
34585                                 Top, Bot                 []Box
34586                                 Front, Left, Back, Right []Box
34587                         }))(obj)).Right)[local415]).serialize(w)
34588                 }); err != nil {
34589                         if err == io.EOF {
34590                                 chk(io.EOF)
34591                         }
34592                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34593                 }
34594         }
34595 }
34596
34597 func (obj *DirBoxes) deserialize(r io.Reader) {
34598         var local416 uint16
34599         {
34600                 p := &local416
34601                 *p = read16(r)
34602         }
34603         ((*(*(struct {
34604                 Top, Bot                 []Box
34605                 Front, Left, Back, Right []Box
34606         }))(obj)).Top) = make([]Box, local416)
34607         for local417 := range (*(*(struct {
34608                 Top, Bot                 []Box
34609                 Front, Left, Back, Right []Box
34610         }))(obj)).Top {
34611                 if err := pcall(func() {
34612                         (((*(*(struct {
34613                                 Top, Bot                 []Box
34614                                 Front, Left, Back, Right []Box
34615                         }))(obj)).Top)[local417]).deserialize(r)
34616                 }); err != nil {
34617                         if err == io.EOF {
34618                                 chk(io.EOF)
34619                         }
34620                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34621                 }
34622         }
34623         var local418 uint16
34624         {
34625                 p := &local418
34626                 *p = read16(r)
34627         }
34628         ((*(*(struct {
34629                 Top, Bot                 []Box
34630                 Front, Left, Back, Right []Box
34631         }))(obj)).Bot) = make([]Box, local418)
34632         for local419 := range (*(*(struct {
34633                 Top, Bot                 []Box
34634                 Front, Left, Back, Right []Box
34635         }))(obj)).Bot {
34636                 if err := pcall(func() {
34637                         (((*(*(struct {
34638                                 Top, Bot                 []Box
34639                                 Front, Left, Back, Right []Box
34640                         }))(obj)).Bot)[local419]).deserialize(r)
34641                 }); err != nil {
34642                         if err == io.EOF {
34643                                 chk(io.EOF)
34644                         }
34645                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34646                 }
34647         }
34648         var local420 uint16
34649         {
34650                 p := &local420
34651                 *p = read16(r)
34652         }
34653         ((*(*(struct {
34654                 Top, Bot                 []Box
34655                 Front, Left, Back, Right []Box
34656         }))(obj)).Front) = make([]Box, local420)
34657         for local421 := range (*(*(struct {
34658                 Top, Bot                 []Box
34659                 Front, Left, Back, Right []Box
34660         }))(obj)).Front {
34661                 if err := pcall(func() {
34662                         (((*(*(struct {
34663                                 Top, Bot                 []Box
34664                                 Front, Left, Back, Right []Box
34665                         }))(obj)).Front)[local421]).deserialize(r)
34666                 }); err != nil {
34667                         if err == io.EOF {
34668                                 chk(io.EOF)
34669                         }
34670                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34671                 }
34672         }
34673         var local422 uint16
34674         {
34675                 p := &local422
34676                 *p = read16(r)
34677         }
34678         ((*(*(struct {
34679                 Top, Bot                 []Box
34680                 Front, Left, Back, Right []Box
34681         }))(obj)).Left) = make([]Box, local422)
34682         for local423 := range (*(*(struct {
34683                 Top, Bot                 []Box
34684                 Front, Left, Back, Right []Box
34685         }))(obj)).Left {
34686                 if err := pcall(func() {
34687                         (((*(*(struct {
34688                                 Top, Bot                 []Box
34689                                 Front, Left, Back, Right []Box
34690                         }))(obj)).Left)[local423]).deserialize(r)
34691                 }); err != nil {
34692                         if err == io.EOF {
34693                                 chk(io.EOF)
34694                         }
34695                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34696                 }
34697         }
34698         var local424 uint16
34699         {
34700                 p := &local424
34701                 *p = read16(r)
34702         }
34703         ((*(*(struct {
34704                 Top, Bot                 []Box
34705                 Front, Left, Back, Right []Box
34706         }))(obj)).Back) = make([]Box, local424)
34707         for local425 := range (*(*(struct {
34708                 Top, Bot                 []Box
34709                 Front, Left, Back, Right []Box
34710         }))(obj)).Back {
34711                 if err := pcall(func() {
34712                         (((*(*(struct {
34713                                 Top, Bot                 []Box
34714                                 Front, Left, Back, Right []Box
34715                         }))(obj)).Back)[local425]).deserialize(r)
34716                 }); err != nil {
34717                         if err == io.EOF {
34718                                 chk(io.EOF)
34719                         }
34720                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34721                 }
34722         }
34723         var local426 uint16
34724         {
34725                 p := &local426
34726                 *p = read16(r)
34727         }
34728         ((*(*(struct {
34729                 Top, Bot                 []Box
34730                 Front, Left, Back, Right []Box
34731         }))(obj)).Right) = make([]Box, local426)
34732         for local427 := range (*(*(struct {
34733                 Top, Bot                 []Box
34734                 Front, Left, Back, Right []Box
34735         }))(obj)).Right {
34736                 if err := pcall(func() {
34737                         (((*(*(struct {
34738                                 Top, Bot                 []Box
34739                                 Front, Left, Back, Right []Box
34740                         }))(obj)).Right)[local427]).deserialize(r)
34741                 }); err != nil {
34742                         if err == io.EOF {
34743                                 chk(io.EOF)
34744                         }
34745                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
34746                 }
34747         }
34748 }
34749
34750 func (obj *ToolGroupCap) serialize(w io.Writer) {
34751         if len(([]byte((*(*(struct {
34752                 Name string
34753
34754                 //mt:32to16
34755                 Uses int32
34756
34757                 MaxLvl int16
34758
34759                 //mt:len32
34760                 Times []DigTime
34761         }))(obj)).Name))) > math.MaxUint16 {
34762                 chk(ErrTooLong)
34763         }
34764         {
34765                 x := uint16(len(([]byte((*(*(struct {
34766                         Name string
34767
34768                         //mt:32to16
34769                         Uses int32
34770
34771                         MaxLvl int16
34772
34773                         //mt:len32
34774                         Times []DigTime
34775                 }))(obj)).Name))))
34776                 write16(w, uint16(x))
34777         }
34778         {
34779                 _, err := w.Write(([]byte((*(*(struct {
34780                         Name string
34781
34782                         //mt:32to16
34783                         Uses int32
34784
34785                         MaxLvl int16
34786
34787                         //mt:len32
34788                         Times []DigTime
34789                 }))(obj)).Name))[:])
34790                 chk(err)
34791         }
34792         {
34793                 x := int16((*(*(struct {
34794                         Name string
34795
34796                         //mt:32to16
34797                         Uses int32
34798
34799                         MaxLvl int16
34800
34801                         //mt:len32
34802                         Times []DigTime
34803                 }))(obj)).Uses)
34804                 write16(w, uint16(x))
34805         }
34806         {
34807                 x := (*(*(struct {
34808                         Name string
34809
34810                         //mt:32to16
34811                         Uses int32
34812
34813                         MaxLvl int16
34814
34815                         //mt:len32
34816                         Times []DigTime
34817                 }))(obj)).MaxLvl
34818                 write16(w, uint16(x))
34819         }
34820         if len(((*(*(struct {
34821                 Name string
34822
34823                 //mt:32to16
34824                 Uses int32
34825
34826                 MaxLvl int16
34827
34828                 //mt:len32
34829                 Times []DigTime
34830         }))(obj)).Times)) > math.MaxUint32 {
34831                 chk(ErrTooLong)
34832         }
34833         {
34834                 x := uint32(len(((*(*(struct {
34835                         Name string
34836
34837                         //mt:32to16
34838                         Uses int32
34839
34840                         MaxLvl int16
34841
34842                         //mt:len32
34843                         Times []DigTime
34844                 }))(obj)).Times)))
34845                 write32(w, uint32(x))
34846         }
34847         for local428 := range (*(*(struct {
34848                 Name string
34849
34850                 //mt:32to16
34851                 Uses int32
34852
34853                 MaxLvl int16
34854
34855                 //mt:len32
34856                 Times []DigTime
34857         }))(obj)).Times {
34858                 if err := pcall(func() {
34859                         (((*(*(struct {
34860                                 Name string
34861
34862                                 //mt:32to16
34863                                 Uses int32
34864
34865                                 MaxLvl int16
34866
34867                                 //mt:len32
34868                                 Times []DigTime
34869                         }))(obj)).Times)[local428]).serialize(w)
34870                 }); err != nil {
34871                         if err == io.EOF {
34872                                 chk(io.EOF)
34873                         }
34874                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34875                 }
34876         }
34877 }
34878
34879 func (obj *ToolGroupCap) deserialize(r io.Reader) {
34880         var local429 []uint8
34881         var local430 uint16
34882         {
34883                 p := &local430
34884                 *p = read16(r)
34885         }
34886         (local429) = make([]uint8, local430)
34887         {
34888                 _, err := io.ReadFull(r, (local429)[:])
34889                 chk(err)
34890         }
34891         ((*(*(struct {
34892                 Name string
34893
34894                 //mt:32to16
34895                 Uses int32
34896
34897                 MaxLvl int16
34898
34899                 //mt:len32
34900                 Times []DigTime
34901         }))(obj)).Name) = string(local429)
34902         var local431 int16
34903         {
34904                 p := &local431
34905                 *p = int16(read16(r))
34906         }
34907         (*(*(struct {
34908                 Name string
34909
34910                 //mt:32to16
34911                 Uses int32
34912
34913                 MaxLvl int16
34914
34915                 //mt:len32
34916                 Times []DigTime
34917         }))(obj)).Uses = int32(local431)
34918         {
34919                 p := &(*(*(struct {
34920                         Name string
34921
34922                         //mt:32to16
34923                         Uses int32
34924
34925                         MaxLvl int16
34926
34927                         //mt:len32
34928                         Times []DigTime
34929                 }))(obj)).MaxLvl
34930                 *p = int16(read16(r))
34931         }
34932         var local432 uint32
34933         {
34934                 p := &local432
34935                 *p = read32(r)
34936         }
34937         ((*(*(struct {
34938                 Name string
34939
34940                 //mt:32to16
34941                 Uses int32
34942
34943                 MaxLvl int16
34944
34945                 //mt:len32
34946                 Times []DigTime
34947         }))(obj)).Times) = make([]DigTime, local432)
34948         for local433 := range (*(*(struct {
34949                 Name string
34950
34951                 //mt:32to16
34952                 Uses int32
34953
34954                 MaxLvl int16
34955
34956                 //mt:len32
34957                 Times []DigTime
34958         }))(obj)).Times {
34959                 if err := pcall(func() {
34960                         (((*(*(struct {
34961                                 Name string
34962
34963                                 //mt:32to16
34964                                 Uses int32
34965
34966                                 MaxLvl int16
34967
34968                                 //mt:len32
34969                                 Times []DigTime
34970                         }))(obj)).Times)[local433]).deserialize(r)
34971                 }); err != nil {
34972                         if err == io.EOF {
34973                                 chk(io.EOF)
34974                         }
34975                         chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DigTime", err))
34976                 }
34977         }
34978 }
34979
34980 func (obj *DigTime) serialize(w io.Writer) {
34981         {
34982                 x := (*(*(struct {
34983                         Rating int16
34984                         Time   float32
34985                 }))(obj)).Rating
34986                 write16(w, uint16(x))
34987         }
34988         {
34989                 x := (*(*(struct {
34990                         Rating int16
34991                         Time   float32
34992                 }))(obj)).Time
34993                 write32(w, math.Float32bits(x))
34994         }
34995 }
34996
34997 func (obj *DigTime) deserialize(r io.Reader) {
34998         {
34999                 p := &(*(*(struct {
35000                         Rating int16
35001                         Time   float32
35002                 }))(obj)).Rating
35003                 *p = int16(read16(r))
35004         }
35005         {
35006                 p := &(*(*(struct {
35007                         Rating int16
35008                         Time   float32
35009                 }))(obj)).Time
35010                 *p = math.Float32frombits(read32(r))
35011         }
35012 }